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 42096 : transformAggregateCall(ParseState *pstate, Aggref *agg,
110 : List *args, List *aggorder, bool agg_distinct)
111 : {
112 42096 : List *argtypes = NIL;
113 42096 : List *tlist = NIL;
114 42096 : List *torder = NIL;
115 42096 : List *tdistinct = NIL;
116 42096 : AttrNumber attno = 1;
117 : int save_next_resno;
118 : ListCell *lc;
119 :
120 42096 : 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 41778 : agg->aggdirectargs = NIL;
162 :
163 : /*
164 : * Transform the plain list of Exprs into a targetlist.
165 : */
166 76136 : foreach(lc, args)
167 : {
168 34358 : Expr *arg = (Expr *) lfirst(lc);
169 : TargetEntry *tle;
170 :
171 : /* We don't bother to assign column names to the entries */
172 34358 : tle = makeTargetEntry(arg, attno++, NULL, false);
173 34358 : 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 41778 : save_next_resno = pstate->p_next_resno;
186 41778 : pstate->p_next_resno = attno;
187 :
188 41778 : 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 41778 : if (agg_distinct)
198 : {
199 538 : 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 1172 : foreach(lc, tdistinct)
206 : {
207 670 : SortGroupClause *sortcl = (SortGroupClause *) lfirst(lc);
208 :
209 670 : 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 41742 : pstate->p_next_resno = save_next_resno;
224 : }
225 :
226 : /* Update the Aggref with the transformation results */
227 42060 : agg->args = tlist;
228 42060 : agg->aggorder = torder;
229 42060 : 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 42426 : foreach(lc, agg->aggdirectargs)
239 : {
240 366 : Expr *arg = (Expr *) lfirst(lc);
241 :
242 366 : argtypes = lappend_oid(argtypes, exprType((Node *) arg));
243 : }
244 77782 : foreach(lc, tlist)
245 : {
246 35722 : TargetEntry *tle = (TargetEntry *) lfirst(lc);
247 :
248 35722 : if (tle->resjunk)
249 1088 : continue; /* ignore junk */
250 34634 : argtypes = lappend_oid(argtypes, exprType((Node *) tle->expr));
251 : }
252 42060 : agg->aggargtypes = argtypes;
253 :
254 42060 : check_agglevels_and_constraints(pstate, (Node *) agg);
255 41922 : }
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 42422 : check_agglevels_and_constraints(ParseState *pstate, Node *expr)
305 : {
306 42422 : List *directargs = NIL;
307 42422 : List *args = NIL;
308 42422 : Expr *filter = NULL;
309 : int min_varlevel;
310 42422 : int location = -1;
311 : Index *p_levelsup;
312 : const char *err;
313 : bool errkind;
314 42422 : bool isAgg = IsA(expr, Aggref);
315 :
316 42422 : if (isAgg)
317 : {
318 42060 : Aggref *agg = (Aggref *) expr;
319 :
320 42060 : directargs = agg->aggdirectargs;
321 42060 : args = agg->args;
322 42060 : filter = agg->aggfilter;
323 42060 : location = agg->location;
324 42060 : 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 42422 : min_varlevel = check_agg_arguments(pstate,
340 : directargs,
341 : args,
342 : filter);
343 :
344 42374 : *p_levelsup = min_varlevel;
345 :
346 : /* Mark the correct pstate level as having aggregates */
347 42552 : while (min_varlevel-- > 0)
348 178 : pstate = pstate->parentParseState;
349 42374 : 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 42374 : err = NULL;
362 42374 : errkind = false;
363 42374 : 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 676 : case EXPR_KIND_HAVING:
413 : /* okay */
414 676 : 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 41516 : case EXPR_KIND_SELECT_TARGET:
446 : /* okay */
447 41516 : 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 6 : case EXPR_KIND_GENERATED_COLUMN:
555 :
556 6 : if (isAgg)
557 6 : 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 6 : 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 42374 : if (err)
593 66 : ereport(ERROR,
594 : (errcode(ERRCODE_GROUPING_ERROR),
595 : errmsg_internal("%s", err),
596 : parser_errposition(pstate, location)));
597 :
598 42308 : 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 42284 : }
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 42422 : 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 42422 : context.pstate = pstate;
650 42422 : context.min_varlevel = -1; /* signifies nothing found yet */
651 42422 : context.min_agglevel = -1;
652 42422 : context.sublevels_up = 0;
653 :
654 42422 : (void) check_agg_arguments_walker((Node *) args, &context);
655 42416 : (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 42416 : if (context.min_varlevel < 0)
662 : {
663 12864 : if (context.min_agglevel < 0)
664 12864 : agglevel = 0;
665 : else
666 0 : agglevel = context.min_agglevel;
667 : }
668 29552 : else if (context.min_agglevel < 0)
669 29516 : 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 42416 : 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 42386 : 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 42374 : return agglevel;
719 : }
720 :
721 : static bool
722 175770 : check_agg_arguments_walker(Node *node,
723 : check_agg_arguments_context *context)
724 : {
725 175770 : if (node == NULL)
726 55510 : return false;
727 120260 : if (IsA(node, Var))
728 : {
729 32648 : int varlevelsup = ((Var *) node)->varlevelsup;
730 :
731 : /* convert levelsup to frame of reference of original query */
732 32648 : varlevelsup -= context->sublevels_up;
733 : /* ignore local vars of subqueries */
734 32648 : if (varlevelsup >= 0)
735 : {
736 32518 : if (context->min_varlevel < 0 ||
737 2906 : context->min_varlevel > varlevelsup)
738 29714 : context->min_varlevel = varlevelsup;
739 : }
740 32648 : return false;
741 : }
742 87612 : 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 87612 : 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 87612 : if (context->sublevels_up == 0)
779 : {
780 86888 : if ((IsA(node, FuncExpr) && ((FuncExpr *) node)->funcretset) ||
781 86882 : (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 86882 : 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 87606 : if (IsA(node, Query))
795 : {
796 : /* Recurse into subselects */
797 : bool result;
798 :
799 120 : context->sublevels_up++;
800 120 : result = query_tree_walker((Query *) node,
801 : check_agg_arguments_walker,
802 : context,
803 : 0);
804 120 : context->sublevels_up--;
805 120 : return result;
806 : }
807 :
808 87486 : return expression_tree_walker(node,
809 : check_agg_arguments_walker,
810 : context);
811 : }
812 :
813 : /*
814 : * transformWindowFuncCall -
815 : * Finish initial transformation of a window function call
816 : *
817 : * parse_func.c has recognized the function as a window function, and has set
818 : * up all the fields of the WindowFunc except winref. Here we must (1) add
819 : * the WindowDef to the pstate (if not a duplicate of one already present) and
820 : * set winref to link to it; and (2) mark p_hasWindowFuncs true in the pstate.
821 : * Unlike aggregates, only the most closely nested pstate level need be
822 : * considered --- there are no "outer window functions" per SQL spec.
823 : */
824 : void
825 3412 : transformWindowFuncCall(ParseState *pstate, WindowFunc *wfunc,
826 : WindowDef *windef)
827 : {
828 : const char *err;
829 : bool errkind;
830 :
831 : /*
832 : * A window function call can't contain another one (but aggs are OK). XXX
833 : * is this required by spec, or just an unimplemented feature?
834 : *
835 : * Note: we don't need to check the filter expression here, because the
836 : * context checks done below and in transformAggregateCall would have
837 : * already rejected any window funcs or aggs within the filter.
838 : */
839 4264 : if (pstate->p_hasWindowFuncs &&
840 852 : contain_windowfuncs((Node *) wfunc->args))
841 0 : ereport(ERROR,
842 : (errcode(ERRCODE_WINDOWING_ERROR),
843 : errmsg("window function calls cannot be nested"),
844 : parser_errposition(pstate,
845 : locate_windowfunc((Node *) wfunc->args))));
846 :
847 : /*
848 : * Check to see if the window function is in an invalid place within the
849 : * query.
850 : *
851 : * For brevity we support two schemes for reporting an error here: set
852 : * "err" to a custom message, or set "errkind" true if the error context
853 : * is sufficiently identified by what ParseExprKindName will return, *and*
854 : * what it will return is just a SQL keyword. (Otherwise, use a custom
855 : * message to avoid creating translation problems.)
856 : */
857 3412 : err = NULL;
858 3412 : errkind = false;
859 3412 : switch (pstate->p_expr_kind)
860 : {
861 0 : case EXPR_KIND_NONE:
862 : Assert(false); /* can't happen */
863 0 : break;
864 0 : case EXPR_KIND_OTHER:
865 : /* Accept window func here; caller must throw error if wanted */
866 0 : break;
867 6 : case EXPR_KIND_JOIN_ON:
868 : case EXPR_KIND_JOIN_USING:
869 6 : err = _("window functions are not allowed in JOIN conditions");
870 6 : break;
871 0 : case EXPR_KIND_FROM_SUBSELECT:
872 : /* can't get here, but just in case, throw an error */
873 0 : errkind = true;
874 0 : break;
875 0 : case EXPR_KIND_FROM_FUNCTION:
876 0 : err = _("window functions are not allowed in functions in FROM");
877 0 : break;
878 12 : case EXPR_KIND_WHERE:
879 12 : errkind = true;
880 12 : break;
881 0 : case EXPR_KIND_POLICY:
882 0 : err = _("window functions are not allowed in policy expressions");
883 0 : break;
884 0 : case EXPR_KIND_HAVING:
885 0 : errkind = true;
886 0 : break;
887 0 : case EXPR_KIND_FILTER:
888 0 : errkind = true;
889 0 : break;
890 6 : case EXPR_KIND_WINDOW_PARTITION:
891 : case EXPR_KIND_WINDOW_ORDER:
892 : case EXPR_KIND_WINDOW_FRAME_RANGE:
893 : case EXPR_KIND_WINDOW_FRAME_ROWS:
894 : case EXPR_KIND_WINDOW_FRAME_GROUPS:
895 6 : err = _("window functions are not allowed in window definitions");
896 6 : break;
897 3356 : case EXPR_KIND_SELECT_TARGET:
898 : /* okay */
899 3356 : break;
900 0 : case EXPR_KIND_INSERT_TARGET:
901 : case EXPR_KIND_UPDATE_SOURCE:
902 : case EXPR_KIND_UPDATE_TARGET:
903 0 : errkind = true;
904 0 : break;
905 0 : case EXPR_KIND_MERGE_WHEN:
906 0 : err = _("window functions are not allowed in MERGE WHEN conditions");
907 0 : break;
908 0 : case EXPR_KIND_GROUP_BY:
909 0 : errkind = true;
910 0 : break;
911 8 : case EXPR_KIND_ORDER_BY:
912 : /* okay */
913 8 : break;
914 0 : case EXPR_KIND_DISTINCT_ON:
915 : /* okay */
916 0 : break;
917 0 : case EXPR_KIND_LIMIT:
918 : case EXPR_KIND_OFFSET:
919 0 : errkind = true;
920 0 : break;
921 6 : case EXPR_KIND_RETURNING:
922 : case EXPR_KIND_MERGE_RETURNING:
923 6 : errkind = true;
924 6 : break;
925 0 : case EXPR_KIND_VALUES:
926 : case EXPR_KIND_VALUES_SINGLE:
927 0 : errkind = true;
928 0 : break;
929 0 : case EXPR_KIND_CHECK_CONSTRAINT:
930 : case EXPR_KIND_DOMAIN_CHECK:
931 0 : err = _("window functions are not allowed in check constraints");
932 0 : break;
933 0 : case EXPR_KIND_COLUMN_DEFAULT:
934 : case EXPR_KIND_FUNCTION_DEFAULT:
935 0 : err = _("window functions are not allowed in DEFAULT expressions");
936 0 : break;
937 0 : case EXPR_KIND_INDEX_EXPRESSION:
938 0 : err = _("window functions are not allowed in index expressions");
939 0 : break;
940 0 : case EXPR_KIND_STATS_EXPRESSION:
941 0 : err = _("window functions are not allowed in statistics expressions");
942 0 : break;
943 0 : case EXPR_KIND_INDEX_PREDICATE:
944 0 : err = _("window functions are not allowed in index predicates");
945 0 : break;
946 0 : case EXPR_KIND_ALTER_COL_TRANSFORM:
947 0 : err = _("window functions are not allowed in transform expressions");
948 0 : break;
949 0 : case EXPR_KIND_EXECUTE_PARAMETER:
950 0 : err = _("window functions are not allowed in EXECUTE parameters");
951 0 : break;
952 0 : case EXPR_KIND_TRIGGER_WHEN:
953 0 : err = _("window functions are not allowed in trigger WHEN conditions");
954 0 : break;
955 0 : case EXPR_KIND_PARTITION_BOUND:
956 0 : err = _("window functions are not allowed in partition bound");
957 0 : break;
958 6 : case EXPR_KIND_PARTITION_EXPRESSION:
959 6 : err = _("window functions are not allowed in partition key expressions");
960 6 : break;
961 0 : case EXPR_KIND_CALL_ARGUMENT:
962 0 : err = _("window functions are not allowed in CALL arguments");
963 0 : break;
964 6 : case EXPR_KIND_COPY_WHERE:
965 6 : err = _("window functions are not allowed in COPY FROM WHERE conditions");
966 6 : break;
967 6 : case EXPR_KIND_GENERATED_COLUMN:
968 6 : err = _("window functions are not allowed in column generation expressions");
969 6 : break;
970 0 : case EXPR_KIND_CYCLE_MARK:
971 0 : errkind = true;
972 0 : break;
973 :
974 : /*
975 : * There is intentionally no default: case here, so that the
976 : * compiler will warn if we add a new ParseExprKind without
977 : * extending this switch. If we do see an unrecognized value at
978 : * runtime, the behavior will be the same as for EXPR_KIND_OTHER,
979 : * which is sane anyway.
980 : */
981 : }
982 3412 : if (err)
983 30 : ereport(ERROR,
984 : (errcode(ERRCODE_WINDOWING_ERROR),
985 : errmsg_internal("%s", err),
986 : parser_errposition(pstate, wfunc->location)));
987 3382 : if (errkind)
988 18 : ereport(ERROR,
989 : (errcode(ERRCODE_WINDOWING_ERROR),
990 : /* translator: %s is name of a SQL construct, eg GROUP BY */
991 : errmsg("window functions are not allowed in %s",
992 : ParseExprKindName(pstate->p_expr_kind)),
993 : parser_errposition(pstate, wfunc->location)));
994 :
995 : /*
996 : * If the OVER clause just specifies a window name, find that WINDOW
997 : * clause (which had better be present). Otherwise, try to match all the
998 : * properties of the OVER clause, and make a new entry in the p_windowdefs
999 : * list if no luck.
1000 : */
1001 3364 : if (windef->name)
1002 : {
1003 942 : Index winref = 0;
1004 : ListCell *lc;
1005 :
1006 : Assert(windef->refname == NULL &&
1007 : windef->partitionClause == NIL &&
1008 : windef->orderClause == NIL &&
1009 : windef->frameOptions == FRAMEOPTION_DEFAULTS);
1010 :
1011 948 : foreach(lc, pstate->p_windowdefs)
1012 : {
1013 948 : WindowDef *refwin = (WindowDef *) lfirst(lc);
1014 :
1015 948 : winref++;
1016 948 : if (refwin->name && strcmp(refwin->name, windef->name) == 0)
1017 : {
1018 942 : wfunc->winref = winref;
1019 942 : break;
1020 : }
1021 : }
1022 942 : if (lc == NULL) /* didn't find it? */
1023 0 : ereport(ERROR,
1024 : (errcode(ERRCODE_UNDEFINED_OBJECT),
1025 : errmsg("window \"%s\" does not exist", windef->name),
1026 : parser_errposition(pstate, windef->location)));
1027 : }
1028 : else
1029 : {
1030 2422 : Index winref = 0;
1031 : ListCell *lc;
1032 :
1033 2752 : foreach(lc, pstate->p_windowdefs)
1034 : {
1035 552 : WindowDef *refwin = (WindowDef *) lfirst(lc);
1036 :
1037 552 : winref++;
1038 552 : if (refwin->refname && windef->refname &&
1039 0 : strcmp(refwin->refname, windef->refname) == 0)
1040 : /* matched on refname */ ;
1041 552 : else if (!refwin->refname && !windef->refname)
1042 : /* matched, no refname */ ;
1043 : else
1044 24 : continue;
1045 :
1046 : /*
1047 : * Also see similar de-duplication code in optimize_window_clauses
1048 : */
1049 966 : if (equal(refwin->partitionClause, windef->partitionClause) &&
1050 438 : equal(refwin->orderClause, windef->orderClause) &&
1051 600 : refwin->frameOptions == windef->frameOptions &&
1052 444 : equal(refwin->startOffset, windef->startOffset) &&
1053 222 : equal(refwin->endOffset, windef->endOffset))
1054 : {
1055 : /* found a duplicate window specification */
1056 222 : wfunc->winref = winref;
1057 222 : break;
1058 : }
1059 : }
1060 2422 : if (lc == NULL) /* didn't find it? */
1061 : {
1062 2200 : pstate->p_windowdefs = lappend(pstate->p_windowdefs, windef);
1063 2200 : wfunc->winref = list_length(pstate->p_windowdefs);
1064 : }
1065 : }
1066 :
1067 3364 : pstate->p_hasWindowFuncs = true;
1068 3364 : }
1069 :
1070 : /*
1071 : * parseCheckAggregates
1072 : * Check for aggregates where they shouldn't be and improper grouping, and
1073 : * replace grouped variables in the targetlist and HAVING clause with Vars
1074 : * that reference the RTE_GROUP RTE.
1075 : * This function should be called after the target list and qualifications
1076 : * are finalized.
1077 : *
1078 : * Misplaced aggregates are now mostly detected in transformAggregateCall,
1079 : * but it seems more robust to check for aggregates in recursive queries
1080 : * only after everything is finalized. In any case it's hard to detect
1081 : * improper grouping on-the-fly, so we have to make another pass over the
1082 : * query for that.
1083 : */
1084 : void
1085 37288 : parseCheckAggregates(ParseState *pstate, Query *qry)
1086 : {
1087 37288 : List *gset_common = NIL;
1088 37288 : List *groupClauses = NIL;
1089 37288 : List *groupClauseCommonVars = NIL;
1090 : bool have_non_var_grouping;
1091 37288 : List *func_grouped_rels = NIL;
1092 : ListCell *l;
1093 : bool hasJoinRTEs;
1094 : bool hasSelfRefRTEs;
1095 : Node *clause;
1096 :
1097 : /* This should only be called if we found aggregates or grouping */
1098 : Assert(pstate->p_hasAggs || qry->groupClause || qry->havingQual || qry->groupingSets);
1099 :
1100 : /*
1101 : * If we have grouping sets, expand them and find the intersection of all
1102 : * sets.
1103 : */
1104 37288 : if (qry->groupingSets)
1105 : {
1106 : /*
1107 : * The limit of 4096 is arbitrary and exists simply to avoid resource
1108 : * issues from pathological constructs.
1109 : */
1110 884 : List *gsets = expand_grouping_sets(qry->groupingSets, qry->groupDistinct, 4096);
1111 :
1112 884 : if (!gsets)
1113 0 : ereport(ERROR,
1114 : (errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
1115 : errmsg("too many grouping sets present (maximum 4096)"),
1116 : parser_errposition(pstate,
1117 : qry->groupClause
1118 : ? exprLocation((Node *) qry->groupClause)
1119 : : exprLocation((Node *) qry->groupingSets))));
1120 :
1121 : /*
1122 : * The intersection will often be empty, so help things along by
1123 : * seeding the intersect with the smallest set.
1124 : */
1125 884 : gset_common = linitial(gsets);
1126 :
1127 884 : if (gset_common)
1128 : {
1129 580 : for_each_from(l, gsets, 1)
1130 : {
1131 382 : gset_common = list_intersection_int(gset_common, lfirst(l));
1132 382 : if (!gset_common)
1133 160 : break;
1134 : }
1135 : }
1136 :
1137 : /*
1138 : * If there was only one grouping set in the expansion, AND if the
1139 : * groupClause is non-empty (meaning that the grouping set is not
1140 : * empty either), then we can ditch the grouping set and pretend we
1141 : * just had a normal GROUP BY.
1142 : */
1143 884 : if (list_length(gsets) == 1 && qry->groupClause)
1144 24 : qry->groupingSets = NIL;
1145 : }
1146 :
1147 : /*
1148 : * Scan the range table to see if there are JOIN or self-reference CTE
1149 : * entries. We'll need this info below.
1150 : */
1151 37288 : hasJoinRTEs = hasSelfRefRTEs = false;
1152 81658 : foreach(l, pstate->p_rtable)
1153 : {
1154 44370 : RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
1155 :
1156 44370 : if (rte->rtekind == RTE_JOIN)
1157 1876 : hasJoinRTEs = true;
1158 42494 : else if (rte->rtekind == RTE_CTE && rte->self_reference)
1159 12 : hasSelfRefRTEs = true;
1160 : }
1161 :
1162 : /*
1163 : * Build a list of the acceptable GROUP BY expressions for use by
1164 : * substitute_grouped_columns().
1165 : *
1166 : * We get the TLE, not just the expr, because GROUPING wants to know the
1167 : * sortgroupref.
1168 : */
1169 44874 : foreach(l, qry->groupClause)
1170 : {
1171 7586 : SortGroupClause *grpcl = (SortGroupClause *) lfirst(l);
1172 : TargetEntry *expr;
1173 :
1174 7586 : expr = get_sortgroupclause_tle(grpcl, qry->targetList);
1175 7586 : if (expr == NULL)
1176 0 : continue; /* probably cannot happen */
1177 :
1178 7586 : groupClauses = lappend(groupClauses, expr);
1179 : }
1180 :
1181 : /*
1182 : * If there are join alias vars involved, we have to flatten them to the
1183 : * underlying vars, so that aliased and unaliased vars will be correctly
1184 : * taken as equal. We can skip the expense of doing this if no rangetable
1185 : * entries are RTE_JOIN kind.
1186 : */
1187 37288 : if (hasJoinRTEs)
1188 1566 : groupClauses = (List *) flatten_join_alias_vars(NULL, qry,
1189 : (Node *) groupClauses);
1190 :
1191 : /*
1192 : * Detect whether any of the grouping expressions aren't simple Vars; if
1193 : * they're all Vars then we don't have to work so hard in the recursive
1194 : * scans. (Note we have to flatten aliases before this.)
1195 : *
1196 : * Track Vars that are included in all grouping sets separately in
1197 : * groupClauseCommonVars, since these are the only ones we can use to
1198 : * check for functional dependencies.
1199 : */
1200 37288 : have_non_var_grouping = false;
1201 44874 : foreach(l, groupClauses)
1202 : {
1203 7586 : TargetEntry *tle = lfirst(l);
1204 :
1205 7586 : if (!IsA(tle->expr, Var))
1206 : {
1207 1384 : have_non_var_grouping = true;
1208 : }
1209 7762 : else if (!qry->groupingSets ||
1210 1560 : list_member_int(gset_common, tle->ressortgroupref))
1211 : {
1212 4816 : groupClauseCommonVars = lappend(groupClauseCommonVars, tle->expr);
1213 : }
1214 : }
1215 :
1216 : /*
1217 : * If there are any acceptable GROUP BY expressions, build an RTE and
1218 : * nsitem for the result of the grouping step.
1219 : */
1220 37288 : if (groupClauses)
1221 : {
1222 4402 : pstate->p_grouping_nsitem =
1223 4402 : addRangeTableEntryForGroup(pstate, groupClauses);
1224 :
1225 : /* Set qry->rtable again in case it was previously NIL */
1226 4402 : qry->rtable = pstate->p_rtable;
1227 : /* Mark the Query as having RTE_GROUP RTE */
1228 4402 : qry->hasGroupRTE = true;
1229 : }
1230 :
1231 : /*
1232 : * Replace grouped variables in the targetlist and HAVING clause with Vars
1233 : * that reference the RTE_GROUP RTE. Emit an error message if we find any
1234 : * ungrouped variables.
1235 : *
1236 : * Note: because we check resjunk tlist elements as well as regular ones,
1237 : * this will also find ungrouped variables that came from ORDER BY and
1238 : * WINDOW clauses. For that matter, it's also going to examine the
1239 : * grouping expressions themselves --- but they'll all pass the test ...
1240 : *
1241 : * We also finalize GROUPING expressions, but for that we need to traverse
1242 : * the original (unflattened) clause in order to modify nodes.
1243 : */
1244 37288 : clause = (Node *) qry->targetList;
1245 37288 : finalize_grouping_exprs(clause, pstate, qry,
1246 : groupClauses, hasJoinRTEs,
1247 : have_non_var_grouping);
1248 37282 : if (hasJoinRTEs)
1249 1566 : clause = flatten_join_alias_vars(NULL, qry, clause);
1250 37198 : qry->targetList = (List *)
1251 37282 : substitute_grouped_columns(clause, pstate, qry,
1252 : groupClauses, groupClauseCommonVars,
1253 : gset_common,
1254 : have_non_var_grouping,
1255 : &func_grouped_rels);
1256 :
1257 37198 : clause = (Node *) qry->havingQual;
1258 37198 : finalize_grouping_exprs(clause, pstate, qry,
1259 : groupClauses, hasJoinRTEs,
1260 : have_non_var_grouping);
1261 37198 : if (hasJoinRTEs)
1262 1542 : clause = flatten_join_alias_vars(NULL, qry, clause);
1263 37192 : qry->havingQual =
1264 37198 : substitute_grouped_columns(clause, pstate, qry,
1265 : groupClauses, groupClauseCommonVars,
1266 : gset_common,
1267 : have_non_var_grouping,
1268 : &func_grouped_rels);
1269 :
1270 : /*
1271 : * Per spec, aggregates can't appear in a recursive term.
1272 : */
1273 37192 : if (pstate->p_hasAggs && hasSelfRefRTEs)
1274 12 : ereport(ERROR,
1275 : (errcode(ERRCODE_INVALID_RECURSION),
1276 : errmsg("aggregate functions are not allowed in a recursive query's recursive term"),
1277 : parser_errposition(pstate,
1278 : locate_agg_of_level((Node *) qry, 0))));
1279 37180 : }
1280 :
1281 : /*
1282 : * substitute_grouped_columns -
1283 : * Scan the given expression tree for grouped variables (variables that
1284 : * are listed in the groupClauses list) and replace them with Vars that
1285 : * reference the RTE_GROUP RTE. Emit a suitable error message if any
1286 : * ungrouped variables (variables that are not listed in the groupClauses
1287 : * list and are not within the arguments of aggregate functions) are
1288 : * found.
1289 : *
1290 : * NOTE: we assume that the given clause has been transformed suitably for
1291 : * parser output. This means we can use expression_tree_mutator.
1292 : *
1293 : * NOTE: we recognize grouping expressions in the main query, but only
1294 : * grouping Vars in subqueries. For example, this will be rejected,
1295 : * although it could be allowed:
1296 : * SELECT
1297 : * (SELECT x FROM bar where y = (foo.a + foo.b))
1298 : * FROM foo
1299 : * GROUP BY a + b;
1300 : * The difficulty is the need to account for different sublevels_up.
1301 : * This appears to require a whole custom version of equal(), which is
1302 : * way more pain than the feature seems worth.
1303 : */
1304 : static Node *
1305 74480 : substitute_grouped_columns(Node *node, ParseState *pstate, Query *qry,
1306 : List *groupClauses, List *groupClauseCommonVars,
1307 : List *gset_common,
1308 : bool have_non_var_grouping,
1309 : List **func_grouped_rels)
1310 : {
1311 : substitute_grouped_columns_context context;
1312 :
1313 74480 : context.pstate = pstate;
1314 74480 : context.qry = qry;
1315 74480 : context.hasJoinRTEs = false; /* assume caller flattened join Vars */
1316 74480 : context.groupClauses = groupClauses;
1317 74480 : context.groupClauseCommonVars = groupClauseCommonVars;
1318 74480 : context.gset_common = gset_common;
1319 74480 : context.have_non_var_grouping = have_non_var_grouping;
1320 74480 : context.func_grouped_rels = func_grouped_rels;
1321 74480 : context.sublevels_up = 0;
1322 74480 : context.in_agg_direct_args = false;
1323 74480 : return substitute_grouped_columns_mutator(node, &context);
1324 : }
1325 :
1326 : static Node *
1327 258968 : substitute_grouped_columns_mutator(Node *node,
1328 : substitute_grouped_columns_context *context)
1329 : {
1330 : ListCell *gl;
1331 :
1332 258968 : if (node == NULL)
1333 84132 : return NULL;
1334 :
1335 174836 : if (IsA(node, Aggref))
1336 : {
1337 42616 : Aggref *agg = (Aggref *) node;
1338 :
1339 42616 : if ((int) agg->agglevelsup == context->sublevels_up)
1340 : {
1341 : /*
1342 : * If we find an aggregate call of the original level, do not
1343 : * recurse into its normal arguments, ORDER BY arguments, or
1344 : * filter; grouped vars there do not need to be replaced and
1345 : * ungrouped vars there are not an error. But we should check
1346 : * direct arguments as though they weren't in an aggregate. We
1347 : * set a special flag in the context to help produce a useful
1348 : * error message for ungrouped vars in direct arguments.
1349 : */
1350 42610 : agg = copyObject(agg);
1351 :
1352 : Assert(!context->in_agg_direct_args);
1353 42610 : context->in_agg_direct_args = true;
1354 42604 : agg->aggdirectargs = (List *)
1355 42610 : substitute_grouped_columns_mutator((Node *) agg->aggdirectargs,
1356 : context);
1357 42604 : context->in_agg_direct_args = false;
1358 42604 : return (Node *) agg;
1359 : }
1360 :
1361 : /*
1362 : * We can skip recursing into aggregates of higher levels altogether,
1363 : * since they could not possibly contain Vars of concern to us (see
1364 : * transformAggregateCall). We do need to look at aggregates of lower
1365 : * levels, however.
1366 : */
1367 6 : if ((int) agg->agglevelsup > context->sublevels_up)
1368 0 : return node;
1369 : }
1370 :
1371 132226 : if (IsA(node, GroupingFunc))
1372 : {
1373 396 : GroupingFunc *grp = (GroupingFunc *) node;
1374 :
1375 : /* handled GroupingFunc separately, no need to recheck at this level */
1376 :
1377 396 : if ((int) grp->agglevelsup >= context->sublevels_up)
1378 364 : return node;
1379 : }
1380 :
1381 : /*
1382 : * If we have any GROUP BY items that are not simple Vars, check to see if
1383 : * subexpression as a whole matches any GROUP BY item. We need to do this
1384 : * at every recursion level so that we recognize GROUPed-BY expressions
1385 : * before reaching variables within them. But this only works at the outer
1386 : * query level, as noted above.
1387 : */
1388 131862 : if (context->have_non_var_grouping && context->sublevels_up == 0)
1389 : {
1390 7650 : int attnum = 0;
1391 :
1392 20870 : foreach(gl, context->groupClauses)
1393 : {
1394 15378 : TargetEntry *tle = (TargetEntry *) lfirst(gl);
1395 :
1396 15378 : attnum++;
1397 15378 : if (equal(node, tle->expr))
1398 : {
1399 : /* acceptable, replace it with a GROUP Var */
1400 2158 : return (Node *) buildGroupedVar(attnum,
1401 : tle->ressortgroupref,
1402 : context);
1403 : }
1404 : }
1405 : }
1406 :
1407 : /*
1408 : * Constants are always acceptable. We have to do this after we checked
1409 : * the subexpression as a whole for a match, because it is possible that
1410 : * we have GROUP BY items that are constants, and the constants would
1411 : * become not so constant after the grouping step.
1412 : */
1413 129704 : if (IsA(node, Const) ||
1414 125536 : IsA(node, Param))
1415 4408 : return node;
1416 :
1417 : /*
1418 : * If we have an ungrouped Var of the original query level, we have a
1419 : * failure. Vars below the original query level are not a problem, and
1420 : * neither are Vars from above it. (If such Vars are ungrouped as far as
1421 : * their own query level is concerned, that's someone else's problem...)
1422 : */
1423 125296 : if (IsA(node, Var))
1424 : {
1425 9462 : Var *var = (Var *) node;
1426 : RangeTblEntry *rte;
1427 : char *attname;
1428 :
1429 9462 : if (var->varlevelsup != context->sublevels_up)
1430 428 : return node; /* it's not local to my query, ignore */
1431 :
1432 : /*
1433 : * Check for a match, if we didn't do it above.
1434 : */
1435 9034 : if (!context->have_non_var_grouping || context->sublevels_up != 0)
1436 : {
1437 9028 : int attnum = 0;
1438 :
1439 12704 : foreach(gl, context->groupClauses)
1440 : {
1441 12360 : TargetEntry *tle = (TargetEntry *) lfirst(gl);
1442 12360 : Var *gvar = (Var *) tle->expr;
1443 :
1444 12360 : attnum++;
1445 12360 : if (IsA(gvar, Var) &&
1446 12360 : gvar->varno == var->varno &&
1447 11674 : gvar->varattno == var->varattno &&
1448 8684 : gvar->varlevelsup == 0)
1449 : {
1450 : /* acceptable, replace it with a GROUP Var */
1451 8684 : return (Node *) buildGroupedVar(attnum,
1452 : tle->ressortgroupref,
1453 : context);
1454 : }
1455 : }
1456 : }
1457 :
1458 : /*
1459 : * Check whether the Var is known functionally dependent on the GROUP
1460 : * BY columns. If so, we can allow the Var to be used, because the
1461 : * grouping is really a no-op for this table. However, this deduction
1462 : * depends on one or more constraints of the table, so we have to add
1463 : * those constraints to the query's constraintDeps list, because it's
1464 : * not semantically valid anymore if the constraint(s) get dropped.
1465 : * (Therefore, this check must be the last-ditch effort before raising
1466 : * error: we don't want to add dependencies unnecessarily.)
1467 : *
1468 : * Because this is a pretty expensive check, and will have the same
1469 : * outcome for all columns of a table, we remember which RTEs we've
1470 : * already proven functional dependency for in the func_grouped_rels
1471 : * list. This test also prevents us from adding duplicate entries to
1472 : * the constraintDeps list.
1473 : */
1474 350 : if (list_member_int(*context->func_grouped_rels, var->varno))
1475 138 : return node; /* previously proven acceptable */
1476 :
1477 : Assert(var->varno > 0 &&
1478 : (int) var->varno <= list_length(context->pstate->p_rtable));
1479 212 : rte = rt_fetch(var->varno, context->pstate->p_rtable);
1480 212 : if (rte->rtekind == RTE_RELATION)
1481 : {
1482 206 : if (check_functional_grouping(rte->relid,
1483 206 : var->varno,
1484 : 0,
1485 : context->groupClauseCommonVars,
1486 206 : &context->qry->constraintDeps))
1487 : {
1488 244 : *context->func_grouped_rels =
1489 122 : lappend_int(*context->func_grouped_rels, var->varno);
1490 122 : return node; /* acceptable */
1491 : }
1492 : }
1493 :
1494 : /* Found an ungrouped local variable; generate error message */
1495 90 : attname = get_rte_attribute_name(rte, var->varattno);
1496 90 : if (context->sublevels_up == 0)
1497 90 : ereport(ERROR,
1498 : (errcode(ERRCODE_GROUPING_ERROR),
1499 : errmsg("column \"%s.%s\" must appear in the GROUP BY clause or be used in an aggregate function",
1500 : rte->eref->aliasname, attname),
1501 : context->in_agg_direct_args ?
1502 : errdetail("Direct arguments of an ordered-set aggregate must use only grouped columns.") : 0,
1503 : parser_errposition(context->pstate, var->location)));
1504 : else
1505 0 : ereport(ERROR,
1506 : (errcode(ERRCODE_GROUPING_ERROR),
1507 : errmsg("subquery uses ungrouped column \"%s.%s\" from outer query",
1508 : rte->eref->aliasname, attname),
1509 : parser_errposition(context->pstate, var->location)));
1510 : }
1511 :
1512 115834 : if (IsA(node, Query))
1513 : {
1514 : /* Recurse into subselects */
1515 : Query *newnode;
1516 :
1517 320 : context->sublevels_up++;
1518 320 : newnode = query_tree_mutator((Query *) node,
1519 : substitute_grouped_columns_mutator,
1520 : context,
1521 : 0);
1522 320 : context->sublevels_up--;
1523 320 : return (Node *) newnode;
1524 : }
1525 115514 : return expression_tree_mutator(node, substitute_grouped_columns_mutator,
1526 : context);
1527 : }
1528 :
1529 : /*
1530 : * finalize_grouping_exprs -
1531 : * Scan the given expression tree for GROUPING() and related calls,
1532 : * and validate and process their arguments.
1533 : *
1534 : * This is split out from substitute_grouped_columns above because it needs
1535 : * to modify the nodes (which it does in-place, not via a mutator) while
1536 : * substitute_grouped_columns may see only a copy of the original thanks to
1537 : * flattening of join alias vars. So here, we flatten each individual
1538 : * GROUPING argument as we see it before comparing it.
1539 : */
1540 : static void
1541 74486 : finalize_grouping_exprs(Node *node, ParseState *pstate, Query *qry,
1542 : List *groupClauses, bool hasJoinRTEs,
1543 : bool have_non_var_grouping)
1544 : {
1545 : substitute_grouped_columns_context context;
1546 :
1547 74486 : context.pstate = pstate;
1548 74486 : context.qry = qry;
1549 74486 : context.hasJoinRTEs = hasJoinRTEs;
1550 74486 : context.groupClauses = groupClauses;
1551 74486 : context.groupClauseCommonVars = NIL;
1552 74486 : context.gset_common = NIL;
1553 74486 : context.have_non_var_grouping = have_non_var_grouping;
1554 74486 : context.func_grouped_rels = NULL;
1555 74486 : context.sublevels_up = 0;
1556 74486 : context.in_agg_direct_args = false;
1557 74486 : finalize_grouping_exprs_walker(node, &context);
1558 74480 : }
1559 :
1560 : static bool
1561 254346 : finalize_grouping_exprs_walker(Node *node,
1562 : substitute_grouped_columns_context *context)
1563 : {
1564 : ListCell *gl;
1565 :
1566 254346 : if (node == NULL)
1567 85358 : return false;
1568 168988 : if (IsA(node, Const) ||
1569 163554 : IsA(node, Param))
1570 5686 : return false; /* constants are always acceptable */
1571 :
1572 163302 : if (IsA(node, Aggref))
1573 : {
1574 42622 : Aggref *agg = (Aggref *) node;
1575 :
1576 42622 : if ((int) agg->agglevelsup == context->sublevels_up)
1577 : {
1578 : /*
1579 : * If we find an aggregate call of the original level, do not
1580 : * recurse into its normal arguments, ORDER BY arguments, or
1581 : * filter; GROUPING exprs of this level are not allowed there. But
1582 : * check direct arguments as though they weren't in an aggregate.
1583 : */
1584 : bool result;
1585 :
1586 : Assert(!context->in_agg_direct_args);
1587 42616 : context->in_agg_direct_args = true;
1588 42616 : result = finalize_grouping_exprs_walker((Node *) agg->aggdirectargs,
1589 : context);
1590 42616 : context->in_agg_direct_args = false;
1591 42616 : return result;
1592 : }
1593 :
1594 : /*
1595 : * We can skip recursing into aggregates of higher levels altogether,
1596 : * since they could not possibly contain exprs of concern to us (see
1597 : * transformAggregateCall). We do need to look at aggregates of lower
1598 : * levels, however.
1599 : */
1600 6 : if ((int) agg->agglevelsup > context->sublevels_up)
1601 0 : return false;
1602 : }
1603 :
1604 120686 : if (IsA(node, GroupingFunc))
1605 : {
1606 402 : GroupingFunc *grp = (GroupingFunc *) node;
1607 :
1608 : /*
1609 : * We only need to check GroupingFunc nodes at the exact level to
1610 : * which they belong, since they cannot mix levels in arguments.
1611 : */
1612 :
1613 402 : if ((int) grp->agglevelsup == context->sublevels_up)
1614 : {
1615 : ListCell *lc;
1616 362 : List *ref_list = NIL;
1617 :
1618 908 : foreach(lc, grp->args)
1619 : {
1620 552 : Node *expr = lfirst(lc);
1621 552 : Index ref = 0;
1622 :
1623 552 : if (context->hasJoinRTEs)
1624 48 : expr = flatten_join_alias_vars(NULL, context->qry, expr);
1625 :
1626 : /*
1627 : * Each expression must match a grouping entry at the current
1628 : * query level. Unlike the general expression case, we don't
1629 : * allow functional dependencies or outer references.
1630 : */
1631 :
1632 552 : if (IsA(expr, Var))
1633 : {
1634 492 : Var *var = (Var *) expr;
1635 :
1636 492 : if (var->varlevelsup == context->sublevels_up)
1637 : {
1638 724 : foreach(gl, context->groupClauses)
1639 : {
1640 718 : TargetEntry *tle = lfirst(gl);
1641 718 : Var *gvar = (Var *) tle->expr;
1642 :
1643 718 : if (IsA(gvar, Var) &&
1644 718 : gvar->varno == var->varno &&
1645 706 : gvar->varattno == var->varattno &&
1646 486 : gvar->varlevelsup == 0)
1647 : {
1648 486 : ref = tle->ressortgroupref;
1649 486 : break;
1650 : }
1651 : }
1652 : }
1653 : }
1654 60 : else if (context->have_non_var_grouping &&
1655 60 : context->sublevels_up == 0)
1656 : {
1657 120 : foreach(gl, context->groupClauses)
1658 : {
1659 120 : TargetEntry *tle = lfirst(gl);
1660 :
1661 120 : if (equal(expr, tle->expr))
1662 : {
1663 60 : ref = tle->ressortgroupref;
1664 60 : break;
1665 : }
1666 : }
1667 : }
1668 :
1669 552 : if (ref == 0)
1670 6 : ereport(ERROR,
1671 : (errcode(ERRCODE_GROUPING_ERROR),
1672 : errmsg("arguments to GROUPING must be grouping expressions of the associated query level"),
1673 : parser_errposition(context->pstate,
1674 : exprLocation(expr))));
1675 :
1676 546 : ref_list = lappend_int(ref_list, ref);
1677 : }
1678 :
1679 356 : grp->refs = ref_list;
1680 : }
1681 :
1682 396 : if ((int) grp->agglevelsup > context->sublevels_up)
1683 8 : return false;
1684 : }
1685 :
1686 120672 : if (IsA(node, Query))
1687 : {
1688 : /* Recurse into subselects */
1689 : bool result;
1690 :
1691 420 : context->sublevels_up++;
1692 420 : result = query_tree_walker((Query *) node,
1693 : finalize_grouping_exprs_walker,
1694 : context,
1695 : 0);
1696 420 : context->sublevels_up--;
1697 420 : return result;
1698 : }
1699 120252 : return expression_tree_walker(node, finalize_grouping_exprs_walker,
1700 : context);
1701 : }
1702 :
1703 : /*
1704 : * buildGroupedVar -
1705 : * build a Var node that references the RTE_GROUP RTE
1706 : */
1707 : static Var *
1708 10842 : buildGroupedVar(int attnum, Index ressortgroupref,
1709 : substitute_grouped_columns_context *context)
1710 : {
1711 : Var *var;
1712 10842 : ParseNamespaceItem *grouping_nsitem = context->pstate->p_grouping_nsitem;
1713 10842 : ParseNamespaceColumn *nscol = grouping_nsitem->p_nscolumns + attnum - 1;
1714 :
1715 : Assert(nscol->p_varno == grouping_nsitem->p_rtindex);
1716 : Assert(nscol->p_varattno == attnum);
1717 10842 : var = makeVar(nscol->p_varno,
1718 10842 : nscol->p_varattno,
1719 : nscol->p_vartype,
1720 : nscol->p_vartypmod,
1721 : nscol->p_varcollid,
1722 10842 : context->sublevels_up);
1723 : /* makeVar doesn't offer parameters for these, so set by hand: */
1724 10842 : var->varnosyn = nscol->p_varnosyn;
1725 10842 : var->varattnosyn = nscol->p_varattnosyn;
1726 :
1727 10842 : if (context->qry->groupingSets &&
1728 1926 : !list_member_int(context->gset_common, ressortgroupref))
1729 1722 : var->varnullingrels =
1730 1722 : bms_add_member(var->varnullingrels, grouping_nsitem->p_rtindex);
1731 :
1732 10842 : return var;
1733 : }
1734 :
1735 :
1736 : /*
1737 : * Given a GroupingSet node, expand it and return a list of lists.
1738 : *
1739 : * For EMPTY nodes, return a list of one empty list.
1740 : *
1741 : * For SIMPLE nodes, return a list of one list, which is the node content.
1742 : *
1743 : * For CUBE and ROLLUP nodes, return a list of the expansions.
1744 : *
1745 : * For SET nodes, recursively expand contained CUBE and ROLLUP.
1746 : */
1747 : static List *
1748 4114 : expand_groupingset_node(GroupingSet *gs)
1749 : {
1750 4114 : List *result = NIL;
1751 :
1752 4114 : switch (gs->kind)
1753 : {
1754 432 : case GROUPING_SET_EMPTY:
1755 432 : result = list_make1(NIL);
1756 432 : break;
1757 :
1758 1864 : case GROUPING_SET_SIMPLE:
1759 1864 : result = list_make1(gs->content);
1760 1864 : break;
1761 :
1762 554 : case GROUPING_SET_ROLLUP:
1763 : {
1764 554 : List *rollup_val = gs->content;
1765 : ListCell *lc;
1766 554 : int curgroup_size = list_length(gs->content);
1767 :
1768 1438 : while (curgroup_size > 0)
1769 : {
1770 884 : List *current_result = NIL;
1771 884 : int i = curgroup_size;
1772 :
1773 1214 : foreach(lc, rollup_val)
1774 : {
1775 1214 : GroupingSet *gs_current = (GroupingSet *) lfirst(lc);
1776 :
1777 : Assert(gs_current->kind == GROUPING_SET_SIMPLE);
1778 :
1779 1214 : current_result = list_concat(current_result,
1780 1214 : gs_current->content);
1781 :
1782 : /* If we are done with making the current group, break */
1783 1214 : if (--i == 0)
1784 884 : break;
1785 : }
1786 :
1787 884 : result = lappend(result, current_result);
1788 884 : --curgroup_size;
1789 : }
1790 :
1791 554 : result = lappend(result, NIL);
1792 : }
1793 554 : break;
1794 :
1795 368 : case GROUPING_SET_CUBE:
1796 : {
1797 368 : List *cube_list = gs->content;
1798 368 : int number_bits = list_length(cube_list);
1799 : uint32 num_sets;
1800 : uint32 i;
1801 :
1802 : /* parser should cap this much lower */
1803 : Assert(number_bits < 31);
1804 :
1805 368 : num_sets = (1U << number_bits);
1806 :
1807 2040 : for (i = 0; i < num_sets; i++)
1808 : {
1809 1672 : List *current_result = NIL;
1810 : ListCell *lc;
1811 1672 : uint32 mask = 1U;
1812 :
1813 5552 : foreach(lc, cube_list)
1814 : {
1815 3880 : GroupingSet *gs_current = (GroupingSet *) lfirst(lc);
1816 :
1817 : Assert(gs_current->kind == GROUPING_SET_SIMPLE);
1818 :
1819 3880 : if (mask & i)
1820 1940 : current_result = list_concat(current_result,
1821 1940 : gs_current->content);
1822 :
1823 3880 : mask <<= 1;
1824 : }
1825 :
1826 1672 : result = lappend(result, current_result);
1827 : }
1828 : }
1829 368 : break;
1830 :
1831 896 : case GROUPING_SET_SETS:
1832 : {
1833 : ListCell *lc;
1834 :
1835 3144 : foreach(lc, gs->content)
1836 : {
1837 2248 : List *current_result = expand_groupingset_node(lfirst(lc));
1838 :
1839 2248 : result = list_concat(result, current_result);
1840 : }
1841 : }
1842 896 : break;
1843 : }
1844 :
1845 4114 : return result;
1846 : }
1847 :
1848 : /* list_sort comparator to sort sub-lists by length */
1849 : static int
1850 5670 : cmp_list_len_asc(const ListCell *a, const ListCell *b)
1851 : {
1852 5670 : int la = list_length((const List *) lfirst(a));
1853 5670 : int lb = list_length((const List *) lfirst(b));
1854 :
1855 5670 : return pg_cmp_s32(la, lb);
1856 : }
1857 :
1858 : /* list_sort comparator to sort sub-lists by length and contents */
1859 : static int
1860 320 : cmp_list_len_contents_asc(const ListCell *a, const ListCell *b)
1861 : {
1862 320 : int res = cmp_list_len_asc(a, b);
1863 :
1864 320 : if (res == 0)
1865 : {
1866 96 : List *la = (List *) lfirst(a);
1867 96 : List *lb = (List *) lfirst(b);
1868 : ListCell *lca;
1869 : ListCell *lcb;
1870 :
1871 224 : forboth(lca, la, lcb, lb)
1872 : {
1873 160 : int va = lfirst_int(lca);
1874 160 : int vb = lfirst_int(lcb);
1875 :
1876 160 : if (va > vb)
1877 32 : return 1;
1878 144 : if (va < vb)
1879 16 : return -1;
1880 : }
1881 : }
1882 :
1883 288 : return res;
1884 : }
1885 :
1886 : /*
1887 : * Expand a groupingSets clause to a flat list of grouping sets.
1888 : * The returned list is sorted by length, shortest sets first.
1889 : *
1890 : * This is mainly for the planner, but we use it here too to do
1891 : * some consistency checks.
1892 : */
1893 : List *
1894 1738 : expand_grouping_sets(List *groupingSets, bool groupDistinct, int limit)
1895 : {
1896 1738 : List *expanded_groups = NIL;
1897 1738 : List *result = NIL;
1898 1738 : double numsets = 1;
1899 : ListCell *lc;
1900 :
1901 1738 : if (groupingSets == NIL)
1902 0 : return NIL;
1903 :
1904 3604 : foreach(lc, groupingSets)
1905 : {
1906 1866 : List *current_result = NIL;
1907 1866 : GroupingSet *gs = lfirst(lc);
1908 :
1909 1866 : current_result = expand_groupingset_node(gs);
1910 :
1911 : Assert(current_result != NIL);
1912 :
1913 1866 : numsets *= list_length(current_result);
1914 :
1915 1866 : if (limit >= 0 && numsets > limit)
1916 0 : return NIL;
1917 :
1918 1866 : expanded_groups = lappend(expanded_groups, current_result);
1919 : }
1920 :
1921 : /*
1922 : * Do cartesian product between sublists of expanded_groups. While at it,
1923 : * remove any duplicate elements from individual grouping sets (we must
1924 : * NOT change the number of sets though)
1925 : */
1926 :
1927 6856 : foreach(lc, (List *) linitial(expanded_groups))
1928 : {
1929 5118 : result = lappend(result, list_union_int(NIL, (List *) lfirst(lc)));
1930 : }
1931 :
1932 1866 : for_each_from(lc, expanded_groups, 1)
1933 : {
1934 128 : List *p = lfirst(lc);
1935 128 : List *new_result = NIL;
1936 : ListCell *lc2;
1937 :
1938 404 : foreach(lc2, result)
1939 : {
1940 276 : List *q = lfirst(lc2);
1941 : ListCell *lc3;
1942 :
1943 960 : foreach(lc3, p)
1944 : {
1945 684 : new_result = lappend(new_result,
1946 684 : list_union_int(q, (List *) lfirst(lc3)));
1947 : }
1948 : }
1949 128 : result = new_result;
1950 : }
1951 :
1952 : /* Now sort the lists by length and deduplicate if necessary */
1953 1738 : if (!groupDistinct || list_length(result) < 2)
1954 1722 : list_sort(result, cmp_list_len_asc);
1955 : else
1956 : {
1957 : ListCell *cell;
1958 : List *prev;
1959 :
1960 : /* Sort each groupset individually */
1961 160 : foreach(cell, result)
1962 144 : list_sort(lfirst(cell), list_int_cmp);
1963 :
1964 : /* Now sort the list of groupsets by length and contents */
1965 16 : list_sort(result, cmp_list_len_contents_asc);
1966 :
1967 : /* Finally, remove duplicates */
1968 16 : prev = linitial(result);
1969 144 : for_each_from(cell, result, 1)
1970 : {
1971 128 : if (equal(lfirst(cell), prev))
1972 64 : result = foreach_delete_current(result, cell);
1973 : else
1974 64 : prev = lfirst(cell);
1975 : }
1976 : }
1977 :
1978 1738 : return result;
1979 : }
1980 :
1981 : /*
1982 : * get_aggregate_argtypes
1983 : * Identify the specific datatypes passed to an aggregate call.
1984 : *
1985 : * Given an Aggref, extract the actual datatypes of the input arguments.
1986 : * The input datatypes are reported in a way that matches up with the
1987 : * aggregate's declaration, ie, any ORDER BY columns attached to a plain
1988 : * aggregate are ignored, but we report both direct and aggregated args of
1989 : * an ordered-set aggregate.
1990 : *
1991 : * Datatypes are returned into inputTypes[], which must reference an array
1992 : * of length FUNC_MAX_ARGS.
1993 : *
1994 : * The function result is the number of actual arguments.
1995 : */
1996 : int
1997 93406 : get_aggregate_argtypes(Aggref *aggref, Oid *inputTypes)
1998 : {
1999 93406 : int numArguments = 0;
2000 : ListCell *lc;
2001 :
2002 : Assert(list_length(aggref->aggargtypes) <= FUNC_MAX_ARGS);
2003 :
2004 170542 : foreach(lc, aggref->aggargtypes)
2005 : {
2006 77136 : inputTypes[numArguments++] = lfirst_oid(lc);
2007 : }
2008 :
2009 93406 : return numArguments;
2010 : }
2011 :
2012 : /*
2013 : * resolve_aggregate_transtype
2014 : * Identify the transition state value's datatype for an aggregate call.
2015 : *
2016 : * This function resolves a polymorphic aggregate's state datatype.
2017 : * It must be passed the aggtranstype from the aggregate's catalog entry,
2018 : * as well as the actual argument types extracted by get_aggregate_argtypes.
2019 : * (We could fetch pg_aggregate.aggtranstype internally, but all existing
2020 : * callers already have the value at hand, so we make them pass it.)
2021 : */
2022 : Oid
2023 43582 : resolve_aggregate_transtype(Oid aggfuncid,
2024 : Oid aggtranstype,
2025 : Oid *inputTypes,
2026 : int numArguments)
2027 : {
2028 : /* resolve actual type of transition state, if polymorphic */
2029 43582 : if (IsPolymorphicType(aggtranstype))
2030 : {
2031 : /* have to fetch the agg's declared input types... */
2032 : Oid *declaredArgTypes;
2033 : int agg_nargs;
2034 :
2035 544 : (void) get_func_signature(aggfuncid, &declaredArgTypes, &agg_nargs);
2036 :
2037 : /*
2038 : * VARIADIC ANY aggs could have more actual than declared args, but
2039 : * such extra args can't affect polymorphic type resolution.
2040 : */
2041 : Assert(agg_nargs <= numArguments);
2042 :
2043 544 : aggtranstype = enforce_generic_type_consistency(inputTypes,
2044 : declaredArgTypes,
2045 : agg_nargs,
2046 : aggtranstype,
2047 : false);
2048 544 : pfree(declaredArgTypes);
2049 : }
2050 43582 : return aggtranstype;
2051 : }
2052 :
2053 : /*
2054 : * agg_args_support_sendreceive
2055 : * Returns true if all non-byval of aggref's arg types have send and
2056 : * receive functions.
2057 : */
2058 : bool
2059 13034 : agg_args_support_sendreceive(Aggref *aggref)
2060 : {
2061 : ListCell *lc;
2062 :
2063 25982 : foreach(lc, aggref->args)
2064 : {
2065 : HeapTuple typeTuple;
2066 : Form_pg_type pt;
2067 13034 : TargetEntry *tle = (TargetEntry *) lfirst(lc);
2068 13034 : Oid type = exprType((Node *) tle->expr);
2069 :
2070 13034 : typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type));
2071 13034 : if (!HeapTupleIsValid(typeTuple))
2072 0 : elog(ERROR, "cache lookup failed for type %u", type);
2073 :
2074 13034 : pt = (Form_pg_type) GETSTRUCT(typeTuple);
2075 :
2076 13034 : if (!pt->typbyval &&
2077 11054 : (!OidIsValid(pt->typsend) || !OidIsValid(pt->typreceive)))
2078 : {
2079 86 : ReleaseSysCache(typeTuple);
2080 86 : return false;
2081 : }
2082 12948 : ReleaseSysCache(typeTuple);
2083 : }
2084 12948 : return true;
2085 : }
2086 :
2087 : /*
2088 : * Create an expression tree for the transition function of an aggregate.
2089 : * This is needed so that polymorphic functions can be used within an
2090 : * aggregate --- without the expression tree, such functions would not know
2091 : * the datatypes they are supposed to use. (The trees will never actually
2092 : * be executed, however, so we can skimp a bit on correctness.)
2093 : *
2094 : * agg_input_types and agg_state_type identifies the input types of the
2095 : * aggregate. These should be resolved to actual types (ie, none should
2096 : * ever be ANYELEMENT etc).
2097 : * agg_input_collation is the aggregate function's input collation.
2098 : *
2099 : * For an ordered-set aggregate, remember that agg_input_types describes
2100 : * the direct arguments followed by the aggregated arguments.
2101 : *
2102 : * transfn_oid and invtransfn_oid identify the funcs to be called; the
2103 : * latter may be InvalidOid, however if invtransfn_oid is set then
2104 : * transfn_oid must also be set.
2105 : *
2106 : * transfn_oid may also be passed as the aggcombinefn when the *transfnexpr is
2107 : * to be used for a combine aggregate phase. We expect invtransfn_oid to be
2108 : * InvalidOid in this case since there is no such thing as an inverse
2109 : * combinefn.
2110 : *
2111 : * Pointers to the constructed trees are returned into *transfnexpr,
2112 : * *invtransfnexpr. If there is no invtransfn, the respective pointer is set
2113 : * to NULL. Since use of the invtransfn is optional, NULL may be passed for
2114 : * invtransfnexpr.
2115 : */
2116 : void
2117 50704 : build_aggregate_transfn_expr(Oid *agg_input_types,
2118 : int agg_num_inputs,
2119 : int agg_num_direct_inputs,
2120 : bool agg_variadic,
2121 : Oid agg_state_type,
2122 : Oid agg_input_collation,
2123 : Oid transfn_oid,
2124 : Oid invtransfn_oid,
2125 : Expr **transfnexpr,
2126 : Expr **invtransfnexpr)
2127 : {
2128 : List *args;
2129 : FuncExpr *fexpr;
2130 : int i;
2131 :
2132 : /*
2133 : * Build arg list to use in the transfn FuncExpr node.
2134 : */
2135 50704 : args = list_make1(make_agg_arg(agg_state_type, agg_input_collation));
2136 :
2137 93506 : for (i = agg_num_direct_inputs; i < agg_num_inputs; i++)
2138 : {
2139 42802 : args = lappend(args,
2140 42802 : make_agg_arg(agg_input_types[i], agg_input_collation));
2141 : }
2142 :
2143 50704 : fexpr = makeFuncExpr(transfn_oid,
2144 : agg_state_type,
2145 : args,
2146 : InvalidOid,
2147 : agg_input_collation,
2148 : COERCE_EXPLICIT_CALL);
2149 50704 : fexpr->funcvariadic = agg_variadic;
2150 50704 : *transfnexpr = (Expr *) fexpr;
2151 :
2152 : /*
2153 : * Build invtransfn expression if requested, with same args as transfn
2154 : */
2155 50704 : if (invtransfnexpr != NULL)
2156 : {
2157 1448 : if (OidIsValid(invtransfn_oid))
2158 : {
2159 792 : fexpr = makeFuncExpr(invtransfn_oid,
2160 : agg_state_type,
2161 : args,
2162 : InvalidOid,
2163 : agg_input_collation,
2164 : COERCE_EXPLICIT_CALL);
2165 792 : fexpr->funcvariadic = agg_variadic;
2166 792 : *invtransfnexpr = (Expr *) fexpr;
2167 : }
2168 : else
2169 656 : *invtransfnexpr = NULL;
2170 : }
2171 50704 : }
2172 :
2173 : /*
2174 : * Like build_aggregate_transfn_expr, but creates an expression tree for the
2175 : * serialization function of an aggregate.
2176 : */
2177 : void
2178 336 : build_aggregate_serialfn_expr(Oid serialfn_oid,
2179 : Expr **serialfnexpr)
2180 : {
2181 : List *args;
2182 : FuncExpr *fexpr;
2183 :
2184 : /* serialfn always takes INTERNAL and returns BYTEA */
2185 336 : args = list_make1(make_agg_arg(INTERNALOID, InvalidOid));
2186 :
2187 336 : fexpr = makeFuncExpr(serialfn_oid,
2188 : BYTEAOID,
2189 : args,
2190 : InvalidOid,
2191 : InvalidOid,
2192 : COERCE_EXPLICIT_CALL);
2193 336 : *serialfnexpr = (Expr *) fexpr;
2194 336 : }
2195 :
2196 : /*
2197 : * Like build_aggregate_transfn_expr, but creates an expression tree for the
2198 : * deserialization function of an aggregate.
2199 : */
2200 : void
2201 120 : build_aggregate_deserialfn_expr(Oid deserialfn_oid,
2202 : Expr **deserialfnexpr)
2203 : {
2204 : List *args;
2205 : FuncExpr *fexpr;
2206 :
2207 : /* deserialfn always takes BYTEA, INTERNAL and returns INTERNAL */
2208 120 : args = list_make2(make_agg_arg(BYTEAOID, InvalidOid),
2209 : make_agg_arg(INTERNALOID, InvalidOid));
2210 :
2211 120 : fexpr = makeFuncExpr(deserialfn_oid,
2212 : INTERNALOID,
2213 : args,
2214 : InvalidOid,
2215 : InvalidOid,
2216 : COERCE_EXPLICIT_CALL);
2217 120 : *deserialfnexpr = (Expr *) fexpr;
2218 120 : }
2219 :
2220 : /*
2221 : * Like build_aggregate_transfn_expr, but creates an expression tree for the
2222 : * final function of an aggregate, rather than the transition function.
2223 : */
2224 : void
2225 23870 : build_aggregate_finalfn_expr(Oid *agg_input_types,
2226 : int num_finalfn_inputs,
2227 : Oid agg_state_type,
2228 : Oid agg_result_type,
2229 : Oid agg_input_collation,
2230 : Oid finalfn_oid,
2231 : Expr **finalfnexpr)
2232 : {
2233 : List *args;
2234 : int i;
2235 :
2236 : /*
2237 : * Build expr tree for final function
2238 : */
2239 23870 : args = list_make1(make_agg_arg(agg_state_type, agg_input_collation));
2240 :
2241 : /* finalfn may take additional args, which match agg's input types */
2242 39852 : for (i = 0; i < num_finalfn_inputs - 1; i++)
2243 : {
2244 15982 : args = lappend(args,
2245 15982 : make_agg_arg(agg_input_types[i], agg_input_collation));
2246 : }
2247 :
2248 23870 : *finalfnexpr = (Expr *) makeFuncExpr(finalfn_oid,
2249 : agg_result_type,
2250 : args,
2251 : InvalidOid,
2252 : agg_input_collation,
2253 : COERCE_EXPLICIT_CALL);
2254 : /* finalfn is currently never treated as variadic */
2255 23870 : }
2256 :
2257 : /*
2258 : * Convenience function to build dummy argument expressions for aggregates.
2259 : *
2260 : * We really only care that an aggregate support function can discover its
2261 : * actual argument types at runtime using get_fn_expr_argtype(), so it's okay
2262 : * to use Param nodes that don't correspond to any real Param.
2263 : */
2264 : static Node *
2265 133934 : make_agg_arg(Oid argtype, Oid argcollation)
2266 : {
2267 133934 : Param *argp = makeNode(Param);
2268 :
2269 133934 : argp->paramkind = PARAM_EXEC;
2270 133934 : argp->paramid = -1;
2271 133934 : argp->paramtype = argtype;
2272 133934 : argp->paramtypmod = -1;
2273 133934 : argp->paramcollid = argcollation;
2274 133934 : argp->location = -1;
2275 133934 : return (Node *) argp;
2276 : }
|
