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