1539 lines
56 KiB
C++
1539 lines
56 KiB
C++
/* -------------------------------------------------------------------------
|
|
*
|
|
* parse_agg.c
|
|
* handle aggregates and window functions in parser
|
|
*
|
|
* Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
*
|
|
* IDENTIFICATION
|
|
* src/common/backend/parser/parse_agg.cpp
|
|
*
|
|
* -------------------------------------------------------------------------
|
|
*/
|
|
#include "postgres.h"
|
|
#include "knl/knl_variable.h"
|
|
|
|
#include "catalog/pg_aggregate.h"
|
|
#include "catalog/pg_constraint.h"
|
|
#include "catalog/pg_type.h"
|
|
#include "nodes/makefuncs.h"
|
|
#include "nodes/nodeFuncs.h"
|
|
#include "optimizer/tlist.h"
|
|
#include "parser/parse_agg.h"
|
|
#include "parser/parse_clause.h"
|
|
#include "parser/parse_coerce.h"
|
|
#include "parser/parsetree.h"
|
|
#include "parser/parse_expr.h"
|
|
#include "rewrite/rewriteManip.h"
|
|
#include "utils/builtins.h"
|
|
#include "utils/lsyscache.h"
|
|
#ifdef PGXC
|
|
#include "pgxc/pgxc.h"
|
|
#include "access/htup.h"
|
|
#include "catalog/pg_aggregate.h"
|
|
#include "utils/syscache.h"
|
|
#endif
|
|
|
|
typedef struct {
|
|
ParseState* pstate;
|
|
Query* qry;
|
|
PlannerInfo* root;
|
|
List* groupClauses;
|
|
List* groupClauseCommonVars;
|
|
bool have_non_var_grouping;
|
|
List** func_grouped_rels;
|
|
int sublevels_up;
|
|
bool in_agg_direct_args;
|
|
} check_ungrouped_columns_context;
|
|
|
|
static void check_ungrouped_columns(Node* node, ParseState* pstate, Query* qry, List* groupClauses,
|
|
List* groupClauseVars, bool have_non_var_grouping, List** func_grouped_rels);
|
|
static bool check_ungrouped_columns_walker(Node* node, check_ungrouped_columns_context* context);
|
|
static void finalize_grouping_exprs(
|
|
Node* node, ParseState* pstate, Query* qry, List* groupClauses, PlannerInfo* root, bool have_non_var_grouping);
|
|
|
|
static bool finalize_grouping_exprs_walker(Node* node, check_ungrouped_columns_context* context);
|
|
static List* expand_groupingset_node(GroupingSet* gs);
|
|
#ifndef ENABLE_MULTIPLE_NODES
|
|
static void find_rownum_in_groupby_clauses(Rownum *rownumVar, check_ungrouped_columns_context* context);
|
|
#endif
|
|
/*
|
|
* transformAggregateCall -
|
|
* Finish initial transformation of an aggregate call
|
|
*
|
|
* parse_func.c has recognized the function as an aggregate, and has set up
|
|
* all the fields of the Aggref except args, aggorder, aggdistinct and
|
|
* agglevelsup. The passed-in args list has been through standard expression
|
|
* transformation, while the passed-in aggorder list hasn't been transformed
|
|
* at all.
|
|
*
|
|
* Here we convert the args list into a targetlist by inserting TargetEntry
|
|
* nodes, and then transform the aggorder and agg_distinct specifications to
|
|
* produce lists of SortGroupClause nodes. (That might also result in adding
|
|
* resjunk expressions to the targetlist.)
|
|
*
|
|
* We must also determine which query level the aggregate actually belongs to,
|
|
* set agglevelsup accordingly, and mark p_hasAggs true in the corresponding
|
|
* pstate level.
|
|
*/
|
|
void transformAggregateCall(ParseState* pstate, Aggref* agg, List* args, List* aggorder, bool agg_distinct)
|
|
{
|
|
#define anyenum_typeoid 3500
|
|
List* tlist = NIL;
|
|
List* torder = NIL;
|
|
List* tdistinct = NIL;
|
|
AttrNumber attno = 1;
|
|
int save_next_resno;
|
|
int min_varlevel;
|
|
ListCell* lc = NULL;
|
|
#ifdef PGXC
|
|
HeapTuple aggTuple;
|
|
Form_pg_aggregate aggform;
|
|
#endif /* PGXC */
|
|
|
|
if (AGGKIND_IS_ORDERED_SET(agg->aggkind)) {
|
|
/*
|
|
* The ordered-set aggs contain direct args and aggregated args.
|
|
* The direct args are saved at the first "numDirectArgs" args,
|
|
* and the aggregated args are at the tail. We must split them apart.
|
|
*/
|
|
int numDirectArgs = list_length(args) - list_length(aggorder);
|
|
List* aargs = NIL;
|
|
ListCell* lc1 = NULL;
|
|
ListCell* lc2 = NULL;
|
|
|
|
Assert(numDirectArgs >= 0);
|
|
|
|
aargs = list_copy_tail(args, numDirectArgs);
|
|
agg->aggdirectargs = list_truncate(args, numDirectArgs);
|
|
|
|
/*
|
|
* We should save the sort information for ordered-set agg, so we
|
|
* need build a tlist (normally only have a target entry) which contains
|
|
* aggregated args (list of Exprs). And we need save the regarding order
|
|
* target which is use to transformed to SortGroupClause.
|
|
*/
|
|
forboth(lc1, aargs, lc2, aggorder)
|
|
{
|
|
TargetEntry* tle = makeTargetEntry((Expr*)lfirst(lc1), attno++, NULL, false);
|
|
tlist = lappend(tlist, tle);
|
|
|
|
torder = addTargetToSortList(pstate, tle, torder, tlist, (SortBy*)lfirst(lc2), true); /* fix unknowns */
|
|
}
|
|
|
|
/* DISTINCT cannot be used in an ordered-set agg */
|
|
Assert(!agg_distinct);
|
|
} else {
|
|
/* Normal aggregate dose not have direct args */
|
|
agg->aggdirectargs = NIL;
|
|
|
|
/*
|
|
* Transform the plain list of Exprs into a targetlist. We don't bother
|
|
* to assign column names to the entries.
|
|
*/
|
|
foreach (lc, args) {
|
|
Expr* arg = (Expr*)lfirst(lc);
|
|
TargetEntry* tle = makeTargetEntry(arg, attno++, NULL, false);
|
|
tlist = lappend(tlist, tle);
|
|
}
|
|
|
|
/*
|
|
* If we have an ORDER BY, transform it. This will add columns to the
|
|
* tlist if they appear in ORDER BY but weren't already in the arg
|
|
* list. They will be marked resjunk = true so we can tell them apart
|
|
* from regular aggregate arguments later.
|
|
*
|
|
* We need to mess with p_next_resno since it will be used to number
|
|
* any new targetlist entries.
|
|
*/
|
|
save_next_resno = pstate->p_next_resno;
|
|
pstate->p_next_resno = attno;
|
|
|
|
torder = transformSortClause(pstate,
|
|
aggorder,
|
|
&tlist,
|
|
true, /* fix unknowns */
|
|
true); /* force SQL99 rules */
|
|
|
|
/*
|
|
* If we have DISTINCT, transform that to produce a distinctList.
|
|
*/
|
|
if (agg_distinct) {
|
|
tdistinct = transformDistinctClause(pstate, &tlist, torder, true);
|
|
|
|
/*
|
|
* Remove this check if executor support for hashed distinct for
|
|
* aggregates is ever added.
|
|
*/
|
|
foreach (lc, tdistinct) {
|
|
SortGroupClause* sortcl = (SortGroupClause*)lfirst(lc);
|
|
|
|
if (!OidIsValid(sortcl->sortop)) {
|
|
Node* expr = get_sortgroupclause_expr(sortcl, tlist);
|
|
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_UNDEFINED_FUNCTION),
|
|
errmsg(
|
|
"could not identify an ordering operator for type %s", format_type_be(exprType(expr))),
|
|
errdetail("Aggregates with DISTINCT must be able to sort their inputs."),
|
|
parser_errposition(pstate, exprLocation(expr))));
|
|
}
|
|
}
|
|
}
|
|
|
|
pstate->p_next_resno = save_next_resno;
|
|
}
|
|
|
|
/* Update the Aggref with the transformation results */
|
|
agg->args = tlist;
|
|
agg->aggorder = torder;
|
|
agg->aggdistinct = tdistinct;
|
|
|
|
/*
|
|
* The aggregate's level is the same as the level of the lowest-level
|
|
* variable or aggregate in its arguments; or if it contains no variables
|
|
* at all, we presume it to be local.
|
|
*/
|
|
min_varlevel = find_minimum_var_level((Node*)agg->args);
|
|
/*
|
|
* An aggregate can't directly contain another aggregate call of the same
|
|
* level (though outer aggs are okay). We can skip this check if we
|
|
* didn't find any local vars or aggs.
|
|
*/
|
|
if (min_varlevel == 0) {
|
|
if (pstate->p_hasAggs && checkExprHasAggs((Node*)agg->args)) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_GROUPING_ERROR),
|
|
errmsg("aggregate function calls cannot be nested"),
|
|
parser_errposition(pstate, locate_agg_of_level((Node*)agg->args, 0))));
|
|
}
|
|
}
|
|
|
|
/* It can't contain set-returning functions either */
|
|
if (checkExprHasSetReturningFuncs((Node*)agg->args)) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_GROUPING_ERROR),
|
|
errmsg("aggregate function calls cannot contain set-returning function calls"),
|
|
parser_errposition(pstate, locate_srfunc((Node*)agg->args))));
|
|
}
|
|
|
|
/* It can't contain window functions either */
|
|
if (pstate->p_hasWindowFuncs && checkExprHasWindowFuncs((Node*)agg->args)) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_GROUPING_ERROR),
|
|
errmsg("aggregate function calls cannot contain window function calls"),
|
|
parser_errposition(pstate, locate_windowfunc((Node*)agg->args))));
|
|
}
|
|
|
|
if (min_varlevel < 0) {
|
|
min_varlevel = 0;
|
|
}
|
|
agg->agglevelsup = min_varlevel;
|
|
|
|
/* Mark the correct pstate as having aggregates */
|
|
while (min_varlevel-- > 0)
|
|
pstate = pstate->parentParseState;
|
|
pstate->p_hasAggs = true;
|
|
/*
|
|
* Complain if we are inside a LATERAL subquery of the aggregation query.
|
|
* We must be in its FROM clause, so the aggregate is misplaced.
|
|
*/
|
|
if (pstate->p_lateral_active)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_GROUPING_ERROR),
|
|
errmsg("aggregates not allowed in FROM clause"),
|
|
parser_errposition(pstate, agg->location)));
|
|
#ifdef PGXC
|
|
/*
|
|
* Return data type of PGXC Datanode's aggregate should always return the
|
|
* result of transition function, that is expected by collection function
|
|
* on the Coordinator.
|
|
* Look up the aggregate definition and replace agg->aggtype
|
|
*/
|
|
|
|
aggTuple = SearchSysCache(AGGFNOID, ObjectIdGetDatum(agg->aggfnoid), 0, 0, 0);
|
|
if (!HeapTupleIsValid(aggTuple))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_CACHE_LOOKUP_FAILED), errmsg("cache lookup failed for aggregate %u", agg->aggfnoid)));
|
|
aggform = (Form_pg_aggregate)GETSTRUCT(aggTuple);
|
|
agg->aggtrantype = aggform->aggtranstype;
|
|
agg->agghas_collectfn = OidIsValid(aggform->aggcollectfn);
|
|
|
|
/*
|
|
* We need ensure upgrade successfully when view include avg function,
|
|
* otherwise may lead to similar error: operator does not exist: bigint[] = integer.
|
|
*
|
|
* For example:
|
|
* create view t1_v as select a from t1 group by a having avg(a) = 10;
|
|
* For user-defined enum type, do not replace agg->aggtype here, otherwise may lead to error:
|
|
* operator does not exist: (user-defined enum type) = anyenum.
|
|
*/
|
|
if (IS_PGXC_DATANODE && !isRestoreMode && !u_sess->catalog_cxt.Parse_sql_language && !IsInitdb &&
|
|
!u_sess->attr.attr_common.IsInplaceUpgrade && !IS_SINGLE_NODE && (anyenum_typeoid != agg->aggtrantype))
|
|
agg->aggtype = agg->aggtrantype;
|
|
|
|
ReleaseSysCache(aggTuple);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* transformWindowFuncCall -
|
|
* Finish initial transformation of a window function call
|
|
*
|
|
* parse_func.c has recognized the function as a window function, and has set
|
|
* up all the fields of the WindowFunc except winref. Here we must (1) add
|
|
* the WindowDef to the pstate (if not a duplicate of one already present) and
|
|
* set winref to link to it; and (2) mark p_hasWindowFuncs true in the pstate.
|
|
* Unlike aggregates, only the most closely nested pstate level need be
|
|
* considered --- there are no "outer window functions" per SQL spec.
|
|
*/
|
|
void transformWindowFuncCall(ParseState* pstate, WindowFunc* wfunc, WindowDef* windef)
|
|
{
|
|
/*
|
|
* A window function call can't contain another one (but aggs are OK). XXX
|
|
* is this required by spec, or just an unimplemented feature?
|
|
*/
|
|
if (pstate->p_hasWindowFuncs && checkExprHasWindowFuncs((Node*)wfunc->args)) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_WINDOWING_ERROR),
|
|
errmsg("window function calls cannot be nested"),
|
|
parser_errposition(pstate, locate_windowfunc((Node*)wfunc->args))));
|
|
}
|
|
|
|
/*
|
|
* If the OVER clause just specifies a window name, find that WINDOW
|
|
* clause (which had better be present). Otherwise, try to match all the
|
|
* properties of the OVER clause, and make a new entry in the p_windowdefs
|
|
* list if no luck.
|
|
*/
|
|
if (windef->name) {
|
|
Index winref = 0;
|
|
ListCell* lc = NULL;
|
|
|
|
AssertEreport(windef->refname == NULL && windef->partitionClause == NIL && windef->orderClause == NIL &&
|
|
windef->frameOptions == FRAMEOPTION_DEFAULTS,
|
|
MOD_OPT,
|
|
"");
|
|
|
|
foreach (lc, pstate->p_windowdefs) {
|
|
WindowDef* refwin = (WindowDef*)lfirst(lc);
|
|
|
|
winref++;
|
|
if (refwin->name && strcmp(refwin->name, windef->name) == 0) {
|
|
wfunc->winref = winref;
|
|
break;
|
|
}
|
|
}
|
|
if (lc == NULL) { /* didn't find it? */
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_UNDEFINED_OBJECT),
|
|
errmsg("window \"%s\" does not exist", windef->name),
|
|
parser_errposition(pstate, windef->location)));
|
|
}
|
|
} else {
|
|
Index winref = 0;
|
|
ListCell* lc = NULL;
|
|
|
|
foreach (lc, pstate->p_windowdefs) {
|
|
WindowDef* refwin = (WindowDef*)lfirst(lc);
|
|
|
|
winref++;
|
|
if (refwin->refname && windef->refname && strcmp(refwin->refname, windef->refname) == 0)
|
|
/* matched on refname */;
|
|
else if (!refwin->refname && !windef->refname)
|
|
/* matched, no refname */;
|
|
else
|
|
continue;
|
|
if (equal(refwin->partitionClause, windef->partitionClause) &&
|
|
equal(refwin->orderClause, windef->orderClause) && refwin->frameOptions == windef->frameOptions &&
|
|
equal(refwin->startOffset, windef->startOffset) && equal(refwin->endOffset, windef->endOffset)) {
|
|
/* found a duplicate window specification */
|
|
wfunc->winref = winref;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* didn't find it? */
|
|
if (lc == NULL) {
|
|
pstate->p_windowdefs = lappend(pstate->p_windowdefs, windef);
|
|
wfunc->winref = list_length(pstate->p_windowdefs);
|
|
}
|
|
}
|
|
|
|
pstate->p_hasWindowFuncs = true;
|
|
}
|
|
|
|
/*
|
|
* parseCheckAggregates
|
|
* Check for aggregates where they shouldn't be and improper grouping.
|
|
*
|
|
* Ideally this should be done earlier, but it's difficult to distinguish
|
|
* aggregates from plain functions at the grammar level. So instead we
|
|
* check here. This function should be called after the target list and
|
|
* qualifications are finalized.
|
|
*/
|
|
void parseCheckAggregates(ParseState* pstate, Query* qry)
|
|
{
|
|
List* gset_common = NIL;
|
|
List* groupClauses = NIL;
|
|
List* groupClauseCommonVars = NIL;
|
|
bool have_non_var_grouping = false;
|
|
List* func_grouped_rels = NIL;
|
|
ListCell* l = NULL;
|
|
bool hasJoinRTEs = false;
|
|
bool hasSelfRefRTEs = false;
|
|
PlannerInfo* root = NULL;
|
|
Node* clause = NULL;
|
|
|
|
/* This should only be called if we found aggregates or grouping */
|
|
AssertEreport(pstate->p_hasAggs || qry->groupClause || qry->havingQual || qry->groupingSets,
|
|
MOD_OPT,
|
|
"only be called if we found aggregates or grouping");
|
|
|
|
/*
|
|
* If we have grouping sets, expand them and find the intersection of all
|
|
* sets.
|
|
*/
|
|
if (qry->groupingSets) {
|
|
/*
|
|
* The limit of 4096 is arbitrary and exists simply to avoid resource
|
|
* issues from pathological constructs.
|
|
*/
|
|
List* gsets = expand_grouping_sets(qry->groupingSets, 4096);
|
|
|
|
if (gsets == NULL)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
|
|
errmsg("too many grouping sets present (max 4096)"),
|
|
parser_errposition(pstate,
|
|
qry->groupClause ? exprLocation((Node*)qry->groupClause)
|
|
: exprLocation((Node*)qry->groupingSets))));
|
|
|
|
/*
|
|
* The intersection will often be empty, so help things along by
|
|
* seeding the intersect with the smallest set.
|
|
*/
|
|
gset_common = (List*)linitial(gsets);
|
|
|
|
if (gset_common != NULL) {
|
|
for_each_cell(l, lnext(list_head(gsets))) {
|
|
gset_common = list_intersection_int(gset_common, (List*)lfirst(l));
|
|
if (gset_common == NULL) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If there was only one grouping set in the expansion, AND if the
|
|
* groupClause is non-empty (meaning that the grouping set is not
|
|
* empty either), then we can ditch the grouping set and pretend we
|
|
* just had a normal GROUP BY.
|
|
*/
|
|
if (list_length(gsets) == 1 && qry->groupClause) {
|
|
qry->groupingSets = NIL;
|
|
}
|
|
}
|
|
/*
|
|
* Scan the range table to see if there are JOIN or self-reference CTE
|
|
* entries. We'll need this info below.
|
|
*/
|
|
hasJoinRTEs = hasSelfRefRTEs = false;
|
|
foreach (l, pstate->p_rtable) {
|
|
RangeTblEntry* rte = (RangeTblEntry*)lfirst(l);
|
|
|
|
if (rte->rtekind == RTE_JOIN) {
|
|
hasJoinRTEs = true;
|
|
} else if (rte->rtekind == RTE_CTE && rte->self_reference) {
|
|
hasSelfRefRTEs = true;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Aggregates must never appear in WHERE or JOIN/ON clauses.
|
|
*
|
|
* (Note this check should appear first to deliver an appropriate error
|
|
* message; otherwise we are likely to complain about some innocent
|
|
* variable in the target list, which is outright misleading if the
|
|
* problem is in WHERE.)
|
|
*/
|
|
if (checkExprHasAggs(qry->jointree->quals)) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_GROUPING_ERROR),
|
|
errmsg("aggregates not allowed in WHERE clause"),
|
|
parser_errposition(pstate, locate_agg_of_level(qry->jointree->quals, 0))));
|
|
}
|
|
if (checkExprHasAggs((Node*)qry->jointree->fromlist)) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_GROUPING_ERROR),
|
|
errmsg("aggregates not allowed in JOIN conditions"),
|
|
parser_errposition(pstate, locate_agg_of_level((Node*)qry->jointree->fromlist, 0))));
|
|
}
|
|
|
|
/*
|
|
* No aggregates allowed in GROUP BY clauses, either.
|
|
*
|
|
* While we are at it, build a list of the acceptable GROUP BY expressions
|
|
* for use by check_ungrouped_columns().
|
|
*/
|
|
foreach (l, qry->groupClause) {
|
|
SortGroupClause* grpcl = (SortGroupClause*)lfirst(l);
|
|
TargetEntry* expr = NULL;
|
|
|
|
expr = get_sortgroupclause_tle(grpcl, qry->targetList);
|
|
if (expr == NULL) {
|
|
continue; /* probably cannot happen */
|
|
}
|
|
if (checkExprHasAggs((Node*)expr->expr)) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_GROUPING_ERROR),
|
|
errmsg("aggregates not allowed in GROUP BY clause"),
|
|
parser_errposition(pstate, locate_agg_of_level((Node*)expr->expr, 0))));
|
|
}
|
|
groupClauses = lcons(expr, groupClauses);
|
|
}
|
|
|
|
/*
|
|
* If there are join alias vars involved, we have to flatten them to the
|
|
* underlying vars, so that aliased and unaliased vars will be correctly
|
|
* taken as equal. We can skip the expense of doing this if no rangetable
|
|
* entries are RTE_JOIN kind. We use the planner's flatten_join_alias_vars
|
|
* routine to do the flattening; it wants a PlannerInfo root node, which
|
|
* fortunately can be mostly dummy.
|
|
*/
|
|
if (hasJoinRTEs) {
|
|
root = makeNode(PlannerInfo);
|
|
root->parse = qry;
|
|
root->planner_cxt = CurrentMemoryContext;
|
|
root->hasJoinRTEs = true;
|
|
|
|
groupClauses = (List*)flatten_join_alias_vars(root, (Node*)groupClauses);
|
|
} else
|
|
root = NULL; /* keep compiler quiet */
|
|
|
|
/*
|
|
* Detect whether any of the grouping expressions aren't simple Vars; if
|
|
* they're all Vars then we don't have to work so hard in the recursive
|
|
* scans. (Note we have to flatten aliases before this.)
|
|
*
|
|
* Track Vars that are included in all grouping sets separately in
|
|
* groupClauseCommonVars, since these are the only ones we can use to
|
|
* check for functional dependencies.
|
|
*/
|
|
have_non_var_grouping = false;
|
|
foreach (l, groupClauses) {
|
|
TargetEntry* tle = (TargetEntry*)lfirst(l);
|
|
if (!IsA(tle->expr, Var)) {
|
|
have_non_var_grouping = true;
|
|
} else if (!qry->groupingSets || list_member_int(gset_common, tle->ressortgroupref)) {
|
|
groupClauseCommonVars = lappend(groupClauseCommonVars, tle->expr);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Check the targetlist and HAVING clause for ungrouped variables.
|
|
*
|
|
* Note: because we check resjunk tlist elements as well as regular ones,
|
|
* this will also find ungrouped variables that came from ORDER BY and
|
|
* WINDOW clauses. For that matter, it's also going to examine the
|
|
* grouping expressions themselves --- but they'll all pass the test ...
|
|
*
|
|
* We also finalize GROUPING expressions, but for that we need to traverse
|
|
* the original (unflattened) clause in order to modify nodes.
|
|
*/
|
|
clause = (Node*)qry->targetList;
|
|
finalize_grouping_exprs(clause, pstate, qry, groupClauses, root, have_non_var_grouping);
|
|
if (hasJoinRTEs) {
|
|
clause = flatten_join_alias_vars(root, clause);
|
|
}
|
|
check_ungrouped_columns(
|
|
clause, pstate, qry, groupClauses, groupClauseCommonVars, have_non_var_grouping, &func_grouped_rels);
|
|
|
|
clause = (Node*)qry->havingQual;
|
|
finalize_grouping_exprs(clause, pstate, qry, groupClauses, root, have_non_var_grouping);
|
|
if (hasJoinRTEs) {
|
|
clause = flatten_join_alias_vars(root, clause);
|
|
}
|
|
check_ungrouped_columns(
|
|
clause, pstate, qry, groupClauses, groupClauseCommonVars, have_non_var_grouping, &func_grouped_rels);
|
|
|
|
/*
|
|
* Per spec, aggregates can't appear in a recursive term.
|
|
*/
|
|
if (pstate->p_hasAggs && hasSelfRefRTEs) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_RECURSION),
|
|
errmsg("aggregate functions not allowed in a recursive query's recursive term"),
|
|
parser_errposition(pstate, locate_agg_of_level((Node*)qry, 0))));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* parseCheckWindowFuncs
|
|
* Check for window functions where they shouldn't be.
|
|
*
|
|
* We have to forbid window functions in WHERE, JOIN/ON, HAVING, GROUP BY,
|
|
* and window specifications. (Other clauses, such as RETURNING and LIMIT,
|
|
* have already been checked.) Transformation of all these clauses must
|
|
* be completed already.
|
|
*/
|
|
void parseCheckWindowFuncs(ParseState* pstate, Query* qry)
|
|
{
|
|
ListCell* l = NULL;
|
|
|
|
/* This should only be called if we found window functions */
|
|
AssertEreport(pstate->p_hasWindowFuncs, MOD_OPT, "Only deal with WindowFuncs here");
|
|
|
|
if (checkExprHasWindowFuncs(qry->jointree->quals)) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_WINDOWING_ERROR),
|
|
errmsg("window functions not allowed in WHERE clause"),
|
|
parser_errposition(pstate, locate_windowfunc(qry->jointree->quals))));
|
|
}
|
|
if (checkExprHasWindowFuncs((Node*)qry->jointree->fromlist)) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_WINDOWING_ERROR),
|
|
errmsg("window functions not allowed in JOIN conditions"),
|
|
parser_errposition(pstate, locate_windowfunc((Node*)qry->jointree->fromlist))));
|
|
}
|
|
if (checkExprHasWindowFuncs(qry->havingQual)) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_WINDOWING_ERROR),
|
|
errmsg("window functions not allowed in HAVING clause"),
|
|
parser_errposition(pstate, locate_windowfunc(qry->havingQual))));
|
|
}
|
|
|
|
foreach (l, qry->groupClause) {
|
|
SortGroupClause* grpcl = (SortGroupClause*)lfirst(l);
|
|
Node* expr = NULL;
|
|
|
|
expr = get_sortgroupclause_expr(grpcl, qry->targetList);
|
|
if (checkExprHasWindowFuncs(expr)) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_WINDOWING_ERROR),
|
|
errmsg("window functions not allowed in GROUP BY clause"),
|
|
parser_errposition(pstate, locate_windowfunc(expr))));
|
|
}
|
|
}
|
|
|
|
foreach (l, qry->windowClause) {
|
|
WindowClause* wc = (WindowClause*)lfirst(l);
|
|
ListCell* l2 = NULL;
|
|
|
|
foreach (l2, wc->partitionClause) {
|
|
SortGroupClause* grpcl = (SortGroupClause*)lfirst(l2);
|
|
Node* expr = NULL;
|
|
|
|
expr = get_sortgroupclause_expr(grpcl, qry->targetList);
|
|
if (checkExprHasWindowFuncs(expr)) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_WINDOWING_ERROR),
|
|
errmsg("window functions not allowed in window definition"),
|
|
parser_errposition(pstate, locate_windowfunc(expr))));
|
|
}
|
|
}
|
|
foreach (l2, wc->orderClause) {
|
|
SortGroupClause* grpcl = (SortGroupClause*)lfirst(l2);
|
|
Node* expr = NULL;
|
|
|
|
expr = get_sortgroupclause_expr(grpcl, qry->targetList);
|
|
if (checkExprHasWindowFuncs(expr)) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_WINDOWING_ERROR),
|
|
errmsg("window functions not allowed in window definition"),
|
|
parser_errposition(pstate, locate_windowfunc(expr))));
|
|
}
|
|
}
|
|
/* startOffset and limitOffset were checked in transformFrameOffset */
|
|
}
|
|
}
|
|
|
|
/*
|
|
* check_ungrouped_columns -
|
|
* Scan the given expression tree for ungrouped variables (variables
|
|
* that are not listed in the groupClauses list and are not within
|
|
* the arguments of aggregate functions). Emit a suitable error message
|
|
* if any are found.
|
|
*
|
|
* NOTE: we assume that the given clause has been transformed suitably for
|
|
* parser output. This means we can use expression_tree_walker.
|
|
*
|
|
* NOTE: we recognize grouping expressions in the main query, but only
|
|
* grouping Vars in subqueries. For example, this will be rejected,
|
|
* although it could be allowed:
|
|
* SELECT
|
|
* (SELECT x FROM bar where y = (foo.a + foo.b))
|
|
* FROM foo
|
|
* GROUP BY a + b;
|
|
* The difficulty is the need to account for different sublevels_up.
|
|
* This appears to require a whole custom version of equal(), which is
|
|
* way more pain than the feature seems worth.
|
|
*/
|
|
static void check_ungrouped_columns(Node* node, ParseState* pstate, Query* qry, List* groupClauses,
|
|
List* groupClauseCommonVars, bool have_non_var_grouping, List** func_grouped_rels)
|
|
{
|
|
check_ungrouped_columns_context context;
|
|
|
|
context.pstate = pstate;
|
|
context.qry = qry;
|
|
context.root = NULL;
|
|
context.groupClauses = groupClauses;
|
|
context.groupClauseCommonVars = groupClauseCommonVars;
|
|
context.have_non_var_grouping = have_non_var_grouping;
|
|
context.func_grouped_rels = func_grouped_rels;
|
|
context.sublevels_up = 0;
|
|
context.in_agg_direct_args = false;
|
|
(void)check_ungrouped_columns_walker(node, &context);
|
|
}
|
|
|
|
static bool check_ungrouped_columns_walker(Node* node, check_ungrouped_columns_context* context)
|
|
{
|
|
ListCell* gl = NULL;
|
|
|
|
if (node == NULL) {
|
|
return false;
|
|
}
|
|
if (IsA(node, Const) || IsA(node, Param)) {
|
|
return false; /* constants are always acceptable */
|
|
}
|
|
|
|
if (IsA(node, Aggref)) {
|
|
Aggref* agg = (Aggref*)node;
|
|
|
|
if ((int)agg->agglevelsup == context->sublevels_up) {
|
|
/*
|
|
* For ordered set agg, its direct args should not inside an
|
|
* aggregate. If we find an aggregate call of the original level
|
|
* (that means if it is inside an outer query , the context should
|
|
* be same), do not recurse into its normal arguments, ORDER BY
|
|
* arguments, or filter; ungrouped vars there are not an error.
|
|
* We use in_agg_direct_args in the context to help produce a useful
|
|
* error message for ungrouped vars in direct arguments.
|
|
*/
|
|
bool result = false;
|
|
|
|
if (context->in_agg_direct_args) {
|
|
ereport(ERROR, (errcode(ERRCODE_INVALID_AGG), errmsg("unexpected args inside agg direct args")));
|
|
}
|
|
context->in_agg_direct_args = true;
|
|
result = check_ungrouped_columns_walker((Node*)agg->aggdirectargs, context);
|
|
context->in_agg_direct_args = false;
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* We can also skip looking at the arguments of aggregates of higher levels,
|
|
* since they could not possibly contain Vars of concern to us (see
|
|
* transformAggregateCall). We do need to look into arguments of aggregates
|
|
* of lower levels, however.
|
|
*/
|
|
if ((int)agg->agglevelsup > context->sublevels_up) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (IsA(node, GroupingFunc)) {
|
|
GroupingFunc* grp = (GroupingFunc*)node;
|
|
|
|
/* handled GroupingFunc separately, no need to recheck at this level */
|
|
if ((int)grp->agglevelsup >= context->sublevels_up) {
|
|
return false;
|
|
}
|
|
}
|
|
/*
|
|
* If we have any GROUP BY items that are not simple Vars, check to see if
|
|
* subexpression as a whole matches any GROUP BY item. We need to do this
|
|
* at every recursion level so that we recognize GROUPed-BY expressions
|
|
* before reaching variables within them. But this only works at the outer
|
|
* query level, as noted above.
|
|
*/
|
|
if (context->have_non_var_grouping && context->sublevels_up == 0) {
|
|
foreach (gl, context->groupClauses) {
|
|
TargetEntry* tle = (TargetEntry*)lfirst(gl);
|
|
if (equal(node, tle->expr)) {
|
|
return false; /* acceptable, do not descend more */
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifndef ENABLE_MULTIPLE_NODES
|
|
/* If There is ROWNUM, it must appear in the GROUP BY clause or be used in an aggregate function. */
|
|
if (IsA(node, Rownum) && context->sublevels_up == 0) {
|
|
find_rownum_in_groupby_clauses((Rownum *)node, context);
|
|
}
|
|
#endif
|
|
/*
|
|
* If we have an ungrouped Var of the original query level, we have a
|
|
* failure. Vars below the original query level are not a problem, and
|
|
* neither are Vars from above it. (If such Vars are ungrouped as far as
|
|
* their own query level is concerned, that's someone else's problem...)
|
|
*/
|
|
if (IsA(node, Var)) {
|
|
Var* var = (Var*)node;
|
|
RangeTblEntry* rte = NULL;
|
|
char* attname = NULL;
|
|
|
|
if (var->varlevelsup != (unsigned int)context->sublevels_up) {
|
|
return false; /* it's not local to my query, ignore */
|
|
}
|
|
|
|
/*
|
|
* Check for a match, if we didn't do it above.
|
|
*/
|
|
if (!context->have_non_var_grouping || context->sublevels_up != 0) {
|
|
foreach (gl, context->groupClauses) {
|
|
Var* gvar = (Var*)((TargetEntry*)lfirst(gl))->expr;
|
|
|
|
if (IsA(gvar, Var) && gvar->varno == var->varno && gvar->varattno == var->varattno &&
|
|
gvar->varlevelsup == 0)
|
|
return false; /* acceptable, we're okay */
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Check whether the Var is known functionally dependent on the GROUP
|
|
* BY columns. If so, we can allow the Var to be used, because the
|
|
* grouping is really a no-op for this table. However, this deduction
|
|
* depends on one or more constraints of the table, so we have to add
|
|
* those constraints to the query's constraintDeps list, because it's
|
|
* not semantically valid anymore if the constraint(s) get dropped.
|
|
* (Therefore, this check must be the last-ditch effort before raising
|
|
* error: we don't want to add dependencies unnecessarily.)
|
|
*
|
|
* Because this is a pretty expensive check, and will have the same
|
|
* outcome for all columns of a table, we remember which RTEs we've
|
|
* already proven functional dependency for in the func_grouped_rels
|
|
* list. This test also prevents us from adding duplicate entries to
|
|
* the constraintDeps list.
|
|
*/
|
|
if (list_member_int(*context->func_grouped_rels, var->varno)) {
|
|
return false; /* previously proven acceptable */
|
|
}
|
|
|
|
AssertEreport(
|
|
var->varno > 0 && (int)var->varno <= list_length(context->pstate->p_rtable), MOD_OPT, "Var is unexpected");
|
|
rte = rt_fetch(var->varno, context->pstate->p_rtable);
|
|
if (rte->rtekind == RTE_RELATION) {
|
|
if (check_functional_grouping(
|
|
rte->relid, var->varno, 0, context->groupClauseCommonVars, &context->qry->constraintDeps)) {
|
|
*context->func_grouped_rels = lappend_int(*context->func_grouped_rels, var->varno);
|
|
return false; /* acceptable */
|
|
}
|
|
}
|
|
|
|
/* Found an ungrouped local variable; generate error message */
|
|
attname = get_rte_attribute_name(rte, var->varattno);
|
|
|
|
/* Fix attname if the RTE has been rewrited by start with...connect by. */
|
|
char* orig_attname = attname;
|
|
if (IsSWCBRewriteRTE(rte)) {
|
|
attname = strrchr(attname, '@');
|
|
attname = (attname != NULL) ? (attname + 1) : orig_attname;
|
|
}
|
|
|
|
if (context->sublevels_up == 0) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_GROUPING_ERROR),
|
|
errmsg("column \"%s.%s\" must appear in the GROUP BY clause or be used in an aggregate function",
|
|
rte->eref->aliasname,
|
|
attname),
|
|
context->in_agg_direct_args
|
|
? errdetail("Direct arguments of an ordered-set aggregate must use only grouped columns.")
|
|
: 0,
|
|
rte->swConverted ? errdetail("Please check your start with rewrite table's column.") : 0,
|
|
parser_errposition(context->pstate, var->location)));
|
|
} else {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_GROUPING_ERROR),
|
|
errmsg("subquery uses ungrouped column \"%s.%s\" from outer query", rte->eref->aliasname, attname),
|
|
parser_errposition(context->pstate, var->location)));
|
|
}
|
|
if (attname != NULL) {
|
|
pfree_ext(attname);
|
|
}
|
|
}
|
|
|
|
if (IsA(node, Query)) {
|
|
/* Recurse into subselects */
|
|
bool result = false;
|
|
|
|
context->sublevels_up++;
|
|
result = query_tree_walker((Query*)node, (bool (*)())check_ungrouped_columns_walker, (void*)context, 0);
|
|
context->sublevels_up--;
|
|
return result;
|
|
}
|
|
return expression_tree_walker(node, (bool (*)())check_ungrouped_columns_walker, (void*)context);
|
|
}
|
|
|
|
/*
|
|
* finalize_grouping_exprs -
|
|
* Scan the given expression tree for GROUPING() and related calls,
|
|
* and validate and process their arguments.
|
|
*
|
|
* This is split out from check_ungrouped_columns above because it needs
|
|
* to modify the nodes (which it does in-place, not via a mutator) while
|
|
* check_ungrouped_columns may see only a copy of the original thanks to
|
|
* flattening of join alias vars. So here, we flatten each individual
|
|
* GROUPING argument as we see it before comparing it.
|
|
*/
|
|
static void finalize_grouping_exprs(
|
|
Node* node, ParseState* pstate, Query* qry, List* groupClauses, PlannerInfo* root, bool have_non_var_grouping)
|
|
{
|
|
check_ungrouped_columns_context context;
|
|
|
|
context.pstate = pstate;
|
|
context.qry = qry;
|
|
context.root = root;
|
|
context.groupClauses = groupClauses;
|
|
context.groupClauseCommonVars = NIL;
|
|
context.have_non_var_grouping = have_non_var_grouping;
|
|
context.func_grouped_rels = NULL;
|
|
context.sublevels_up = 0;
|
|
context.in_agg_direct_args = false;
|
|
(void)finalize_grouping_exprs_walker(node, &context);
|
|
}
|
|
|
|
static bool finalize_grouping_exprs_walker(Node* node, check_ungrouped_columns_context* context)
|
|
{
|
|
ListCell* gl = NULL;
|
|
|
|
if (node == NULL) {
|
|
return false;
|
|
}
|
|
if (IsA(node, Const) || IsA(node, Param)) {
|
|
return false; /* constants are always acceptable */
|
|
}
|
|
|
|
if (IsA(node, Aggref)) {
|
|
Aggref* agg = (Aggref*)node;
|
|
|
|
if ((int)agg->agglevelsup == context->sublevels_up) {
|
|
/*
|
|
* If we find an aggregate call of the original level, do not
|
|
* recurse into its normal arguments, ORDER BY arguments, or
|
|
* filter; GROUPING exprs of this level are not allowed there. But
|
|
* check direct arguments as though they weren't in an aggregate.
|
|
*/
|
|
bool result = false;
|
|
|
|
AssertEreport(!context->in_agg_direct_args, MOD_OPT, "");
|
|
context->in_agg_direct_args = true;
|
|
result = finalize_grouping_exprs_walker((Node*)agg->aggdirectargs, context);
|
|
context->in_agg_direct_args = false;
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* We can skip recursing into aggregates of higher levels altogether,
|
|
* since they could not possibly contain exprs of concern to us (see
|
|
* transformAggregateCall). We do need to look at aggregates of lower
|
|
* levels, however.
|
|
*/
|
|
if ((int)agg->agglevelsup > context->sublevels_up) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (IsA(node, GroupingFunc)) {
|
|
GroupingFunc* grp = (GroupingFunc*)node;
|
|
|
|
/*
|
|
* We only need to check GroupingFunc nodes at the exact level to
|
|
* which they belong, since they cannot mix levels in arguments.
|
|
*/
|
|
if ((int)grp->agglevelsup == context->sublevels_up) {
|
|
ListCell* lc = NULL;
|
|
List* ref_list = NIL;
|
|
|
|
foreach (lc, grp->args) {
|
|
Node* expr = (Node*)lfirst(lc);
|
|
Index ref = 0;
|
|
|
|
if (context->root != NULL) {
|
|
expr = flatten_join_alias_vars(context->root, expr);
|
|
}
|
|
|
|
/*
|
|
* Each expression must match a grouping entry at the current
|
|
* query level. Unlike the general expression case, we don't
|
|
* allow functional dependencies or outer references.
|
|
*/
|
|
if (IsA(expr, Var)) {
|
|
Var* var = (Var*)expr;
|
|
|
|
if ((int)var->varlevelsup == context->sublevels_up) {
|
|
foreach (gl, context->groupClauses) {
|
|
TargetEntry* tle = (TargetEntry*)lfirst(gl);
|
|
Var* gvar = (Var*)tle->expr;
|
|
|
|
if (IsA(gvar, Var) && gvar->varno == var->varno && gvar->varattno == var->varattno &&
|
|
gvar->varlevelsup == 0) {
|
|
ref = tle->ressortgroupref;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else if (context->have_non_var_grouping && context->sublevels_up == 0) {
|
|
foreach (gl, context->groupClauses) {
|
|
TargetEntry* tle = (TargetEntry*)lfirst(gl);
|
|
|
|
if (equal(expr, tle->expr)) {
|
|
ref = tle->ressortgroupref;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ref == 0) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_GROUPING_ERROR),
|
|
errmsg("arguments to GROUPING must be grouping expressions of the associated query level"),
|
|
parser_errposition(context->pstate, exprLocation(expr))));
|
|
}
|
|
|
|
ref_list = lappend_int(ref_list, ref);
|
|
}
|
|
|
|
grp->refs = ref_list;
|
|
}
|
|
|
|
if ((int)grp->agglevelsup > context->sublevels_up) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (IsA(node, Query)) {
|
|
/* Recurse into subselects */
|
|
bool result = false;
|
|
|
|
context->sublevels_up++;
|
|
result = query_tree_walker((Query*)node, (bool (*)())finalize_grouping_exprs_walker, (void*)context, 0);
|
|
context->sublevels_up--;
|
|
return result;
|
|
}
|
|
return expression_tree_walker(node, (bool (*)())finalize_grouping_exprs_walker, (void*)context);
|
|
}
|
|
|
|
/*
|
|
* Given a GroupingSet node, expand it and return a list of lists.
|
|
*
|
|
* For EMPTY nodes, return a list of one empty list.
|
|
*
|
|
* For SIMPLE nodes, return a list of one list, which is the node content.
|
|
*
|
|
* For CUBE and ROLLUP nodes, return a list of the expansions.
|
|
*
|
|
* For SET nodes, recursively expand contained CUBE and ROLLUP.
|
|
*/
|
|
static List* expand_groupingset_node(GroupingSet* gs)
|
|
{
|
|
List* result = NIL;
|
|
|
|
switch (gs->kind) {
|
|
case GROUPING_SET_EMPTY:
|
|
result = list_make1(NIL);
|
|
break;
|
|
|
|
case GROUPING_SET_SIMPLE:
|
|
result = list_make1(gs->content);
|
|
break;
|
|
|
|
case GROUPING_SET_ROLLUP: {
|
|
List* rollup_val = gs->content;
|
|
ListCell* lc = NULL;
|
|
int curgroup_size = list_length(gs->content);
|
|
|
|
while (curgroup_size > 0) {
|
|
List* current_result = NIL;
|
|
int i = curgroup_size;
|
|
|
|
foreach (lc, rollup_val) {
|
|
GroupingSet* gs_current = (GroupingSet*)lfirst(lc);
|
|
|
|
AssertEreport(gs_current->kind == GROUPING_SET_SIMPLE, MOD_OPT, "Kind is unexpected");
|
|
|
|
current_result = list_concat(current_result, list_copy(gs_current->content));
|
|
|
|
/* If we are done with making the current group, break */
|
|
if (--i == 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
result = lappend(result, current_result);
|
|
--curgroup_size;
|
|
}
|
|
|
|
result = lappend(result, NIL);
|
|
} break;
|
|
|
|
case GROUPING_SET_CUBE: {
|
|
List* cube_list = gs->content;
|
|
int number_bits = list_length(cube_list);
|
|
uint32 num_sets;
|
|
uint32 i;
|
|
|
|
/* parser should cap this much lower */
|
|
AssertEreport(number_bits < 31, MOD_OPT, "parser should cap this much lower");
|
|
|
|
num_sets = (1U << (unsigned int)number_bits);
|
|
|
|
for (i = 0; i < num_sets; i++) {
|
|
List* current_result = NIL;
|
|
ListCell* lc = NULL;
|
|
uint32 mask = 1U;
|
|
|
|
foreach (lc, cube_list) {
|
|
GroupingSet* gs_current = (GroupingSet*)lfirst(lc);
|
|
|
|
AssertEreport(gs_current->kind == GROUPING_SET_SIMPLE, MOD_OPT, "Kind is unexpected");
|
|
|
|
if (mask & i) {
|
|
current_result = list_concat(current_result, list_copy(gs_current->content));
|
|
}
|
|
|
|
mask <<= 1;
|
|
}
|
|
|
|
result = lappend(result, current_result);
|
|
}
|
|
} break;
|
|
|
|
case GROUPING_SET_SETS: {
|
|
ListCell* lc = NULL;
|
|
|
|
foreach (lc, gs->content) {
|
|
List* current_result = expand_groupingset_node((GroupingSet*)lfirst(lc));
|
|
|
|
result = list_concat(result, current_result);
|
|
}
|
|
} break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static int cmp_list_len_asc(const void* a, const void* b)
|
|
{
|
|
int la = list_length(*(List* const*)a);
|
|
int lb = list_length(*(List* const*)b);
|
|
|
|
return (la > lb) ? 1 : (la == lb) ? 0 : -1;
|
|
}
|
|
|
|
/*
|
|
* Create expression trees for the transition and final functions
|
|
* of an aggregate. These are needed so that polymorphic functions
|
|
* can be used within an aggregate --- without the expression trees,
|
|
* such functions would not know the datatypes they are supposed to use.
|
|
* (The trees will never actually be executed, however, so we can skimp
|
|
* a bit on correctness.)
|
|
*
|
|
* agg_input_types, agg_state_type, agg_result_type identify the input,
|
|
* transition, and result types of the aggregate. These should all be
|
|
* resolved to actual types (ie, none should ever be ANYELEMENT etc).
|
|
* agg_input_collation is the aggregate function's input collation.
|
|
*
|
|
* transfn_oid and finalfn_oid identify the funcs to be called; the latter
|
|
* may be InvalidOid.
|
|
*
|
|
* Pointers to the constructed trees are returned into *transfnexpr and
|
|
* *finalfnexpr. The latter is set to NULL if there's no finalfn.
|
|
*/
|
|
void build_aggregate_fnexprs(Oid* agg_input_types, int agg_num_inputs, Oid agg_state_type, Oid agg_result_type,
|
|
Oid agg_input_collation, Oid transfn_oid, Oid finalfn_oid, Expr** transfnexpr, Expr** finalfnexpr)
|
|
{
|
|
Param* argp = NULL;
|
|
List* args = NIL;
|
|
int i;
|
|
|
|
/*
|
|
* Build arg list to use in the transfn FuncExpr node. We really only care
|
|
* that transfn can discover the actual argument types at runtime using
|
|
* get_fn_expr_argtype(), so it's okay to use Param nodes that don't
|
|
* correspond to any real Param.
|
|
*/
|
|
argp = makeNode(Param);
|
|
argp->paramkind = PARAM_EXEC;
|
|
argp->paramid = -1;
|
|
argp->paramtype = agg_state_type;
|
|
argp->paramtypmod = -1;
|
|
argp->paramcollid = agg_input_collation;
|
|
argp->location = -1;
|
|
|
|
args = list_make1(argp);
|
|
|
|
for (i = 0; i < agg_num_inputs; i++) {
|
|
argp = makeNode(Param);
|
|
argp->paramkind = PARAM_EXEC;
|
|
argp->paramid = -1;
|
|
argp->paramtype = agg_input_types[i];
|
|
argp->paramtypmod = -1;
|
|
argp->paramcollid = agg_input_collation;
|
|
argp->location = -1;
|
|
args = lappend(args, argp);
|
|
}
|
|
|
|
*transfnexpr =
|
|
(Expr*)makeFuncExpr(transfn_oid, agg_state_type, args, InvalidOid, agg_input_collation, COERCE_DONTCARE);
|
|
|
|
/* see if we have a final function */
|
|
if (!OidIsValid(finalfn_oid)) {
|
|
*finalfnexpr = NULL;
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Build expr tree for final function
|
|
*/
|
|
argp = makeNode(Param);
|
|
argp->paramkind = PARAM_EXEC;
|
|
argp->paramid = -1;
|
|
argp->paramtype = agg_state_type;
|
|
argp->paramtypmod = -1;
|
|
argp->paramcollid = agg_input_collation;
|
|
argp->location = -1;
|
|
args = list_make1(argp);
|
|
|
|
*finalfnexpr =
|
|
(Expr*)makeFuncExpr(finalfn_oid, agg_result_type, args, InvalidOid, agg_input_collation, COERCE_DONTCARE);
|
|
}
|
|
|
|
/*
|
|
* Create expression trees for the transition and final functions
|
|
* of an aggregate. These are needed so that polymorphic functions
|
|
* can be used within an aggregate --- without the expression trees,
|
|
* such functions would not know the datatypes they are supposed to use.
|
|
* (The trees will never actually be executed, however, so we can skimp
|
|
* a bit on correctness.)
|
|
*
|
|
* agg_input_types, agg_state_type, agg_result_type identify the input,
|
|
* transition, and result types of the aggregate. These should all be
|
|
* resolved to actual types (ie, none should ever be ANYELEMENT etc).
|
|
* agg_input_collation is the aggregate function's input collation.
|
|
*
|
|
* For an ordered-set aggregate, remember that agg_input_types describes
|
|
* the direct arguments followed by the aggregated arguments.
|
|
*
|
|
* transfn_oid and finalfn_oid identify the funcs to be called; the latter
|
|
* may be InvalidOid.
|
|
*
|
|
* Pointers to the constructed trees are returned into *transfnexpr and
|
|
* *finalfnexpr. The latter is set to NULL if there's no finalfn.
|
|
*/
|
|
void build_trans_aggregate_fnexprs(int agg_num_inputs, int agg_num_direct_inputs, bool agg_ordered_set,
|
|
bool agg_variadic, Oid agg_state_type, Oid* agg_input_types, Oid agg_result_type, Oid agg_input_collation,
|
|
Oid transfn_oid, Oid finalfn_oid, Expr** transfnexpr, Expr** finalfnexpr)
|
|
{
|
|
Param* argp = NULL;
|
|
List* args = NULL;
|
|
FuncExpr* fexpr = NULL;
|
|
int i;
|
|
|
|
/*
|
|
* Build arg list to use in the transfn FuncExpr node. We really only care
|
|
* that transfn can discover the actual argument types at runtime using
|
|
* get_fn_expr_argtype(), so it's okay to use Param nodes that don't
|
|
* correspond to any real Param.
|
|
*/
|
|
argp = makeParam(PARAM_EXEC, -1, agg_state_type, -1, agg_input_collation, -1);
|
|
args = list_make1(argp);
|
|
|
|
for (i = agg_num_direct_inputs; i < agg_num_inputs; i++) {
|
|
argp = makeParam(PARAM_EXEC, -1, agg_input_types[i], -1, agg_input_collation, -1);
|
|
args = lappend(args, argp);
|
|
}
|
|
|
|
fexpr = makeFuncExpr(transfn_oid, agg_state_type, args, InvalidOid, agg_input_collation, COERCE_EXPLICIT_CALL);
|
|
fexpr->funcvariadic = agg_variadic;
|
|
*transfnexpr = (Expr*)fexpr;
|
|
|
|
/* see if we have a final function */
|
|
if (!OidIsValid(finalfn_oid)) {
|
|
*finalfnexpr = NULL;
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Build expr tree for final function
|
|
*/
|
|
argp = makeParam(PARAM_EXEC, -1, agg_state_type, -1, agg_input_collation, -1);
|
|
args = list_make1(argp);
|
|
|
|
if (agg_ordered_set) {
|
|
for (i = 0; i < agg_num_inputs; i++) {
|
|
argp = makeParam(PARAM_EXEC, -1, agg_input_types[i], -1, agg_input_collation, -1);
|
|
args = lappend(args, argp);
|
|
}
|
|
}
|
|
|
|
*finalfnexpr =
|
|
(Expr*)makeFuncExpr(finalfn_oid, agg_result_type, args, InvalidOid, agg_input_collation, COERCE_EXPLICIT_CALL);
|
|
/* finalfn is currently never treated as variadic */
|
|
}
|
|
|
|
/*
|
|
* Expand a groupingSets clause to a flat list of grouping sets.
|
|
* The returned list is sorted by length, shortest sets first.
|
|
*
|
|
* This is mainly for the planner, but we use it here too to do
|
|
* some consistency checks.
|
|
*/
|
|
List* expand_grouping_sets(List* groupingSets, int limit)
|
|
{
|
|
List* expanded_groups = NIL;
|
|
List* result = NIL;
|
|
double numsets = 1;
|
|
ListCell* lc = NULL;
|
|
|
|
if (groupingSets == NIL) {
|
|
return NIL;
|
|
}
|
|
|
|
foreach (lc, groupingSets) {
|
|
List* current_result = NIL;
|
|
GroupingSet* gs = (GroupingSet*)lfirst(lc);
|
|
current_result = expand_groupingset_node(gs);
|
|
AssertEreport(current_result != NIL, MOD_OPT, "para should not be NULL here");
|
|
numsets *= list_length(current_result);
|
|
|
|
if (limit >= 0 && numsets > limit) {
|
|
return NIL;
|
|
}
|
|
|
|
expanded_groups = lappend(expanded_groups, current_result);
|
|
}
|
|
|
|
/*
|
|
* Do cartesian product between sublists of expanded_groups. While at it,
|
|
* remove any duplicate elements from individual grouping sets (we must
|
|
* NOT change the number of sets though)
|
|
*/
|
|
foreach (lc, (List*)linitial(expanded_groups)) {
|
|
result = lappend(result, list_union_int(NIL, (List*)lfirst(lc)));
|
|
}
|
|
|
|
for_each_cell(lc, lnext(list_head(expanded_groups)))
|
|
{
|
|
List* p = (List*)lfirst(lc);
|
|
List* new_result = NIL;
|
|
ListCell* lc2 = NULL;
|
|
|
|
foreach (lc2, result) {
|
|
List* q = (List*)lfirst(lc2);
|
|
ListCell* lc3 = NULL;
|
|
|
|
foreach (lc3, p) {
|
|
new_result = lappend(new_result, list_union_int(q, (List*)lfirst(lc3)));
|
|
}
|
|
}
|
|
result = new_result;
|
|
}
|
|
|
|
if (list_length(result) > 1) {
|
|
int result_len = list_length(result);
|
|
List** buf = (List**)palloc(sizeof(List*) * result_len);
|
|
List** ptr = buf;
|
|
|
|
foreach (lc, result) {
|
|
*ptr++ = (List*)lfirst(lc);
|
|
}
|
|
|
|
qsort(buf, result_len, sizeof(List*), cmp_list_len_asc);
|
|
|
|
result = NIL;
|
|
ptr = buf;
|
|
|
|
while (result_len-- > 0)
|
|
result = lappend(result, *ptr++);
|
|
|
|
pfree_ext(buf);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* transformGroupingFunc
|
|
* Transform a GROUPING expression
|
|
*
|
|
* GROUPING() behaves very like an aggregate. Processing of levels and nesting
|
|
* is done as for aggregates. We set p_hasAggs for these expressions too.
|
|
*/
|
|
Node* transformGroupingFunc(ParseState* pstate, GroupingFunc* p)
|
|
{
|
|
ListCell* lc = NULL;
|
|
List* args = p->args;
|
|
List* result_list = NIL;
|
|
bool orig_is_replace = false;
|
|
|
|
GroupingFunc* result = makeNode(GroupingFunc);
|
|
|
|
if (list_length(args) > 31) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_TOO_MANY_ARGUMENTS),
|
|
errmsg("GROUPING must have fewer than 32 arguments"),
|
|
parser_errposition(pstate, p->location)));
|
|
}
|
|
orig_is_replace = pstate->isAliasReplace;
|
|
|
|
/* Grouping is not support Alias Replace. */
|
|
pstate->isAliasReplace = false;
|
|
|
|
foreach (lc, args) {
|
|
Node* current_result = NULL;
|
|
current_result = transformExpr(pstate, (Node*)lfirst(lc));
|
|
/* acceptability of expressions is checked later */
|
|
result_list = lappend(result_list, current_result);
|
|
}
|
|
|
|
pstate->isAliasReplace = orig_is_replace;
|
|
|
|
result->args = result_list;
|
|
result->location = p->location;
|
|
|
|
pstate->p_hasAggs = true;
|
|
|
|
return (Node*)result;
|
|
}
|
|
|
|
/*
|
|
* check_windowagg_can_shuffle
|
|
* Check if windowagg can be shuffled
|
|
*/
|
|
bool check_windowagg_can_shuffle(List* partitionClause, List* targetList)
|
|
{
|
|
if (partitionClause == NIL) {
|
|
return true;
|
|
}
|
|
|
|
ListCell* l = NULL;
|
|
foreach (l, partitionClause) {
|
|
SortGroupClause* grpcl = (SortGroupClause*)lfirst(l);
|
|
TargetEntry* expr = get_sortgroupclause_tle(grpcl, targetList, false);
|
|
if (expr == NULL) {
|
|
continue;
|
|
}
|
|
if (checkExprHasAggs((Node*)expr->expr)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* get_aggregate_argtypes
|
|
* Get the actual datatypes passed to an aggregate call and return the
|
|
* number of actual arguments.
|
|
*
|
|
* Given an Aggref, extract the actual datatypes of the input arguments.
|
|
* For ordered-set agg, Aggref contains direct args and aggregated args,
|
|
* and direct args is saved before aggregate args.
|
|
*
|
|
* Datatypes are load into inputTypes[], which must reference an array
|
|
* of length FUNC_MAX_ARGS.
|
|
*/
|
|
int get_aggregate_argtypes(Aggref* aggref, Oid* inputTypes, int func_max_args)
|
|
{
|
|
int narg = 0;
|
|
ListCell* lc = NULL;
|
|
|
|
/*
|
|
* If is ordered-set agg, aggref->aggdirectargs is not null.
|
|
* So we need first handle the direct args.
|
|
*/
|
|
foreach (lc, aggref->aggdirectargs) {
|
|
inputTypes[narg] = exprType((Node*)lfirst(lc));
|
|
narg++;
|
|
if (narg >= func_max_args) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
|
|
errmsg("functions can have at most %d parameters", func_max_args)));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Then get the aggregated arguments, both contained by normal
|
|
* agg and orderd-set agg.
|
|
*/
|
|
foreach (lc, aggref->args) {
|
|
TargetEntry* tle = (TargetEntry*)lfirst(lc);
|
|
|
|
/* Ignore ordering columns of a plain aggregate */
|
|
if (tle->resjunk) {
|
|
continue;
|
|
}
|
|
|
|
inputTypes[narg] = exprType((Node*)tle->expr);
|
|
narg++;
|
|
if (narg >= func_max_args) {
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
|
|
errmsg("functions can have at most %d parameters", func_max_args)));
|
|
}
|
|
}
|
|
|
|
return narg;
|
|
}
|
|
|
|
/*
|
|
* resolve_aggregate_transtype
|
|
* Identify the transition state value's datatype for an aggregate call
|
|
* when agg accepts ANY or a polymorphic type.
|
|
*
|
|
* This function resolves a polymorphic aggregate's state datatype.
|
|
* The aggtranstype is passed by searching from the pg_aggregate catalog,
|
|
* as well as the actual argument types extracted by get_aggregate_argtypes.
|
|
*/
|
|
Oid resolve_aggregate_transtype(Oid aggfuncid, Oid aggtranstype, Oid* inputTypes, int numArguments)
|
|
{
|
|
/* Only resolve actual type of transition state when it is polymorphic */
|
|
if (IsPolymorphicType(aggtranstype)) {
|
|
Oid* declaredArgTypes = NULL;
|
|
int agg_nargs = 0;
|
|
/* get the agg's function's argument and result types... */
|
|
(void)get_func_signature(aggfuncid, &declaredArgTypes, &agg_nargs);
|
|
|
|
Assert(agg_nargs <= numArguments);
|
|
|
|
aggtranstype = enforce_generic_type_consistency(inputTypes, declaredArgTypes, agg_nargs, aggtranstype, false);
|
|
pfree(declaredArgTypes);
|
|
}
|
|
return aggtranstype;
|
|
}
|
|
|
|
#ifndef ENABLE_MULTIPLE_NODES
|
|
static void find_rownum_in_groupby_clauses(Rownum *rownumVar, check_ungrouped_columns_context *context)
|
|
{
|
|
/*
|
|
* have_non_var_grouping makes SQL
|
|
* SELECT a + a FROM t GROUP BY a + a having rownum <= 1;
|
|
* allowed, but SQL
|
|
* SELECT a FROM t GROUP BY a having rownum <= 1;
|
|
* not allowed, which is different from O.
|
|
*/
|
|
if (!context->have_non_var_grouping) {
|
|
bool haveRownum = false;
|
|
ListCell *gl = NULL;
|
|
foreach (gl, context->groupClauses) {
|
|
Node *gnode = (Node *)((TargetEntry *)lfirst(gl))->expr;
|
|
if (IsA(gnode, Rownum)) {
|
|
haveRownum = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (haveRownum == false) {
|
|
ereport(ERROR, (errcode(ERRCODE_GROUPING_ERROR),
|
|
errmsg("ROWNUM must appear in the GROUP BY clause or be used in an aggregate function"),
|
|
parser_errposition(context->pstate, rownumVar->location)));
|
|
}
|
|
}
|
|
}
|
|
#endif
|