Debian Codegraph @

src/backend/parser/parse_agg.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * parse_agg.c
4 * handle aggregates and window functions in parser
5 *
6 * Portions Copyright (c) 1996-2025, 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 */
15 #include "postgres.h"
16
17 #include "access/htup_details.h"
18 #include "catalog/pg_aggregate.h"
19 #include "catalog/pg_constraint.h"
20 #include "catalog/pg_type.h"
21 #include "common/int.h"
22 #include "nodes/makefuncs.h"
23 #include "nodes/nodeFuncs.h"
24 #include "optimizer/optimizer.h"
25 #include "parser/parse_agg.h"
26 #include "parser/parse_clause.h"
27 #include "parser/parse_coerce.h"
28 #include "parser/parse_expr.h"
29 #include "parser/parse_relation.h"
30 #include "parser/parsetree.h"
31 #include "rewrite/rewriteManip.h"
32 #include "utils/builtins.h"
33 #include "utils/lsyscache.h"
34 #include "utils/syscache.h"
35
36 typedef struct
37 {
38 ParseState *pstate;
39 int min_varlevel;
40 int min_agglevel;
41 int min_ctelevel;
42 RangeTblEntry *min_cte;
43 int sublevels_up;
44 } check_agg_arguments_context;
45
46 typedef struct
47 {
48 ParseState *pstate;
49 Query *qry;
50 bool hasJoinRTEs;
51 List *groupClauses;
52 List *groupClauseCommonVars;
53 List *gset_common;
54 bool have_non_var_grouping;
55 List **func_grouped_rels;
56 int sublevels_up;
57 bool in_agg_direct_args;
58 } substitute_grouped_columns_context;
59
60 static int check_agg_arguments(ParseState *pstate,
61 List *directargs,
62 List *args,
63 Expr *filter,
64 int agglocation);
65 static bool check_agg_arguments_walker(Node *node,
66 check_agg_arguments_context *context);
67 static Node *substitute_grouped_columns(Node *node, ParseState *pstate, Query *qry,
68 List *groupClauses, List *groupClauseCommonVars,
69 List *gset_common,
70 bool have_non_var_grouping,
71 List **func_grouped_rels);
72 static Node *substitute_grouped_columns_mutator(Node *node,
73 substitute_grouped_columns_context *context);
74 static void finalize_grouping_exprs(Node *node, ParseState *pstate, Query *qry,
75 List *groupClauses, bool hasJoinRTEs,
76 bool have_non_var_grouping);
77 static bool finalize_grouping_exprs_walker(Node *node,
78 substitute_grouped_columns_context *context);
79 static Var *buildGroupedVar(int attnum, Index ressortgroupref,
80 substitute_grouped_columns_context *context);
81 static void check_agglevels_and_constraints(ParseState *pstate, Node *expr);
82 static List *expand_groupingset_node(GroupingSet *gs);
83 static Node *make_agg_arg(Oid argtype, Oid argcollation);
84
85
86 /*
87 * transformAggregateCall -
88 * Finish initial transformation of an aggregate call
89 *
90 * parse_func.c has recognized the function as an aggregate, and has set up
91 * all the fields of the Aggref except aggargtypes, aggdirectargs, args,
92 * aggorder, aggdistinct and agglevelsup. The passed-in args list has been
93 * through standard expression transformation and type coercion to match the
94 * agg's declared arg types, while the passed-in aggorder list hasn't been
95 * transformed at all.
96 *
97 * Here we separate the args list into direct and aggregated args, storing the
98 * former in agg->aggdirectargs and the latter in agg->args. The regular
99 * args, but not the direct args, are converted into a targetlist by inserting
100 * TargetEntry nodes. We then transform the aggorder and agg_distinct
101 * specifications to produce lists of SortGroupClause nodes for agg->aggorder
102 * and agg->aggdistinct. (For a regular aggregate, this might result in
103 * adding resjunk expressions to the targetlist; but for ordered-set
104 * aggregates the aggorder list will always be one-to-one with the aggregated
105 * args.)
106 *
107 * We must also determine which query level the aggregate actually belongs to,
108 * set agglevelsup accordingly, and mark p_hasAggs true in the corresponding
109 * pstate level.
110 */
111 void
112 transformAggregateCall(ParseState *pstate, Aggref *agg,
113 List *args, List *aggorder, bool agg_distinct)
114 {
115 List *argtypes = NIL;
116 List *tlist = NIL;
117 List *torder = NIL;
118 List *tdistinct = NIL;
119 AttrNumber attno = 1;
120 int save_next_resno;
121 ListCell *lc;
122
123 if (AGGKIND_IS_ORDERED_SET(agg->aggkind))
124 {
125 /*
126 * For an ordered-set agg, the args list includes direct args and
127 * aggregated args; we must split them apart.
128 */
129 int numDirectArgs = list_length(args) - list_length(aggorder);
130 List *aargs;
131 ListCell *lc2;
132
133 Assert(numDirectArgs >= 0);
134
135 aargs = list_copy_tail(args, numDirectArgs);
136 agg->aggdirectargs = list_truncate(args, numDirectArgs);
137
138 /*
139 * Build a tlist from the aggregated args, and make a sortlist entry
140 * for each one. Note that the expressions in the SortBy nodes are
141 * ignored (they are the raw versions of the transformed args); we are
142 * just looking at the sort information in the SortBy nodes.
143 */
144 forboth(lc, aargs, lc2, aggorder)
145 {
146 Expr *arg = (Expr *) lfirst(lc);
147 SortBy *sortby = (SortBy *) lfirst(lc2);
148 TargetEntry *tle;
149
150 /* We don't bother to assign column names to the entries */
151 tle = makeTargetEntry(arg, attno++, NULL, false);
152 tlist = lappend(tlist, tle);
153
154 torder = addTargetToSortList(pstate, tle,
155 torder, tlist, sortby);
156 }
157
158 /* Never any DISTINCT in an ordered-set agg */
159 Assert(!agg_distinct);
160 }
161 else
162 {
163 /* Regular aggregate, so it has no direct args */
164 agg->aggdirectargs = NIL;
165
166 /*
167 * Transform the plain list of Exprs into a targetlist.
168 */
169 foreach(lc, args)
170 {
171 Expr *arg = (Expr *) lfirst(lc);
172 TargetEntry *tle;
173
174 /* We don't bother to assign column names to the entries */
175 tle = makeTargetEntry(arg, attno++, NULL, false);
176 tlist = lappend(tlist, tle);
177 }
178
179 /*
180 * If we have an ORDER BY, transform it. This will add columns to the
181 * tlist if they appear in ORDER BY but weren't already in the arg
182 * list. They will be marked resjunk = true so we can tell them apart
183 * from regular aggregate arguments later.
184 *
185 * We need to mess with p_next_resno since it will be used to number
186 * any new targetlist entries.
187 */
188 save_next_resno = pstate->p_next_resno;
189 pstate->p_next_resno = attno;
190
191 torder = transformSortClause(pstate,
192 aggorder,
193 &tlist,
194 EXPR_KIND_ORDER_BY,
195 true /* force SQL99 rules */ );
196
197 /*
198 * If we have DISTINCT, transform that to produce a distinctList.
199 */
200 if (agg_distinct)
201 {
202 tdistinct = transformDistinctClause(pstate, &tlist, torder, true);
203
204 /*
205 * Remove this check if executor support for hashed distinct for
206 * aggregates is ever added.
207 */
208 foreach(lc, tdistinct)
209 {
210 SortGroupClause *sortcl = (SortGroupClause *) lfirst(lc);
211
212 if (!OidIsValid(sortcl->sortop))
213 {
214 Node *expr = get_sortgroupclause_expr(sortcl, tlist);
215
216 ereport(ERROR,
217 (errcode(ERRCODE_UNDEFINED_FUNCTION),
218 errmsg("could not identify an ordering operator for type %s",
219 format_type_be(exprType(expr))),
220 errdetail("Aggregates with DISTINCT must be able to sort their inputs."),
221 parser_errposition(pstate, exprLocation(expr))));
222 }
223 }
224 }
225
226 pstate->p_next_resno = save_next_resno;
227 }
228
229 /* Update the Aggref with the transformation results */
230 agg->args = tlist;
231 agg->aggorder = torder;
232 agg->aggdistinct = tdistinct;
233
234 /*
235 * Now build the aggargtypes list with the type OIDs of the direct and
236 * aggregated args, ignoring any resjunk entries that might have been
237 * added by ORDER BY/DISTINCT processing. We can't do this earlier
238 * because said processing can modify some args' data types, in particular
239 * by resolving previously-unresolved "unknown" literals.
240 */
241 foreach(lc, agg->aggdirectargs)
242 {
243 Expr *arg = (Expr *) lfirst(lc);
244
245 argtypes = lappend_oid(argtypes, exprType((Node *) arg));
246 }
247 foreach(lc, tlist)
248 {
249 TargetEntry *tle = (TargetEntry *) lfirst(lc);
250
251 if (tle->resjunk)
252 continue; /* ignore junk */
253 argtypes = lappend_oid(argtypes, exprType((Node *) tle->expr));
254 }
255 agg->aggargtypes = argtypes;
256
257 check_agglevels_and_constraints(pstate, (Node *) agg);
258 }
259
260 /*
261 * transformGroupingFunc
262 * Transform a GROUPING expression
263 *
264 * GROUPING() behaves very like an aggregate. Processing of levels and nesting
265 * is done as for aggregates. We set p_hasAggs for these expressions too.
266 */
267 Node *
268 transformGroupingFunc(ParseState *pstate, GroupingFunc *p)
269 {
270 ListCell *lc;
271 List *args = p->args;
272 List *result_list = NIL;
273 GroupingFunc *result = makeNode(GroupingFunc);
274
275 if (list_length(args) > 31)
276 ereport(ERROR,
277 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
278 errmsg("GROUPING must have fewer than 32 arguments"),
279 parser_errposition(pstate, p->location)));
280
281 foreach(lc, args)
282 {
283 Node *current_result;
284
285 current_result = transformExpr(pstate, (Node *) lfirst(lc), pstate->p_expr_kind);
286
287 /* acceptability of expressions is checked later */
288
289 result_list = lappend(result_list, current_result);
290 }
291
292 result->args = result_list;
293 result->location = p->location;
294
295 check_agglevels_and_constraints(pstate, (Node *) result);
296
297 return (Node *) result;
298 }
299
300 /*
301 * Aggregate functions and grouping operations (which are combined in the spec
302 * as <set function specification>) are very similar with regard to level and
303 * nesting restrictions (though we allow a lot more things than the spec does).
304 * Centralise those restrictions here.
305 */
306 static void
307 check_agglevels_and_constraints(ParseState *pstate, Node *expr)
308 {
309 List *directargs = NIL;
310 List *args = NIL;
311 Expr *filter = NULL;
312 int min_varlevel;
313 int location = -1;
314 Index *p_levelsup;
315 const char *err;
316 bool errkind;
317 bool isAgg = IsA(expr, Aggref);
318
319 if (isAgg)
320 {
321 Aggref *agg = (Aggref *) expr;
322
323 directargs = agg->aggdirectargs;
324 args = agg->args;
325 filter = agg->aggfilter;
326 location = agg->location;
327 p_levelsup = &agg->agglevelsup;
328 }
329 else
330 {
331 GroupingFunc *grp = (GroupingFunc *) expr;
332
333 args = grp->args;
334 location = grp->location;
335 p_levelsup = &grp->agglevelsup;
336 }
337
338 /*
339 * Check the arguments to compute the aggregate's level and detect
340 * improper nesting.
341 */
342 min_varlevel = check_agg_arguments(pstate,
343 directargs,
344 args,
345 filter,
346 location);
347
348 *p_levelsup = min_varlevel;
349
350 /* Mark the correct pstate level as having aggregates */
351 while (min_varlevel-- > 0)
352 pstate = pstate->parentParseState;
353 pstate->p_hasAggs = true;
354
355 /*
356 * Check to see if the aggregate function is in an invalid place within
357 * its aggregation query.
358 *
359 * For brevity we support two schemes for reporting an error here: set
360 * "err" to a custom message, or set "errkind" true if the error context
361 * is sufficiently identified by what ParseExprKindName will return, *and*
362 * what it will return is just a SQL keyword. (Otherwise, use a custom
363 * message to avoid creating translation problems.)
364 */
365 err = NULL;
366 errkind = false;
367 switch (pstate->p_expr_kind)
368 {
369 case EXPR_KIND_NONE:
370 Assert(false); /* can't happen */
371 break;
372 case EXPR_KIND_OTHER:
373
374 /*
375 * Accept aggregate/grouping here; caller must throw error if
376 * wanted
377 */
378 break;
379 case EXPR_KIND_JOIN_ON:
380 case EXPR_KIND_JOIN_USING:
381 if (isAgg)
382 err = _("aggregate functions are not allowed in JOIN conditions");
383 else
384 err = _("grouping operations are not allowed in JOIN conditions");
385
386 break;
387 case EXPR_KIND_FROM_SUBSELECT:
388
389 /*
390 * Aggregate/grouping scope rules make it worth being explicit
391 * here
392 */
393 if (isAgg)
394 err = _("aggregate functions are not allowed in FROM clause of their own query level");
395 else
396 err = _("grouping operations are not allowed in FROM clause of their own query level");
397
398 break;
399 case EXPR_KIND_FROM_FUNCTION:
400 if (isAgg)
401 err = _("aggregate functions are not allowed in functions in FROM");
402 else
403 err = _("grouping operations are not allowed in functions in FROM");
404
405 break;
406 case EXPR_KIND_WHERE:
407 errkind = true;
408 break;
409 case EXPR_KIND_POLICY:
410 if (isAgg)
411 err = _("aggregate functions are not allowed in policy expressions");
412 else
413 err = _("grouping operations are not allowed in policy expressions");
414
415 break;
416 case EXPR_KIND_HAVING:
417 /* okay */
418 break;
419 case EXPR_KIND_FILTER:
420 errkind = true;
421 break;
422 case EXPR_KIND_WINDOW_PARTITION:
423 /* okay */
424 break;
425 case EXPR_KIND_WINDOW_ORDER:
426 /* okay */
427 break;
428 case EXPR_KIND_WINDOW_FRAME_RANGE:
429 if (isAgg)
430 err = _("aggregate functions are not allowed in window RANGE");
431 else
432 err = _("grouping operations are not allowed in window RANGE");
433
434 break;
435 case EXPR_KIND_WINDOW_FRAME_ROWS:
436 if (isAgg)
437 err = _("aggregate functions are not allowed in window ROWS");
438 else
439 err = _("grouping operations are not allowed in window ROWS");
440
441 break;
442 case EXPR_KIND_WINDOW_FRAME_GROUPS:
443 if (isAgg)
444 err = _("aggregate functions are not allowed in window GROUPS");
445 else
446 err = _("grouping operations are not allowed in window GROUPS");
447
448 break;
449 case EXPR_KIND_SELECT_TARGET:
450 /* okay */
451 break;
452 case EXPR_KIND_INSERT_TARGET:
453 case EXPR_KIND_UPDATE_SOURCE:
454 case EXPR_KIND_UPDATE_TARGET:
455 errkind = true;
456 break;
457 case EXPR_KIND_MERGE_WHEN:
458 if (isAgg)
459 err = _("aggregate functions are not allowed in MERGE WHEN conditions");
460 else
461 err = _("grouping operations are not allowed in MERGE WHEN conditions");
462
463 break;
464 case EXPR_KIND_GROUP_BY:
465 errkind = true;
466 break;
467 case EXPR_KIND_ORDER_BY:
468 /* okay */
469 break;
470 case EXPR_KIND_DISTINCT_ON:
471 /* okay */
472 break;
473 case EXPR_KIND_LIMIT:
474 case EXPR_KIND_OFFSET:
475 errkind = true;
476 break;
477 case EXPR_KIND_RETURNING:
478 case EXPR_KIND_MERGE_RETURNING:
479 errkind = true;
480 break;
481 case EXPR_KIND_VALUES:
482 case EXPR_KIND_VALUES_SINGLE:
483 errkind = true;
484 break;
485 case EXPR_KIND_CHECK_CONSTRAINT:
486 case EXPR_KIND_DOMAIN_CHECK:
487 if (isAgg)
488 err = _("aggregate functions are not allowed in check constraints");
489 else
490 err = _("grouping operations are not allowed in check constraints");
491
492 break;
493 case EXPR_KIND_COLUMN_DEFAULT:
494 case EXPR_KIND_FUNCTION_DEFAULT:
495
496 if (isAgg)
497 err = _("aggregate functions are not allowed in DEFAULT expressions");
498 else
499 err = _("grouping operations are not allowed in DEFAULT expressions");
500
501 break;
502 case EXPR_KIND_INDEX_EXPRESSION:
503 if (isAgg)
504 err = _("aggregate functions are not allowed in index expressions");
505 else
506 err = _("grouping operations are not allowed in index expressions");
507
508 break;
509 case EXPR_KIND_INDEX_PREDICATE:
510 if (isAgg)
511 err = _("aggregate functions are not allowed in index predicates");
512 else
513 err = _("grouping operations are not allowed in index predicates");
514
515 break;
516 case EXPR_KIND_STATS_EXPRESSION:
517 if (isAgg)
518 err = _("aggregate functions are not allowed in statistics expressions");
519 else
520 err = _("grouping operations are not allowed in statistics expressions");
521
522 break;
523 case EXPR_KIND_ALTER_COL_TRANSFORM:
524 if (isAgg)
525 err = _("aggregate functions are not allowed in transform expressions");
526 else
527 err = _("grouping operations are not allowed in transform expressions");
528
529 break;
530 case EXPR_KIND_EXECUTE_PARAMETER:
531 if (isAgg)
532 err = _("aggregate functions are not allowed in EXECUTE parameters");
533 else
534 err = _("grouping operations are not allowed in EXECUTE parameters");
535
536 break;
537 case EXPR_KIND_TRIGGER_WHEN:
538 if (isAgg)
539 err = _("aggregate functions are not allowed in trigger WHEN conditions");
540 else
541 err = _("grouping operations are not allowed in trigger WHEN conditions");
542
543 break;
544 case EXPR_KIND_PARTITION_BOUND:
545 if (isAgg)
546 err = _("aggregate functions are not allowed in partition bound");
547 else
548 err = _("grouping operations are not allowed in partition bound");
549
550 break;
551 case EXPR_KIND_PARTITION_EXPRESSION:
552 if (isAgg)
553 err = _("aggregate functions are not allowed in partition key expressions");
554 else
555 err = _("grouping operations are not allowed in partition key expressions");
556
557 break;
558 case EXPR_KIND_GENERATED_COLUMN:
559
560 if (isAgg)
561 err = _("aggregate functions are not allowed in column generation expressions");
562 else
563 err = _("grouping operations are not allowed in column generation expressions");
564
565 break;
566
567 case EXPR_KIND_CALL_ARGUMENT:
568 if (isAgg)
569 err = _("aggregate functions are not allowed in CALL arguments");
570 else
571 err = _("grouping operations are not allowed in CALL arguments");
572
573 break;
574
575 case EXPR_KIND_COPY_WHERE:
576 if (isAgg)
577 err = _("aggregate functions are not allowed in COPY FROM WHERE conditions");
578 else
579 err = _("grouping operations are not allowed in COPY FROM WHERE conditions");
580
581 break;
582
583 case EXPR_KIND_CYCLE_MARK:
584 errkind = true;
585 break;
586
587 /*
588 * There is intentionally no default: case here, so that the
589 * compiler will warn if we add a new ParseExprKind without
590 * extending this switch. If we do see an unrecognized value at
591 * runtime, the behavior will be the same as for EXPR_KIND_OTHER,
592 * which is sane anyway.
593 */
594 }
595
596 if (err)
597 ereport(ERROR,
598 (errcode(ERRCODE_GROUPING_ERROR),
599 errmsg_internal("%s", err),
600 parser_errposition(pstate, location)));
601
602 if (errkind)
603 {
604 if (isAgg)
605 /* translator: %s is name of a SQL construct, eg GROUP BY */
606 err = _("aggregate functions are not allowed in %s");
607 else
608 /* translator: %s is name of a SQL construct, eg GROUP BY */
609 err = _("grouping operations are not allowed in %s");
610
611 ereport(ERROR,
612 (errcode(ERRCODE_GROUPING_ERROR),
613 errmsg_internal(err,
614 ParseExprKindName(pstate->p_expr_kind)),
615 parser_errposition(pstate, location)));
616 }
617 }
618
619 /*
620 * check_agg_arguments
621 * Scan the arguments of an aggregate function to determine the
622 * aggregate's semantic level (zero is the current select's level,
623 * one is its parent, etc).
624 *
625 * The aggregate's level is the same as the level of the lowest-level variable
626 * or aggregate in its aggregated arguments (including any ORDER BY columns)
627 * or filter expression; or if it contains no variables at all, we presume it
628 * to be local.
629 *
630 * Vars/Aggs in direct arguments are *not* counted towards determining the
631 * agg's level, as those arguments aren't evaluated per-row but only
632 * per-group, and so in some sense aren't really agg arguments. However,
633 * this can mean that we decide an agg is upper-level even when its direct
634 * args contain lower-level Vars/Aggs, and that case has to be disallowed.
635 * (This is a little strange, but the SQL standard seems pretty definite that
636 * direct args are not to be considered when setting the agg's level.)
637 *
638 * We also take this opportunity to detect any aggregates or window functions
639 * nested within the arguments. We can throw error immediately if we find
640 * a window function. Aggregates are a bit trickier because it's only an
641 * error if the inner aggregate is of the same semantic level as the outer,
642 * which we can't know until we finish scanning the arguments.
643 */
644 static int
645 check_agg_arguments(ParseState *pstate,
646 List *directargs,
647 List *args,
648 Expr *filter,
649 int agglocation)
650 {
651 int agglevel;
652 check_agg_arguments_context context;
653
654 context.pstate = pstate;
655 context.min_varlevel = -1; /* signifies nothing found yet */
656 context.min_agglevel = -1;
657 context.min_ctelevel = -1;
658 context.min_cte = NULL;
659 context.sublevels_up = 0;
660
661 (void) check_agg_arguments_walker((Node *) args, &context);
662 (void) check_agg_arguments_walker((Node *) filter, &context);
663
664 /*
665 * If we found no vars nor aggs at all, it's a level-zero aggregate;
666 * otherwise, its level is the minimum of vars or aggs.
667 */
668 if (context.min_varlevel < 0)
669 {
670 if (context.min_agglevel < 0)
671 agglevel = 0;
672 else
673 agglevel = context.min_agglevel;
674 }
675 else if (context.min_agglevel < 0)
676 agglevel = context.min_varlevel;
677 else
678 agglevel = Min(context.min_varlevel, context.min_agglevel);
679
680 /*
681 * If there's a nested aggregate of the same semantic level, complain.
682 */
683 if (agglevel == context.min_agglevel)
684 {
685 int aggloc;
686
687 aggloc = locate_agg_of_level((Node *) args, agglevel);
688 if (aggloc < 0)
689 aggloc = locate_agg_of_level((Node *) filter, agglevel);
690 ereport(ERROR,
691 (errcode(ERRCODE_GROUPING_ERROR),
692 errmsg("aggregate function calls cannot be nested"),
693 parser_errposition(pstate, aggloc)));
694 }
695
696 /*
697 * If there's a non-local CTE that's below the aggregate's semantic level,
698 * complain. It's not quite clear what we should do to fix up such a case
699 * (treating the CTE reference like a Var seems wrong), and it's also
700 * unclear whether there is a real-world use for such cases.
701 */
702 if (context.min_ctelevel >= 0 && context.min_ctelevel < agglevel)
703 ereport(ERROR,
704 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
705 errmsg("outer-level aggregate cannot use a nested CTE"),
706 errdetail("CTE \"%s\" is below the aggregate's semantic level.",
707 context.min_cte->eref->aliasname),
708 parser_errposition(pstate, agglocation)));
709
710 /*
711 * Now check for vars/aggs in the direct arguments, and throw error if
712 * needed. Note that we allow a Var of the agg's semantic level, but not
713 * an Agg of that level. In principle such Aggs could probably be
714 * supported, but it would create an ordering dependency among the
715 * aggregates at execution time. Since the case appears neither to be
716 * required by spec nor particularly useful, we just treat it as a
717 * nested-aggregate situation.
718 */
719 if (directargs)
720 {
721 context.min_varlevel = -1;
722 context.min_agglevel = -1;
723 context.min_ctelevel = -1;
724 (void) check_agg_arguments_walker((Node *) directargs, &context);
725 if (context.min_varlevel >= 0 && context.min_varlevel < agglevel)
726 ereport(ERROR,
727 (errcode(ERRCODE_GROUPING_ERROR),
728 errmsg("outer-level aggregate cannot contain a lower-level variable in its direct arguments"),
729 parser_errposition(pstate,
730 locate_var_of_level((Node *) directargs,
731 context.min_varlevel))));
732 if (context.min_agglevel >= 0 && context.min_agglevel <= agglevel)
733 ereport(ERROR,
734 (errcode(ERRCODE_GROUPING_ERROR),
735 errmsg("aggregate function calls cannot be nested"),
736 parser_errposition(pstate,
737 locate_agg_of_level((Node *) directargs,
738 context.min_agglevel))));
739 if (context.min_ctelevel >= 0 && context.min_ctelevel < agglevel)
740 ereport(ERROR,
741 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
742 errmsg("outer-level aggregate cannot use a nested CTE"),
743 errdetail("CTE \"%s\" is below the aggregate's semantic level.",
744 context.min_cte->eref->aliasname),
745 parser_errposition(pstate, agglocation)));
746 }
747 return agglevel;
748 }
749
750 static bool
751 check_agg_arguments_walker(Node *node,
752 check_agg_arguments_context *context)
753 {
754 if (node == NULL)
755 return false;
756 if (IsA(node, Var))
757 {
758 int varlevelsup = ((Var *) node)->varlevelsup;
759
760 /* convert levelsup to frame of reference of original query */
761 varlevelsup -= context->sublevels_up;
762 /* ignore local vars of subqueries */
763 if (varlevelsup >= 0)
764 {
765 if (context->min_varlevel < 0 ||
766 context->min_varlevel > varlevelsup)
767 context->min_varlevel = varlevelsup;
768 }
769 return false;
770 }
771 if (IsA(node, Aggref))
772 {
773 int agglevelsup = ((Aggref *) node)->agglevelsup;
774
775 /* convert levelsup to frame of reference of original query */
776 agglevelsup -= context->sublevels_up;
777 /* ignore local aggs of subqueries */
778 if (agglevelsup >= 0)
779 {
780 if (context->min_agglevel < 0 ||
781 context->min_agglevel > agglevelsup)
782 context->min_agglevel = agglevelsup;
783 }
784 /* Continue and descend into subtree */
785 }
786 if (IsA(node, GroupingFunc))
787 {
788 int agglevelsup = ((GroupingFunc *) node)->agglevelsup;
789
790 /* convert levelsup to frame of reference of original query */
791 agglevelsup -= context->sublevels_up;
792 /* ignore local aggs of subqueries */
793 if (agglevelsup >= 0)
794 {
795 if (context->min_agglevel < 0 ||
796 context->min_agglevel > agglevelsup)
797 context->min_agglevel = agglevelsup;
798 }
799 /* Continue and descend into subtree */
800 }
801
802 /*
803 * SRFs and window functions can be rejected immediately, unless we are
804 * within a sub-select within the aggregate's arguments; in that case
805 * they're OK.
806 */
807 if (context->sublevels_up == 0)
808 {
809 if ((IsA(node, FuncExpr) && ((FuncExpr *) node)->funcretset) ||
810 (IsA(node, OpExpr) && ((OpExpr *) node)->opretset))
811 ereport(ERROR,
812 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
813 errmsg("aggregate function calls cannot contain set-returning function calls"),
814 errhint("You might be able to move the set-returning function into a LATERAL FROM item."),
815 parser_errposition(context->pstate, exprLocation(node))));
816 if (IsA(node, WindowFunc))
817 ereport(ERROR,
818 (errcode(ERRCODE_GROUPING_ERROR),
819 errmsg("aggregate function calls cannot contain window function calls"),
820 parser_errposition(context->pstate,
821 ((WindowFunc *) node)->location)));
822 }
823
824 if (IsA(node, RangeTblEntry))
825 {
826 RangeTblEntry *rte = (RangeTblEntry *) node;
827
828 if (rte->rtekind == RTE_CTE)
829 {
830 int ctelevelsup = rte->ctelevelsup;
831
832 /* convert levelsup to frame of reference of original query */
833 ctelevelsup -= context->sublevels_up;
834 /* ignore local CTEs of subqueries */
835 if (ctelevelsup >= 0)
836 {
837 if (context->min_ctelevel < 0 ||
838 context->min_ctelevel > ctelevelsup)
839 {
840 context->min_ctelevel = ctelevelsup;
841 context->min_cte = rte;
842 }
843 }
844 }
845 return false; /* allow range_table_walker to continue */
846 }
847 if (IsA(node, Query))
848 {
849 /* Recurse into subselects */
850 bool result;
851
852 context->sublevels_up++;
853 result = query_tree_walker((Query *) node,
854 check_agg_arguments_walker,
855 context,
856 QTW_EXAMINE_RTES_BEFORE);
857 context->sublevels_up--;
858 return result;
859 }
860
861 return expression_tree_walker(node,
862 check_agg_arguments_walker,
863 context);
864 }
865
866 /*
867 * transformWindowFuncCall -
868 * Finish initial transformation of a window function call
869 *
870 * parse_func.c has recognized the function as a window function, and has set
871 * up all the fields of the WindowFunc except winref. Here we must (1) add
872 * the WindowDef to the pstate (if not a duplicate of one already present) and
873 * set winref to link to it; and (2) mark p_hasWindowFuncs true in the pstate.
874 * Unlike aggregates, only the most closely nested pstate level need be
875 * considered --- there are no "outer window functions" per SQL spec.
876 */
877 void
878 transformWindowFuncCall(ParseState *pstate, WindowFunc *wfunc,
879 WindowDef *windef)
880 {
881 const char *err;
882 bool errkind;
883
884 /*
885 * A window function call can't contain another one (but aggs are OK). XXX
886 * is this required by spec, or just an unimplemented feature?
887 *
888 * Note: we don't need to check the filter expression here, because the
889 * context checks done below and in transformAggregateCall would have
890 * already rejected any window funcs or aggs within the filter.
891 */
892 if (pstate->p_hasWindowFuncs &&
893 contain_windowfuncs((Node *) wfunc->args))
894 ereport(ERROR,
895 (errcode(ERRCODE_WINDOWING_ERROR),
896 errmsg("window function calls cannot be nested"),
897 parser_errposition(pstate,
898 locate_windowfunc((Node *) wfunc->args))));
899
900 /*
901 * Check to see if the window function is in an invalid place within the
902 * query.
903 *
904 * For brevity we support two schemes for reporting an error here: set
905 * "err" to a custom message, or set "errkind" true if the error context
906 * is sufficiently identified by what ParseExprKindName will return, *and*
907 * what it will return is just a SQL keyword. (Otherwise, use a custom
908 * message to avoid creating translation problems.)
909 */
910 err = NULL;
911 errkind = false;
912 switch (pstate->p_expr_kind)
913 {
914 case EXPR_KIND_NONE:
915 Assert(false); /* can't happen */
916 break;
917 case EXPR_KIND_OTHER:
918 /* Accept window func here; caller must throw error if wanted */
919 break;
920 case EXPR_KIND_JOIN_ON:
921 case EXPR_KIND_JOIN_USING:
922 err = _("window functions are not allowed in JOIN conditions");
923 break;
924 case EXPR_KIND_FROM_SUBSELECT:
925 /* can't get here, but just in case, throw an error */
926 errkind = true;
927 break;
928 case EXPR_KIND_FROM_FUNCTION:
929 err = _("window functions are not allowed in functions in FROM");
930 break;
931 case EXPR_KIND_WHERE:
932 errkind = true;
933 break;
934 case EXPR_KIND_POLICY:
935 err = _("window functions are not allowed in policy expressions");
936 break;
937 case EXPR_KIND_HAVING:
938 errkind = true;
939 break;
940 case EXPR_KIND_FILTER:
941 errkind = true;
942 break;
943 case EXPR_KIND_WINDOW_PARTITION:
944 case EXPR_KIND_WINDOW_ORDER:
945 case EXPR_KIND_WINDOW_FRAME_RANGE:
946 case EXPR_KIND_WINDOW_FRAME_ROWS:
947 case EXPR_KIND_WINDOW_FRAME_GROUPS:
948 err = _("window functions are not allowed in window definitions");
949 break;
950 case EXPR_KIND_SELECT_TARGET:
951 /* okay */
952 break;
953 case EXPR_KIND_INSERT_TARGET:
954 case EXPR_KIND_UPDATE_SOURCE:
955 case EXPR_KIND_UPDATE_TARGET:
956 errkind = true;
957 break;
958 case EXPR_KIND_MERGE_WHEN:
959 err = _("window functions are not allowed in MERGE WHEN conditions");
960 break;
961 case EXPR_KIND_GROUP_BY:
962 errkind = true;
963 break;
964 case EXPR_KIND_ORDER_BY:
965 /* okay */
966 break;
967 case EXPR_KIND_DISTINCT_ON:
968 /* okay */
969 break;
970 case EXPR_KIND_LIMIT:
971 case EXPR_KIND_OFFSET:
972 errkind = true;
973 break;
974 case EXPR_KIND_RETURNING:
975 case EXPR_KIND_MERGE_RETURNING:
976 errkind = true;
977 break;
978 case EXPR_KIND_VALUES:
979 case EXPR_KIND_VALUES_SINGLE:
980 errkind = true;
981 break;
982 case EXPR_KIND_CHECK_CONSTRAINT:
983 case EXPR_KIND_DOMAIN_CHECK:
984 err = _("window functions are not allowed in check constraints");
985 break;
986 case EXPR_KIND_COLUMN_DEFAULT:
987 case EXPR_KIND_FUNCTION_DEFAULT:
988 err = _("window functions are not allowed in DEFAULT expressions");
989 break;
990 case EXPR_KIND_INDEX_EXPRESSION:
991 err = _("window functions are not allowed in index expressions");
992 break;
993 case EXPR_KIND_STATS_EXPRESSION:
994 err = _("window functions are not allowed in statistics expressions");
995 break;
996 case EXPR_KIND_INDEX_PREDICATE:
997 err = _("window functions are not allowed in index predicates");
998 break;
999 case EXPR_KIND_ALTER_COL_TRANSFORM:
1000 err = _("window functions are not allowed in transform expressions");
1001 break;
1002 case EXPR_KIND_EXECUTE_PARAMETER:
1003 err = _("window functions are not allowed in EXECUTE parameters");
1004 break;
1005 case EXPR_KIND_TRIGGER_WHEN:
1006 err = _("window functions are not allowed in trigger WHEN conditions");
1007 break;
1008 case EXPR_KIND_PARTITION_BOUND:
1009 err = _("window functions are not allowed in partition bound");
1010 break;
1011 case EXPR_KIND_PARTITION_EXPRESSION:
1012 err = _("window functions are not allowed in partition key expressions");
1013 break;
1014 case EXPR_KIND_CALL_ARGUMENT:
1015 err = _("window functions are not allowed in CALL arguments");
1016 break;
1017 case EXPR_KIND_COPY_WHERE:
1018 err = _("window functions are not allowed in COPY FROM WHERE conditions");
1019 break;
1020 case EXPR_KIND_GENERATED_COLUMN:
1021 err = _("window functions are not allowed in column generation expressions");
1022 break;
1023 case EXPR_KIND_CYCLE_MARK:
1024 errkind = true;
1025 break;
1026
1027 /*
1028 * There is intentionally no default: case here, so that the
1029 * compiler will warn if we add a new ParseExprKind without
1030 * extending this switch. If we do see an unrecognized value at
1031 * runtime, the behavior will be the same as for EXPR_KIND_OTHER,
1032 * which is sane anyway.
1033 */
1034 }
1035 if (err)
1036 ereport(ERROR,
1037 (errcode(ERRCODE_WINDOWING_ERROR),
1038 errmsg_internal("%s", err),
1039 parser_errposition(pstate, wfunc->location)));
1040 if (errkind)
1041 ereport(ERROR,
1042 (errcode(ERRCODE_WINDOWING_ERROR),
1043 /* translator: %s is name of a SQL construct, eg GROUP BY */
1044 errmsg("window functions are not allowed in %s",
1045 ParseExprKindName(pstate->p_expr_kind)),
1046 parser_errposition(pstate, wfunc->location)));
1047
1048 /*
1049 * If the OVER clause just specifies a window name, find that WINDOW
1050 * clause (which had better be present). Otherwise, try to match all the
1051 * properties of the OVER clause, and make a new entry in the p_windowdefs
1052 * list if no luck.
1053 */
1054 if (windef->name)
1055 {
1056 Index winref = 0;
1057 ListCell *lc;
1058
1059 Assert(windef->refname == NULL &&
1060 windef->partitionClause == NIL &&
1061 windef->orderClause == NIL &&
1062 windef->frameOptions == FRAMEOPTION_DEFAULTS);
1063
1064 foreach(lc, pstate->p_windowdefs)
1065 {
1066 WindowDef *refwin = (WindowDef *) lfirst(lc);
1067
1068 winref++;
1069 if (refwin->name && strcmp(refwin->name, windef->name) == 0)
1070 {
1071 wfunc->winref = winref;
1072 break;
1073 }
1074 }
1075 if (lc == NULL) /* didn't find it? */
1076 ereport(ERROR,
1077 (errcode(ERRCODE_UNDEFINED_OBJECT),
1078 errmsg("window \"%s\" does not exist", windef->name),
1079 parser_errposition(pstate, windef->location)));
1080 }
1081 else
1082 {
1083 Index winref = 0;
1084 ListCell *lc;
1085
1086 foreach(lc, pstate->p_windowdefs)
1087 {
1088 WindowDef *refwin = (WindowDef *) lfirst(lc);
1089
1090 winref++;
1091 if (refwin->refname && windef->refname &&
1092 strcmp(refwin->refname, windef->refname) == 0)
1093 /* matched on refname */ ;
1094 else if (!refwin->refname && !windef->refname)
1095 /* matched, no refname */ ;
1096 else
1097 continue;
1098
1099 /*
1100 * Also see similar de-duplication code in optimize_window_clauses
1101 */
1102 if (equal(refwin->partitionClause, windef->partitionClause) &&
1103 equal(refwin->orderClause, windef->orderClause) &&
1104 refwin->frameOptions == windef->frameOptions &&
1105 equal(refwin->startOffset, windef->startOffset) &&
1106 equal(refwin->endOffset, windef->endOffset))
1107 {
1108 /* found a duplicate window specification */
1109 wfunc->winref = winref;
1110 break;
1111 }
1112 }
1113 if (lc == NULL) /* didn't find it? */
1114 {
1115 pstate->p_windowdefs = lappend(pstate->p_windowdefs, windef);
1116 wfunc->winref = list_length(pstate->p_windowdefs);
1117 }
1118 }
1119
1120 pstate->p_hasWindowFuncs = true;
1121 }
1122
1123 /*
1124 * parseCheckAggregates
1125 * Check for aggregates where they shouldn't be and improper grouping, and
1126 * replace grouped variables in the targetlist and HAVING clause with Vars
1127 * that reference the RTE_GROUP RTE.
1128 * This function should be called after the target list and qualifications
1129 * are finalized.
1130 *
1131 * Misplaced aggregates are now mostly detected in transformAggregateCall,
1132 * but it seems more robust to check for aggregates in recursive queries
1133 * only after everything is finalized. In any case it's hard to detect
1134 * improper grouping on-the-fly, so we have to make another pass over the
1135 * query for that.
1136 */
1137 void
1138 parseCheckAggregates(ParseState *pstate, Query *qry)
1139 {
1140 List *gset_common = NIL;
1141 List *groupClauses = NIL;
1142 List *groupClauseCommonVars = NIL;
1143 bool have_non_var_grouping;
1144 List *func_grouped_rels = NIL;
1145 ListCell *l;
1146 bool hasJoinRTEs;
1147 bool hasSelfRefRTEs;
1148 Node *clause;
1149
1150 /* This should only be called if we found aggregates or grouping */
1151 Assert(pstate->p_hasAggs || qry->groupClause || qry->havingQual || qry->groupingSets);
1152
1153 /*
1154 * If we have grouping sets, expand them and find the intersection of all
1155 * sets.
1156 */
1157 if (qry->groupingSets)
1158 {
1159 /*
1160 * The limit of 4096 is arbitrary and exists simply to avoid resource
1161 * issues from pathological constructs.
1162 */
1163 List *gsets = expand_grouping_sets(qry->groupingSets, qry->groupDistinct, 4096);
1164
1165 if (!gsets)
1166 ereport(ERROR,
1167 (errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
1168 errmsg("too many grouping sets present (maximum 4096)"),
1169 parser_errposition(pstate,
1170 qry->groupClause
1171 ? exprLocation((Node *) qry->groupClause)
1172 : exprLocation((Node *) qry->groupingSets))));
1173
1174 /*
1175 * The intersection will often be empty, so help things along by
1176 * seeding the intersect with the smallest set.
1177 */
1178 gset_common = linitial(gsets);
1179
1180 if (gset_common)
1181 {
1182 for_each_from(l, gsets, 1)
1183 {
1184 gset_common = list_intersection_int(gset_common, lfirst(l));
1185 if (!gset_common)
1186 break;
1187 }
1188 }
1189
1190 /*
1191 * If there was only one grouping set in the expansion, AND if the
1192 * groupClause is non-empty (meaning that the grouping set is not
1193 * empty either), then we can ditch the grouping set and pretend we
1194 * just had a normal GROUP BY.
1195 */
1196 if (list_length(gsets) == 1 && qry->groupClause)
1197 qry->groupingSets = NIL;
1198 }
1199
1200 /*
1201 * Scan the range table to see if there are JOIN or self-reference CTE
1202 * entries. We'll need this info below.
1203 */
1204 hasJoinRTEs = hasSelfRefRTEs = false;
1205 foreach(l, pstate->p_rtable)
1206 {
1207 RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
1208
1209 if (rte->rtekind == RTE_JOIN)
1210 hasJoinRTEs = true;
1211 else if (rte->rtekind == RTE_CTE && rte->self_reference)
1212 hasSelfRefRTEs = true;
1213 }
1214
1215 /*
1216 * Build a list of the acceptable GROUP BY expressions to save in the
1217 * RTE_GROUP RTE, and for use by substitute_grouped_columns().
1218 *
1219 * We get the TLE, not just the expr, because GROUPING wants to know the
1220 * sortgroupref.
1221 */
1222 foreach(l, qry->groupClause)
1223 {
1224 SortGroupClause *grpcl = (SortGroupClause *) lfirst(l);
1225 TargetEntry *expr;
1226
1227 expr = get_sortgroupclause_tle(grpcl, qry->targetList);
1228 if (expr == NULL)
1229 continue; /* probably cannot happen */
1230
1231 groupClauses = lappend(groupClauses, expr);
1232 }
1233
1234 /*
1235 * If there are any acceptable GROUP BY expressions, build an RTE and
1236 * nsitem for the result of the grouping step. (It's important to do this
1237 * before flattening join alias vars in groupClauses, because the RTE
1238 * should preserve any alias vars that were in the input.)
1239 */
1240 if (groupClauses)
1241 {
1242 pstate->p_grouping_nsitem =
1243 addRangeTableEntryForGroup(pstate, groupClauses);
1244
1245 /* Set qry->rtable again in case it was previously NIL */
1246 qry->rtable = pstate->p_rtable;
1247 /* Mark the Query as having RTE_GROUP RTE */
1248 qry->hasGroupRTE = true;
1249 }
1250
1251 /*
1252 * If there are join alias vars involved, we have to flatten them to the
1253 * underlying vars, so that aliased and unaliased vars will be correctly
1254 * taken as equal. We can skip the expense of doing this if no rangetable
1255 * entries are RTE_JOIN kind.
1256 */
1257 if (hasJoinRTEs)
1258 groupClauses = (List *) flatten_join_alias_vars(NULL, qry,
1259 (Node *) groupClauses);
1260
1261 /*
1262 * Detect whether any of the grouping expressions aren't simple Vars; if
1263 * they're all Vars then we don't have to work so hard in the recursive
1264 * scans. (Note we have to flatten aliases before this.)
1265 *
1266 * Track Vars that are included in all grouping sets separately in
1267 * groupClauseCommonVars, since these are the only ones we can use to
1268 * check for functional dependencies.
1269 */
1270 have_non_var_grouping = false;
1271 foreach(l, groupClauses)
1272 {
1273 TargetEntry *tle = lfirst(l);
1274
1275 if (!IsA(tle->expr, Var))
1276 {
1277 have_non_var_grouping = true;
1278 }
1279 else if (!qry->groupingSets ||
1280 list_member_int(gset_common, tle->ressortgroupref))
1281 {
1282 groupClauseCommonVars = lappend(groupClauseCommonVars, tle->expr);
1283 }
1284 }
1285
1286 /*
1287 * Replace grouped variables in the targetlist and HAVING clause with Vars
1288 * that reference the RTE_GROUP RTE. Emit an error message if we find any
1289 * ungrouped variables.
1290 *
1291 * Note: because we check resjunk tlist elements as well as regular ones,
1292 * this will also find ungrouped variables that came from ORDER BY and
1293 * WINDOW clauses. For that matter, it's also going to examine the
1294 * grouping expressions themselves --- but they'll all pass the test ...
1295 *
1296 * We also finalize GROUPING expressions, but for that we need to traverse
1297 * the original (unflattened) clause in order to modify nodes.
1298 */
1299 clause = (Node *) qry->targetList;
1300 finalize_grouping_exprs(clause, pstate, qry,
1301 groupClauses, hasJoinRTEs,
1302 have_non_var_grouping);
1303 if (hasJoinRTEs)
1304 clause = flatten_join_alias_vars(NULL, qry, clause);
1305 qry->targetList = (List *)
1306 substitute_grouped_columns(clause, pstate, qry,
1307 groupClauses, groupClauseCommonVars,
1308 gset_common,
1309 have_non_var_grouping,
1310 &func_grouped_rels);
1311
1312 clause = (Node *) qry->havingQual;
1313 finalize_grouping_exprs(clause, pstate, qry,
1314 groupClauses, hasJoinRTEs,
1315 have_non_var_grouping);
1316 if (hasJoinRTEs)
1317 clause = flatten_join_alias_vars(NULL, qry, clause);
1318 qry->havingQual =
1319 substitute_grouped_columns(clause, pstate, qry,
1320 groupClauses, groupClauseCommonVars,
1321 gset_common,
1322 have_non_var_grouping,
1323 &func_grouped_rels);
1324
1325 /*
1326 * Per spec, aggregates can't appear in a recursive term.
1327 */
1328 if (pstate->p_hasAggs && hasSelfRefRTEs)
1329 ereport(ERROR,
1330 (errcode(ERRCODE_INVALID_RECURSION),
1331 errmsg("aggregate functions are not allowed in a recursive query's recursive term"),
1332 parser_errposition(pstate,
1333 locate_agg_of_level((Node *) qry, 0))));
1334 }
1335
1336 /*
1337 * substitute_grouped_columns -
1338 * Scan the given expression tree for grouped variables (variables that
1339 * are listed in the groupClauses list) and replace them with Vars that
1340 * reference the RTE_GROUP RTE. Emit a suitable error message if any
1341 * ungrouped variables (variables that are not listed in the groupClauses
1342 * list and are not within the arguments of aggregate functions) are
1343 * found.
1344 *
1345 * NOTE: we assume that the given clause has been transformed suitably for
1346 * parser output. This means we can use expression_tree_mutator.
1347 *
1348 * NOTE: we recognize grouping expressions in the main query, but only
1349 * grouping Vars in subqueries. For example, this will be rejected,
1350 * although it could be allowed:
1351 * SELECT
1352 * (SELECT x FROM bar where y = (foo.a + foo.b))
1353 * FROM foo
1354 * GROUP BY a + b;
1355 * The difficulty is the need to account for different sublevels_up.
1356 * This appears to require a whole custom version of equal(), which is
1357 * way more pain than the feature seems worth.
1358 */
1359 static Node *
1360 substitute_grouped_columns(Node *node, ParseState *pstate, Query *qry,
1361 List *groupClauses, List *groupClauseCommonVars,
1362 List *gset_common,
1363 bool have_non_var_grouping,
1364 List **func_grouped_rels)
1365 {
1366 substitute_grouped_columns_context context;
1367
1368 context.pstate = pstate;
1369 context.qry = qry;
1370 context.hasJoinRTEs = false; /* assume caller flattened join Vars */
1371 context.groupClauses = groupClauses;
1372 context.groupClauseCommonVars = groupClauseCommonVars;
1373 context.gset_common = gset_common;
1374 context.have_non_var_grouping = have_non_var_grouping;
1375 context.func_grouped_rels = func_grouped_rels;
1376 context.sublevels_up = 0;
1377 context.in_agg_direct_args = false;
1378 return substitute_grouped_columns_mutator(node, &context);
1379 }
1380
1381 static Node *
1382 substitute_grouped_columns_mutator(Node *node,
1383 substitute_grouped_columns_context *context)
1384 {
1385 ListCell *gl;
1386
1387 if (node == NULL)
1388 return NULL;
1389
1390 if (IsA(node, Aggref))
1391 {
1392 Aggref *agg = (Aggref *) node;
1393
1394 if ((int) agg->agglevelsup == context->sublevels_up)
1395 {
1396 /*
1397 * If we find an aggregate call of the original level, do not
1398 * recurse into its normal arguments, ORDER BY arguments, or
1399 * filter; grouped vars there do not need to be replaced and
1400 * ungrouped vars there are not an error. But we should check
1401 * direct arguments as though they weren't in an aggregate. We
1402 * set a special flag in the context to help produce a useful
1403 * error message for ungrouped vars in direct arguments.
1404 */
1405 agg = copyObject(agg);
1406
1407 Assert(!context->in_agg_direct_args);
1408 context->in_agg_direct_args = true;
1409 agg->aggdirectargs = (List *)
1410 substitute_grouped_columns_mutator((Node *) agg->aggdirectargs,
1411 context);
1412 context->in_agg_direct_args = false;
1413 return (Node *) agg;
1414 }
1415
1416 /*
1417 * We can skip recursing into aggregates of higher levels altogether,
1418 * since they could not possibly contain Vars of concern to us (see
1419 * transformAggregateCall). We do need to look at aggregates of lower
1420 * levels, however.
1421 */
1422 if ((int) agg->agglevelsup > context->sublevels_up)
1423 return node;
1424 }
1425
1426 if (IsA(node, GroupingFunc))
1427 {
1428 GroupingFunc *grp = (GroupingFunc *) node;
1429
1430 /* handled GroupingFunc separately, no need to recheck at this level */
1431
1432 if ((int) grp->agglevelsup >= context->sublevels_up)
1433 return node;
1434 }
1435
1436 /*
1437 * If we have any GROUP BY items that are not simple Vars, check to see if
1438 * subexpression as a whole matches any GROUP BY item. We need to do this
1439 * at every recursion level so that we recognize GROUPed-BY expressions
1440 * before reaching variables within them. But this only works at the outer
1441 * query level, as noted above.
1442 */
1443 if (context->have_non_var_grouping && context->sublevels_up == 0)
1444 {
1445 int attnum = 0;
1446
1447 foreach(gl, context->groupClauses)
1448 {
1449 TargetEntry *tle = (TargetEntry *) lfirst(gl);
1450
1451 attnum++;
1452 if (equal(node, tle->expr))
1453 {
1454 /* acceptable, replace it with a GROUP Var */
1455 return (Node *) buildGroupedVar(attnum,
1456 tle->ressortgroupref,
1457 context);
1458 }
1459 }
1460 }
1461
1462 /*
1463 * Constants are always acceptable. We have to do this after we checked
1464 * the subexpression as a whole for a match, because it is possible that
1465 * we have GROUP BY items that are constants, and the constants would
1466 * become not so constant after the grouping step.
1467 */
1468 if (IsA(node, Const) ||
1469 IsA(node, Param))
1470 return node;
1471
1472 /*
1473 * If we have an ungrouped Var of the original query level, we have a
1474 * failure. Vars below the original query level are not a problem, and
1475 * neither are Vars from above it. (If such Vars are ungrouped as far as
1476 * their own query level is concerned, that's someone else's problem...)
1477 */
1478 if (IsA(node, Var))
1479 {
1480 Var *var = (Var *) node;
1481 RangeTblEntry *rte;
1482 char *attname;
1483
1484 if (var->varlevelsup != context->sublevels_up)
1485 return node; /* it's not local to my query, ignore */
1486
1487 /*
1488 * Check for a match, if we didn't do it above.
1489 */
1490 if (!context->have_non_var_grouping || context->sublevels_up != 0)
1491 {
1492 int attnum = 0;
1493
1494 foreach(gl, context->groupClauses)
1495 {
1496 TargetEntry *tle = (TargetEntry *) lfirst(gl);
1497 Var *gvar = (Var *) tle->expr;
1498
1499 attnum++;
1500 if (IsA(gvar, Var) &&
1501 gvar->varno == var->varno &&
1502 gvar->varattno == var->varattno &&
1503 gvar->varlevelsup == 0)
1504 {
1505 /* acceptable, replace it with a GROUP Var */
1506 return (Node *) buildGroupedVar(attnum,
1507 tle->ressortgroupref,
1508 context);
1509 }
1510 }
1511 }
1512
1513 /*
1514 * Check whether the Var is known functionally dependent on the GROUP
1515 * BY columns. If so, we can allow the Var to be used, because the
1516 * grouping is really a no-op for this table. However, this deduction
1517 * depends on one or more constraints of the table, so we have to add
1518 * those constraints to the query's constraintDeps list, because it's
1519 * not semantically valid anymore if the constraint(s) get dropped.
1520 * (Therefore, this check must be the last-ditch effort before raising
1521 * error: we don't want to add dependencies unnecessarily.)
1522 *
1523 * Because this is a pretty expensive check, and will have the same
1524 * outcome for all columns of a table, we remember which RTEs we've
1525 * already proven functional dependency for in the func_grouped_rels
1526 * list. This test also prevents us from adding duplicate entries to
1527 * the constraintDeps list.
1528 */
1529 if (list_member_int(*context->func_grouped_rels, var->varno))
1530 return node; /* previously proven acceptable */
1531
1532 Assert(var->varno > 0 &&
1533 (int) var->varno <= list_length(context->pstate->p_rtable));
1534 rte = rt_fetch(var->varno, context->pstate->p_rtable);
1535 if (rte->rtekind == RTE_RELATION)
1536 {
1537 if (check_functional_grouping(rte->relid,
1538 var->varno,
1539 0,
1540 context->groupClauseCommonVars,
1541 &context->qry->constraintDeps))
1542 {
1543 *context->func_grouped_rels =
1544 lappend_int(*context->func_grouped_rels, var->varno);
1545 return node; /* acceptable */
1546 }
1547 }
1548
1549 /* Found an ungrouped local variable; generate error message */
1550 attname = get_rte_attribute_name(rte, var->varattno);
1551 if (context->sublevels_up == 0)
1552 ereport(ERROR,
1553 (errcode(ERRCODE_GROUPING_ERROR),
1554 errmsg("column \"%s.%s\" must appear in the GROUP BY clause or be used in an aggregate function",
1555 rte->eref->aliasname, attname),
1556 context->in_agg_direct_args ?
1557 errdetail("Direct arguments of an ordered-set aggregate must use only grouped columns.") : 0,
1558 parser_errposition(context->pstate, var->location)));
1559 else
1560 ereport(ERROR,
1561 (errcode(ERRCODE_GROUPING_ERROR),
1562 errmsg("subquery uses ungrouped column \"%s.%s\" from outer query",
1563 rte->eref->aliasname, attname),
1564 parser_errposition(context->pstate, var->location)));
1565 }
1566
1567 if (IsA(node, Query))
1568 {
1569 /* Recurse into subselects */
1570 Query *newnode;
1571
1572 context->sublevels_up++;
1573 newnode = query_tree_mutator((Query *) node,
1574 substitute_grouped_columns_mutator,
1575 context,
1576 0);
1577 context->sublevels_up--;
1578 return (Node *) newnode;
1579 }
1580 return expression_tree_mutator(node, substitute_grouped_columns_mutator,
1581 context);
1582 }
1583
1584 /*
1585 * finalize_grouping_exprs -
1586 * Scan the given expression tree for GROUPING() and related calls,
1587 * and validate and process their arguments.
1588 *
1589 * This is split out from substitute_grouped_columns above because it needs
1590 * to modify the nodes (which it does in-place, not via a mutator) while
1591 * substitute_grouped_columns may see only a copy of the original thanks to
1592 * flattening of join alias vars. So here, we flatten each individual
1593 * GROUPING argument as we see it before comparing it.
1594 */
1595 static void
1596 finalize_grouping_exprs(Node *node, ParseState *pstate, Query *qry,
1597 List *groupClauses, bool hasJoinRTEs,
1598 bool have_non_var_grouping)
1599 {
1600 substitute_grouped_columns_context context;
1601
1602 context.pstate = pstate;
1603 context.qry = qry;
1604 context.hasJoinRTEs = hasJoinRTEs;
1605 context.groupClauses = groupClauses;
1606 context.groupClauseCommonVars = NIL;
1607 context.gset_common = NIL;
1608 context.have_non_var_grouping = have_non_var_grouping;
1609 context.func_grouped_rels = NULL;
1610 context.sublevels_up = 0;
1611 context.in_agg_direct_args = false;
1612 finalize_grouping_exprs_walker(node, &context);
1613 }
1614
1615 static bool
1616 finalize_grouping_exprs_walker(Node *node,
1617 substitute_grouped_columns_context *context)
1618 {
1619 ListCell *gl;
1620
1621 if (node == NULL)
1622 return false;
1623 if (IsA(node, Const) ||
1624 IsA(node, Param))
1625 return false; /* constants are always acceptable */
1626
1627 if (IsA(node, Aggref))
1628 {
1629 Aggref *agg = (Aggref *) node;
1630
1631 if ((int) agg->agglevelsup == context->sublevels_up)
1632 {
1633 /*
1634 * If we find an aggregate call of the original level, do not
1635 * recurse into its normal arguments, ORDER BY arguments, or
1636 * filter; GROUPING exprs of this level are not allowed there. But
1637 * check direct arguments as though they weren't in an aggregate.
1638 */
1639 bool result;
1640
1641 Assert(!context->in_agg_direct_args);
1642 context->in_agg_direct_args = true;
1643 result = finalize_grouping_exprs_walker((Node *) agg->aggdirectargs,
1644 context);
1645 context->in_agg_direct_args = false;
1646 return result;
1647 }
1648
1649 /*
1650 * We can skip recursing into aggregates of higher levels altogether,
1651 * since they could not possibly contain exprs of concern to us (see
1652 * transformAggregateCall). We do need to look at aggregates of lower
1653 * levels, however.
1654 */
1655 if ((int) agg->agglevelsup > context->sublevels_up)
1656 return false;
1657 }
1658
1659 if (IsA(node, GroupingFunc))
1660 {
1661 GroupingFunc *grp = (GroupingFunc *) node;
1662
1663 /*
1664 * We only need to check GroupingFunc nodes at the exact level to
1665 * which they belong, since they cannot mix levels in arguments.
1666 */
1667
1668 if ((int) grp->agglevelsup == context->sublevels_up)
1669 {
1670 ListCell *lc;
1671 List *ref_list = NIL;
1672
1673 foreach(lc, grp->args)
1674 {
1675 Node *expr = lfirst(lc);
1676 Index ref = 0;
1677
1678 if (context->hasJoinRTEs)
1679 expr = flatten_join_alias_vars(NULL, context->qry, expr);
1680
1681 /*
1682 * Each expression must match a grouping entry at the current
1683 * query level. Unlike the general expression case, we don't
1684 * allow functional dependencies or outer references.
1685 */
1686
1687 if (IsA(expr, Var))
1688 {
1689 Var *var = (Var *) expr;
1690
1691 if (var->varlevelsup == context->sublevels_up)
1692 {
1693 foreach(gl, context->groupClauses)
1694 {
1695 TargetEntry *tle = lfirst(gl);
1696 Var *gvar = (Var *) tle->expr;
1697
1698 if (IsA(gvar, Var) &&
1699 gvar->varno == var->varno &&
1700 gvar->varattno == var->varattno &&
1701 gvar->varlevelsup == 0)
1702 {
1703 ref = tle->ressortgroupref;
1704 break;
1705 }
1706 }
1707 }
1708 }
1709 else if (context->have_non_var_grouping &&
1710 context->sublevels_up == 0)
1711 {
1712 foreach(gl, context->groupClauses)
1713 {
1714 TargetEntry *tle = lfirst(gl);
1715
1716 if (equal(expr, tle->expr))
1717 {
1718 ref = tle->ressortgroupref;
1719 break;
1720 }
1721 }
1722 }
1723
1724 if (ref == 0)
1725 ereport(ERROR,
1726 (errcode(ERRCODE_GROUPING_ERROR),
1727 errmsg("arguments to GROUPING must be grouping expressions of the associated query level"),
1728 parser_errposition(context->pstate,
1729 exprLocation(expr))));
1730
1731 ref_list = lappend_int(ref_list, ref);
1732 }
1733
1734 grp->refs = ref_list;
1735 }
1736
1737 if ((int) grp->agglevelsup > context->sublevels_up)
1738 return false;
1739 }
1740
1741 if (IsA(node, Query))
1742 {
1743 /* Recurse into subselects */
1744 bool result;
1745
1746 context->sublevels_up++;
1747 result = query_tree_walker((Query *) node,
1748 finalize_grouping_exprs_walker,
1749 context,
1750 0);
1751 context->sublevels_up--;
1752 return result;
1753 }
1754 return expression_tree_walker(node, finalize_grouping_exprs_walker,
1755 context);
1756 }
1757
1758 /*
1759 * buildGroupedVar -
1760 * build a Var node that references the RTE_GROUP RTE
1761 */
1762 static Var *
1763 buildGroupedVar(int attnum, Index ressortgroupref,
1764 substitute_grouped_columns_context *context)
1765 {
1766 Var *var;
1767 ParseNamespaceItem *grouping_nsitem = context->pstate->p_grouping_nsitem;
1768 ParseNamespaceColumn *nscol = grouping_nsitem->p_nscolumns + attnum - 1;
1769
1770 Assert(nscol->p_varno == grouping_nsitem->p_rtindex);
1771 Assert(nscol->p_varattno == attnum);
1772 var = makeVar(nscol->p_varno,
1773 nscol->p_varattno,
1774 nscol->p_vartype,
1775 nscol->p_vartypmod,
1776 nscol->p_varcollid,
1777 context->sublevels_up);
1778 /* makeVar doesn't offer parameters for these, so set by hand: */
1779 var->varnosyn = nscol->p_varnosyn;
1780 var->varattnosyn = nscol->p_varattnosyn;
1781
1782 if (context->qry->groupingSets &&
1783 !list_member_int(context->gset_common, ressortgroupref))
1784 var->varnullingrels =
1785 bms_add_member(var->varnullingrels, grouping_nsitem->p_rtindex);
1786
1787 return var;
1788 }
1789
1790
1791 /*
1792 * Given a GroupingSet node, expand it and return a list of lists.
1793 *
1794 * For EMPTY nodes, return a list of one empty list.
1795 *
1796 * For SIMPLE nodes, return a list of one list, which is the node content.
1797 *
1798 * For CUBE and ROLLUP nodes, return a list of the expansions.
1799 *
1800 * For SET nodes, recursively expand contained CUBE and ROLLUP.
1801 */
1802 static List *
1803 expand_groupingset_node(GroupingSet *gs)
1804 {
1805 List *result = NIL;
1806
1807 switch (gs->kind)
1808 {
1809 case GROUPING_SET_EMPTY:
1810 result = list_make1(NIL);
1811 break;
1812
1813 case GROUPING_SET_SIMPLE:
1814 result = list_make1(gs->content);
1815 break;
1816
1817 case GROUPING_SET_ROLLUP:
1818 {
1819 List *rollup_val = gs->content;
1820 ListCell *lc;
1821 int curgroup_size = list_length(gs->content);
1822
1823 while (curgroup_size > 0)
1824 {
1825 List *current_result = NIL;
1826 int i = curgroup_size;
1827
1828 foreach(lc, rollup_val)
1829 {
1830 GroupingSet *gs_current = (GroupingSet *) lfirst(lc);
1831
1832 Assert(gs_current->kind == GROUPING_SET_SIMPLE);
1833
1834 current_result = list_concat(current_result,
1835 gs_current->content);
1836
1837 /* If we are done with making the current group, break */
1838 if (--i == 0)
1839 break;
1840 }
1841
1842 result = lappend(result, current_result);
1843 --curgroup_size;
1844 }
1845
1846 result = lappend(result, NIL);
1847 }
1848 break;
1849
1850 case GROUPING_SET_CUBE:
1851 {
1852 List *cube_list = gs->content;
1853 int number_bits = list_length(cube_list);
1854 uint32 num_sets;
1855 uint32 i;
1856
1857 /* parser should cap this much lower */
1858 Assert(number_bits < 31);
1859
1860 num_sets = (1U << number_bits);
1861
1862 for (i = 0; i < num_sets; i++)
1863 {
1864 List *current_result = NIL;
1865 ListCell *lc;
1866 uint32 mask = 1U;
1867
1868 foreach(lc, cube_list)
1869 {
1870 GroupingSet *gs_current = (GroupingSet *) lfirst(lc);
1871
1872 Assert(gs_current->kind == GROUPING_SET_SIMPLE);
1873
1874 if (mask & i)
1875 current_result = list_concat(current_result,
1876 gs_current->content);
1877
1878 mask <<= 1;
1879 }
1880
1881 result = lappend(result, current_result);
1882 }
1883 }
1884 break;
1885
1886 case GROUPING_SET_SETS:
1887 {
1888 ListCell *lc;
1889
1890 foreach(lc, gs->content)
1891 {
1892 List *current_result = expand_groupingset_node(lfirst(lc));
1893
1894 result = list_concat(result, current_result);
1895 }
1896 }
1897 break;
1898 }
1899
1900 return result;
1901 }
1902
1903 /* list_sort comparator to sort sub-lists by length */
1904 static int
1905 cmp_list_len_asc(const ListCell *a, const ListCell *b)
1906 {
1907 int la = list_length((const List *) lfirst(a));
1908 int lb = list_length((const List *) lfirst(b));
1909
1910 return pg_cmp_s32(la, lb);
1911 }
1912
1913 /* list_sort comparator to sort sub-lists by length and contents */
1914 static int
1915 cmp_list_len_contents_asc(const ListCell *a, const ListCell *b)
1916 {
1917 int res = cmp_list_len_asc(a, b);
1918
1919 if (res == 0)
1920 {
1921 List *la = (List *) lfirst(a);
1922 List *lb = (List *) lfirst(b);
1923 ListCell *lca;
1924 ListCell *lcb;
1925
1926 forboth(lca, la, lcb, lb)
1927 {
1928 int va = lfirst_int(lca);
1929 int vb = lfirst_int(lcb);
1930
1931 if (va > vb)
1932 return 1;
1933 if (va < vb)
1934 return -1;
1935 }
1936 }
1937
1938 return res;
1939 }
1940
1941 /*
1942 * Expand a groupingSets clause to a flat list of grouping sets.
1943 * The returned list is sorted by length, shortest sets first.
1944 *
1945 * This is mainly for the planner, but we use it here too to do
1946 * some consistency checks.
1947 */
1948 List *
1949 expand_grouping_sets(List *groupingSets, bool groupDistinct, int limit)
1950 {
1951 List *expanded_groups = NIL;
1952 List *result = NIL;
1953 double numsets = 1;
1954 ListCell *lc;
1955
1956 if (groupingSets == NIL)
1957 return NIL;
1958
1959 foreach(lc, groupingSets)
1960 {
1961 List *current_result = NIL;
1962 GroupingSet *gs = lfirst(lc);
1963
1964 current_result = expand_groupingset_node(gs);
1965
1966 Assert(current_result != NIL);
1967
1968 numsets *= list_length(current_result);
1969
1970 if (limit >= 0 && numsets > limit)
1971 return NIL;
1972
1973 expanded_groups = lappend(expanded_groups, current_result);
1974 }
1975
1976 /*
1977 * Do cartesian product between sublists of expanded_groups. While at it,
1978 * remove any duplicate elements from individual grouping sets (we must
1979 * NOT change the number of sets though)
1980 */
1981
1982 foreach(lc, (List *) linitial(expanded_groups))
1983 {
1984 result = lappend(result, list_union_int(NIL, (List *) lfirst(lc)));
1985 }
1986
1987 for_each_from(lc, expanded_groups, 1)
1988 {
1989 List *p = lfirst(lc);
1990 List *new_result = NIL;
1991 ListCell *lc2;
1992
1993 foreach(lc2, result)
1994 {
1995 List *q = lfirst(lc2);
1996 ListCell *lc3;
1997
1998 foreach(lc3, p)
1999 {
2000 new_result = lappend(new_result,
2001 list_union_int(q, (List *) lfirst(lc3)));
2002 }
2003 }
2004 result = new_result;
2005 }
2006
2007 /* Now sort the lists by length and deduplicate if necessary */
2008 if (!groupDistinct || list_length(result) < 2)
2009 list_sort(result, cmp_list_len_asc);
2010 else
2011 {
2012 ListCell *cell;
2013 List *prev;
2014
2015 /* Sort each groupset individually */
2016 foreach(cell, result)
2017 list_sort(lfirst(cell), list_int_cmp);
2018
2019 /* Now sort the list of groupsets by length and contents */
2020 list_sort(result, cmp_list_len_contents_asc);
2021
2022 /* Finally, remove duplicates */
2023 prev = linitial(result);
2024 for_each_from(cell, result, 1)
2025 {
2026 if (equal(lfirst(cell), prev))
2027 result = foreach_delete_current(result, cell);
2028 else
2029 prev = lfirst(cell);
2030 }
2031 }
2032
2033 return result;
2034 }
2035
2036 /*
2037 * get_aggregate_argtypes
2038 * Identify the specific datatypes passed to an aggregate call.
2039 *
2040 * Given an Aggref, extract the actual datatypes of the input arguments.
2041 * The input datatypes are reported in a way that matches up with the
2042 * aggregate's declaration, ie, any ORDER BY columns attached to a plain
2043 * aggregate are ignored, but we report both direct and aggregated args of
2044 * an ordered-set aggregate.
2045 *
2046 * Datatypes are returned into inputTypes[], which must reference an array
2047 * of length FUNC_MAX_ARGS.
2048 *
2049 * The function result is the number of actual arguments.
2050 */
2051 int
2052 get_aggregate_argtypes(Aggref *aggref, Oid *inputTypes)
2053 {
2054 int numArguments = 0;
2055 ListCell *lc;
2056
2057 /*
2058 * Check the number of arguments to protect fixed-size arrays in callers.
2059 *
2060 * Aggregates can have at most FUNC_MAX_ARGS-1 args (compare
2061 * AggregateCreate, whose error message we want to match). Ordinarily
2062 * this would have been checked while creating the Aggref, but it's
2063 * possible that we are looking at a parsetree from a stored view that was
2064 * made by a server executable with a different value of FUNC_MAX_ARGS, or
2065 * an executable in which parse_func.c didn't enforce the correct limit.
2066 */
2067 if (list_length(aggref->aggargtypes) > FUNC_MAX_ARGS - 1)
2068 ereport(ERROR,
2069 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
2070 errmsg_plural("aggregates cannot have more than %d argument",
2071 "aggregates cannot have more than %d arguments",
2072 FUNC_MAX_ARGS - 1,
2073 FUNC_MAX_ARGS - 1)));
2074
2075 foreach(lc, aggref->aggargtypes)
2076 {
2077 inputTypes[numArguments++] = lfirst_oid(lc);
2078 }
2079
2080 return numArguments;
2081 }
2082
2083 /*
2084 * resolve_aggregate_transtype
2085 * Identify the transition state value's datatype for an aggregate call.
2086 *
2087 * This function resolves a polymorphic aggregate's state datatype.
2088 * It must be passed the aggtranstype from the aggregate's catalog entry,
2089 * as well as the actual argument types extracted by get_aggregate_argtypes.
2090 * (We could fetch pg_aggregate.aggtranstype internally, but all existing
2091 * callers already have the value at hand, so we make them pass it.)
2092 */
2093 Oid
2094 resolve_aggregate_transtype(Oid aggfuncid,
2095 Oid aggtranstype,
2096 Oid *inputTypes,
2097 int numArguments)
2098 {
2099 /* resolve actual type of transition state, if polymorphic */
2100 if (IsPolymorphicType(aggtranstype))
2101 {
2102 /* have to fetch the agg's declared input types... */
2103 Oid *declaredArgTypes;
2104 int agg_nargs;
2105
2106 (void) get_func_signature(aggfuncid, &declaredArgTypes, &agg_nargs);
2107
2108 /*
2109 * VARIADIC ANY aggs could have more actual than declared args, but
2110 * such extra args can't affect polymorphic type resolution.
2111 */
2112 Assert(agg_nargs <= numArguments);
2113
2114 aggtranstype = enforce_generic_type_consistency(inputTypes,
2115 declaredArgTypes,
2116 agg_nargs,
2117 aggtranstype,
2118 false);
2119 pfree(declaredArgTypes);
2120 }
2121 return aggtranstype;
2122 }
2123
2124 /*
2125 * agg_args_support_sendreceive
2126 * Returns true if all non-byval types of aggref's args have send and
2127 * receive functions.
2128 */
2129 bool
2130 agg_args_support_sendreceive(Aggref *aggref)
2131 {
2132 ListCell *lc;
2133
2134 foreach(lc, aggref->args)
2135 {
2136 HeapTuple typeTuple;
2137 Form_pg_type pt;
2138 TargetEntry *tle = (TargetEntry *) lfirst(lc);
2139 Oid type = exprType((Node *) tle->expr);
2140
2141 /*
2142 * RECORD is a special case: it has typsend/typreceive functions, but
2143 * record_recv only works if passed the correct typmod to identify the
2144 * specific anonymous record type. array_agg_deserialize cannot do
2145 * that, so we have to disclaim support for the case.
2146 */
2147 if (type == RECORDOID)
2148 return false;
2149
2150 typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type));
2151 if (!HeapTupleIsValid(typeTuple))
2152 elog(ERROR, "cache lookup failed for type %u", type);
2153
2154 pt = (Form_pg_type) GETSTRUCT(typeTuple);
2155
2156 if (!pt->typbyval &&
2157 (!OidIsValid(pt->typsend) || !OidIsValid(pt->typreceive)))
2158 {
2159 ReleaseSysCache(typeTuple);
2160 return false;
2161 }
2162 ReleaseSysCache(typeTuple);
2163 }
2164 return true;
2165 }
2166
2167 /*
2168 * Create an expression tree for the transition function of an aggregate.
2169 * This is needed so that polymorphic functions can be used within an
2170 * aggregate --- without the expression tree, such functions would not know
2171 * the datatypes they are supposed to use. (The trees will never actually
2172 * be executed, however, so we can skimp a bit on correctness.)
2173 *
2174 * agg_input_types and agg_state_type identifies the input types of the
2175 * aggregate. These should be resolved to actual types (ie, none should
2176 * ever be ANYELEMENT etc).
2177 * agg_input_collation is the aggregate function's input collation.
2178 *
2179 * For an ordered-set aggregate, remember that agg_input_types describes
2180 * the direct arguments followed by the aggregated arguments.
2181 *
2182 * transfn_oid and invtransfn_oid identify the funcs to be called; the
2183 * latter may be InvalidOid, however if invtransfn_oid is set then
2184 * transfn_oid must also be set.
2185 *
2186 * transfn_oid may also be passed as the aggcombinefn when the *transfnexpr is
2187 * to be used for a combine aggregate phase. We expect invtransfn_oid to be
2188 * InvalidOid in this case since there is no such thing as an inverse
2189 * combinefn.
2190 *
2191 * Pointers to the constructed trees are returned into *transfnexpr,
2192 * *invtransfnexpr. If there is no invtransfn, the respective pointer is set
2193 * to NULL. Since use of the invtransfn is optional, NULL may be passed for
2194 * invtransfnexpr.
2195 */
2196 void
2197 build_aggregate_transfn_expr(Oid *agg_input_types,
2198 int agg_num_inputs,
2199 int agg_num_direct_inputs,
2200 bool agg_variadic,
2201 Oid agg_state_type,
2202 Oid agg_input_collation,
2203 Oid transfn_oid,
2204 Oid invtransfn_oid,
2205 Expr **transfnexpr,
2206 Expr **invtransfnexpr)
2207 {
2208 List *args;
2209 FuncExpr *fexpr;
2210 int i;
2211
2212 /*
2213 * Build arg list to use in the transfn FuncExpr node.
2214 */
2215 args = list_make1(make_agg_arg(agg_state_type, agg_input_collation));
2216
2217 for (i = agg_num_direct_inputs; i < agg_num_inputs; i++)
2218 {
2219 args = lappend(args,
2220 make_agg_arg(agg_input_types[i], agg_input_collation));
2221 }
2222
2223 fexpr = makeFuncExpr(transfn_oid,
2224 agg_state_type,
2225 args,
2226 InvalidOid,
2227 agg_input_collation,
2228 COERCE_EXPLICIT_CALL);
2229 fexpr->funcvariadic = agg_variadic;
2230 *transfnexpr = (Expr *) fexpr;
2231
2232 /*
2233 * Build invtransfn expression if requested, with same args as transfn
2234 */
2235 if (invtransfnexpr != NULL)
2236 {
2237 if (OidIsValid(invtransfn_oid))
2238 {
2239 fexpr = makeFuncExpr(invtransfn_oid,
2240 agg_state_type,
2241 args,
2242 InvalidOid,
2243 agg_input_collation,
2244 COERCE_EXPLICIT_CALL);
2245 fexpr->funcvariadic = agg_variadic;
2246 *invtransfnexpr = (Expr *) fexpr;
2247 }
2248 else
2249 *invtransfnexpr = NULL;
2250 }
2251 }
2252
2253 /*
2254 * Like build_aggregate_transfn_expr, but creates an expression tree for the
2255 * serialization function of an aggregate.
2256 */
2257 void
2258 build_aggregate_serialfn_expr(Oid serialfn_oid,
2259 Expr **serialfnexpr)
2260 {
2261 List *args;
2262 FuncExpr *fexpr;
2263
2264 /* serialfn always takes INTERNAL and returns BYTEA */
2265 args = list_make1(make_agg_arg(INTERNALOID, InvalidOid));
2266
2267 fexpr = makeFuncExpr(serialfn_oid,
2268 BYTEAOID,
2269 args,
2270 InvalidOid,
2271 InvalidOid,
2272 COERCE_EXPLICIT_CALL);
2273 *serialfnexpr = (Expr *) fexpr;
2274 }
2275
2276 /*
2277 * Like build_aggregate_transfn_expr, but creates an expression tree for the
2278 * deserialization function of an aggregate.
2279 */
2280 void
2281 build_aggregate_deserialfn_expr(Oid deserialfn_oid,
2282 Expr **deserialfnexpr)
2283 {
2284 List *args;
2285 FuncExpr *fexpr;
2286
2287 /* deserialfn always takes BYTEA, INTERNAL and returns INTERNAL */
2288 args = list_make2(make_agg_arg(BYTEAOID, InvalidOid),
2289 make_agg_arg(INTERNALOID, InvalidOid));
2290
2291 fexpr = makeFuncExpr(deserialfn_oid,
2292 INTERNALOID,
2293 args,
2294 InvalidOid,
2295 InvalidOid,
2296 COERCE_EXPLICIT_CALL);
2297 *deserialfnexpr = (Expr *) fexpr;
2298 }
2299
2300 /*
2301 * Like build_aggregate_transfn_expr, but creates an expression tree for the
2302 * final function of an aggregate, rather than the transition function.
2303 */
2304 void
2305 build_aggregate_finalfn_expr(Oid *agg_input_types,
2306 int num_finalfn_inputs,
2307 Oid agg_state_type,
2308 Oid agg_result_type,
2309 Oid agg_input_collation,
2310 Oid finalfn_oid,
2311 Expr **finalfnexpr)
2312 {
2313 List *args;
2314 int i;
2315
2316 /*
2317 * Build expr tree for final function
2318 */
2319 args = list_make1(make_agg_arg(agg_state_type, agg_input_collation));
2320
2321 /* finalfn may take additional args, which match agg's input types */
2322 for (i = 0; i < num_finalfn_inputs - 1; i++)
2323 {
2324 args = lappend(args,
2325 make_agg_arg(agg_input_types[i], agg_input_collation));
2326 }
2327
2328 *finalfnexpr = (Expr *) makeFuncExpr(finalfn_oid,
2329 agg_result_type,
2330 args,
2331 InvalidOid,
2332 agg_input_collation,
2333 COERCE_EXPLICIT_CALL);
2334 /* finalfn is currently never treated as variadic */
2335 }
2336
2337 /*
2338 * Convenience function to build dummy argument expressions for aggregates.
2339 *
2340 * We really only care that an aggregate support function can discover its
2341 * actual argument types at runtime using get_fn_expr_argtype(), so it's okay
2342 * to use Param nodes that don't correspond to any real Param.
2343 */
2344 static Node *
2345 make_agg_arg(Oid argtype, Oid argcollation)
2346 {
2347 Param *argp = makeNode(Param);
2348
2349 argp->paramkind = PARAM_EXEC;
2350 argp->paramid = -1;
2351 argp->paramtype = argtype;
2352 argp->paramtypmod = -1;
2353 argp->paramcollid = argcollation;
2354 argp->location = -1;
2355 return (Node *) argp;
2356 }