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