summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorMichael Paquier2012-10-12 00:26:50 +0000
committerMichael Paquier2012-10-12 00:33:25 +0000
commit6c6ba3c4583bd55edf5d3498d57635dec36419e0 (patch)
treefe5495c09b4b51f3a0471244623450257f795b1d
parent66c17a5a348a4ed09859be3c45c64e9a99cc2d49 (diff)
Revert "The commit has following changes: GROUP BY optimization patch"
This reverts commit 66c17a5a348a4ed09859be3c45c64e9a99cc2d49. This patch basically broke HEAD for aggregate pushdown, so reverting it is the right thing to do to keep a master version stable.
-rw-r--r--src/backend/nodes/copyfuncs.c1
-rw-r--r--src/backend/nodes/outfuncs.c1
-rw-r--r--src/backend/optimizer/plan/pgxcplan.c563
-rw-r--r--src/backend/optimizer/plan/setrefs.c98
-rw-r--r--src/backend/optimizer/util/pgxcship.c26
-rw-r--r--src/include/optimizer/pgxcplan.h1
-rw-r--r--src/include/optimizer/pgxcship.h1
-rw-r--r--src/test/regress/expected/aggregates.out38
-rw-r--r--src/test/regress/expected/aggregates_1.out36
-rw-r--r--src/test/regress/expected/xc_FQS.out12
-rw-r--r--src/test/regress/expected/xc_groupby.out1154
-rw-r--r--src/test/regress/expected/xc_having.out274
-rw-r--r--src/test/regress/sql/xc_FQS.sql2
-rw-r--r--src/test/regress/sql/xc_groupby.sql275
-rw-r--r--src/test/regress/sql/xc_having.sql24
15 files changed, 1287 insertions, 1219 deletions
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index dd4d5b288f..9db6c2b46a 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -1038,6 +1038,7 @@ _copyRemoteQuery(const RemoteQuery *from)
COPY_NODE_FIELD(base_tlist);
COPY_NODE_FIELD(coord_var_tlist);
COPY_NODE_FIELD(query_var_tlist);
+ COPY_SCALAR_FIELD(is_shippable_tlist);
COPY_SCALAR_FIELD(has_row_marks);
COPY_SCALAR_FIELD(has_ins_child_sel_parent);
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 533b88f150..8e858316fe 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -487,6 +487,7 @@ _outRemoteQuery(StringInfo str, const RemoteQuery *node)
WRITE_NODE_FIELD(remote_query);
WRITE_NODE_FIELD(coord_var_tlist);
WRITE_NODE_FIELD(query_var_tlist);
+ WRITE_BOOL_FIELD(is_shippable_tlist);
WRITE_BOOL_FIELD(has_ins_child_sel_parent);
}
diff --git a/src/backend/optimizer/plan/pgxcplan.c b/src/backend/optimizer/plan/pgxcplan.c
index ec65956ebd..97ec9f183e 100644
--- a/src/backend/optimizer/plan/pgxcplan.c
+++ b/src/backend/optimizer/plan/pgxcplan.c
@@ -57,17 +57,17 @@ static RemoteQuery *pgxc_FQS_create_remote_plan(Query *query,
ExecNodes *exec_nodes,
bool is_exec_direct);
static void pgxc_set_remote_parameters(PlannedStmt *plan, ParamListInfo boundParams);
-static bool pgxc_locate_grouping_columns(PlannerInfo *root, List *tlist,
+static void pgxc_locate_grouping_columns(PlannerInfo *root, List *tlist,
AttrNumber *grpColIdx);
-static List *pgxc_process_grouping_targetlist(List *local_tlist,
- bool single_node_grouping);
-static List *pgxc_process_having_clause(List *remote_tlist, bool single_node_grouping,
+static List *pgxc_process_grouping_targetlist(PlannerInfo *root,
+ List **local_tlist);
+static List *pgxc_process_having_clause(PlannerInfo *root, List *remote_tlist,
Node *havingQual, List **local_qual,
- List **remote_qual);
+ List **remote_qual, bool *reduce_plan);
static Expr *pgxc_set_en_expr(Oid tableoid, Index resultRelationIndex);
static int pgxc_count_rowmarks_entries(List *rowMarks);
static Oid *pgxc_build_rowmark_entries(List *rowMarks, List *rtable, Oid *types, int prepparams, int totparams);
-static List *pgxc_separate_quals(List *quals, List **local_quals, bool has_aggs);
+static List *pgxc_separate_quals(List *quals, List **local_quals);
static Query *pgxc_build_shippable_query_recurse(PlannerInfo *root,
RemoteQueryPath *rqpath,
List **unshippable_quals,
@@ -75,10 +75,6 @@ static Query *pgxc_build_shippable_query_recurse(PlannerInfo *root,
static RemoteQuery *make_remotequery(List *qptlist, List *qpqual,
Index scanrelid);
static RangeTblEntry *make_dummy_remote_rte(char *relname, Alias *alias);
-static List *pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals,
- bool has_aggs);
-static List *pgxc_add_to_flat_tlist(List *remote_tlist, Node *expr,
- Index ressortgroupref);
static void pgxc_rqplan_adjust_vars(RemoteQuery *rqplan, Node *node);
/*
@@ -87,23 +83,17 @@ static void pgxc_rqplan_adjust_vars(RemoteQuery *rqplan, Node *node);
* quals as return value and unshippable quals as local_quals
*/
static List *
-pgxc_separate_quals(List *quals, List **unshippabl_quals, bool has_aggs)
+pgxc_separate_quals(List *quals, List **unshippabl_quals)
{
ListCell *l;
List *shippabl_quals = NIL;
- /*
- * If the caller knows that there can be aggregates in the calls, we better
- * take steps for the same. See prologue of pgxc_is_expr_shippable().
- */
- bool tmp_has_aggs;
- bool *tmp_bool_ptr = has_aggs ? &tmp_has_aggs : NULL;
*unshippabl_quals = NIL;
foreach(l, quals)
{
Expr *clause = lfirst(l);
- if (pgxc_is_expr_shippable(clause, tmp_bool_ptr))
+ if (pgxc_is_expr_shippable(clause, NULL))
shippabl_quals = lappend(shippabl_quals, clause);
else
*unshippabl_quals = lappend(*unshippabl_quals, clause);
@@ -124,15 +114,11 @@ pgxc_separate_quals(List *quals, List **unshippabl_quals, bool has_aggs)
* those in the target list for the datanode.
*/
static List *
-pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals, bool has_aggs)
+pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals)
{
- ListCell *lcell;
- List *remote_tlist = NIL;
- PVCAggregateBehavior pvc_agg_spec = has_aggs ? PVC_INCLUDE_AGGREGATES
- : PVC_REJECT_AGGREGATES;
- List *unshippable_expr = list_copy(unshippabl_quals);
- List *aggs_n_vars;
- bool tmp_has_aggs;
+ ListCell *lcell;
+ List *remote_tlist = NIL;
+ List *tmp_rtlist = NIL;
/*
* Add all the shippable members as they are to the target list being built,
@@ -140,15 +126,8 @@ pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals, bool has_aggs)
*/
foreach(lcell, tlist)
{
- TargetEntry *tle = lfirst(lcell);
- Expr *expr;
- bool *tmp_ptr;
-
- /*
- * If there are aggregates in the targetlist, we should say so while
- * checking the expression shippability.
- */
- tmp_ptr = has_aggs ? &tmp_has_aggs : NULL;
+ TargetEntry *tle = lfirst(lcell);
+ Expr *expr;
if (!IsA(tle, TargetEntry))
elog(ERROR, "Expected TargetEntry node, but got node with type %d",
@@ -159,29 +138,22 @@ pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals, bool has_aggs)
* pgxc_is_expr_shippable(). Helps in detecting top level RowExpr, which
* are unshippable
*/
- if (pgxc_is_expr_shippable((Expr *)tle, tmp_ptr))
- remote_tlist = pgxc_add_to_flat_tlist(remote_tlist, (Node *)expr,
- tle->ressortgroupref);
+ if (pgxc_is_expr_shippable((Expr *)tle, NULL))
+ tmp_rtlist = lappend(tmp_rtlist, expr);
else
- unshippable_expr = lappend(unshippable_expr, expr);
+ tmp_rtlist = list_concat(tmp_rtlist, pull_var_clause((Node *)expr,
+ PVC_REJECT_AGGREGATES,
+ PVC_RECURSE_PLACEHOLDERS));
}
+ remote_tlist = add_to_flat_tlist(remote_tlist, tmp_rtlist);
/*
- * Now collect the aggregates (if needed) and Vars from the unshippable
- * expressions (from targetlist and unshippable quals and add them to
- * remote targetlist.
+ * The passed in quals are already checked for shippability, so just add the
+ * vars from those clauses to the targetlist being built.
*/
- aggs_n_vars = pull_var_clause((Node *)unshippable_expr, pvc_agg_spec,
- PVC_RECURSE_PLACEHOLDERS);
- foreach(lcell, aggs_n_vars)
- {
- Node *agg_or_var = lfirst(lcell);
- Assert(IsA(agg_or_var, Aggref) || IsA(agg_or_var, Var));
- /* If it's an aggregate expression, better it be shippable. */
- Assert(!IsA(agg_or_var, Aggref) ||
- pgxc_is_expr_shippable((Expr *)agg_or_var, &tmp_has_aggs));
- remote_tlist = pgxc_add_to_flat_tlist(remote_tlist, agg_or_var, 0);
- }
+ remote_tlist = add_to_flat_tlist(remote_tlist, pull_var_clause((Node *)unshippabl_quals,
+ PVC_RECURSE_AGGREGATES,
+ PVC_RECURSE_PLACEHOLDERS));
return remote_tlist;
}
@@ -228,7 +200,7 @@ pgxc_build_shippable_query_baserel(PlannerInfo *root, RemoteQueryPath *rqpath,
scan_clauses = pgxc_order_qual_clauses(root, baserel->baserestrictinfo);
scan_clauses = list_concat(extract_actual_clauses(scan_clauses, false),
extract_actual_clauses(scan_clauses, true));
- shippable_quals = pgxc_separate_quals(scan_clauses, unshippable_quals, false);
+ shippable_quals = pgxc_separate_quals(scan_clauses, unshippable_quals);
shippable_quals = copyObject(shippable_quals);
/*
@@ -390,13 +362,13 @@ pgxc_build_shippable_query_jointree(PlannerInfo *root, RemoteQueryPath *rqpath,
*/
extract_actual_join_clauses(rqpath->join_restrictlist, &join_clauses,
&other_clauses);
- if (!pgxc_is_expr_shippable((Expr *)join_clauses, NULL))
+ if (!pgxc_is_expr_shippable((Expr *)join_clauses, false))
elog(ERROR, "join with unshippable join clauses can not be shipped");
join_clauses = copyObject(join_clauses);
other_clauses = list_concat(other_clauses,
extract_actual_clauses(rqpath->join_restrictlist,
true));
- other_clauses = pgxc_separate_quals(other_clauses, unshippable_quals, false);
+ other_clauses = pgxc_separate_quals(other_clauses, unshippable_quals);
other_clauses = copyObject(other_clauses);
/*
@@ -570,10 +542,12 @@ pgxc_rqplan_adjust_tlist(RemoteQuery *rqplan)
List *query_tlist;
/*
* Build the target list to be shipped to the datanode from the targetlist
- * expected from the plan.
+ * expected from the plan, if the targetlist is not shippable as is.
*/
- base_tlist = pgxc_build_shippable_tlist(plan->targetlist, plan->qual,
- rqplan->remote_query->hasAggs);
+ if (!rqplan->is_shippable_tlist)
+ base_tlist = pgxc_build_shippable_tlist(plan->targetlist, plan->qual);
+ else
+ base_tlist = copyObject(plan->targetlist);
query_tlist = copyObject(base_tlist);
/* Replace the targetlist of remote_query with the new base_tlist */
@@ -1309,24 +1283,20 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan)
RangeTblEntry *dummy_rte;
int numGroupCols;
AttrNumber *grpColIdx;
+ bool reduce_plan;
List *remote_qual;
List *local_qual;
- bool single_node_grouping;/* Can grouping be entirely performed
- * on a given datanode?
- */
- List *remote_scan_tlist;
/* Remote grouping is not enabled, don't do anything */
if (!enable_remotegroup)
return local_plan;
-
/*
- * PGXCTODO: These optimizations do not work in presence of the window functions,
- * because of the target list adjustments. The targetlist set for the passed
- * in Group/Agg plan nodes contains window functions if any, but gets
- * changed while planning for windowing. So, for now stay away :)
+ * We don't push aggregation and grouping to Datanodes, in case there are
+ * windowing aggregates, distinct, having clause or sort clauses.
*/
- if (query->hasWindowFuncs)
+ if (query->hasWindowFuncs ||
+ query->distinctClause ||
+ query->sortClause)
return local_plan;
/* for now only Agg/Group plans */
@@ -1357,7 +1327,10 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan)
sort_plan = (Sort *)temp_plan;
temp_plan = temp_plan->lefttree;
}
-
+ if (temp_plan && IsA(temp_plan, Result))
+ temp_plan = temp_plan->lefttree;
+ if (temp_plan && IsA(temp_plan, Material))
+ temp_plan = temp_plan->lefttree;
if (temp_plan && IsA(temp_plan, RemoteQuery))
remote_scan = (RemoteQuery *)temp_plan;
@@ -1399,74 +1372,44 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan)
}
}
- if (pgxc_query_has_distcolgrouping(query) ||
- list_length(remote_scan->exec_nodes->nodeList) == 1)
- single_node_grouping = true;
- /*
- * If we are able to completely evaluate the aggregates on datanodes, we
- * need to ask datanode/s to finalise the aggregates
- */
- remote_scan->remote_query->qry_finalise_aggs = single_node_grouping;
-
/*
- * Build the targetlist of the query plan.
+ * process the targetlist of the grouping plan, also construct the
+ * targetlist of the query to be shipped to the remote side
*/
- remote_scan_tlist = pgxc_process_grouping_targetlist(local_plan->targetlist,
- single_node_grouping);
- remote_scan_tlist = pgxc_process_having_clause(remote_scan_tlist, single_node_grouping,
- query->havingQual, &local_qual,
- &remote_qual);
+ base_tlist = pgxc_process_grouping_targetlist(root, &(local_plan->targetlist));
/*
* If can not construct a targetlist shippable to the Datanode. Resort to
* the plan created by grouping_planner()
*/
- if (!remote_scan_tlist)
+ if (!base_tlist)
return local_plan;
- /*
- * Copy the quals to be included in the Query to be sent to the datanodes,
- * so that the nodes (e.g. Vars) can be changed.
- */
- remote_qual = copyObject(remote_qual);
- /* Modify the targetlist of the JOIN plan with the new targetlist */
- remote_scan->scan.plan.targetlist = remote_scan_tlist;
- /* we need to adjust the Vars in HAVING clause to be shipped */
- pgxc_rqplan_adjust_vars(remote_scan, (Node *)remote_qual);
- /* Attach the local quals at appropriate plan */
- if (single_node_grouping)
- remote_scan->scan.plan.qual = local_qual;
- else
- local_plan->qual = local_qual;
- remote_scan->remote_query->havingQual = (Node *)remote_qual;
+ base_tlist = pgxc_process_having_clause(root, base_tlist, query->havingQual,
+ &local_qual, &remote_qual, &reduce_plan);
+ remote_qual = copyObject(remote_qual);
/*
- * Generate the targetlist to be shipped to the datanode, so that we can
- * check whether we are able to ship the grouping clauses to the datanode/s.
- * If the original query has aggregates, set the same in Query to be sent to
- * the datanodes, so that we have right expectations about the aggregates
- * while generating the targetlist.
+ * Because of HAVING clause, we can not push the aggregates and GROUP BY
+ * clause to the Datanode. Resort to the plan created by grouping planner.
*/
- remote_scan->remote_query->hasAggs = query->hasAggs;
- pgxc_rqplan_adjust_tlist(remote_scan);
- base_tlist = remote_scan->base_tlist;
-
+ if (!reduce_plan)
+ return local_plan;
+ Assert(base_tlist);
+ /* Modify the targetlist of the JOIN plan with the new targetlist */
+ remote_scan->scan.plan.targetlist = base_tlist;
/*
* recompute the column ids of the grouping columns,
* the group column indexes computed earlier point in the
- * targetlists of the scan plans under Agg/Group node. But now the grouping
+ * targetlists of the scan plans under this node. But now the grouping
* column indexes will be pointing in the targetlist of the new
* RemoteQuery, hence those need to be recomputed
- * If we couldn't locate a particular GROUP BY
*/
- if (!pgxc_locate_grouping_columns(root, base_tlist, grpColIdx))
- return local_plan;
+ pgxc_locate_grouping_columns(root, base_tlist, grpColIdx);
/* Add the GROUP BY clause to the JOIN query */
remote_scan->remote_query->groupClause = query->groupClause;
- /*
- * Add the ORDER BY clause if necessary, this ordering important, because
- * rest of the plan depends upon it.
- */
+ remote_scan->remote_query->hasAggs = query->hasAggs;
+ /* Add the ORDER BY clause if necessary */
if (sort_plan)
{
List *sortClause = NIL;
@@ -1507,31 +1450,29 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan)
remote_scan->remote_query->sortClause = sortClause;
}
+ /* we need to adjust the Vars in HAVING clause to be shipped */
+ pgxc_rqplan_adjust_vars(remote_scan, (Node *)remote_qual);
+ remote_scan->remote_query->havingQual = (Node *)remote_qual;
/*
- * We have added new clauses to the query being shipped to the datanode/s,
- * re-build the quals.
+ * Ultimately modify the targetlist of the remote_query according to the new
+ * base_tlist and generate the SQL statement. We don't want to check again
+ * for shippability while adjusting the Vars.
*/
- pgxc_rqplan_build_statement(remote_scan);
+ remote_scan->is_shippable_tlist = true;
+ pgxc_rqplan_adjust_tlist(remote_scan);
+
+ local_plan->lefttree = (Plan *)remote_scan;
+ local_plan->qual = local_qual;
/* Change the dummy RTE added to show the new place of reduction */
dummy_rte = rt_fetch(remote_scan->scan.scanrelid, query->rtable);
dummy_rte->relname = "__REMOTE_GROUP_QUERY__";
dummy_rte->eref = makeAlias("__REMOTE_GROUP_QUERY__", NIL);
+ /* indicate that we should apply collection function directly */
+ if (IsA(local_plan, Agg))
+ ((Agg *)local_plan)->skip_trans = true;
- /*
- * If we can finalise the aggregates on the datanode/s, we don't need the
- * covering Agg/Group plan.
- */
- if (single_node_grouping)
- return (Plan *)remote_scan;
- else
- {
- local_plan->lefttree = (Plan *)remote_scan;
- /* indicate that we should apply collection function directly */
- if (IsA(local_plan, Agg))
- ((Agg *)local_plan)->skip_trans = true;
- return local_plan;
- }
+ return local_plan;
}
/*
@@ -1542,53 +1483,70 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan)
* PGXCTODO: Can we reuse locate_grouping_columns() instead of writing this
* function? But this function is optimized to search in the same target list.
*/
-static bool
+static void
pgxc_locate_grouping_columns(PlannerInfo *root, List *tlist,
AttrNumber *groupColIdx)
{
int keyno = 0;
ListCell *gl;
- Assert(!root->parse->groupClause || groupColIdx != NULL);
+ /*
+ * No work unless grouping.
+ */
+ if (!root->parse->groupClause)
+ {
+ Assert(groupColIdx == NULL);
+ return;
+ }
+ Assert(groupColIdx != NULL);
foreach(gl, root->parse->groupClause)
{
SortGroupClause *grpcl = (SortGroupClause *) lfirst(gl);
TargetEntry *te = get_sortgroupclause_tle(grpcl, tlist);
if (!te)
- return false;
+ elog(ERROR, "failed to locate grouping columns");
groupColIdx[keyno++] = te->resno;
}
- return true;
}
/*
- * pgxc_add_to_flat_tlist
- * Add the given node to the target list to be sent to the Datanode. This is
- * similar to add_to_flat_tlist, except that it preserves the ressortgroupref
- * member in TargetEntry.
- *
- * Note about ressortgroupref
- * While constructing targetlist to be shipped to the datanode/s we try to
- * accomodate the GROUP BY or ORDER BY clauses if possible. So, we need to have
- * the ressortgroupref set in the query targetlist. Hence this function. We
- * consider following cases to set the given ressortgroupref.
- * 1. If the expression does not already exist, it is added to the list and
- * given ressortgroupref is set.
- * 2. If the expression already exists, and does not have ressortgroupref in the
- * target entry, the given one is set.
- * 3. PGXCTODO: If the expression already exists but has a different ressortgroupref set
- * in the target entry, we set that in target entry to 0 to avoid conflicts.
- * This would disable further optimizations but for the time being it's safe for
- * correctness.
+ * pgxc_add_node_to_grouping_tlist
+ * Add the given node to the target list to be sent to the Datanode. If it's
+ * Aggref node, also change the passed in node to point to the Aggref node in
+ * the Datanode's target list
*/
static List *
-pgxc_add_to_flat_tlist(List *remote_tlist, Node *expr, Index ressortgroupref)
+pgxc_add_node_to_grouping_tlist(List *remote_tlist, Node *expr, Index ressortgroupref)
{
TargetEntry *remote_tle;
+ Oid saved_aggtype;
+ /*
+ * When we add an aggregate to the remote targetlist the aggtype of such
+ * Aggref node is changed to aggtrantype. Hence while searching a given
+ * Aggref in remote targetlist, we need to change the aggtype accordingly
+ * and then switch it back.
+ */
+ if (IsA(expr, Aggref))
+ {
+ Aggref *aggref = (Aggref *)expr;
+ saved_aggtype = aggref->aggtype;
+ aggref->aggtype = aggref->aggtrantype;
+ }
+ else
+ {
+ /*
+ * When we use saved_aggtype later, compiler complains that this
+ * variable can be used without assigning a value to it, which can not
+ * be a case. Still keep compiler silent
+ */
+ saved_aggtype = InvalidOid;
+ }
remote_tle = tlist_member(expr, remote_tlist);
+ if (IsA(expr, Aggref))
+ ((Aggref *)expr)->aggtype = saved_aggtype;
if (!remote_tle)
{
@@ -1612,130 +1570,164 @@ pgxc_add_to_flat_tlist(List *remote_tlist, Node *expr, Index ressortgroupref)
{
/*
* if the expression's TLE already has a Sorting/Grouping reference,
- * and caller has passed a non-zero one as well, the same expression
- * is being used twice in the targetlist with different aliases. Do
- * not set ressortgroupref for either of them. The callers need to
- * set the ressortgroupref because they want to find the sort or
- * group column references in the targetlists. If we don't set
- * ressortgroupref, the optimizations will fail, which at least
- * doesn't have any correctness issue.
+ * and caller has passed a non-zero one as well, better both of them
+ * be same
*/
- if (remote_tle->ressortgroupref != ressortgroupref);
- remote_tle->ressortgroupref = 0;
+ Assert(remote_tle->ressortgroupref == ressortgroupref);
}
}
+ /*
+ * Replace the args of the local Aggref with Aggref node to be
+ * included in RemoteQuery node, so that set_plan_refs can convert
+ * the args into VAR pointing to the appropriate result in the tuple
+ * coming from RemoteQuery node
+ * PGXCTODO: should we push this change in targetlists of plans
+ * above?
+ */
+ if (IsA(expr, Aggref))
+ {
+ Aggref *local_aggref = (Aggref *)expr;
+ Aggref *remote_aggref = (Aggref *)remote_tle->expr;
+ Assert(IsA(remote_tle->expr, Aggref));
+ remote_aggref->aggtype = remote_aggref->aggtrantype;
+ /* Is copyObject() needed here? probably yes */
+ local_aggref->args = list_make1(makeTargetEntry(copyObject(remote_tle->expr),
+ 1, NULL,
+ false));
+ }
return remote_tlist;
}
/*
* pgxc_process_grouping_targetlist
- * The function scans the targetlist to build the targetlist of RemoteQuery
- * plan. While doing so, it checks for possibility of shipping the aggregates to
- * the datanodes. Either we push none or all of the aggregates and the aggregate
- * expressions need to shippable.
- * If aggregates can be completely evaluated on datanode/s, we don't need covering
- * Agg/Group plan. RemoteQuery node replaces the covering Agg/Group node. In
- * such case the targetlist passed in becomes targetlist of the RemoteQuery
- * node.
+ * The function scans the targetlist to check if the we can push anything
+ * from the targetlist to the Datanode. Following rules govern the choice
+ * 1. Either all of the aggregates are pushed to the Datanode or none is pushed
+ * 2. If there are no aggregates, the targetlist is good to be shipped as is
+ * 3. If aggregates are involved in expressions, we push the aggregates to the
+ * Datanodes but not the involving expressions.
+ *
+ * The function constructs the targetlist for the query to be pushed to the
+ * Datanode. It modifies the local targetlist to point to the expressions in
+ * remote targetlist wherever necessary (e.g. aggregates)
+ *
+ * PGXCTODO: we should be careful while pushing the function expressions, it's
+ * better to push functions like strlen() which can be evaluated at the
+ * Datanode, but we should avoid pushing functions which can only be evaluated
+ * at Coordinator.
*/
static List *
-pgxc_process_grouping_targetlist(List *local_tlist, bool single_node_grouping)
+pgxc_process_grouping_targetlist(PlannerInfo *root, List **local_tlist)
{
- List *remote_tlist = NIL;
+ bool shippable_remote_tlist = true;
+ List *remote_tlist = NIL;
+ List *orig_local_tlist = NIL;/* Copy original local_tlist, in case it changes */
ListCell *temp;
- if (single_node_grouping)
+ /*
+ * Walk through the target list and find out whether we can push the
+ * aggregates and grouping to Datanodes. Also while doing so, create the
+ * targetlist for the query to be shipped to the Datanode. Adjust the local
+ * targetlist accordingly.
+ */
+ foreach(temp, *local_tlist)
{
- /* Check that all the aggregates in the targetlist are shippable */
- List *aggs_n_vars = pull_var_clause((Node *)local_tlist, PVC_INCLUDE_AGGREGATES,
- PVC_RECURSE_PLACEHOLDERS);
- ListCell *lcell;
- bool tmp_has_aggs;
+ TargetEntry *local_tle = lfirst(temp);
+ Node *expr = (Node *)local_tle->expr;
+ bool has_aggs;
- foreach (lcell, aggs_n_vars)
+ /*
+ * If the expression is not Aggref but involves aggregates (has Aggref
+ * nodes in the expression tree, we can not push the entire expression
+ * to the Datanode, but push those aggregates to the Datanode, if those
+ * aggregates can be evaluated at the Datanodes (if is_foreign_expr
+ * returns true for entire expression). To evaluate the rest of the
+ * expression, we need to fetch the values of VARs participating in the
+ * expression. But, if we include the VARs under the aggregate nodes,
+ * they may not be part of GROUP BY clause, thus generating an invalid
+ * query. Hence, is_foreign_expr() wouldn't collect VARs under the
+ * expression tree rooted under Aggref node.
+ * For example, the original query is
+ * SELECT sum(val) * val2 FROM tab1 GROUP BY val2;
+ * the query pushed to the Datanode is
+ * SELECT sum(val), val2 FROM tab1 GROUP BY val2;
+ * Notice that, if we include val in the query, it will become invalid.
+ *
+ * It's crucial that we pass TargetEntry here to detect top-level
+ * RowExpr which are unshippable.
+ */
+ if (!pgxc_is_expr_shippable((Expr *)local_tle, &has_aggs))
{
- Expr *av_expr = (Expr *)lfirst(lcell);
- Assert(IsA(av_expr, Aggref) || IsA(av_expr, Var));
-
- /*
- * If the tree routed under the aggregate expression is not
- * shippable, we can not ship the entire targetlist.
- */
- if (IsA(av_expr, Aggref) &&
- !pgxc_is_expr_shippable(av_expr, &tmp_has_aggs))
- return NULL;
+ shippable_remote_tlist = false;
+ break;
}
- remote_tlist = copyObject(local_tlist);
- }
- else
- {
+
+ /*
+ * We are about to change the local_tlist, check if we have already
+ * copied original local_tlist, if not take a copy
+ */
+ if (!orig_local_tlist && has_aggs)
+ orig_local_tlist = copyObject(*local_tlist);
+
/*
- * For every expression check if it has aggregates in it, if it has
- * check whether those aggregates are shippable and include the
- * aggregates and Vars outside the aggregates in the RemoteQuery plan's
- * targetlist.
- * We can push all aggregates or none. Hence even if there is a single
- * non-shippable aggregate, we can not ship any other aggregates, and
- * resort to the complete aggregation and grouping on the datanode.
- * If the expression does not have any aggregates, add it as it is to
- * the RemoteQuery plan's targetlist
+ * If there are aggregates involved in the expression, whole expression
+ * can not be pushed to the Datanode. Pick up the aggregates and the
+ * VAR nodes not covered by aggregates.
*/
- foreach(temp, local_tlist)
+ if (has_aggs)
{
- TargetEntry *local_tle = lfirst(temp);
- Node *expr = (Node *)local_tle->expr;
- bool has_agg = false;
- bool tmp_has_aggs;
ListCell *lcell;
List *aggs_n_vars;
-
- aggs_n_vars = pull_var_clause(expr, PVC_INCLUDE_AGGREGATES,
- PVC_RECURSE_PLACEHOLDERS);
-
/*
- * See if there are any aggregates in the current target entry and
- * whether those aggregates are shippable.
+ * This expression is not going to be pushed as whole, thus other
+ * clauses won't be able to find out this TLE in the results
+ * obtained from Datanode. Hence can't optimize this query.
+ * PGXCTODO: with projection support in RemoteQuery node, this
+ * condition can be worked around, please check.
*/
- foreach (lcell, aggs_n_vars)
+ if (local_tle->ressortgroupref > 0)
{
- Expr *av_expr = (Expr *)lfirst(lcell);
- Assert(IsA(av_expr, Aggref) || IsA(av_expr, Var));
-
- /*
- * If the tree rooted under the aggregate expression is not
- * shippable, we can not ship the entire targetlist.
- */
- if (IsA(av_expr, Aggref))
- {
- has_agg = true;
- if (!pgxc_is_expr_shippable(av_expr, &tmp_has_aggs))
- return NULL;
- }
+ shippable_remote_tlist = false;
+ break;
}
- /*
- * If there are aggregates in the target list or if the expression
- * is not shippable in itself, we should just project the aggregates
- * and Vars outside the aggregates to upper nodes, since rest of
- * the expression needs to be evaluated after we have finalised the
- * aggregates.
- */
- if (has_agg || !pgxc_is_expr_shippable((Expr *)local_tle, NULL))
- {
- /*
- * It's fine to use add_to_flat_tlist here, since broken down
- * targetlist entry can not have ressortgroupref set.
- */
- remote_tlist = add_to_flat_tlist(remote_tlist, aggs_n_vars);
- }
- else
+ aggs_n_vars = pull_var_clause(expr, PVC_INCLUDE_AGGREGATES,
+ PVC_RECURSE_PLACEHOLDERS);
+ /* copy the aggregates into the remote target list */
+ foreach (lcell, aggs_n_vars)
{
- TargetEntry *remote_tle = copyObject(local_tle);
- remote_tle->resno = list_length(remote_tlist) + 1;
- remote_tlist = lappend(remote_tlist, remote_tle);
+ Assert(IsA(lfirst(lcell), Aggref) || IsA(lfirst(lcell), Var));
+ remote_tlist = pgxc_add_node_to_grouping_tlist(remote_tlist, lfirst(lcell),
+ 0);
}
}
+ /* Expression doesn't contain any aggregate */
+ else
+ remote_tlist = pgxc_add_node_to_grouping_tlist(remote_tlist, expr,
+ local_tle->ressortgroupref);
}
+
+ if (!shippable_remote_tlist)
+ {
+ /*
+ * If local_tlist has changed but we didn't find anything shippable to
+ * Datanode, we need to restore the local_tlist to original state,
+ */
+ if (orig_local_tlist)
+ *local_tlist = orig_local_tlist;
+ if (remote_tlist)
+ list_free_deep(remote_tlist);
+ remote_tlist = NIL;
+ }
+ else if (orig_local_tlist)
+ {
+ /*
+ * If we have changed the targetlist passed, we need to pass back the
+ * changed targetlist. Free the copy that has been created.
+ */
+ list_free_deep(orig_local_tlist);
+ }
+
return remote_tlist;
}
@@ -1749,17 +1741,18 @@ pgxc_process_grouping_targetlist(List *local_tlist, bool single_node_grouping)
* 2. If the expression does not have aggregates and the whole expression can be
* evaluated at the Datanode, add the expression to the remote qual to be
* evaluated at the Datanode.
- * 3. If qual contains an aggregate which can not be evaluated at the data
+ * 3. If qual contains an expression which can not be evaluated at the data
* node, the parent group plan can not be reduced to a remote_query.
*/
static List *
-pgxc_process_having_clause(List *remote_tlist, bool single_node_grouping,
- Node *havingQual, List **local_qual,
- List **remote_qual)
+pgxc_process_having_clause(PlannerInfo *root, List *remote_tlist, Node *havingQual,
+ List **local_qual, List **remote_qual,
+ bool *reduce_plan)
{
+ List *qual;
ListCell *temp;
- List *quals;
+ *reduce_plan = true;
*remote_qual = NIL;
*local_qual = NIL;
@@ -1770,29 +1763,28 @@ pgxc_process_having_clause(List *remote_tlist, bool single_node_grouping,
* possibility that the quals will be another form?
*/
if (!IsA(havingQual, List))
- return NULL;
-
- quals = (List *)havingQual;
- foreach(temp, quals)
+ {
+ *reduce_plan = false;
+ return remote_tlist;
+ }
+ /*
+ * Copy the havingQual so that the copy can be modified later. In case we
+ * back out in between, the original expression remains intact.
+ */
+ qual = copyObject(havingQual);
+ foreach(temp, qual)
{
Node *expr = lfirst(temp);
bool has_aggs;
List *vars_n_aggs;
- bool shippable_qual;
- shippable_qual = pgxc_is_expr_shippable((Expr *)expr, &has_aggs);
+ if (!pgxc_is_expr_shippable((Expr *)expr, &has_aggs))
+ {
+ *reduce_plan = false;
+ break;
+ }
- /*
- * If the expression is not shippable OR
- * if there are aggregates involved in the expression, whole expression
- * can not be pushed to the Datanode if grouping involves more than one
- * datanode. Pick up the aggregates and the VAR nodes not covered by
- * aggreagetes.
- * We can push all aggregates or none. Hence even if there is a single
- * non-shippable aggregate, we can not ship any other aggregates, and
- * resort to the complete aggregation and grouping on the datanode.
- */
- if (!shippable_qual || (!single_node_grouping && has_aggs))
+ if (has_aggs)
{
ListCell *lcell;
@@ -1802,30 +1794,19 @@ pgxc_process_having_clause(List *remote_tlist, bool single_node_grouping,
/* copy the aggregates into the remote target list */
foreach (lcell, vars_n_aggs)
{
- Node *agg_or_var = lfirst(lcell);
- bool tmp_has_agg;
-
- Assert(IsA(agg_or_var, Aggref) || IsA(agg_or_var, Var));
- if (IsA(agg_or_var, Aggref) &&
- !pgxc_is_expr_shippable((Expr *)agg_or_var, &tmp_has_agg))
- return NULL;
-
- /*
- * If the aggregation can not be evaluated on a single, we will
- * need a covering Agg/Group plan, where the aggregates will be
- * finalised and quals will be applied. In that case, the
- * targetlist of the RemoteQuery plan needs to have the
- * transitioned aggregates to be projected to Agg/Group plan.
- */
- if (!single_node_grouping)
- remote_tlist = pgxc_add_to_flat_tlist(remote_tlist,
- agg_or_var, 0);
+ Assert(IsA(lfirst(lcell), Aggref) || IsA(lfirst(lcell), Var));
+ remote_tlist = pgxc_add_node_to_grouping_tlist(remote_tlist, lfirst(lcell),
+ 0);
}
*local_qual = lappend(*local_qual, expr);
}
else
*remote_qual = lappend(*remote_qual, expr);
}
+
+ if (!(*reduce_plan))
+ list_free_deep(qual);
+
return remote_tlist;
}
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index d20364e37f..81243dbc50 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -26,7 +26,6 @@
#include "utils/lsyscache.h"
#include "utils/syscache.h"
#ifdef PGXC
-#include "pgxc/pgxc.h"
#include "optimizer/pgxcplan.h"
#endif
@@ -152,7 +151,6 @@ static List * fix_remote_expr(PlannerInfo *root,
static Node *fix_remote_expr_mutator(Node *node,
fix_remote_expr_context *context);
static void set_remote_references(PlannerInfo *root, RemoteQuery *rscan, int rtoffset);
-static void pgxc_set_agg_references(PlannerInfo *root, Agg *aggplan);
#endif
@@ -552,11 +550,6 @@ set_plan_refs(PlannerInfo *root, Plan *plan, int rtoffset)
}
break;
case T_Agg:
-#ifdef PGXC
- /* If the lower plan is RemoteQuery plan, adjust the aggregates */
- pgxc_set_agg_references(root, (Agg *)plan);
- /* Fall through */
-#endif /* PGXC */
case T_Group:
set_upper_references(root, plan, rtoffset);
break;
@@ -2116,94 +2109,3 @@ set_remote_references(PlannerInfo *root, RemoteQuery *rscan, int rtoffset)
pfree(base_itlist);
}
-
-#ifdef PGXC
-/*
- * For Agg plans, if the lower scan plan is a RemoteQuery node, adjust the
- * Aggref nodes to pull the transition results from the datanodes. We do while
- * setting planner references so that the upper nodes will find the nodes that
- * they expect in Agg plans.
- */
-void
-pgxc_set_agg_references(PlannerInfo *root, Agg *aggplan)
-{
- RemoteQuery *rqplan = (RemoteQuery *)aggplan->plan.lefttree;
- List *aggs_n_vars;
- ListCell *lcell;
- List *nodes_to_modify;
- List *rq_nodes_to_modify;
-
-
- /* Nothing to do if the lower plan is not RemoteQuery */
- if (!IsA(rqplan, RemoteQuery))
- return;
-
- Assert(IS_PGXC_COORDINATOR && !IsConnFromCoord());
- /*
- * If there are not transition results expected from lower plans, nothing to
- * be done here.
- */
- if (!aggplan->skip_trans)
- return;
-
- /* Gather all the aggregates that need fixing */
- nodes_to_modify = list_copy(aggplan->plan.targetlist);
- nodes_to_modify = list_concat(nodes_to_modify, aggplan->plan.qual);
- aggs_n_vars = pull_var_clause((Node *)nodes_to_modify, PVC_INCLUDE_AGGREGATES,
- PVC_RECURSE_PLACEHOLDERS);
- rq_nodes_to_modify = NIL;
- /*
- * For every aggregate, find corresponding aggregate in the lower plan and
- * modify it correctly.
- */
- foreach (lcell, aggs_n_vars)
- {
- Aggref *aggref = lfirst(lcell);
- TargetEntry *tle;
- Aggref *rq_aggref;
-
- if (!IsA(aggref, Aggref))
- {
- Assert(IsA(aggref, Var));
- continue;
- }
-
- tle = tlist_member((Node *)aggref, rqplan->scan.plan.targetlist);
-
- if (!tle)
- elog(ERROR, "Could not find the Aggref node");
-
- rq_aggref = (Aggref *)tle->expr;
- Assert(equal(rq_aggref, aggref));
-
- /*
- * Remember the Aggref nodes of which we need to modify. This is done so
- * that, if there multiple copies of same aggregate, we will match all
- * of them
- */
- rq_nodes_to_modify = list_append_unique(rq_nodes_to_modify, rq_aggref);
- /*
- * The transition result from the datanodes acts as an input to the
- * Aggref node on coordinator.
- */
- aggref->args = list_make1(makeTargetEntry((Expr *)rq_aggref, 1, NULL,
- false));
- }
-
- /* Modify the transition types now */
- foreach (lcell, rq_nodes_to_modify)
- {
- Aggref *rq_aggref = lfirst(lcell);
- Assert(IsA(rq_aggref, Aggref));
- rq_aggref->aggtype = rq_aggref->aggtrantype;
- }
-
- /*
- * We have modified the targetlist of the RemoteQuery plan below the Agg
- * plan. Adjust its targetlist as well.
- */
- pgxc_rqplan_adjust_tlist(rqplan);
-
- return;
-}
-#endif /* PGXC */
diff --git a/src/backend/optimizer/util/pgxcship.c b/src/backend/optimizer/util/pgxcship.c
index 4f8fc65c81..44937bafaf 100644
--- a/src/backend/optimizer/util/pgxcship.c
+++ b/src/backend/optimizer/util/pgxcship.c
@@ -113,8 +113,10 @@ static void pgxc_FQS_find_datanodes(Shippability_context *sc_context);
static bool pgxc_query_needs_coord(Query *query);
static bool pgxc_query_contains_only_pg_catalog(List *rtable);
static bool pgxc_is_var_distrib_column(Var *var, List *rtable);
+static bool pgxc_query_has_distcolgrouping(Query *query);
static bool pgxc_distinct_has_distcol(Query *query);
+
/*
* Set the given reason in Shippability_context indicating why the query can not be
* shipped directly to remote nodes.
@@ -478,7 +480,7 @@ pgxc_FQS_get_relation_nodes(RangeTblEntry *rte, Index varno, Query *query)
return rel_exec_nodes;
}
-bool
+static bool
pgxc_query_has_distcolgrouping(Query *query)
{
ListCell *lcell;
@@ -737,14 +739,6 @@ pgxc_shippability_walker(Node *node, Shippability_context *sc_context)
if (!pgxc_is_func_shippable(funcexpr->funcid))
pgxc_set_shippability_reason(sc_context, SS_UNSHIPPABLE_EXPR);
- /*
- * If this is a stand alone expression and the function returns a
- * set of rows, we need to handle it along with the final result of
- * other expressions. So, it can not be shippable.
- */
- if (funcexpr->funcretset && sc_context->sc_for_expr)
- pgxc_set_shippability_reason(sc_context, SS_UNSHIPPABLE_EXPR);
-
pgxc_set_exprtype_shippability(exprType(node), sc_context);
}
break;
@@ -1222,17 +1216,9 @@ pgxc_is_query_shippable(Query *query, int query_level)
/*
* pgxc_is_expr_shippable
- * Check whether the given expression can be shipped to datanodes.
- *
- * Note on has_aggs
- * The aggregate expressions are not shippable if they can not be completely
- * evaluated on a single datanode. But this function does not have enough
- * context to determine the set of datanodes where the expression will be
- * evaluated. Hence, the caller of this function can handle aggregate
- * expressions, it passes a non-NULL value for has_aggs. This function returns
- * whether the expression has any aggregates or not through this argument. If a
- * caller passes NULL value for has_aggs, this function assumes that the caller
- * can not handle the aggregates and deems the expression has unshippable.
+ * Check whether the given expression can be shipped to remote nodes.
+ * This can be used as an entry point to check the shippability of
+ * an expression.
*/
bool
pgxc_is_expr_shippable(Expr *node, bool *has_aggs)
diff --git a/src/include/optimizer/pgxcplan.h b/src/include/optimizer/pgxcplan.h
index 5abb40ec96..2d9620630c 100644
--- a/src/include/optimizer/pgxcplan.h
+++ b/src/include/optimizer/pgxcplan.h
@@ -112,6 +112,7 @@ typedef struct
*/
List *coord_var_tlist;
List *query_var_tlist;
+ bool is_shippable_tlist;
bool has_row_marks; /* Did SELECT had FOR UPDATE/SHARE? */
bool has_ins_child_sel_parent; /* This node is part of an INSERT SELECT that
* inserts into child by selecting from its parent */
diff --git a/src/include/optimizer/pgxcship.h b/src/include/optimizer/pgxcship.h
index a14a08d74e..0f960e1a5a 100644
--- a/src/include/optimizer/pgxcship.h
+++ b/src/include/optimizer/pgxcship.h
@@ -33,6 +33,5 @@ extern bool pgxc_qual_has_dist_equijoin(Relids varnos_1,
/* Merge given execution nodes based on join shippability conditions */
extern ExecNodes *pgxc_merge_exec_nodes(ExecNodes *en1,
ExecNodes *en2, bool merge_dist_equijoin, bool merge_replicated_only);
-extern bool pgxc_query_has_distcolgrouping(Query *query);
#endif
diff --git a/src/test/regress/expected/aggregates.out b/src/test/regress/expected/aggregates.out
index 8f9e32c948..b35a78e55c 100644
--- a/src/test/regress/expected/aggregates.out
+++ b/src/test/regress/expected/aggregates.out
@@ -309,8 +309,6 @@ from tenk1 o;
--
-- test for bitwise integer aggregates
--
--- Enforce use of COMMIT instead of 2PC for temporary objects
-SET enforce_two_phase_commit TO off;
CREATE TEMPORARY TABLE bitwise_test(
i2 INT2,
i4 INT4,
@@ -579,11 +577,11 @@ order by f1;
-- check some cases that were handled incorrectly in 8.3.0
explain (costs off, nodes off)
select distinct max(unique2) from tenk1;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
HashAggregate
-> Aggregate
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
(3 rows)
select distinct max(unique2) from tenk1;
@@ -594,12 +592,12 @@ select distinct max(unique2) from tenk1;
explain (costs off, nodes off)
select max(unique2) from tenk1 order by 1;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
Sort
- Sort Key: (max((max(tenk1.unique2))))
+ Sort Key: (max(tenk1.unique2))
-> Aggregate
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
(4 rows)
select max(unique2) from tenk1 order by 1;
@@ -610,12 +608,12 @@ select max(unique2) from tenk1 order by 1;
explain (costs off, nodes off)
select max(unique2) from tenk1 order by max(unique2);
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
Sort
- Sort Key: (max((max(tenk1.unique2))))
+ Sort Key: (max(tenk1.unique2))
-> Aggregate
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
(4 rows)
select max(unique2) from tenk1 order by max(unique2);
@@ -626,12 +624,12 @@ select max(unique2) from tenk1 order by max(unique2);
explain (costs off, nodes off)
select max(unique2) from tenk1 order by max(unique2)+1;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
Sort
- Sort Key: ((max((max(tenk1.unique2))) + 1))
+ Sort Key: ((max(tenk1.unique2) + 1))
-> Aggregate
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
(4 rows)
select max(unique2) from tenk1 order by max(unique2)+1;
@@ -642,12 +640,12 @@ select max(unique2) from tenk1 order by max(unique2)+1;
explain (costs off, nodes off)
select max(unique2), generate_series(1,3) as g from tenk1 order by g desc;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
Sort
Sort Key: (generate_series(1, 3))
-> Aggregate
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
(4 rows)
select max(unique2), generate_series(1,3) as g from tenk1 order by g desc;
diff --git a/src/test/regress/expected/aggregates_1.out b/src/test/regress/expected/aggregates_1.out
index d8c6e862b6..db22e478e9 100644
--- a/src/test/regress/expected/aggregates_1.out
+++ b/src/test/regress/expected/aggregates_1.out
@@ -579,11 +579,11 @@ order by f1;
-- check some cases that were handled incorrectly in 8.3.0
explain (costs off, nodes off)
select distinct max(unique2) from tenk1;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
HashAggregate
-> Aggregate
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
(3 rows)
select distinct max(unique2) from tenk1;
@@ -594,12 +594,12 @@ select distinct max(unique2) from tenk1;
explain (costs off, nodes off)
select max(unique2) from tenk1 order by 1;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
Sort
- Sort Key: (max((max(tenk1.unique2))))
+ Sort Key: (max(tenk1.unique2))
-> Aggregate
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
(4 rows)
select max(unique2) from tenk1 order by 1;
@@ -610,12 +610,12 @@ select max(unique2) from tenk1 order by 1;
explain (costs off, nodes off)
select max(unique2) from tenk1 order by max(unique2);
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
Sort
- Sort Key: (max((max(tenk1.unique2))))
+ Sort Key: (max(tenk1.unique2))
-> Aggregate
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
(4 rows)
select max(unique2) from tenk1 order by max(unique2);
@@ -626,12 +626,12 @@ select max(unique2) from tenk1 order by max(unique2);
explain (costs off, nodes off)
select max(unique2) from tenk1 order by max(unique2)+1;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
Sort
- Sort Key: ((max((max(tenk1.unique2))) + 1))
+ Sort Key: ((max(tenk1.unique2) + 1))
-> Aggregate
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
(4 rows)
select max(unique2) from tenk1 order by max(unique2)+1;
@@ -642,12 +642,12 @@ select max(unique2) from tenk1 order by max(unique2)+1;
explain (costs off, nodes off)
select max(unique2), generate_series(1,3) as g from tenk1 order by g desc;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
Sort
Sort Key: (generate_series(1, 3))
-> Aggregate
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
(4 rows)
select max(unique2), generate_series(1,3) as g from tenk1 order by g desc;
diff --git a/src/test/regress/expected/xc_FQS.out b/src/test/regress/expected/xc_FQS.out
index a988866e31..a90ba10273 100644
--- a/src/test/regress/expected/xc_FQS.out
+++ b/src/test/regress/expected/xc_FQS.out
@@ -516,14 +516,14 @@ select distinct on (val2) val, val2 from tab1_hash where val2 = 8;
7 | 8
(1 row)
-explain (costs off, verbose on, nodes off) select distinct on (val2) val, val2 from tab1_hash where val2 = 8;
- QUERY PLAN
------------------------------------------------------------------------------
+explain (costs off, verbose on, nodes off) select distinct (val2) val, val2 from tab1_hash where val2 = 8;
+ QUERY PLAN
+------------------------------------------------------------------------
Unique
- Output: tab1_hash.val, tab1_hash.val2
+ Output: tab1_hash.val2, tab1_hash.val2
-> Data Node Scan on tab1_hash "_REMOTE_TABLE_QUERY_"
- Output: tab1_hash.val, tab1_hash.val2
- Remote query: SELECT val, val2 FROM ONLY tab1_hash WHERE (val2 = 8)
+ Output: tab1_hash.val2, tab1_hash.val2
+ Remote query: SELECT val2 FROM ONLY tab1_hash WHERE (val2 = 8)
(5 rows)
-- should not get FQSed because of presence of aggregates and HAVING clause
diff --git a/src/test/regress/expected/xc_groupby.out b/src/test/regress/expected/xc_groupby.out
index 36127d1e0e..f2122c1cea 100644
--- a/src/test/regress/expected/xc_groupby.out
+++ b/src/test/regress/expected/xc_groupby.out
@@ -13,7 +13,7 @@ create table xc_groupby_tab1 (val int, val2 int);
create table xc_groupby_tab2 (val int, val2 int);
insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3);
insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
-select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2;
+select * from (select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2) q order by q.val2;
count | sum | avg | ?column? | val2
-------+-----+--------------------+------------------+------
3 | 6 | 2.0000000000000000 | 2 | 1
@@ -21,18 +21,21 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_gro
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(3 rows)
-explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate
- Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((pg_catalog.sum((sum(xc_groupby_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_groupby_tab1.val2
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
- Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
-(5 rows)
+explain (verbose true, costs false, nodes false) select * from (select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2) q order by q.val2;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Output: (pg_catalog.count(*)), (pg_catalog.sum((sum(xc_groupby_tab1.val)))), (pg_catalog.avg((avg(xc_groupby_tab1.val)))), (((pg_catalog.sum((sum(xc_groupby_tab1.val))))::double precision / (pg_catalog.count(*))::double precision)), xc_groupby_tab1.val2
+ Sort Key: xc_groupby_tab1.val2
+ -> HashAggregate
+ Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((pg_catalog.sum((sum(xc_groupby_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_groupby_tab1.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
+ Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2
+(8 rows)
-- joins and group by
-select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 gt1_val2, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by gt1_val2, gt2_val2;
+select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 gt1_val2, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.gt1_val2, q.gt2_val2;
count | sum | avg | ?column? | gt1_val2 | gt2_val2
-------+-----+---------------------+------------------+----------+----------
9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1
@@ -41,16 +44,16 @@ select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_
3 | | | | | 4
(4 rows)
-explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 gt1_val2, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by gt1_val2, gt2_val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate
- Output: count(*), sum((xc_groupby_tab1.val * xc_groupby_tab2.val)), avg((xc_groupby_tab1.val * xc_groupby_tab2.val)), ((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))::double precision / (count(*))::double precision), xc_groupby_tab1.val2, xc_groupby_tab2.val2
- -> Sort
- Output: xc_groupby_tab1.val2, xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val
- Sort Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2
+explain (verbose true, costs false, nodes false) select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 gt1_val2, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.gt1_val2, q.gt2_val2;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Output: (count(*)), (sum((xc_groupby_tab1.val * xc_groupby_tab2.val))), (avg((xc_groupby_tab1.val * xc_groupby_tab2.val))), (((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))::double precision / (count(*))::double precision)), xc_groupby_tab1.val2, xc_groupby_tab2.val2
+ Sort Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2
+ -> HashAggregate
+ Output: count(*), sum((xc_groupby_tab1.val * xc_groupby_tab2.val)), avg((xc_groupby_tab1.val * xc_groupby_tab2.val)), ((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))::double precision / (count(*))::double precision), xc_groupby_tab1.val2, xc_groupby_tab2.val2
-> Hash Full Join
- Output: xc_groupby_tab1.val2, xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val
+ Output: xc_groupby_tab1.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2, xc_groupby_tab2.val
Hash Cond: (xc_groupby_tab1.val2 = xc_groupby_tab2.val2)
-> Data Node Scan on xc_groupby_tab1 "_REMOTE_TABLE_QUERY_"
Output: xc_groupby_tab1.val2, xc_groupby_tab1.val
@@ -88,7 +91,7 @@ explain (verbose true, costs false, nodes false) select sum(y) from (select sum(
(12 rows)
-- group by without aggregate
-select val2 from xc_groupby_tab1 group by val2 order by val2;
+select * from (select val2 from xc_groupby_tab1 group by val2) q order by q.val2;
val2
------
1
@@ -96,17 +99,20 @@ select val2 from xc_groupby_tab1 group by val2 order by val2;
3
(3 rows)
-explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2;
- QUERY PLAN
-----------------------------------------------------------------------------------------------------
- Group
+explain (verbose true, costs false, nodes false) select * from (select val2 from xc_groupby_tab1 group by val2) q order by q.val2;
+ QUERY PLAN
+--------------------------------------------------------------------------------------------
+ Sort
Output: xc_groupby_tab1.val2
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Sort Key: xc_groupby_tab1.val2
+ -> HashAggregate
Output: xc_groupby_tab1.val2
- Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
-(5 rows)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: xc_groupby_tab1.val2
+ Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2
+(8 rows)
-select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2;
+select * from (select val + val2 from xc_groupby_tab1 group by val + val2) q order by 1;
?column?
----------
2
@@ -117,17 +123,20 @@ select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2;
9
(6 rows)
-explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2;
- QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------
- Group
+explain (verbose true, costs false, nodes false) select * from (select val + val2 from xc_groupby_tab1 group by val + val2) q order by 1;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------
+ Sort
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
+ -> HashAggregate
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
- Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2)
-(5 rows)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
+ Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2)
+(8 rows)
-select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2;
+select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2;
?column? | val | val2
----------+-----+------
2 | 1 | 1
@@ -140,15 +149,20 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by va
9 | 6 | 3
(8 rows)
-explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+explain (verbose true, costs false, nodes false) select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2;
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------
+ Sort
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
- Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2
-(3 rows)
+ Sort Key: xc_groupby_tab1.val, xc_groupby_tab1.val2
+ -> HashAggregate
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
+ Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2
+(8 rows)
-select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2 order by gt1_val, gt2_val2;
+select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.gt1_val, q.gt2_val2;
?column? | gt1_val | gt2_val2
----------+---------+----------
2 | 1 | 1
@@ -159,15 +173,20 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val,
6 | 4 | 2
(6 rows)
-explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2 order by gt1_val, gt2_val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.gt1_val, q.gt2_val2;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Sort
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
- Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1
-(3 rows)
+ Sort Key: xc_groupby_tab1.val, xc_groupby_tab2.val2
+ -> HashAggregate
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
+ Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1
+(8 rows)
-select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by 1;
+select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by 1;
?column?
----------
2
@@ -176,18 +195,21 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_group
7
(4 rows)
-explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by 1;
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Group
+explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by 1;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Sort
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
+ -> HashAggregate
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
- Remote query: SELECT (l.a_1 + r.a_1) FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY (l.a_1 + r.a_1) ORDER BY (l.a_1 + r.a_1)
-(5 rows)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
+ Remote query: SELECT (l.a_1 + r.a_1) FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY (l.a_1 + r.a_1)
+(8 rows)
-- group by with aggregates in expression
-select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2;
+select * from (select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2) q order by q.val2;
?column? | val2
---------------------+------
11.0000000000000000 | 1
@@ -195,18 +217,21 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 o
17.6666666666666667 | 3
(3 rows)
-explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2;
- QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate
- Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(xc_groupby_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_groupby_tab1.val)))), xc_groupby_tab1.val2
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
- Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
-(5 rows)
+explain (verbose true, costs false, nodes false) select * from (select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2) q order by q.val2;
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Output: ((((pg_catalog.count(*) + pg_catalog.sum((sum(xc_groupby_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_groupby_tab1.val))))), xc_groupby_tab1.val2
+ Sort Key: xc_groupby_tab1.val2
+ -> HashAggregate
+ Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(xc_groupby_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_groupby_tab1.val)))), xc_groupby_tab1.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
+ Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2
+(8 rows)
-- group by with expressions in group by clause
-select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2 order by expr;
+select * from (select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2) q order by q.expr;
sum | avg | expr
-----+--------------------+------
6 | 2.0000000000000000 | 2
@@ -214,15 +239,18 @@ select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2
11 | 3.6666666666666667 | 6
(3 rows)
-explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2 order by expr;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate
- Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((2 * xc_groupby_tab1.val2))
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2))
- Remote query: SELECT sum(val), avg(val), (2 * val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (2 * val2) ORDER BY (2 * val2)
-(5 rows)
+explain (verbose true, costs false, nodes false) select * from (select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2) q order by q.expr;
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Output: (pg_catalog.sum((sum(xc_groupby_tab1.val)))), (pg_catalog.avg((avg(xc_groupby_tab1.val)))), ((2 * xc_groupby_tab1.val2))
+ Sort Key: ((2 * xc_groupby_tab1.val2))
+ -> HashAggregate
+ Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((2 * xc_groupby_tab1.val2))
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2))
+ Remote query: SELECT sum(val), avg(val), (2 * val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (2 * val2)
+(8 rows)
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -241,7 +269,7 @@ insert into xc_groupby_def VALUES (7, NULL);
insert into xc_groupby_def VALUES (8, 'Two');
insert into xc_groupby_def VALUES (9, 'Three');
insert into xc_groupby_def VALUES (10, 'Three');
-select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
+select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
avg | sum | count | b
--------------------+-----+-------+-------
| | 1 | One
@@ -250,17 +278,20 @@ select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
4.0000000000000000 | 8 | 3 |
(4 rows)
-explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
- QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate
- Output: pg_catalog.avg((avg(xc_groupby_def.a))), pg_catalog.sum((sum(xc_groupby_def.a))), pg_catalog.count(*), xc_groupby_def.b
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (avg(xc_groupby_def.a)), (sum(xc_groupby_def.a)), (count(*)), xc_groupby_def.b
- Remote query: SELECT avg(a), sum(a), count(*), b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
-(5 rows)
+explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Output: (pg_catalog.avg((avg(xc_groupby_def.a)))), (pg_catalog.sum((sum(xc_groupby_def.a)))), (pg_catalog.count(*)), xc_groupby_def.b
+ Sort Key: xc_groupby_def.b
+ -> HashAggregate
+ Output: pg_catalog.avg((avg(xc_groupby_def.a))), pg_catalog.sum((sum(xc_groupby_def.a))), pg_catalog.count(*), xc_groupby_def.b
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (avg(xc_groupby_def.a)), (sum(xc_groupby_def.a)), (count(*)), xc_groupby_def.b
+ Remote query: SELECT avg(a), sum(a), count(*), b FROM ONLY xc_groupby_def WHERE true GROUP BY b
+(8 rows)
-select b from xc_groupby_def group by b order by b;
+select * from (select b from xc_groupby_def group by b) q order by q.b;
b
-------
One
@@ -269,17 +300,20 @@ select b from xc_groupby_def group by b order by b;
(4 rows)
-explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b;
- QUERY PLAN
-------------------------------------------------------------------------------------------
- Group
+explain (verbose true, costs false, nodes false) select * from (select b from xc_groupby_def group by b) q order by q.b;
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ Sort
Output: xc_groupby_def.b
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Sort Key: xc_groupby_def.b
+ -> HashAggregate
Output: xc_groupby_def.b
- Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
-(5 rows)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: xc_groupby_def.b
+ Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b
+(8 rows)
-select b,count(b) from xc_groupby_def group by b order by b;
+select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b;
b | count
-------+-------
One | 1
@@ -288,15 +322,18 @@ select b,count(b) from xc_groupby_def group by b order by b;
| 0
(4 rows)
-explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b;
- QUERY PLAN
-----------------------------------------------------------------------------------------------------
- GroupAggregate
- Output: xc_groupby_def.b, count((count(xc_groupby_def.b)))
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: xc_groupby_def.b, (count(xc_groupby_def.b))
- Remote query: SELECT b, count(b) FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
-(5 rows)
+explain (verbose true, costs false, nodes false) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------
+ Sort
+ Output: xc_groupby_def.b, (count((count(xc_groupby_def.b))))
+ Sort Key: xc_groupby_def.b
+ -> HashAggregate
+ Output: xc_groupby_def.b, count((count(xc_groupby_def.b)))
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: xc_groupby_def.b, (count(xc_groupby_def.b))
+ Remote query: SELECT b, count(b) FROM ONLY xc_groupby_def WHERE true GROUP BY b
+(8 rows)
select count(*) from xc_groupby_def where b is null group by b;
count
@@ -318,104 +355,106 @@ create table xc_groupby_g(a int, b float, c numeric);
insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(2,2.3,5.2);
-select sum(a) from xc_groupby_g group by a order by a;
+select sum(a) from xc_groupby_g group by a;
sum
-----
2
2
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a;
- QUERY PLAN
-------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
- Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a ORDER BY a
-(3 rows)
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a;
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ HashAggregate
+ Output: pg_catalog.sum((sum(xc_groupby_g.a))), xc_groupby_g.a
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
+ Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a
+(5 rows)
-select sum(b) from xc_groupby_g group by b order by b;
+select sum(b) from xc_groupby_g group by b;
sum
-----
- 4.2
2.3
+ 4.2
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b;
- QUERY PLAN
-------------------------------------------------------------------------------------------------
- GroupAggregate
+explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b;
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ HashAggregate
Output: sum((sum(xc_groupby_g.b))), xc_groupby_g.b
-> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (sum(xc_groupby_g.b)), xc_groupby_g.b
- Remote query: SELECT sum(b), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b
+ Remote query: SELECT sum(b), b FROM ONLY xc_groupby_g WHERE true GROUP BY b
(5 rows)
-select sum(c) from xc_groupby_g group by b order by b;
+select sum(c) from xc_groupby_g group by b;
sum
-----
- 6.4
5.2
+ 6.4
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b;
- QUERY PLAN
-------------------------------------------------------------------------------------------------
- GroupAggregate
+explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b;
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ HashAggregate
Output: sum((sum(xc_groupby_g.c))), xc_groupby_g.b
-> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (sum(xc_groupby_g.c)), xc_groupby_g.b
- Remote query: SELECT sum(c), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b
+ Remote query: SELECT sum(c), b FROM ONLY xc_groupby_g WHERE true GROUP BY b
(5 rows)
-select avg(a) from xc_groupby_g group by b order by b;
+select avg(a) from xc_groupby_g group by b;
avg
------------------------
- 1.00000000000000000000
2.0000000000000000
+ 1.00000000000000000000
(2 rows)
-explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b;
- QUERY PLAN
-------------------------------------------------------------------------------------------------
- GroupAggregate
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b;
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ HashAggregate
Output: pg_catalog.avg((avg(xc_groupby_g.a))), xc_groupby_g.b
-> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (avg(xc_groupby_g.a)), xc_groupby_g.b
- Remote query: SELECT avg(a), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b
+ Remote query: SELECT avg(a), b FROM ONLY xc_groupby_g WHERE true GROUP BY b
(5 rows)
-select avg(b) from xc_groupby_g group by c order by c;
+select avg(b) from xc_groupby_g group by c;
avg
-----
- 2.1
2.3
+ 2.1
(2 rows)
-explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c;
- QUERY PLAN
-------------------------------------------------------------------------------------------------
- GroupAggregate
+explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c;
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ HashAggregate
Output: pg_catalog.avg((avg(xc_groupby_g.b))), xc_groupby_g.c
-> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (avg(xc_groupby_g.b)), xc_groupby_g.c
- Remote query: SELECT avg(b), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c
+ Remote query: SELECT avg(b), c FROM ONLY xc_groupby_g WHERE true GROUP BY c
(5 rows)
-select avg(c) from xc_groupby_g group by c order by c;
+select avg(c) from xc_groupby_g group by c;
avg
--------------------
- 3.2000000000000000
5.2000000000000000
+ 3.2000000000000000
(2 rows)
-explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c;
- QUERY PLAN
-------------------------------------------------------------------------------------------------
- GroupAggregate
+explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c;
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ HashAggregate
Output: pg_catalog.avg((avg(xc_groupby_g.c))), xc_groupby_g.c
-> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (avg(xc_groupby_g.c)), xc_groupby_g.c
- Remote query: SELECT avg(c), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c
+ Remote query: SELECT avg(c), c FROM ONLY xc_groupby_g WHERE true GROUP BY c
(5 rows)
drop table xc_groupby_def;
@@ -427,7 +466,7 @@ create table xc_groupby_tab1 (val int, val2 int) distribute by replication;
create table xc_groupby_tab2 (val int, val2 int) distribute by replication;
insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3);
insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
-select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2;
+select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2;
count | sum | avg | ?column? | val2
-------+-----+--------------------+------------------+------
3 | 6 | 2.0000000000000000 | 2 | 1
@@ -435,16 +474,18 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_gro
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(3 rows)
-explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2;
- QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), (((sum(xc_groupby_tab1.val))::double precision / (count(*))::double precision)), xc_groupby_tab1.val2
- Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
-(3 rows)
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
+ Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((pg_catalog.sum((sum(xc_groupby_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_groupby_tab1.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
+ Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2
+(5 rows)
-- joins and group by
-select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by c1, c2;
+select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2;
count | sum | avg | ?column? | c1 | c2
-------+-----+---------------------+------------------+----+----
9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1
@@ -453,37 +494,46 @@ select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_
3 | | | | | 4
(4 rows)
-explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by c1, c2;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum((xc_groupby_tab1.val * xc_groupby_tab2.val))), (avg((xc_groupby_tab1.val * xc_groupby_tab2.val))), (((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))::double precision / (count(*))::double precision)), xc_groupby_tab1.val2, xc_groupby_tab2.val2
- Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), pg_catalog.int8_avg(avg((l.a_2 * r.a_2))), ((sum((l.a_2 * r.a_2)))::double precision / (count(*))::double precision), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val2, xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1, a_2) FULL JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON ((l.a_1 = r.a_1))) WHERE true GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1
-(3 rows)
+explain (verbose true, costs false, nodes false) select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2;
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Output: (pg_catalog.count(*)), (pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val))))), (pg_catalog.avg((avg((xc_groupby_tab1.val * xc_groupby_tab2.val))))), (((pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))))::double precision / (pg_catalog.count(*))::double precision)), xc_groupby_tab1.val2, xc_groupby_tab2.val2
+ Sort Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2
+ -> HashAggregate
+ Output: pg_catalog.count(*), pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))), pg_catalog.avg((avg((xc_groupby_tab1.val * xc_groupby_tab2.val)))), ((pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))))::double precision / (pg_catalog.count(*))::double precision), xc_groupby_tab1.val2, xc_groupby_tab2.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum((xc_groupby_tab1.val * xc_groupby_tab2.val))), (avg((xc_groupby_tab1.val * xc_groupby_tab2.val))), xc_groupby_tab1.val2, xc_groupby_tab2.val2
+ Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), avg((l.a_2 * r.a_2)), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val2, xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1, a_2) FULL JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON ((l.a_1 = r.a_1))) WHERE true GROUP BY l.a_1, r.a_1
+(8 rows)
-- aggregates over aggregates
-select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x order by sum;
+select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum;
sum
-----
8
17
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x order by sum;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------
+explain (verbose true, costs false, nodes false) select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------
Sort
- Output: (sum((sum(xc_groupby_tab1.val)))), ((xc_groupby_tab1.val2 % 2))
- Sort Key: (sum((sum(xc_groupby_tab1.val))))
- -> HashAggregate
- Output: sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2))
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
- Remote query: SELECT sum(val), (val2 % 2), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2
-(8 rows)
+ Output: q.sum
+ Sort Key: q.sum
+ -> Subquery Scan on q
+ Output: q.sum
+ -> HashAggregate
+ Output: sum((pg_catalog.sum((sum(xc_groupby_tab1.val))))), ((xc_groupby_tab1.val2 % 2))
+ -> HashAggregate
+ Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
+ Remote query: SELECT sum(val), (val2 % 2), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2
+(12 rows)
-- group by without aggregate
-select val2 from xc_groupby_tab1 group by val2 order by val2;
+select val2 from xc_groupby_tab1 group by val2;
val2
------
1
@@ -491,15 +541,17 @@ select val2 from xc_groupby_tab1 group by val2 order by val2;
3
(3 rows)
-explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2;
- QUERY PLAN
-----------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
+ QUERY PLAN
+--------------------------------------------------------------------------------------
+ HashAggregate
Output: xc_groupby_tab1.val2
- Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
-(3 rows)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: xc_groupby_tab1.val2
+ Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2
+(5 rows)
-select val + val2 sum from xc_groupby_tab1 group by val + val2 order by sum;
+select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum;
sum
-----
2
@@ -510,15 +562,20 @@ select val + val2 sum from xc_groupby_tab1 group by val + val2 order by sum;
9
(6 rows)
-explain (verbose true, costs false, nodes false) select val + val2 sum from xc_groupby_tab1 group by val + val2 order by sum;
- QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------
+ Sort
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
- Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2)
-(3 rows)
+ Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
+ -> HashAggregate
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
+ Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2)
+(8 rows)
-select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2;
+select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2;
?column? | val | val2
----------+-----+------
2 | 1 | 1
@@ -531,15 +588,20 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by va
9 | 6 | 3
(8 rows)
-explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+explain (verbose true, costs false, nodes false) select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2;
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------
+ Sort
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
- Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2
-(3 rows)
+ Sort Key: xc_groupby_tab1.val, xc_groupby_tab1.val2
+ -> HashAggregate
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
+ Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2
+(8 rows)
-select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2 order by val, val2;
+select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2;
?column? | val | val2
----------+-----+------
2 | 1 | 1
@@ -550,15 +612,20 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_group
6 | 4 | 2
(6 rows)
-explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2 order by val, val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Sort
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
- Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1
-(3 rows)
+ Sort Key: xc_groupby_tab1.val, xc_groupby_tab2.val2
+ -> HashAggregate
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
+ Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1
+(8 rows)
-select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by sum;
+select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by q.sum;
sum
-----
2
@@ -567,16 +634,21 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_g
7
(4 rows)
-explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by sum;
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by q.sum;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Sort
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
- Remote query: SELECT (l.a_1 + r.a_1) FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY (l.a_1 + r.a_1) ORDER BY (l.a_1 + r.a_1)
-(3 rows)
+ Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
+ -> HashAggregate
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
+ Remote query: SELECT (l.a_1 + r.a_1) FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY (l.a_1 + r.a_1)
+(8 rows)
-- group by with aggregates in expression
-select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by 1;
+select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
?column? | val2
---------------------+------
11.0000000000000000 | 1
@@ -584,33 +656,34 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 o
17.6666666666666667 | 3
(3 rows)
-explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by 1;
- QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------------
- Sort
- Output: ((((count(*) + sum(xc_groupby_tab1.val)))::numeric + avg(xc_groupby_tab1.val))), xc_groupby_tab1.val2
- Sort Key: ((((count(*) + sum(xc_groupby_tab1.val)))::numeric + avg(xc_groupby_tab1.val)))
+explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
+ Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(xc_groupby_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_groupby_tab1.val)))), xc_groupby_tab1.val2
-> Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: ((((count(*) + sum(xc_groupby_tab1.val)))::numeric + avg(xc_groupby_tab1.val))), xc_groupby_tab1.val2
- Remote query: SELECT (((count(*) + sum(val)))::numeric + pg_catalog.int8_avg(avg(val))), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2
-(6 rows)
+ Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
+ Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2
+(5 rows)
-- group by with expressions in group by clause
-select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2;
+select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
sum | avg | ?column?
-----+--------------------+----------
+ 11 | 3.6666666666666667 | 6
6 | 2.0000000000000000 | 2
8 | 4.0000000000000000 | 4
- 11 | 3.6666666666666667 | 6
(3 rows)
-explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2))
- Remote query: SELECT sum(val), pg_catalog.int8_avg(avg(val)), (2 * val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (2 * val2) ORDER BY (2 * val2)
-(3 rows)
+explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
+ Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((2 * xc_groupby_tab1.val2))
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2))
+ Remote query: SELECT sum(val), avg(val), (2 * val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (2 * val2)
+(5 rows)
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -629,7 +702,7 @@ insert into xc_groupby_def VALUES (7, NULL);
insert into xc_groupby_def VALUES (8, 'Two');
insert into xc_groupby_def VALUES (9, 'Three');
insert into xc_groupby_def VALUES (10, 'Three');
-select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
+select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
avg | sum | count | b
--------------------+-----+-------+-------
| | 1 | One
@@ -638,15 +711,20 @@ select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
4.0000000000000000 | 8 | 3 |
(4 rows)
-explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
- QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (avg(xc_groupby_def.a)), (sum(xc_groupby_def.a)), (count(*)), xc_groupby_def.b
- Remote query: SELECT pg_catalog.int8_avg(avg(a)), sum(a), count(*), b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
-(3 rows)
+explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Output: (pg_catalog.avg((avg(xc_groupby_def.a)))), (pg_catalog.sum((sum(xc_groupby_def.a)))), (pg_catalog.count(*)), xc_groupby_def.b
+ Sort Key: xc_groupby_def.b
+ -> HashAggregate
+ Output: pg_catalog.avg((avg(xc_groupby_def.a))), pg_catalog.sum((sum(xc_groupby_def.a))), pg_catalog.count(*), xc_groupby_def.b
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (avg(xc_groupby_def.a)), (sum(xc_groupby_def.a)), (count(*)), xc_groupby_def.b
+ Remote query: SELECT avg(a), sum(a), count(*), b FROM ONLY xc_groupby_def WHERE true GROUP BY b
+(8 rows)
-select b from xc_groupby_def group by b order by b;
+select * from (select b from xc_groupby_def group by b) q order by q.b;
b
-------
One
@@ -655,15 +733,20 @@ select b from xc_groupby_def group by b order by b;
(4 rows)
-explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b;
- QUERY PLAN
-------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+explain (verbose true, costs false, nodes false) select * from (select b from xc_groupby_def group by b) q order by q.b;
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ Sort
Output: xc_groupby_def.b
- Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
-(3 rows)
+ Sort Key: xc_groupby_def.b
+ -> HashAggregate
+ Output: xc_groupby_def.b
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: xc_groupby_def.b
+ Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b
+(8 rows)
-select b,count(b) from xc_groupby_def group by b order by b;
+select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b;
b | count
-------+-------
One | 1
@@ -672,13 +755,18 @@ select b,count(b) from xc_groupby_def group by b order by b;
| 0
(4 rows)
-explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b;
- QUERY PLAN
-----------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: xc_groupby_def.b, (count(xc_groupby_def.b))
- Remote query: SELECT b, count(b) FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
-(3 rows)
+explain (verbose true, costs false, nodes false) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------
+ Sort
+ Output: xc_groupby_def.b, (count((count(xc_groupby_def.b))))
+ Sort Key: xc_groupby_def.b
+ -> HashAggregate
+ Output: xc_groupby_def.b, count((count(xc_groupby_def.b)))
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: xc_groupby_def.b, (count(xc_groupby_def.b))
+ Remote query: SELECT b, count(b) FROM ONLY xc_groupby_def WHERE true GROUP BY b
+(8 rows)
select count(*) from xc_groupby_def where b is null group by b;
count
@@ -687,106 +775,120 @@ select count(*) from xc_groupby_def where b is null group by b;
(1 row)
explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b;
- QUERY PLAN
-------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), xc_groupby_def.b
- Remote query: SELECT count(*), b FROM ONLY xc_groupby_def WHERE (b IS NULL) GROUP BY b
-(3 rows)
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
+ HashAggregate
+ Output: pg_catalog.count(*), xc_groupby_def.b
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), xc_groupby_def.b
+ Remote query: SELECT count(*), b FROM ONLY xc_groupby_def WHERE (b IS NULL) GROUP BY b
+(5 rows)
create table xc_groupby_g(a int, b float, c numeric) distribute by replication;
insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(2,2.3,5.2);
-select sum(a) from xc_groupby_g group by a order by a;
+select sum(a) from xc_groupby_g group by a;
sum
-----
2
2
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a;
- QUERY PLAN
-------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
- Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a ORDER BY a
-(3 rows)
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a;
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ HashAggregate
+ Output: pg_catalog.sum((sum(xc_groupby_g.a))), xc_groupby_g.a
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
+ Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a
+(5 rows)
-select sum(b) from xc_groupby_g group by b order by b;
+select sum(b) from xc_groupby_g group by b;
sum
-----
- 4.2
2.3
+ 4.2
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b;
- QUERY PLAN
-------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (sum(xc_groupby_g.b)), xc_groupby_g.b
- Remote query: SELECT sum(b), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b
-(3 rows)
+explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b;
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ HashAggregate
+ Output: sum((sum(xc_groupby_g.b))), xc_groupby_g.b
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (sum(xc_groupby_g.b)), xc_groupby_g.b
+ Remote query: SELECT sum(b), b FROM ONLY xc_groupby_g WHERE true GROUP BY b
+(5 rows)
-select sum(c) from xc_groupby_g group by b order by b;
+select sum(c) from xc_groupby_g group by b;
sum
-----
- 6.4
5.2
+ 6.4
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b;
- QUERY PLAN
-------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (sum(xc_groupby_g.c)), xc_groupby_g.b
- Remote query: SELECT sum(c), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b
-(3 rows)
+explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b;
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ HashAggregate
+ Output: sum((sum(xc_groupby_g.c))), xc_groupby_g.b
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (sum(xc_groupby_g.c)), xc_groupby_g.b
+ Remote query: SELECT sum(c), b FROM ONLY xc_groupby_g WHERE true GROUP BY b
+(5 rows)
-select avg(a) from xc_groupby_g group by b order by b;
+select avg(a) from xc_groupby_g group by b;
avg
------------------------
- 1.00000000000000000000
2.0000000000000000
+ 1.00000000000000000000
(2 rows)
-explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (avg(xc_groupby_g.a)), xc_groupby_g.b
- Remote query: SELECT pg_catalog.int8_avg(avg(a)), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b
-(3 rows)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b;
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ HashAggregate
+ Output: pg_catalog.avg((avg(xc_groupby_g.a))), xc_groupby_g.b
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (avg(xc_groupby_g.a)), xc_groupby_g.b
+ Remote query: SELECT avg(a), b FROM ONLY xc_groupby_g WHERE true GROUP BY b
+(5 rows)
-select avg(b) from xc_groupby_g group by c order by c;
+select avg(b) from xc_groupby_g group by c;
avg
-----
- 2.1
2.3
+ 2.1
(2 rows)
-explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c;
- QUERY PLAN
------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (avg(xc_groupby_g.b)), xc_groupby_g.c
- Remote query: SELECT pg_catalog.float8_avg(avg(b)), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c
-(3 rows)
+explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c;
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ HashAggregate
+ Output: pg_catalog.avg((avg(xc_groupby_g.b))), xc_groupby_g.c
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (avg(xc_groupby_g.b)), xc_groupby_g.c
+ Remote query: SELECT avg(b), c FROM ONLY xc_groupby_g WHERE true GROUP BY c
+(5 rows)
-select avg(c) from xc_groupby_g group by c order by c;
+select avg(c) from xc_groupby_g group by c;
avg
--------------------
- 3.2000000000000000
5.2000000000000000
+ 3.2000000000000000
(2 rows)
-explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (avg(xc_groupby_g.c)), xc_groupby_g.c
- Remote query: SELECT pg_catalog.numeric_avg(avg(c)), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c
-(3 rows)
+explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c;
+ QUERY PLAN
+-------------------------------------------------------------------------------------
+ HashAggregate
+ Output: pg_catalog.avg((avg(xc_groupby_g.c))), xc_groupby_g.c
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (avg(xc_groupby_g.c)), xc_groupby_g.c
+ Remote query: SELECT avg(c), c FROM ONLY xc_groupby_g WHERE true GROUP BY c
+(5 rows)
drop table xc_groupby_def;
drop table xc_groupby_g;
@@ -873,7 +975,7 @@ explain (verbose true, costs false, nodes false) select sum(y) from (select sum(
(12 rows)
-- group by without aggregate
-select val2 from xc_groupby_tab1 group by val2 order by val2;
+select val2 from xc_groupby_tab1 group by val2;
val2
------
1
@@ -881,7 +983,7 @@ select val2 from xc_groupby_tab1 group by val2 order by val2;
3
(3 rows)
-explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2;
+explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
QUERY PLAN
----------------------------------------------------------------------------------------------------
Group
@@ -926,12 +1028,14 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
(8 rows)
explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------
+ Group
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
- Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2
-(3 rows)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
+ Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2
+(5 rows)
select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2;
?column? | val | val2
@@ -945,12 +1049,14 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_group
(6 rows)
explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Group
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
- Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1
-(3 rows)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
+ Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1
+(5 rows)
select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2;
?column?
@@ -972,7 +1078,7 @@ explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc
(5 rows)
-- group by with aggregates in expression
-select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2;
+select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
?column? | val2
---------------------+------
11.0000000000000000 | 1
@@ -980,7 +1086,7 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 o
17.6666666666666667 | 3
(3 rows)
-explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2;
+explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------
GroupAggregate
@@ -991,7 +1097,7 @@ explain (verbose true, costs false, nodes false) select count(*) + sum(val) + av
(5 rows)
-- group by with expressions in group by clause
-select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2;
+select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
sum | avg | ?column?
-----+--------------------+----------
6 | 2.0000000000000000 | 2
@@ -999,7 +1105,7 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order
11 | 3.6666666666666667 | 6
(3 rows)
-explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2;
+explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------
GroupAggregate
@@ -1026,7 +1132,7 @@ insert into xc_groupby_def VALUES (7, NULL);
insert into xc_groupby_def VALUES (8, 'Two');
insert into xc_groupby_def VALUES (9, 'Three');
insert into xc_groupby_def VALUES (10, 'Three');
-select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
+select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
avg | sum | count | b
--------------------+-----+-------+-------
| | 1 | One
@@ -1035,7 +1141,7 @@ select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
4.0000000000000000 | 8 | 3 |
(4 rows)
-explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
+explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------
GroupAggregate
@@ -1045,7 +1151,7 @@ explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*)
Remote query: SELECT avg(a), sum(a), count(*), b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
(5 rows)
-select b from xc_groupby_def group by b order by b;
+select b from xc_groupby_def group by b;
b
-------
One
@@ -1054,7 +1160,7 @@ select b from xc_groupby_def group by b order by b;
(4 rows)
-explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b;
+explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b;
QUERY PLAN
------------------------------------------------------------------------------------------
Group
@@ -1064,7 +1170,7 @@ explain (verbose true, costs false, nodes false) select b from xc_groupby_def gr
Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
(5 rows)
-select b,count(b) from xc_groupby_def group by b order by b;
+select b,count(b) from xc_groupby_def group by b;
b | count
-------+-------
One | 1
@@ -1073,7 +1179,7 @@ select b,count(b) from xc_groupby_def group by b order by b;
| 0
(4 rows)
-explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b;
+explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b;
QUERY PLAN
----------------------------------------------------------------------------------------------------
GroupAggregate
@@ -1103,29 +1209,31 @@ create table xc_groupby_g(a int, b float, c numeric);
insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(2,2.3,5.2);
-select sum(a) from xc_groupby_g group by a order by a;
+select sum(a) from xc_groupby_g group by a;
sum
-----
2
2
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a;
- QUERY PLAN
-------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
- Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a ORDER BY a
-(3 rows)
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: pg_catalog.sum((sum(xc_groupby_g.a))), xc_groupby_g.a
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
+ Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a ORDER BY a
+(5 rows)
-select sum(b) from xc_groupby_g group by b order by b;
+select sum(b) from xc_groupby_g group by b;
sum
-----
4.2
2.3
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b;
+explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b;
QUERY PLAN
------------------------------------------------------------------------------------------------
GroupAggregate
@@ -1135,14 +1243,14 @@ explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g
Remote query: SELECT sum(b), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b
(5 rows)
-select sum(c) from xc_groupby_g group by b order by b;
+select sum(c) from xc_groupby_g group by b;
sum
-----
6.4
5.2
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b;
+explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b;
QUERY PLAN
------------------------------------------------------------------------------------------------
GroupAggregate
@@ -1152,14 +1260,14 @@ explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g
Remote query: SELECT sum(c), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b
(5 rows)
-select avg(a) from xc_groupby_g group by b order by b;
+select avg(a) from xc_groupby_g group by b;
avg
------------------------
1.00000000000000000000
2.0000000000000000
(2 rows)
-explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b;
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b;
QUERY PLAN
------------------------------------------------------------------------------------------------
GroupAggregate
@@ -1169,14 +1277,14 @@ explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g
Remote query: SELECT avg(a), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b
(5 rows)
-select avg(b) from xc_groupby_g group by c order by c;
+select avg(b) from xc_groupby_g group by c;
avg
-----
2.1
2.3
(2 rows)
-explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c;
+explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c;
QUERY PLAN
------------------------------------------------------------------------------------------------
GroupAggregate
@@ -1186,14 +1294,14 @@ explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g
Remote query: SELECT avg(b), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c
(5 rows)
-select avg(c) from xc_groupby_g group by c order by c;
+select avg(c) from xc_groupby_g group by c;
avg
--------------------
3.2000000000000000
5.2000000000000000
(2 rows)
-explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c;
+explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c;
QUERY PLAN
------------------------------------------------------------------------------------------------
GroupAggregate
@@ -1212,7 +1320,7 @@ create table xc_groupby_tab1 (val int, val2 int) distribute by replication;
create table xc_groupby_tab2 (val int, val2 int) distribute by replication;
insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3);
insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
-select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2;
+select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2;
count | sum | avg | ?column? | val2
-------+-----+--------------------+------------------+------
3 | 6 | 2.0000000000000000 | 2 | 1
@@ -1220,16 +1328,18 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_gro
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(3 rows)
-explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2;
- QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), (((sum(xc_groupby_tab1.val))::double precision / (count(*))::double precision)), xc_groupby_tab1.val2
- Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
-(3 rows)
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((pg_catalog.sum((sum(xc_groupby_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_groupby_tab1.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
+ Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
+(5 rows)
-- joins and group by
-select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by xc_groupby_tab1.val2, xc_groupby_tab2.val2;
+select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2;
count | sum | avg | ?column? | val2 | val2
-------+-----+---------------------+------------------+------+------
9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1
@@ -1238,25 +1348,27 @@ select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_
3 | | | | | 4
(4 rows)
-explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by xc_groupby_tab1.val2, xc_groupby_tab2.val2;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum((xc_groupby_tab1.val * xc_groupby_tab2.val))), (avg((xc_groupby_tab1.val * xc_groupby_tab2.val))), (((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))::double precision / (count(*))::double precision)), xc_groupby_tab1.val2, xc_groupby_tab2.val2
- Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), pg_catalog.int8_avg(avg((l.a_2 * r.a_2))), ((sum((l.a_2 * r.a_2)))::double precision / (count(*))::double precision), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val2, xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1, a_2) FULL JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON ((l.a_1 = r.a_1))) WHERE true GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1
-(3 rows)
+explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: pg_catalog.count(*), pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))), pg_catalog.avg((avg((xc_groupby_tab1.val * xc_groupby_tab2.val)))), ((pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))))::double precision / (pg_catalog.count(*))::double precision), xc_groupby_tab1.val2, xc_groupby_tab2.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum((xc_groupby_tab1.val * xc_groupby_tab2.val))), (avg((xc_groupby_tab1.val * xc_groupby_tab2.val))), xc_groupby_tab1.val2, xc_groupby_tab2.val2
+ Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), avg((l.a_2 * r.a_2)), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val2, xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1, a_2) FULL JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON ((l.a_1 = r.a_1))) WHERE true GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1
+(5 rows)
-- aggregates over aggregates
-select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x order by x;
+select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
sum
-----
8
17
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x order by x;
- QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------
+explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------------------------------
GroupAggregate
Output: sum(q1.y), q1.x
-> Sort
@@ -1264,13 +1376,15 @@ explain (verbose true, costs false, nodes false) select sum(y) from (select sum(
Sort Key: q1.x
-> Subquery Scan on q1
Output: q1.x, q1.y
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
- Remote query: SELECT sum(val), (val2 % 2), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
-(10 rows)
+ -> GroupAggregate
+ Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
+ Remote query: SELECT sum(val), (val2 % 2), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
+(12 rows)
-- group by without aggregate
-select val2 from xc_groupby_tab1 group by val2 order by val2;
+select val2 from xc_groupby_tab1 group by val2;
val2
------
1
@@ -1278,15 +1392,17 @@ select val2 from xc_groupby_tab1 group by val2 order by val2;
3
(3 rows)
-explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2;
- QUERY PLAN
-----------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------
+ Group
Output: xc_groupby_tab1.val2
- Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
-(3 rows)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: xc_groupby_tab1.val2
+ Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
+(5 rows)
-select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2;
+select val + val2 from xc_groupby_tab1 group by val + val2;
?column?
----------
2
@@ -1297,15 +1413,17 @@ select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2;
9
(6 rows)
-explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2;
- QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2;
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------------------------
+ Group
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
- Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2)
-(3 rows)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
+ Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2)
+(5 rows)
-select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2;
+select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
?column? | val | val2
----------+-----+------
2 | 1 | 1
@@ -1318,15 +1436,17 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by va
9 | 6 | 3
(8 rows)
-explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------
+ Group
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
- Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2
-(3 rows)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
+ Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2
+(5 rows)
-select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2 order by xc_groupby_tab1.val, xc_groupby_tab2.val2;
+select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2;
?column? | val | val2
----------+-----+------
2 | 1 | 1
@@ -1337,15 +1457,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_group
6 | 4 | 2
(6 rows)
-explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2 order by xc_groupby_tab1.val, xc_groupby_tab2.val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Group
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
- Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1
-(3 rows)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
+ Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1
+(5 rows)
-select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by xc_groupby_tab1.val + xc_groupby_tab2.val2;
+select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2;
?column?
----------
2
@@ -1354,16 +1476,18 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_group
7
(4 rows)
-explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by xc_groupby_tab1.val + xc_groupby_tab2.val2;
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2;
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Group
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
- Remote query: SELECT (l.a_1 + r.a_1) FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY (l.a_1 + r.a_1) ORDER BY (l.a_1 + r.a_1)
-(3 rows)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
+ Remote query: SELECT (l.a_1 + r.a_1) FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY (l.a_1 + r.a_1) ORDER BY (l.a_1 + r.a_1)
+(5 rows)
-- group by with aggregates in expression
-select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2;
+select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
?column? | val2
---------------------+------
11.0000000000000000 | 1
@@ -1371,16 +1495,18 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 o
17.6666666666666667 | 3
(3 rows)
-explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: ((((count(*) + sum(xc_groupby_tab1.val)))::numeric + avg(xc_groupby_tab1.val))), xc_groupby_tab1.val2
- Remote query: SELECT (((count(*) + sum(val)))::numeric + pg_catalog.int8_avg(avg(val))), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
-(3 rows)
+explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(xc_groupby_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_groupby_tab1.val)))), xc_groupby_tab1.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
+ Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
+(5 rows)
-- group by with expressions in group by clause
-select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2;
+select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
sum | avg | ?column?
-----+--------------------+----------
6 | 2.0000000000000000 | 2
@@ -1388,13 +1514,15 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order
11 | 3.6666666666666667 | 6
(3 rows)
-explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2))
- Remote query: SELECT sum(val), pg_catalog.int8_avg(avg(val)), (2 * val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (2 * val2) ORDER BY (2 * val2)
-(3 rows)
+explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((2 * xc_groupby_tab1.val2))
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2))
+ Remote query: SELECT sum(val), avg(val), (2 * val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (2 * val2) ORDER BY (2 * val2)
+(5 rows)
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -1413,7 +1541,7 @@ insert into xc_groupby_def VALUES (7, NULL);
insert into xc_groupby_def VALUES (8, 'Two');
insert into xc_groupby_def VALUES (9, 'Three');
insert into xc_groupby_def VALUES (10, 'Three');
-select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
+select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
avg | sum | count | b
--------------------+-----+-------+-------
| | 1 | One
@@ -1422,15 +1550,17 @@ select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
4.0000000000000000 | 8 | 3 |
(4 rows)
-explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
+explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (avg(xc_groupby_def.a)), (sum(xc_groupby_def.a)), (count(*)), xc_groupby_def.b
- Remote query: SELECT pg_catalog.int8_avg(avg(a)), sum(a), count(*), b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
-(3 rows)
+ GroupAggregate
+ Output: pg_catalog.avg((avg(xc_groupby_def.a))), pg_catalog.sum((sum(xc_groupby_def.a))), pg_catalog.count(*), xc_groupby_def.b
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (avg(xc_groupby_def.a)), (sum(xc_groupby_def.a)), (count(*)), xc_groupby_def.b
+ Remote query: SELECT avg(a), sum(a), count(*), b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
+(5 rows)
-select b from xc_groupby_def group by b order by b;
+select b from xc_groupby_def group by b;
b
-------
One
@@ -1439,15 +1569,17 @@ select b from xc_groupby_def group by b order by b;
(4 rows)
-explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b;
- QUERY PLAN
-------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------
+ Group
Output: xc_groupby_def.b
- Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
-(3 rows)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: xc_groupby_def.b
+ Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
+(5 rows)
-select b,count(b) from xc_groupby_def group by b order by b;
+select b,count(b) from xc_groupby_def group by b;
b | count
-------+-------
One | 1
@@ -1456,13 +1588,15 @@ select b,count(b) from xc_groupby_def group by b order by b;
| 0
(4 rows)
-explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b;
- QUERY PLAN
-----------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: xc_groupby_def.b, (count(xc_groupby_def.b))
- Remote query: SELECT b, count(b) FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
-(3 rows)
+explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b;
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: xc_groupby_def.b, count((count(xc_groupby_def.b)))
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: xc_groupby_def.b, (count(xc_groupby_def.b))
+ Remote query: SELECT b, count(b) FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
+(5 rows)
select count(*) from xc_groupby_def where b is null group by b;
count
@@ -1471,106 +1605,120 @@ select count(*) from xc_groupby_def where b is null group by b;
(1 row)
explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b;
- QUERY PLAN
------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), xc_groupby_def.b
- Remote query: SELECT count(*), b FROM ONLY xc_groupby_def WHERE (b IS NULL) GROUP BY b ORDER BY b
-(3 rows)
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: pg_catalog.count(*), xc_groupby_def.b
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), xc_groupby_def.b
+ Remote query: SELECT count(*), b FROM ONLY xc_groupby_def WHERE (b IS NULL) GROUP BY b ORDER BY b
+(5 rows)
create table xc_groupby_g(a int, b float, c numeric) distribute by replication;
insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(2,2.3,5.2);
-select sum(a) from xc_groupby_g group by a order by a;
+select sum(a) from xc_groupby_g group by a;
sum
-----
2
2
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a;
- QUERY PLAN
-------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
- Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a ORDER BY a
-(3 rows)
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: pg_catalog.sum((sum(xc_groupby_g.a))), xc_groupby_g.a
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
+ Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a ORDER BY a
+(5 rows)
-select sum(b) from xc_groupby_g group by b order by b;
+select sum(b) from xc_groupby_g group by b;
sum
-----
4.2
2.3
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b;
- QUERY PLAN
-------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (sum(xc_groupby_g.b)), xc_groupby_g.b
- Remote query: SELECT sum(b), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b
-(3 rows)
+explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: sum((sum(xc_groupby_g.b))), xc_groupby_g.b
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (sum(xc_groupby_g.b)), xc_groupby_g.b
+ Remote query: SELECT sum(b), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b
+(5 rows)
-select sum(c) from xc_groupby_g group by b order by b;
+select sum(c) from xc_groupby_g group by b;
sum
-----
6.4
5.2
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b;
- QUERY PLAN
-------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (sum(xc_groupby_g.c)), xc_groupby_g.b
- Remote query: SELECT sum(c), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b
-(3 rows)
+explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: sum((sum(xc_groupby_g.c))), xc_groupby_g.b
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (sum(xc_groupby_g.c)), xc_groupby_g.b
+ Remote query: SELECT sum(c), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b
+(5 rows)
-select avg(a) from xc_groupby_g group by b order by b;
+select avg(a) from xc_groupby_g group by b;
avg
------------------------
1.00000000000000000000
2.0000000000000000
(2 rows)
-explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (avg(xc_groupby_g.a)), xc_groupby_g.b
- Remote query: SELECT pg_catalog.int8_avg(avg(a)), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b
-(3 rows)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: pg_catalog.avg((avg(xc_groupby_g.a))), xc_groupby_g.b
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (avg(xc_groupby_g.a)), xc_groupby_g.b
+ Remote query: SELECT avg(a), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b
+(5 rows)
-select avg(b) from xc_groupby_g group by c order by c;
+select avg(b) from xc_groupby_g group by c;
avg
-----
2.1
2.3
(2 rows)
-explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c;
- QUERY PLAN
------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (avg(xc_groupby_g.b)), xc_groupby_g.c
- Remote query: SELECT pg_catalog.float8_avg(avg(b)), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c
-(3 rows)
+explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: pg_catalog.avg((avg(xc_groupby_g.b))), xc_groupby_g.c
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (avg(xc_groupby_g.b)), xc_groupby_g.c
+ Remote query: SELECT avg(b), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c
+(5 rows)
-select avg(c) from xc_groupby_g group by c order by c;
+select avg(c) from xc_groupby_g group by c;
avg
--------------------
3.2000000000000000
5.2000000000000000
(2 rows)
-explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (avg(xc_groupby_g.c)), xc_groupby_g.c
- Remote query: SELECT pg_catalog.numeric_avg(avg(c)), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c
-(3 rows)
+explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: pg_catalog.avg((avg(xc_groupby_g.c))), xc_groupby_g.c
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (avg(xc_groupby_g.c)), xc_groupby_g.c
+ Remote query: SELECT avg(c), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c
+(5 rows)
drop table xc_groupby_def;
drop table xc_groupby_g;
diff --git a/src/test/regress/expected/xc_having.out b/src/test/regress/expected/xc_having.out
index d5bbdaafa1..8ff190a121 100644
--- a/src/test/regress/expected/xc_having.out
+++ b/src/test/regress/expected/xc_having.out
@@ -48,22 +48,22 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2
(6 rows)
-select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
+select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
count | sum | avg | ?column? | val2
-------+-----+--------------------+------------------+------
2 | 8 | 4.0000000000000000 | 4 | 2
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(2 rows)
-explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate
+ HashAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
Filter: ((pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75) OR (xc_having_tab1.val2 > 2))
-> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 ORDER BY val2
+ Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2
(6 rows)
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2;
@@ -126,7 +126,7 @@ explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1
Remote query: SELECT val2, sum(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY val2
(6 rows)
-select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum;
+select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum;
sum
-----
4
@@ -134,16 +134,19 @@ select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) >
9
(3 rows)
-explain (verbose true, costs false, nodes false) select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum;
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate
+explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------
+ Sort
Output: ((xc_having_tab1.val + xc_having_tab1.val2))
- Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5)
- -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val))
- Remote query: SELECT (val + val2), sum(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2)
-(6 rows)
+ Sort Key: ((xc_having_tab1.val + xc_having_tab1.val2))
+ -> HashAggregate
+ Output: ((xc_having_tab1.val + xc_having_tab1.val2))
+ Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val))
+ Remote query: SELECT (val + val2), sum(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY (val + val2)
+(9 rows)
-- group by with aggregates in expression
select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
@@ -180,12 +183,14 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
(1 row)
explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2
- Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE ((val2 + 1) > 3) GROUP BY val2
-(3 rows)
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
+ Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
+ Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE ((val2 + 1) > 3) GROUP BY val2
+(5 rows)
-- having clause containing aggregate
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
@@ -195,27 +200,33 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
(1 row)
explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
- QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2
- Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (pg_catalog.int8_avg(avg(val)) > 3.75)
-(3 rows)
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
+ Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
+ Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
+ Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2
+(6 rows)
-select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
+select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
count | sum | avg | ?column? | val2
-------+-----+--------------------+------------------+------
2 | 8 | 4.0000000000000000 | 4 | 2
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(2 rows)
-explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
- QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2
- Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING ((pg_catalog.int8_avg(avg(val)) > 3.75) OR (val2 > 2)) ORDER BY val2
-(3 rows)
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
+ Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
+ Filter: ((pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75) OR (xc_having_tab1.val2 > 2))
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
+ Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2
+(6 rows)
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2;
count | sum | avg | ?column? | val2
@@ -225,10 +236,13 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2
- Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE (val2 > 2) GROUP BY val2 HAVING (pg_catalog.int8_avg(avg(val)) > 3.75)
-(3 rows)
+ HashAggregate
+ Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
+ Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
+ Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE (val2 > 2) GROUP BY val2
+(6 rows)
-- joins and group by and having
select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab1.val*xc_having_tab2.val), sum(xc_having_tab1.val*xc_having_tab2.val)::float8/count(*), xc_having_tab1.val2, xc_having_tab2.val2 from xc_having_tab1 full outer join xc_having_tab2 on xc_having_tab1.val2 = xc_having_tab2.val2 group by xc_having_tab1.val2, xc_having_tab2.val2 having xc_having_tab1.val2 + xc_having_tab2.val2 > 2;
@@ -238,12 +252,14 @@ select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab
(1 row)
explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab1.val*xc_having_tab2.val), sum(xc_having_tab1.val*xc_having_tab2.val)::float8/count(*), xc_having_tab1.val2, xc_having_tab2.val2 from xc_having_tab1 full outer join xc_having_tab2 on xc_having_tab1.val2 = xc_having_tab2.val2 group by xc_having_tab1.val2, xc_having_tab2.val2 having xc_having_tab1.val2 + xc_having_tab2.val2 > 2;
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum((xc_having_tab1.val * xc_having_tab2.val))), (avg((xc_having_tab1.val * xc_having_tab2.val))), (((sum((xc_having_tab1.val * xc_having_tab2.val)))::double precision / (count(*))::double precision)), xc_having_tab1.val2, xc_having_tab2.val2
- Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), pg_catalog.int8_avg(avg((l.a_2 * r.a_2))), ((sum((l.a_2 * r.a_2)))::double precision / (count(*))::double precision), l.a_1, r.a_1 FROM ((SELECT xc_having_tab1.val2, xc_having_tab1.val FROM ONLY xc_having_tab1 WHERE true) l(a_1, a_2) JOIN (SELECT xc_having_tab2.val2, xc_having_tab2.val FROM ONLY xc_having_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (((l.a_1 + r.a_1) > 2) AND (l.a_1 = r.a_1)) GROUP BY l.a_1, r.a_1
-(3 rows)
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
+ Output: pg_catalog.count(*), pg_catalog.sum((sum((xc_having_tab1.val * xc_having_tab2.val)))), pg_catalog.avg((avg((xc_having_tab1.val * xc_having_tab2.val)))), ((pg_catalog.sum((sum((xc_having_tab1.val * xc_having_tab2.val)))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2, xc_having_tab2.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum((xc_having_tab1.val * xc_having_tab2.val))), (avg((xc_having_tab1.val * xc_having_tab2.val))), xc_having_tab1.val2, xc_having_tab2.val2
+ Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), avg((l.a_2 * r.a_2)), l.a_1, r.a_1 FROM ((SELECT xc_having_tab1.val2, xc_having_tab1.val FROM ONLY xc_having_tab1 WHERE true) l(a_1, a_2) JOIN (SELECT xc_having_tab2.val2, xc_having_tab2.val FROM ONLY xc_having_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (((l.a_1 + r.a_1) > 2) AND (l.a_1 = r.a_1)) GROUP BY l.a_1, r.a_1
+(5 rows)
-- group by and having, without aggregate in the target list
select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -253,14 +269,17 @@ select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
(1 row)
explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
- QUERY PLAN
------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------
+ HashAggregate
Output: xc_having_tab1.val2
- Remote query: SELECT val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (sum(val) > 8)
-(3 rows)
+ Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: xc_having_tab1.val2, (sum(xc_having_tab1.val))
+ Remote query: SELECT val2, sum(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY val2
+(6 rows)
-select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum;
+select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum;
sum
-----
4
@@ -268,13 +287,19 @@ select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) >
9
(3 rows)
-explain (verbose true, costs false, nodes false) select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum;
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------
+ Sort
Output: ((xc_having_tab1.val + xc_having_tab1.val2))
- Remote query: SELECT (val + val2) FROM ONLY xc_having_tab1 WHERE true GROUP BY (val + val2) HAVING (sum(val) > 5) ORDER BY (val + val2)
-(3 rows)
+ Sort Key: ((xc_having_tab1.val + xc_having_tab1.val2))
+ -> HashAggregate
+ Output: ((xc_having_tab1.val + xc_having_tab1.val2))
+ Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val))
+ Remote query: SELECT (val + val2), sum(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY (val + val2)
+(9 rows)
-- group by with aggregates in expression
select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
@@ -284,12 +309,15 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha
(1 row)
explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
- QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: ((((count(*) + sum(xc_having_tab1.val)))::numeric + avg(xc_having_tab1.val))), xc_having_tab1.val2
- Remote query: SELECT (((count(*) + sum(val)))::numeric + pg_catalog.int8_avg(avg(val))), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (min(val) < val2)
-(3 rows)
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
+ Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(xc_having_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_having_tab1.val)))), xc_having_tab1.val2
+ Filter: (min((min(xc_having_tab1.val))) < xc_having_tab1.val2)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2, (min(xc_having_tab1.val))
+ Remote query: SELECT count(*), sum(val), avg(val), val2, min(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY val2
+(6 rows)
drop table xc_having_tab1;
drop table xc_having_tab2;
@@ -335,14 +363,14 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 ORDER BY val2
(6 rows)
-select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
+select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
count | sum | avg | ?column? | val2
-------+-----+--------------------+------------------+------
2 | 8 | 4.0000000000000000 | 4 | 2
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(2 rows)
-explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
GroupAggregate
@@ -470,12 +498,14 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
(1 row)
explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2
- Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE ((val2 + 1) > 3) GROUP BY val2 ORDER BY val2
-(3 rows)
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
+ Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE ((val2 + 1) > 3) GROUP BY val2 ORDER BY val2
+(5 rows)
-- having clause containing aggregate
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
@@ -485,27 +515,33 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
(1 row)
explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2
- Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (pg_catalog.int8_avg(avg(val)) > 3.75) ORDER BY val2
-(3 rows)
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
+ Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
+ Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 ORDER BY val2
+(6 rows)
-select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
+select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
count | sum | avg | ?column? | val2
-------+-----+--------------------+------------------+------
2 | 8 | 4.0000000000000000 | 4 | 2
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(2 rows)
-explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
- QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2
- Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING ((pg_catalog.int8_avg(avg(val)) > 3.75) OR (val2 > 2)) ORDER BY val2
-(3 rows)
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
+ Filter: ((pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75) OR (xc_having_tab1.val2 > 2))
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
+ Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 ORDER BY val2
+(6 rows)
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2;
count | sum | avg | ?column? | val2
@@ -513,12 +549,15 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
(0 rows)
explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2;
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2
- Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE (val2 > 2) GROUP BY val2 HAVING (pg_catalog.int8_avg(avg(val)) > 3.75) ORDER BY val2
-(3 rows)
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
+ Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
+ Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE (val2 > 2) GROUP BY val2 ORDER BY val2
+(6 rows)
-- joins and group by and having
select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab1.val*xc_having_tab2.val), sum(xc_having_tab1.val*xc_having_tab2.val)::float8/count(*), xc_having_tab1.val2, xc_having_tab2.val2 from xc_having_tab1 full outer join xc_having_tab2 on xc_having_tab1.val2 = xc_having_tab2.val2 group by xc_having_tab1.val2, xc_having_tab2.val2 having xc_having_tab1.val2 + xc_having_tab2.val2 > 2;
@@ -528,12 +567,14 @@ select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab
(1 row)
explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab1.val*xc_having_tab2.val), sum(xc_having_tab1.val*xc_having_tab2.val)::float8/count(*), xc_having_tab1.val2, xc_having_tab2.val2 from xc_having_tab1 full outer join xc_having_tab2 on xc_having_tab1.val2 = xc_having_tab2.val2 group by xc_having_tab1.val2, xc_having_tab2.val2 having xc_having_tab1.val2 + xc_having_tab2.val2 > 2;
- QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: (count(*)), (sum((xc_having_tab1.val * xc_having_tab2.val))), (avg((xc_having_tab1.val * xc_having_tab2.val))), (((sum((xc_having_tab1.val * xc_having_tab2.val)))::double precision / (count(*))::double precision)), xc_having_tab1.val2, xc_having_tab2.val2
- Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), pg_catalog.int8_avg(avg((l.a_2 * r.a_2))), ((sum((l.a_2 * r.a_2)))::double precision / (count(*))::double precision), l.a_1, r.a_1 FROM ((SELECT xc_having_tab1.val2, xc_having_tab1.val FROM ONLY xc_having_tab1 WHERE true) l(a_1, a_2) JOIN (SELECT xc_having_tab2.val2, xc_having_tab2.val FROM ONLY xc_having_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (((l.a_1 + r.a_1) > 2) AND (l.a_1 = r.a_1)) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1
-(3 rows)
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: pg_catalog.count(*), pg_catalog.sum((sum((xc_having_tab1.val * xc_having_tab2.val)))), pg_catalog.avg((avg((xc_having_tab1.val * xc_having_tab2.val)))), ((pg_catalog.sum((sum((xc_having_tab1.val * xc_having_tab2.val)))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2, xc_having_tab2.val2
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum((xc_having_tab1.val * xc_having_tab2.val))), (avg((xc_having_tab1.val * xc_having_tab2.val))), xc_having_tab1.val2, xc_having_tab2.val2
+ Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), avg((l.a_2 * r.a_2)), l.a_1, r.a_1 FROM ((SELECT xc_having_tab1.val2, xc_having_tab1.val FROM ONLY xc_having_tab1 WHERE true) l(a_1, a_2) JOIN (SELECT xc_having_tab2.val2, xc_having_tab2.val FROM ONLY xc_having_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (((l.a_1 + r.a_1) > 2) AND (l.a_1 = r.a_1)) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1
+(5 rows)
-- group by and having, without aggregate in the target list
select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -543,12 +584,15 @@ select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
(1 row)
explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: xc_having_tab1.val2
- Remote query: SELECT val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (sum(val) > 8) ORDER BY val2
-(3 rows)
+ Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: xc_having_tab1.val2, (sum(xc_having_tab1.val))
+ Remote query: SELECT val2, sum(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 ORDER BY val2
+(6 rows)
select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
?column?
@@ -559,12 +603,15 @@ select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
(3 rows)
explain (verbose true, costs false, nodes false) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: ((xc_having_tab1.val + xc_having_tab1.val2))
- Remote query: SELECT (val + val2) FROM ONLY xc_having_tab1 WHERE true GROUP BY (val + val2) HAVING (sum(val) > 5) ORDER BY (val + val2)
-(3 rows)
+ Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val))
+ Remote query: SELECT (val + val2), sum(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2)
+(6 rows)
-- group by with aggregates in expression
select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
@@ -574,12 +621,15 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha
(1 row)
explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Data Node Scan on "__REMOTE_GROUP_QUERY__"
- Output: ((((count(*) + sum(xc_having_tab1.val)))::numeric + avg(xc_having_tab1.val))), xc_having_tab1.val2
- Remote query: SELECT (((count(*) + sum(val)))::numeric + pg_catalog.int8_avg(avg(val))), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (min(val) < val2) ORDER BY val2
-(3 rows)
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(xc_having_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_having_tab1.val)))), xc_having_tab1.val2
+ Filter: (min((min(xc_having_tab1.val))) < xc_having_tab1.val2)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
+ Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2, (min(xc_having_tab1.val))
+ Remote query: SELECT count(*), sum(val), avg(val), val2, min(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 ORDER BY val2
+(6 rows)
drop table xc_having_tab1;
drop table xc_having_tab2;
diff --git a/src/test/regress/sql/xc_FQS.sql b/src/test/regress/sql/xc_FQS.sql
index c348cabda1..ee879d93f9 100644
--- a/src/test/regress/sql/xc_FQS.sql
+++ b/src/test/regress/sql/xc_FQS.sql
@@ -106,7 +106,7 @@ select val, val2 from tab1_hash where val2 = 8 group by val, val2;
explain (costs off, verbose on, nodes off) select val, val2 from tab1_hash where val2 = 8 group by val, val2;
-- should not get FQSed because of DISTINCT clause
select distinct on (val2) val, val2 from tab1_hash where val2 = 8;
-explain (costs off, verbose on, nodes off) select distinct on (val2) val, val2 from tab1_hash where val2 = 8;
+explain (costs off, verbose on, nodes off) select distinct (val2) val, val2 from tab1_hash where val2 = 8;
-- should not get FQSed because of presence of aggregates and HAVING clause
-- withour distribution column in GROUP BY clause
select sum(val) from tab1_hash where val2 = 2 group by val2 having sum(val) > 1;
diff --git a/src/test/regress/sql/xc_groupby.sql b/src/test/regress/sql/xc_groupby.sql
index 8ef010dfc5..602c643258 100644
--- a/src/test/regress/sql/xc_groupby.sql
+++ b/src/test/regress/sql/xc_groupby.sql
@@ -15,31 +15,31 @@ create table xc_groupby_tab1 (val int, val2 int);
create table xc_groupby_tab2 (val int, val2 int);
insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3);
insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
-select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2;
-explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2;
+select * from (select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2) q order by q.val2;
+explain (verbose true, costs false, nodes false) select * from (select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2) q order by q.val2;
-- joins and group by
-select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 gt1_val2, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by gt1_val2, gt2_val2;
-explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 gt1_val2, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by gt1_val2, gt2_val2;
+select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 gt1_val2, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.gt1_val2, q.gt2_val2;
+explain (verbose true, costs false, nodes false) select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 gt1_val2, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.gt1_val2, q.gt2_val2;
-- aggregates over aggregates
select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x order by x;
explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x order by x;
-- group by without aggregate
-select val2 from xc_groupby_tab1 group by val2 order by val2;
-explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2;
-select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2;
-explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2;
-select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2;
-explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2;
-select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2 order by gt1_val, gt2_val2;
-explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2 order by gt1_val, gt2_val2;
-select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by 1;
-explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by 1;
+select * from (select val2 from xc_groupby_tab1 group by val2) q order by q.val2;
+explain (verbose true, costs false, nodes false) select * from (select val2 from xc_groupby_tab1 group by val2) q order by q.val2;
+select * from (select val + val2 from xc_groupby_tab1 group by val + val2) q order by 1;
+explain (verbose true, costs false, nodes false) select * from (select val + val2 from xc_groupby_tab1 group by val + val2) q order by 1;
+select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2;
+explain (verbose true, costs false, nodes false) select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2;
+select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.gt1_val, q.gt2_val2;
+explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.gt1_val, q.gt2_val2;
+select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by 1;
+explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by 1;
-- group by with aggregates in expression
-select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2;
-explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2;
+select * from (select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2) q order by q.val2;
+explain (verbose true, costs false, nodes false) select * from (select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2) q order by q.val2;
-- group by with expressions in group by clause
-select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2 order by expr;
-explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2 order by expr;
+select * from (select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2) q order by q.expr;
+explain (verbose true, costs false, nodes false) select * from (select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2) q order by q.expr;
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -59,12 +59,13 @@ insert into xc_groupby_def VALUES (8, 'Two');
insert into xc_groupby_def VALUES (9, 'Three');
insert into xc_groupby_def VALUES (10, 'Three');
-select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
-explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
-select b from xc_groupby_def group by b order by b;
-explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b;
-select b,count(b) from xc_groupby_def group by b order by b;
-explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b;
+select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
+explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
+
+select * from (select b from xc_groupby_def group by b) q order by q.b;
+explain (verbose true, costs false, nodes false) select * from (select b from xc_groupby_def group by b) q order by q.b;
+select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b;
+explain (verbose true, costs false, nodes false) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b;
select count(*) from xc_groupby_def where b is null group by b;
explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b;
@@ -73,19 +74,19 @@ insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(2,2.3,5.2);
-select sum(a) from xc_groupby_g group by a order by a;
-explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a;
-select sum(b) from xc_groupby_g group by b order by b;
-explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b;
-select sum(c) from xc_groupby_g group by b order by b;
-explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b;
+select sum(a) from xc_groupby_g group by a;
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a;
+select sum(b) from xc_groupby_g group by b;
+explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b;
+select sum(c) from xc_groupby_g group by b;
+explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b;
-select avg(a) from xc_groupby_g group by b order by b;
-explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b;
-select avg(b) from xc_groupby_g group by c order by c;
-explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c;
-select avg(c) from xc_groupby_g group by c order by c;
-explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c;
+select avg(a) from xc_groupby_g group by b;
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b;
+select avg(b) from xc_groupby_g group by c;
+explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c;
+select avg(c) from xc_groupby_g group by c;
+explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c;
drop table xc_groupby_def;
drop table xc_groupby_g;
@@ -97,31 +98,31 @@ create table xc_groupby_tab1 (val int, val2 int) distribute by replication;
create table xc_groupby_tab2 (val int, val2 int) distribute by replication;
insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3);
insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
-select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2;
-explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2;
+select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2;
-- joins and group by
-select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by c1, c2;
-explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by c1, c2;
+select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2;
+explain (verbose true, costs false, nodes false) select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2;
-- aggregates over aggregates
-select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x order by sum;
-explain (verbose true, costs false, nodes false) select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x order by sum;
+select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum;
+explain (verbose true, costs false, nodes false) select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum;
-- group by without aggregate
-select val2 from xc_groupby_tab1 group by val2 order by val2;
-explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2;
-select val + val2 sum from xc_groupby_tab1 group by val + val2 order by sum;
-explain (verbose true, costs false, nodes false) select val + val2 sum from xc_groupby_tab1 group by val + val2 order by sum;
-select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2;
-explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2;
-select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2 order by val, val2;
-explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2 order by val, val2;
-select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by sum;
-explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by sum;
+select val2 from xc_groupby_tab1 group by val2;
+explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
+select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum;
+explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum;
+select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2;
+explain (verbose true, costs false, nodes false) select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2;
+select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2;
+explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2;
+select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by q.sum;
+explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by q.sum;
-- group by with aggregates in expression
-select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by 1;
-explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by 1;
+select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
+explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
-- group by with expressions in group by clause
-select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2;
-explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2;
+select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
+explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -141,13 +142,13 @@ insert into xc_groupby_def VALUES (8, 'Two');
insert into xc_groupby_def VALUES (9, 'Three');
insert into xc_groupby_def VALUES (10, 'Three');
-select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
-explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
+select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
+explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
-select b from xc_groupby_def group by b order by b;
-explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b;
-select b,count(b) from xc_groupby_def group by b order by b;
-explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b;
+select * from (select b from xc_groupby_def group by b) q order by q.b;
+explain (verbose true, costs false, nodes false) select * from (select b from xc_groupby_def group by b) q order by q.b;
+select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b;
+explain (verbose true, costs false, nodes false) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b;
select count(*) from xc_groupby_def where b is null group by b;
explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b;
@@ -156,19 +157,19 @@ insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(2,2.3,5.2);
-select sum(a) from xc_groupby_g group by a order by a;
-explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a;
-select sum(b) from xc_groupby_g group by b order by b;
-explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b;
-select sum(c) from xc_groupby_g group by b order by b;
-explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b;
+select sum(a) from xc_groupby_g group by a;
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a;
+select sum(b) from xc_groupby_g group by b;
+explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b;
+select sum(c) from xc_groupby_g group by b;
+explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b;
-select avg(a) from xc_groupby_g group by b order by b;
-explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b;
-select avg(b) from xc_groupby_g group by c order by c;
-explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c;
-select avg(c) from xc_groupby_g group by c order by c;
-explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c;
+select avg(a) from xc_groupby_g group by b;
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b;
+select avg(b) from xc_groupby_g group by c;
+explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c;
+select avg(c) from xc_groupby_g group by c;
+explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c;
drop table xc_groupby_def;
drop table xc_groupby_g;
@@ -190,8 +191,8 @@ explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby
select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
-- group by without aggregate
-select val2 from xc_groupby_tab1 group by val2 order by val2;
-explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2;
+select val2 from xc_groupby_tab1 group by val2;
+explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
select val + val2 from xc_groupby_tab1 group by val + val2;
explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2;
select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
@@ -201,11 +202,11 @@ explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc
select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2;
explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2;
-- group by with aggregates in expression
-select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2;
-explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2;
+select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
+explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
-- group by with expressions in group by clause
-select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2;
-explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2;
+select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
+explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -225,13 +226,13 @@ insert into xc_groupby_def VALUES (8, 'Two');
insert into xc_groupby_def VALUES (9, 'Three');
insert into xc_groupby_def VALUES (10, 'Three');
-select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
-explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
+select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
+explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
-select b from xc_groupby_def group by b order by b;
-explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b;
-select b,count(b) from xc_groupby_def group by b order by b;
-explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b;
+select b from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b;
+select b,count(b) from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b;
select count(*) from xc_groupby_def where b is null group by b;
explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b;
@@ -240,19 +241,19 @@ insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(2,2.3,5.2);
-select sum(a) from xc_groupby_g group by a order by a;
-explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a;
-select sum(b) from xc_groupby_g group by b order by b;
-explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b;
-select sum(c) from xc_groupby_g group by b order by b;
-explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b;
+select sum(a) from xc_groupby_g group by a;
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a;
+select sum(b) from xc_groupby_g group by b;
+explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b;
+select sum(c) from xc_groupby_g group by b;
+explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b;
-select avg(a) from xc_groupby_g group by b order by b;
-explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b;
-select avg(b) from xc_groupby_g group by c order by c;
-explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c;
-select avg(c) from xc_groupby_g group by c order by c;
-explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c;
+select avg(a) from xc_groupby_g group by b;
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b;
+select avg(b) from xc_groupby_g group by c;
+explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c;
+select avg(c) from xc_groupby_g group by c;
+explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c;
drop table xc_groupby_def;
drop table xc_groupby_g;
@@ -264,31 +265,31 @@ create table xc_groupby_tab1 (val int, val2 int) distribute by replication;
create table xc_groupby_tab2 (val int, val2 int) distribute by replication;
insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3);
insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
-select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2;
-explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2;
+select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2;
-- joins and group by
-select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by xc_groupby_tab1.val2, xc_groupby_tab2.val2;
-explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by xc_groupby_tab1.val2, xc_groupby_tab2.val2;
+select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2;
+explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2;
-- aggregates over aggregates
-select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x order by x;
-explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x order by x;
+select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
+explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
-- group by without aggregate
-select val2 from xc_groupby_tab1 group by val2 order by val2;
-explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2;
-select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2;
-explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2;
-select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2;
-explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2;
-select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2 order by xc_groupby_tab1.val, xc_groupby_tab2.val2;
-explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2 order by xc_groupby_tab1.val, xc_groupby_tab2.val2;
-select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by xc_groupby_tab1.val + xc_groupby_tab2.val2;
-explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by xc_groupby_tab1.val + xc_groupby_tab2.val2;
+select val2 from xc_groupby_tab1 group by val2;
+explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
+select val + val2 from xc_groupby_tab1 group by val + val2;
+explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2;
+select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
+explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
+select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2;
+explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2;
+select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2;
+explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2;
-- group by with aggregates in expression
-select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2;
-explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2;
+select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
+explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
-- group by with expressions in group by clause
-select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2;
-explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2;
+select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
+explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -308,13 +309,13 @@ insert into xc_groupby_def VALUES (8, 'Two');
insert into xc_groupby_def VALUES (9, 'Three');
insert into xc_groupby_def VALUES (10, 'Three');
-select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
-explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
+select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
+explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
-select b from xc_groupby_def group by b order by b;
-explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b;
-select b,count(b) from xc_groupby_def group by b order by b;
-explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b;
+select b from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b;
+select b,count(b) from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b;
select count(*) from xc_groupby_def where b is null group by b;
explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b;
@@ -323,19 +324,19 @@ insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(1,2.1,3.2);
insert into xc_groupby_g values(2,2.3,5.2);
-select sum(a) from xc_groupby_g group by a order by a;
-explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a;
-select sum(b) from xc_groupby_g group by b order by b;
-explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b;
-select sum(c) from xc_groupby_g group by b order by b;
-explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b;
-
-select avg(a) from xc_groupby_g group by b order by b;
-explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b;
-select avg(b) from xc_groupby_g group by c order by c;
-explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c;
-select avg(c) from xc_groupby_g group by c order by c;
-explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c;
+select sum(a) from xc_groupby_g group by a;
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a;
+select sum(b) from xc_groupby_g group by b;
+explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b;
+select sum(c) from xc_groupby_g group by b;
+explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b;
+
+select avg(a) from xc_groupby_g group by b;
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b;
+select avg(b) from xc_groupby_g group by c;
+explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c;
+select avg(c) from xc_groupby_g group by c;
+explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c;
drop table xc_groupby_def;
drop table xc_groupby_g;
diff --git a/src/test/regress/sql/xc_having.sql b/src/test/regress/sql/xc_having.sql
index 41dc79b2da..061ca3ae1c 100644
--- a/src/test/regress/sql/xc_having.sql
+++ b/src/test/regress/sql/xc_having.sql
@@ -21,8 +21,8 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
-- having clause containing aggregate
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
-select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
-explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
+select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2;
explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2;
-- joins and group by and having
@@ -31,8 +31,8 @@ explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_
-- group by and having, without aggregate in the target list
select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
-select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum;
-explain (verbose true, costs false, nodes false) select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum;
+select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum;
+explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum;
-- group by with aggregates in expression
select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
@@ -52,8 +52,8 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
-- having clause containing aggregate
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
-select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
-explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
+select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2;
explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2;
-- joins and group by and having
@@ -62,8 +62,8 @@ explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_
-- group by and having, without aggregate in the target list
select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
-select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum;
-explain (verbose true, costs false, nodes false) select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum;
+select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum;
+explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum;
-- group by with aggregates in expression
select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
@@ -83,8 +83,8 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
-- having clause containing aggregate
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
-select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
-explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
+select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2;
explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2;
-- joins and group by and having
@@ -114,8 +114,8 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
-- having clause containing aggregate
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
-select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
-explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2;
+select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2;
explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2;
-- joins and group by and having