| blob | ded0a14d7232b18e2bd58d5b5f130122c5b388a9 |
1 /*-------------------------------------------------------------------------
2 *
3 * parse_agg.c
4 * handle aggregates and window functions in parser
5 *
6 * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/parser/parse_agg.c
12 *
13 *-------------------------------------------------------------------------
14 */
34 {
42 {
76 /*
77 * transformAggregateCall -
78 * Finish initial transformation of an aggregate call
79 *
80 * parse_func.c has recognized the function as an aggregate, and has set up
81 * all the fields of the Aggref except aggargtypes, aggdirectargs, args,
82 * aggorder, aggdistinct and agglevelsup. The passed-in args list has been
83 * through standard expression transformation and type coercion to match the
84 * agg's declared arg types, while the passed-in aggorder list hasn't been
85 * transformed at all.
86 *
87 * Here we separate the args list into direct and aggregated args, storing the
88 * former in agg->aggdirectargs and the latter in agg->args. The regular
89 * args, but not the direct args, are converted into a targetlist by inserting
90 * TargetEntry nodes. We then transform the aggorder and agg_distinct
91 * specifications to produce lists of SortGroupClause nodes for agg->aggorder
92 * and agg->aggdistinct. (For a regular aggregate, this might result in
93 * adding resjunk expressions to the targetlist; but for ordered-set
94 * aggregates the aggorder list will always be one-to-one with the aggregated
95 * args.)
96 *
97 * We must also determine which query level the aggregate actually belongs to,
98 * set agglevelsup accordingly, and mark p_hasAggs true in the corresponding
99 * pstate level.
100 */
101 void
104 {
113 /*
114 * Before separating the args into direct and aggregated args, make a list
115 * of their data type OIDs for use later.
116 */
118 {
122 }
126 {
127 /*
128 * For an ordered-set agg, the args list includes direct args and
129 * aggregated args; we must split them apart.
130 */
140 /*
141 * Build a tlist from the aggregated args, and make a sortlist entry
142 * for each one. Note that the expressions in the SortBy nodes are
143 * ignored (they are the raw versions of the transformed args); we are
144 * just looking at the sort information in the SortBy nodes.
145 */
147 {
152 /* We don't bother to assign column names to the entries */
158 }
160 /* Never any DISTINCT in an ordered-set agg */
162 }
163 else
164 {
165 /* Regular aggregate, so it has no direct args */
168 /*
169 * Transform the plain list of Exprs into a targetlist.
170 */
172 {
176 /* We don't bother to assign column names to the entries */
179 }
181 /*
182 * If we have an ORDER BY, transform it. This will add columns to the
183 * tlist if they appear in ORDER BY but weren't already in the arg
184 * list. They will be marked resjunk = true so we can tell them apart
185 * from regular aggregate arguments later.
186 *
187 * We need to mess with p_next_resno since it will be used to number
188 * any new targetlist entries.
189 */
194 aggorder,
196 EXPR_KIND_ORDER_BY,
199 /*
200 * If we have DISTINCT, transform that to produce a distinctList.
201 */
203 {
206 /*
207 * Remove this check if executor support for hashed distinct for
208 * aggregates is ever added.
209 */
211 {
215 {
224 }
225 }
226 }
229 }
231 /* Update the Aggref with the transformation results */
237 }
239 /*
240 * transformGroupingFunc
241 * Transform a GROUPING expression
242 *
243 * GROUPING() behaves very like an aggregate. Processing of levels and nesting
244 * is done as for aggregates. We set p_hasAggs for these expressions too.
245 */
246 Node *
248 {
261 {
266 /* acceptability of expressions is checked later */
269 }
277 }
279 /*
280 * Aggregate functions and grouping operations (which are combined in the spec
281 * as <set function specification>) are very similar with regard to level and
282 * nesting restrictions (though we allow a lot more things than the spec does).
283 * Centralise those restrictions here.
284 */
285 static void
287 {
299 {
307 }
308 else
309 {
315 }
317 /*
318 * Check the arguments to compute the aggregate's level and detect
319 * improper nesting.
320 */
322 directargs,
323 args,
324 filter);
328 /* Mark the correct pstate level as having aggregates */
333 /*
334 * Check to see if the aggregate function is in an invalid place within
335 * its aggregation query.
336 *
337 * For brevity we support two schemes for reporting an error here: set
338 * "err" to a custom message, or set "errkind" true if the error context
339 * is sufficiently identified by what ParseExprKindName will return, *and*
340 * what it will return is just a SQL keyword. (Otherwise, use a custom
341 * message to avoid creating translation problems.)
342 */
346 {
352 /*
353 * Accept aggregate/grouping here; caller must throw error if
354 * wanted
355 */
361 else
366 /* Should only be possible in a LATERAL subquery */
369 /*
370 * Aggregate/grouping scope rules make it worth being explicit
371 * here
372 */
375 else
382 else
392 else
397 /* okay */
403 /* okay */
406 /* okay */
411 else
418 else
425 else
430 /* okay */
441 /* okay */
444 /* okay */
461 else
470 else
477 else
484 else
491 else
498 else
505 else
512 else
519 else
526 else
534 else
542 else
550 else
559 /*
560 * There is intentionally no default: case here, so that the
561 * compiler will warn if we add a new ParseExprKind without
562 * extending this switch. If we do see an unrecognized value at
563 * runtime, the behavior will be the same as for EXPR_KIND_OTHER,
564 * which is sane anyway.
565 */
566 }
575 {
577 /* translator: %s is name of a SQL construct, eg GROUP BY */
579 else
580 /* translator: %s is name of a SQL construct, eg GROUP BY */
588 }
589 }
591 /*
592 * check_agg_arguments
593 * Scan the arguments of an aggregate function to determine the
594 * aggregate's semantic level (zero is the current select's level,
595 * one is its parent, etc).
596 *
597 * The aggregate's level is the same as the level of the lowest-level variable
598 * or aggregate in its aggregated arguments (including any ORDER BY columns)
599 * or filter expression; or if it contains no variables at all, we presume it
600 * to be local.
601 *
602 * Vars/Aggs in direct arguments are *not* counted towards determining the
603 * agg's level, as those arguments aren't evaluated per-row but only
604 * per-group, and so in some sense aren't really agg arguments. However,
605 * this can mean that we decide an agg is upper-level even when its direct
606 * args contain lower-level Vars/Aggs, and that case has to be disallowed.
607 * (This is a little strange, but the SQL standard seems pretty definite that
608 * direct args are not to be considered when setting the agg's level.)
609 *
610 * We also take this opportunity to detect any aggregates or window functions
611 * nested within the arguments. We can throw error immediately if we find
612 * a window function. Aggregates are a bit trickier because it's only an
613 * error if the inner aggregate is of the same semantic level as the outer,
614 * which we can't know until we finish scanning the arguments.
615 */
616 static int
621 {
623 check_agg_arguments_context context;
633 /*
634 * If we found no vars nor aggs at all, it's a level-zero aggregate;
635 * otherwise, its level is the minimum of vars or aggs.
636 */
638 {
641 else
643 }
646 else
649 /*
650 * If there's a nested aggregate of the same semantic level, complain.
651 */
653 {
663 }
665 /*
666 * Now check for vars/aggs in the direct arguments, and throw error if
667 * needed. Note that we allow a Var of the agg's semantic level, but not
668 * an Agg of that level. In principle such Aggs could probably be
669 * supported, but it would create an ordering dependency among the
670 * aggregates at execution time. Since the case appears neither to be
671 * required by spec nor particularly useful, we just treat it as a
672 * nested-aggregate situation.
673 */
675 {
693 }
695 }
697 static bool
700 {
704 {
707 /* convert levelsup to frame of reference of original query */
709 /* ignore local vars of subqueries */
711 {
715 }
717 }
719 {
722 /* convert levelsup to frame of reference of original query */
724 /* ignore local aggs of subqueries */
726 {
730 }
731 /* no need to examine args of the inner aggregate */
733 }
735 {
738 /* convert levelsup to frame of reference of original query */
740 /* ignore local aggs of subqueries */
742 {
746 }
747 /* Continue and descend into subtree */
748 }
750 /*
751 * SRFs and window functions can be rejected immediately, unless we are
752 * within a sub-select within the aggregate's arguments; in that case
753 * they're OK.
754 */
756 {
770 }
772 {
773 /* Recurse into subselects */
778 check_agg_arguments_walker,
783 }
786 check_agg_arguments_walker,
788 }
790 /*
791 * transformWindowFuncCall -
792 * Finish initial transformation of a window function call
793 *
794 * parse_func.c has recognized the function as a window function, and has set
795 * up all the fields of the WindowFunc except winref. Here we must (1) add
796 * the WindowDef to the pstate (if not a duplicate of one already present) and
797 * set winref to link to it; and (2) mark p_hasWindowFuncs true in the pstate.
798 * Unlike aggregates, only the most closely nested pstate level need be
799 * considered --- there are no "outer window functions" per SQL spec.
800 */
801 void
804 {
808 /*
809 * A window function call can't contain another one (but aggs are OK). XXX
810 * is this required by spec, or just an unimplemented feature?
811 *
812 * Note: we don't need to check the filter expression here, because the
813 * context checks done below and in transformAggregateCall would have
814 * already rejected any window funcs or aggs within the filter.
815 */
824 /*
825 * Check to see if the window function is in an invalid place within the
826 * query.
827 *
828 * For brevity we support two schemes for reporting an error here: set
829 * "err" to a custom message, or set "errkind" true if the error context
830 * is sufficiently identified by what ParseExprKindName will return, *and*
831 * what it will return is just a SQL keyword. (Otherwise, use a custom
832 * message to avoid creating translation problems.)
833 */
837 {
842 /* Accept window func here; caller must throw error if wanted */
849 /* can't get here, but just in case, throw an error */
875 /* okay */
886 /* okay */
889 /* okay */
947 /*
948 * There is intentionally no default: case here, so that the
949 * compiler will warn if we add a new ParseExprKind without
950 * extending this switch. If we do see an unrecognized value at
951 * runtime, the behavior will be the same as for EXPR_KIND_OTHER,
952 * which is sane anyway.
953 */
954 }
963 /* translator: %s is name of a SQL construct, eg GROUP BY */
968 /*
969 * If the OVER clause just specifies a window name, find that WINDOW
970 * clause (which had better be present). Otherwise, try to match all the
971 * properties of the OVER clause, and make a new entry in the p_windowdefs
972 * list if no luck.
973 */
975 {
985 {
988 winref++;
990 {
993 }
994 }
1000 }
1001 else
1002 {
1007 {
1010 winref++;
1016 else
1023 {
1024 /* found a duplicate window specification */
1027 }
1028 }
1030 {
1033 }
1034 }
1037 }
1039 /*
1040 * parseCheckAggregates
1041 * Check for aggregates where they shouldn't be and improper grouping.
1042 * This function should be called after the target list and qualifications
1043 * are finalized.
1044 *
1045 * Misplaced aggregates are now mostly detected in transformAggregateCall,
1046 * but it seems more robust to check for aggregates in recursive queries
1047 * only after everything is finalized. In any case it's hard to detect
1048 * improper grouping on-the-fly, so we have to make another pass over the
1049 * query for that.
1050 */
1051 void
1053 {
1064 /* This should only be called if we found aggregates or grouping */
1067 /*
1068 * If we have grouping sets, expand them and find the intersection of all
1069 * sets.
1070 */
1072 {
1073 /*
1074 * The limit of 4096 is arbitrary and exists simply to avoid resource
1075 * issues from pathological constructs.
1076 */
1084 qry->groupClause
1088 /*
1089 * The intersection will often be empty, so help things along by
1090 * seeding the intersect with the smallest set.
1091 */
1095 {
1097 {
1101 }
1102 }
1104 /*
1105 * If there was only one grouping set in the expansion, AND if the
1106 * groupClause is non-empty (meaning that the grouping set is not
1107 * empty either), then we can ditch the grouping set and pretend we
1108 * just had a normal GROUP BY.
1109 */
1112 }
1114 /*
1115 * Scan the range table to see if there are JOIN or self-reference CTE
1116 * entries. We'll need this info below.
1117 */
1120 {
1127 }
1129 /*
1130 * Build a list of the acceptable GROUP BY expressions for use by
1131 * check_ungrouped_columns().
1132 *
1133 * We get the TLE, not just the expr, because GROUPING wants to know the
1134 * sortgroupref.
1135 */
1137 {
1146 }
1148 /*
1149 * If there are join alias vars involved, we have to flatten them to the
1150 * underlying vars, so that aliased and unaliased vars will be correctly
1151 * taken as equal. We can skip the expense of doing this if no rangetable
1152 * entries are RTE_JOIN kind.
1153 */
1158 /*
1159 * Detect whether any of the grouping expressions aren't simple Vars; if
1160 * they're all Vars then we don't have to work so hard in the recursive
1161 * scans. (Note we have to flatten aliases before this.)
1162 *
1163 * Track Vars that are included in all grouping sets separately in
1164 * groupClauseCommonVars, since these are the only ones we can use to
1165 * check for functional dependencies.
1166 */
1169 {
1173 {
1175 }
1178 {
1180 }
1181 }
1183 /*
1184 * Check the targetlist and HAVING clause for ungrouped variables.
1185 *
1186 * Note: because we check resjunk tlist elements as well as regular ones,
1187 * this will also find ungrouped variables that came from ORDER BY and
1188 * WINDOW clauses. For that matter, it's also going to examine the
1189 * grouping expressions themselves --- but they'll all pass the test ...
1190 *
1191 * We also finalize GROUPING expressions, but for that we need to traverse
1192 * the original (unflattened) clause in order to modify nodes.
1193 */
1197 have_non_var_grouping);
1202 have_non_var_grouping,
1208 have_non_var_grouping);
1213 have_non_var_grouping,
1216 /*
1217 * Per spec, aggregates can't appear in a recursive term.
1218 */
1225 }
1227 /*
1228 * check_ungrouped_columns -
1229 * Scan the given expression tree for ungrouped variables (variables
1230 * that are not listed in the groupClauses list and are not within
1231 * the arguments of aggregate functions). Emit a suitable error message
1232 * if any are found.
1233 *
1234 * NOTE: we assume that the given clause has been transformed suitably for
1235 * parser output. This means we can use expression_tree_walker.
1236 *
1237 * NOTE: we recognize grouping expressions in the main query, but only
1238 * grouping Vars in subqueries. For example, this will be rejected,
1239 * although it could be allowed:
1240 * SELECT
1241 * (SELECT x FROM bar where y = (foo.a + foo.b))
1242 * FROM foo
1243 * GROUP BY a + b;
1244 * The difficulty is the need to account for different sublevels_up.
1245 * This appears to require a whole custom version of equal(), which is
1246 * way more pain than the feature seems worth.
1247 */
1248 static void
1253 {
1254 check_ungrouped_columns_context context;
1266 }
1268 static bool
1271 {
1281 {
1285 {
1286 /*
1287 * If we find an aggregate call of the original level, do not
1288 * recurse into its normal arguments, ORDER BY arguments, or
1289 * filter; ungrouped vars there are not an error. But we should
1290 * check direct arguments as though they weren't in an aggregate.
1291 * We set a special flag in the context to help produce a useful
1292 * error message for ungrouped vars in direct arguments.
1293 */
1299 context);
1302 }
1304 /*
1305 * We can skip recursing into aggregates of higher levels altogether,
1306 * since they could not possibly contain Vars of concern to us (see
1307 * transformAggregateCall). We do need to look at aggregates of lower
1308 * levels, however.
1309 */
1312 }
1315 {
1318 /* handled GroupingFunc separately, no need to recheck at this level */
1322 }
1324 /*
1325 * If we have any GROUP BY items that are not simple Vars, check to see if
1326 * subexpression as a whole matches any GROUP BY item. We need to do this
1327 * at every recursion level so that we recognize GROUPed-BY expressions
1328 * before reaching variables within them. But this only works at the outer
1329 * query level, as noted above.
1330 */
1332 {
1334 {
1339 }
1340 }
1342 /*
1343 * If we have an ungrouped Var of the original query level, we have a
1344 * failure. Vars below the original query level are not a problem, and
1345 * neither are Vars from above it. (If such Vars are ungrouped as far as
1346 * their own query level is concerned, that's someone else's problem...)
1347 */
1349 {
1357 /*
1358 * Check for a match, if we didn't do it above.
1359 */
1361 {
1363 {
1371 }
1372 }
1374 /*
1375 * Check whether the Var is known functionally dependent on the GROUP
1376 * BY columns. If so, we can allow the Var to be used, because the
1377 * grouping is really a no-op for this table. However, this deduction
1378 * depends on one or more constraints of the table, so we have to add
1379 * those constraints to the query's constraintDeps list, because it's
1380 * not semantically valid anymore if the constraint(s) get dropped.
1381 * (Therefore, this check must be the last-ditch effort before raising
1382 * error: we don't want to add dependencies unnecessarily.)
1383 *
1384 * Because this is a pretty expensive check, and will have the same
1385 * outcome for all columns of a table, we remember which RTEs we've
1386 * already proven functional dependency for in the func_grouped_rels
1387 * list. This test also prevents us from adding duplicate entries to
1388 * the constraintDeps list.
1389 */
1397 {
1403 {
1407 }
1408 }
1410 /* Found an ungrouped local variable; generate error message */
1415 errmsg("column \"%s.%s\" must appear in the GROUP BY clause or be used in an aggregate function",
1420 else
1426 }
1429 {
1430 /* Recurse into subselects */
1435 check_ungrouped_columns_walker,
1440 }
1443 }
1445 /*
1446 * finalize_grouping_exprs -
1447 * Scan the given expression tree for GROUPING() and related calls,
1448 * and validate and process their arguments.
1449 *
1450 * This is split out from check_ungrouped_columns above because it needs
1451 * to modify the nodes (which it does in-place, not via a mutator) while
1452 * check_ungrouped_columns may see only a copy of the original thanks to
1453 * flattening of join alias vars. So here, we flatten each individual
1454 * GROUPING argument as we see it before comparing it.
1455 */
1456 static void
1460 {
1461 check_ungrouped_columns_context context;
1473 }
1475 static bool
1478 {
1488 {
1492 {
1493 /*
1494 * If we find an aggregate call of the original level, do not
1495 * recurse into its normal arguments, ORDER BY arguments, or
1496 * filter; GROUPING exprs of this level are not allowed there. But
1497 * check direct arguments as though they weren't in an aggregate.
1498 */
1504 context);
1507 }
1509 /*
1510 * We can skip recursing into aggregates of higher levels altogether,
1511 * since they could not possibly contain exprs of concern to us (see
1512 * transformAggregateCall). We do need to look at aggregates of lower
1513 * levels, however.
1514 */
1517 }
1520 {
1523 /*
1524 * We only need to check GroupingFunc nodes at the exact level to
1525 * which they belong, since they cannot mix levels in arguments.
1526 */
1529 {
1534 {
1541 /*
1542 * Each expression must match a grouping entry at the current
1543 * query level. Unlike the general expression case, we don't
1544 * allow functional dependencies or outer references.
1545 */
1548 {
1552 {
1554 {
1562 {
1565 }
1566 }
1567 }
1568 }
1571 {
1573 {
1577 {
1580 }
1581 }
1582 }
1592 }
1595 }
1599 }
1602 {
1603 /* Recurse into subselects */
1608 finalize_grouping_exprs_walker,
1613 }
1616 }
1619 /*
1620 * Given a GroupingSet node, expand it and return a list of lists.
1621 *
1622 * For EMPTY nodes, return a list of one empty list.
1623 *
1624 * For SIMPLE nodes, return a list of one list, which is the node content.
1625 *
1626 * For CUBE and ROLLUP nodes, return a list of the expansions.
1627 *
1628 * For SET nodes, recursively expand contained CUBE and ROLLUP.
1629 */
1632 {
1636 {
1646 {
1652 {
1657 {
1665 /* If we are done with making the current group, break */
1668 }
1672 }
1675 }
1679 {
1682 uint32 num_sets;
1683 uint32 i;
1685 /* parser should cap this much lower */
1691 {
1697 {
1707 }
1710 }
1711 }
1715 {
1719 {
1723 }
1724 }
1726 }
1729 }
1731 /* list_sort comparator to sort sub-lists by length */
1732 static int
1734 {
1739 }
1741 /* list_sort comparator to sort sub-lists by length and contents */
1742 static int
1744 {
1748 {
1755 {
1763 }
1764 }
1767 }
1769 /*
1770 * Expand a groupingSets clause to a flat list of grouping sets.
1771 * The returned list is sorted by length, shortest sets first.
1772 *
1773 * This is mainly for the planner, but we use it here too to do
1774 * some consistency checks.
1775 */
1776 List *
1778 {
1788 {
1802 }
1804 /*
1805 * Do cartesian product between sublists of expanded_groups. While at it,
1806 * remove any duplicate elements from individual grouping sets (we must
1807 * NOT change the number of sets though)
1808 */
1811 {
1813 }
1816 {
1822 {
1827 {
1830 }
1831 }
1833 }
1835 /* Now sort the lists by length and deduplicate if necessary */
1838 else
1839 {
1843 /* Sort each groupset individually */
1847 /* Now sort the list of groupsets by length and contents */
1850 /* Finally, remove duplicates */
1853 {
1856 else
1858 }
1859 }
1862 }
1864 /*
1865 * get_aggregate_argtypes
1866 * Identify the specific datatypes passed to an aggregate call.
1867 *
1868 * Given an Aggref, extract the actual datatypes of the input arguments.
1869 * The input datatypes are reported in a way that matches up with the
1870 * aggregate's declaration, ie, any ORDER BY columns attached to a plain
1871 * aggregate are ignored, but we report both direct and aggregated args of
1872 * an ordered-set aggregate.
1873 *
1874 * Datatypes are returned into inputTypes[], which must reference an array
1875 * of length FUNC_MAX_ARGS.
1876 *
1877 * The function result is the number of actual arguments.
1878 */
1879 int
1881 {
1888 {
1890 }
1893 }
1895 /*
1896 * resolve_aggregate_transtype
1897 * Identify the transition state value's datatype for an aggregate call.
1898 *
1899 * This function resolves a polymorphic aggregate's state datatype.
1900 * It must be passed the aggtranstype from the aggregate's catalog entry,
1901 * as well as the actual argument types extracted by get_aggregate_argtypes.
1902 * (We could fetch pg_aggregate.aggtranstype internally, but all existing
1903 * callers already have the value at hand, so we make them pass it.)
1904 */
1905 Oid
1907 Oid aggtranstype,
1910 {
1911 /* resolve actual type of transition state, if polymorphic */
1913 {
1914 /* have to fetch the agg's declared input types... */
1920 /*
1921 * VARIADIC ANY aggs could have more actual than declared args, but
1922 * such extra args can't affect polymorphic type resolution.
1923 */
1927 declaredArgTypes,
1928 agg_nargs,
1929 aggtranstype,
1932 }
1934 }
1936 /*
1937 * Create an expression tree for the transition function of an aggregate.
1938 * This is needed so that polymorphic functions can be used within an
1939 * aggregate --- without the expression tree, such functions would not know
1940 * the datatypes they are supposed to use. (The trees will never actually
1941 * be executed, however, so we can skimp a bit on correctness.)
1942 *
1943 * agg_input_types and agg_state_type identifies the input types of the
1944 * aggregate. These should be resolved to actual types (ie, none should
1945 * ever be ANYELEMENT etc).
1946 * agg_input_collation is the aggregate function's input collation.
1947 *
1948 * For an ordered-set aggregate, remember that agg_input_types describes
1949 * the direct arguments followed by the aggregated arguments.
1950 *
1951 * transfn_oid and invtransfn_oid identify the funcs to be called; the
1952 * latter may be InvalidOid, however if invtransfn_oid is set then
1953 * transfn_oid must also be set.
1954 *
1955 * transfn_oid may also be passed as the aggcombinefn when the *transfnexpr is
1956 * to be used for a combine aggregate phase. We expect invtransfn_oid to be
1957 * InvalidOid in this case since there is no such thing as an inverse
1958 * combinefn.
1959 *
1960 * Pointers to the constructed trees are returned into *transfnexpr,
1961 * *invtransfnexpr. If there is no invtransfn, the respective pointer is set
1962 * to NULL. Since use of the invtransfn is optional, NULL may be passed for
1963 * invtransfnexpr.
1964 */
1965 void
1970 Oid agg_state_type,
1971 Oid agg_input_collation,
1972 Oid transfn_oid,
1973 Oid invtransfn_oid,
1976 {
1981 /*
1982 * Build arg list to use in the transfn FuncExpr node.
1983 */
1987 {
1990 }
1993 agg_state_type,
1994 args,
1995 InvalidOid,
1996 agg_input_collation,
1997 COERCE_EXPLICIT_CALL);
2001 /*
2002 * Build invtransfn expression if requested, with same args as transfn
2003 */
2005 {
2007 {
2009 agg_state_type,
2010 args,
2011 InvalidOid,
2012 agg_input_collation,
2013 COERCE_EXPLICIT_CALL);
2016 }
2017 else
2019 }
2020 }
2022 /*
2023 * Like build_aggregate_transfn_expr, but creates an expression tree for the
2024 * serialization function of an aggregate.
2025 */
2026 void
2029 {
2033 /* serialfn always takes INTERNAL and returns BYTEA */
2037 BYTEAOID,
2038 args,
2039 InvalidOid,
2040 InvalidOid,
2041 COERCE_EXPLICIT_CALL);
2043 }
2045 /*
2046 * Like build_aggregate_transfn_expr, but creates an expression tree for the
2047 * deserialization function of an aggregate.
2048 */
2049 void
2052 {
2056 /* deserialfn always takes BYTEA, INTERNAL and returns INTERNAL */
2061 INTERNALOID,
2062 args,
2063 InvalidOid,
2064 InvalidOid,
2065 COERCE_EXPLICIT_CALL);
2067 }
2069 /*
2070 * Like build_aggregate_transfn_expr, but creates an expression tree for the
2071 * final function of an aggregate, rather than the transition function.
2072 */
2073 void
2076 Oid agg_state_type,
2077 Oid agg_result_type,
2078 Oid agg_input_collation,
2079 Oid finalfn_oid,
2081 {
2085 /*
2086 * Build expr tree for final function
2087 */
2090 /* finalfn may take additional args, which match agg's input types */
2092 {
2095 }
2098 agg_result_type,
2099 args,
2100 InvalidOid,
2101 agg_input_collation,
2102 COERCE_EXPLICIT_CALL);
2103 /* finalfn is currently never treated as variadic */
2104 }
2106 /*
2107 * Convenience function to build dummy argument expressions for aggregates.
2108 *
2109 * We really only care that an aggregate support function can discover its
2110 * actual argument types at runtime using get_fn_expr_argtype(), so it's okay
2111 * to use Param nodes that don't correspond to any real Param.
2112 */
2115 {
2125 }