| /* |
| * For PostgreSQL Database Management System: |
| * (formerly known as Postgres, then as Postgres95) |
| * |
| * Portions Copyright (c) 1996-2010, The PostgreSQL Global Development Group |
| * |
| * Portions Copyright (c) 1994, The Regents of the University of California |
| * |
| * Permission to use, copy, modify, and distribute this software and its documentation for any purpose, |
| * without fee, and without a written agreement is hereby granted, provided that the above copyright notice |
| * and this paragraph and the following two paragraphs appear in all copies. |
| * |
| * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, |
| * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, |
| * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY |
| * OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, |
| * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. |
| * |
| * THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA |
| * HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. |
| */ |
| |
| #include "postgres.h" |
| |
| #include "catalog/pg_constraint.h" |
| #include "nodes/nodeFuncs.h" |
| #include "optimizer/tlist.h" |
| #include "optimizer/optimizer.h" |
| #include "parser/cypher_parse_agg.h" |
| #include "parser/parsetree.h" |
| #include "rewrite/rewriteManip.h" |
| |
| typedef struct |
| { |
| ParseState *pstate; |
| int min_varlevel; |
| int min_agglevel; |
| int sublevels_up; |
| } check_agg_arguments_context; |
| |
| 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); |
| static List * expand_grouping_sets(List *groupingSets, int limit); |
| |
| /* |
| * From PG's parseCheckAggregates |
| * |
| * Check for aggregates where they shouldn't be and improper grouping. |
| * This function should be called after the target list and qualifications |
| * are finalized. |
| * |
| * Misplaced aggregates are now mostly detected in transformAggregateCall, |
| * but it seems more robust to check for aggregates in recursive queries |
| * only after everything is finalized. In any case it's hard to detect |
| * improper grouping on-the-fly, so we have to make another pass over the |
| * query for that. |
| */ |
| void parse_check_aggregates(ParseState *pstate, Query *qry) |
| { |
| List *gset_common = NIL; |
| List *groupClauses = NIL; |
| List *groupClauseCommonVars = NIL; |
| bool have_non_var_grouping; |
| List *func_grouped_rels = NIL; |
| ListCell *l; |
| bool hasJoinRTEs; |
| bool hasSelfRefRTEs; |
| PlannerInfo *root = NULL; |
| Node *clause; |
| |
| /* This should only be called if we found aggregates or grouping */ |
| Assert(pstate->p_hasAggs || qry->groupClause || qry->havingQual || qry->groupingSets); |
| |
| /* |
| * 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) |
| ereport(ERROR, |
| (errcode(ERRCODE_STATEMENT_TOO_COMPLEX), |
| errmsg("too many grouping sets present (maximum 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 = linitial(gsets); |
| |
| if (gset_common) |
| { |
| for_each_cell(l, gsets, lnext(gsets, list_head(gsets))) |
| { |
| gset_common = list_intersection_int(gset_common, lfirst(l)); |
| if (!gset_common) |
| 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; |
| } |
| |
| /* |
| * Build a list of the acceptable GROUP BY expressions for use by |
| * check_ungrouped_columns(). |
| * |
| * We get the TLE, not just the expr, because GROUPING wants to know the |
| * sortgroupref. |
| */ |
| foreach(l, qry->groupClause) |
| { |
| SortGroupClause *grpcl = (SortGroupClause *) lfirst(l); |
| TargetEntry *expr; |
| |
| expr = get_sortgroupclause_tle(grpcl, qry->targetList); |
| if (expr == NULL) |
| continue; /* probably cannot happen */ |
| |
| 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((Query*)root, |
| (Node *) groupClauses); |
| } |
| |
| /* |
| * 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 = 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((Query*)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((Query*)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 are not allowed in a recursive query's recursive term"), |
| parser_errposition(pstate, locate_agg_of_level((Node *) qry, 0)))); |
| } |
| |
| /* |
| * 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; |
| check_ungrouped_columns_walker(node, &context); |
| } |
| |
| static bool check_ungrouped_columns_walker(Node *node, check_ungrouped_columns_context *context) |
| { |
| ListCell *gl; |
| |
| 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; ungrouped vars there are not an error. But we should |
| * check direct arguments as though they weren't in an aggregate. |
| * We set a special flag in the context to help produce a useful |
| * error message for ungrouped vars in direct arguments. |
| */ |
| bool result; |
| |
| Assert(!context->in_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 skip recursing into aggregates of higher levels altogether, |
| * since they could not possibly contain Vars 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; |
| |
| /* 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 = lfirst(gl); |
| |
| if (equal(node, tle->expr)) |
| return false; /* acceptable, do not descend more */ |
| } |
| } |
| |
| /* |
| * 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; |
| char *attname; |
| |
| if (var->varlevelsup != 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 */ |
| |
| Assert(var->varno > 0 && |
| (int) var->varno <= list_length(context->pstate->p_rtable)); |
| 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); |
| if (context->sublevels_up == 0) |
| ereport(ERROR, (errcode(ERRCODE_GROUPING_ERROR), |
| errmsg("\"%s\" must be either part of an explicitly listed key or used inside an aggregate function", |
| attname), context->in_agg_direct_args ? |
| errdetail("Direct arguments of an ordered-set aggregate must use only grouped columns.") : |
| 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 (IsA(node, Query)) |
| { |
| /* Recurse into subselects */ |
| bool result; |
| |
| context->sublevels_up++; |
| result = query_tree_walker((Query *) node, |
| check_ungrouped_columns_walker, |
| (void *) context, 0); |
| context->sublevels_up--; |
| return result; |
| } |
| |
| return expression_tree_walker(node, 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; |
| finalize_grouping_exprs_walker(node, &context); |
| } |
| |
| static bool finalize_grouping_exprs_walker(Node *node, |
| check_ungrouped_columns_context *context) |
| { |
| ListCell *gl; |
| |
| 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; |
| |
| Assert(!context->in_agg_direct_args); |
| 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; |
| List *ref_list = NIL; |
| |
| foreach(lc, grp->args) |
| { |
| Node *expr = lfirst(lc); |
| Index ref = 0; |
| |
| if (context->root) |
| expr = flatten_join_alias_vars((Query*)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 (var->varlevelsup == context->sublevels_up) |
| { |
| foreach(gl, context->groupClauses) |
| { |
| TargetEntry *tle = 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 = 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; |
| |
| context->sublevels_up++; |
| result = query_tree_walker((Query *) node, |
| finalize_grouping_exprs_walker, |
| (void *) context, 0); |
| context->sublevels_up--; |
| return result; |
| } |
| return expression_tree_walker(node, 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; |
| 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); |
| |
| Assert(gs_current->kind == GROUPING_SET_SIMPLE); |
| |
| 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 */ |
| Assert(number_bits < 31); |
| |
| num_sets = (1U << number_bits); |
| |
| for (i = 0; i < num_sets; i++) |
| { |
| List *current_result = NIL; |
| ListCell *lc; |
| uint32 mask = 1U; |
| |
| foreach(lc, cube_list) |
| { |
| GroupingSet *gs_current = (GroupingSet *) lfirst(lc); |
| |
| Assert(gs_current->kind == GROUPING_SET_SIMPLE); |
| |
| 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; |
| |
| foreach(lc, gs->content) |
| { |
| List *current_result = expand_groupingset_node(lfirst(lc)); |
| |
| result = list_concat(result, current_result); |
| } |
| } |
| 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; |
| } |
| |
| /* |
| * 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. |
| */ |
| static List * expand_grouping_sets(List *groupingSets, int limit) |
| { |
| List *expanded_groups = NIL; |
| List *result = NIL; |
| double numsets = 1; |
| ListCell *lc; |
| |
| if (groupingSets == NIL) |
| return NIL; |
| |
| foreach(lc, groupingSets) |
| { |
| List *current_result = NIL; |
| GroupingSet *gs = lfirst(lc); |
| |
| current_result = expand_groupingset_node(gs); |
| |
| Assert(current_result != NIL); |
| |
| 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, expanded_groups, |
| lnext(expanded_groups, list_head(expanded_groups))) |
| { |
| List *p = lfirst(lc); |
| List *new_result = NIL; |
| ListCell *lc2; |
| |
| foreach(lc2, result) |
| { |
| List *q = lfirst(lc2); |
| ListCell *lc3; |
| |
| 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 = palloc(sizeof(List *) * result_len); |
| List **ptr = buf; |
| |
| foreach(lc, result) |
| { |
| *ptr++ = 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(buf); |
| } |
| |
| return result; |
| } |
