summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorMichael Paquier2012-10-16 08:21:57 +0000
committerMichael Paquier2012-10-16 08:21:57 +0000
commit9ce38d3bf64c17155a0ca283c56987b7ecd9e218 (patch)
tree4344b21b1f54eb86b22710283ce86adc427ba5d2
parent945f83fc5d5b2ef1d51438a7dd48dd9532c9d936 (diff)
GROUP BY clause pushdown optimization with distribution data and aggregates
This patch is a lightly modified version of 66c17a5 reverted by 6c6ba3c once some errors have been noticed regarding aggregate pushdown, like: SELECT count(*) FROM tab; where the query was completely pushed down and returned multiple row results to client (1 per Datanode). Patch and subsequent fix from Ashutosh Bapat, I just did some testing.
-rw-r--r--src/backend/nodes/copyfuncs.c1
-rw-r--r--src/backend/nodes/outfuncs.c1
-rw-r--r--src/backend/optimizer/plan/pgxcplan.c570
-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.h2
-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, 1227 insertions, 1287 deletions
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 9db6c2b46a..dd4d5b288f 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -1038,7 +1038,6 @@ _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 8e858316fe..533b88f150 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -487,7 +487,6 @@ _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 fa70a7a02e..db4fce53e4 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 void pgxc_locate_grouping_columns(PlannerInfo *root, List *tlist,
+static bool pgxc_locate_grouping_columns(PlannerInfo *root, List *tlist,
AttrNumber *grpColIdx);
-static List *pgxc_process_grouping_targetlist(PlannerInfo *root,
- List **local_tlist);
-static List *pgxc_process_having_clause(PlannerInfo *root, List *remote_tlist,
+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,
Node *havingQual, List **local_qual,
- List **remote_qual, bool *reduce_plan);
+ List **remote_qual);
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);
+static List *pgxc_separate_quals(List *quals, List **local_quals, bool has_aggs);
static Query *pgxc_build_shippable_query_recurse(PlannerInfo *root,
RemoteQueryPath *rqpath,
List **unshippable_quals,
@@ -75,6 +75,10 @@ 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);
/*
@@ -83,17 +87,23 @@ 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)
+pgxc_separate_quals(List *quals, List **unshippabl_quals, bool has_aggs)
{
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, NULL))
+ if (pgxc_is_expr_shippable(clause, tmp_bool_ptr))
shippabl_quals = lappend(shippabl_quals, clause);
else
*unshippabl_quals = lappend(*unshippabl_quals, clause);
@@ -114,11 +124,15 @@ pgxc_separate_quals(List *quals, List **unshippabl_quals)
* those in the target list for the datanode.
*/
static List *
-pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals)
+pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals, bool has_aggs)
{
- ListCell *lcell;
- List *remote_tlist = NIL;
- List *tmp_rtlist = NIL;
+ 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;
/*
* Add all the shippable members as they are to the target list being built,
@@ -126,8 +140,15 @@ pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals)
*/
foreach(lcell, tlist)
{
- TargetEntry *tle = lfirst(lcell);
- Expr *expr;
+ 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;
if (!IsA(tle, TargetEntry))
elog(ERROR, "Expected TargetEntry node, but got node with type %d",
@@ -138,22 +159,29 @@ pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals)
* pgxc_is_expr_shippable(). Helps in detecting top level RowExpr, which
* are unshippable
*/
- if (pgxc_is_expr_shippable((Expr *)tle, NULL))
- tmp_rtlist = lappend(tmp_rtlist, expr);
+ if (pgxc_is_expr_shippable((Expr *)tle, tmp_ptr))
+ remote_tlist = pgxc_add_to_flat_tlist(remote_tlist, (Node *)expr,
+ tle->ressortgroupref);
else
- tmp_rtlist = list_concat(tmp_rtlist, pull_var_clause((Node *)expr,
- PVC_REJECT_AGGREGATES,
- PVC_RECURSE_PLACEHOLDERS));
+ unshippable_expr = lappend(unshippable_expr, expr);
}
- remote_tlist = add_to_flat_tlist(remote_tlist, tmp_rtlist);
/*
- * The passed in quals are already checked for shippability, so just add the
- * vars from those clauses to the targetlist being built.
+ * Now collect the aggregates (if needed) and Vars from the unshippable
+ * expressions (from targetlist and unshippable quals and add them to
+ * remote targetlist.
*/
- remote_tlist = add_to_flat_tlist(remote_tlist, pull_var_clause((Node *)unshippabl_quals,
- PVC_RECURSE_AGGREGATES,
- PVC_RECURSE_PLACEHOLDERS));
+ 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);
+ }
return remote_tlist;
}
@@ -200,7 +228,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);
+ shippable_quals = pgxc_separate_quals(scan_clauses, unshippable_quals, false);
shippable_quals = copyObject(shippable_quals);
/*
@@ -362,13 +390,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, false))
+ if (!pgxc_is_expr_shippable((Expr *)join_clauses, NULL))
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);
+ other_clauses = pgxc_separate_quals(other_clauses, unshippable_quals, false);
other_clauses = copyObject(other_clauses);
/*
@@ -542,12 +570,10 @@ 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, if the targetlist is not shippable as is.
+ * expected from the plan.
*/
- if (!rqplan->is_shippable_tlist)
- base_tlist = pgxc_build_shippable_tlist(plan->targetlist, plan->qual);
- else
- base_tlist = copyObject(plan->targetlist);
+ base_tlist = pgxc_build_shippable_tlist(plan->targetlist, plan->qual,
+ rqplan->remote_query->hasAggs);
query_tlist = copyObject(base_tlist);
/* Replace the targetlist of remote_query with the new base_tlist */
@@ -1283,20 +1309,24 @@ 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;
+
/*
- * We don't push aggregation and grouping to Datanodes, in case there are
- * windowing aggregates, distinct, having clause or sort clauses.
+ * 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 :)
*/
- if (query->hasWindowFuncs ||
- query->distinctClause ||
- query->sortClause)
+ if (query->hasWindowFuncs)
return local_plan;
/* for now only Agg/Group plans */
@@ -1327,10 +1357,7 @@ 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;
@@ -1373,43 +1400,80 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan)
}
/*
- * process the targetlist of the grouping plan, also construct the
- * targetlist of the query to be shipped to the remote side
+ * If group by clause has distribution column in it or if there is only one
+ * datanode involved, the evaluation of aggregates and grouping involves
+ * only a single datanode.
*/
- base_tlist = pgxc_process_grouping_targetlist(root, &(local_plan->targetlist));
+ if (pgxc_query_has_distcolgrouping(query) ||
+ list_length(remote_scan->exec_nodes->nodeList) == 1)
+ single_node_grouping = true;
+ else
+ single_node_grouping = false;
+ /*
+ * 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.
+ */
+ 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);
/*
* If can not construct a targetlist shippable to the Datanode. Resort to
* the plan created by grouping_planner()
*/
- if (!base_tlist)
+ if (!remote_scan_tlist)
return local_plan;
-
- base_tlist = pgxc_process_having_clause(root, base_tlist, query->havingQual,
- &local_qual, &remote_qual, &reduce_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;
/*
- * 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.
+ * 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.
*/
- if (!reduce_plan)
- return local_plan;
- Assert(base_tlist);
+ remote_scan->remote_query->hasAggs = query->hasAggs;
+ pgxc_rqplan_adjust_tlist(remote_scan);
+ base_tlist = remote_scan->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 this node. But now the grouping
+ * targetlists of the scan plans under Agg/Group 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
*/
- pgxc_locate_grouping_columns(root, base_tlist, grpColIdx);
+ if (!pgxc_locate_grouping_columns(root, base_tlist, grpColIdx))
+ return local_plan;
/* Add the GROUP BY clause to the JOIN query */
remote_scan->remote_query->groupClause = query->groupClause;
- remote_scan->remote_query->hasAggs = query->hasAggs;
- /* Add the ORDER BY clause if necessary */
+ /*
+ * Add the ORDER BY clause if necessary, this ordering important, because
+ * rest of the plan depends upon it.
+ */
if (sort_plan)
{
List *sortClause = NIL;
@@ -1450,29 +1514,31 @@ 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;
/*
- * 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.
+ * We have added new clauses to the query being shipped to the datanode/s,
+ * re-build the quals.
*/
- remote_scan->is_shippable_tlist = true;
- pgxc_rqplan_adjust_tlist(remote_scan);
-
- local_plan->lefttree = (Plan *)remote_scan;
- local_plan->qual = local_qual;
+ pgxc_rqplan_build_statement(remote_scan);
/* 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;
- return local_plan;
+ /*
+ * 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;
+ }
}
/*
@@ -1483,70 +1549,53 @@ 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 void
+static bool
pgxc_locate_grouping_columns(PlannerInfo *root, List *tlist,
AttrNumber *groupColIdx)
{
int keyno = 0;
ListCell *gl;
- /*
- * No work unless grouping.
- */
- if (!root->parse->groupClause)
- {
- Assert(groupColIdx == NULL);
- return;
- }
- Assert(groupColIdx != NULL);
+ Assert(!root->parse->groupClause || groupColIdx != NULL);
foreach(gl, root->parse->groupClause)
{
SortGroupClause *grpcl = (SortGroupClause *) lfirst(gl);
TargetEntry *te = get_sortgroupclause_tle(grpcl, tlist);
if (!te)
- elog(ERROR, "failed to locate grouping columns");
+ return false;
groupColIdx[keyno++] = te->resno;
}
+ return true;
}
/*
- * 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
+ * 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.
*/
static List *
-pgxc_add_node_to_grouping_tlist(List *remote_tlist, Node *expr, Index ressortgroupref)
+pgxc_add_to_flat_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)
{
@@ -1570,164 +1619,130 @@ pgxc_add_node_to_grouping_tlist(List *remote_tlist, Node *expr, Index ressortgro
{
/*
* if the expression's TLE already has a Sorting/Grouping reference,
- * and caller has passed a non-zero one as well, better both of them
- * be same
+ * 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.
*/
- Assert(remote_tle->ressortgroupref == ressortgroupref);
+ if (remote_tle->ressortgroupref != ressortgroupref);
+ remote_tle->ressortgroupref = 0;
}
}
- /*
- * 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 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.
+ * 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.
*/
static List *
-pgxc_process_grouping_targetlist(PlannerInfo *root, List **local_tlist)
+pgxc_process_grouping_targetlist(List *local_tlist, bool single_node_grouping)
{
- bool shippable_remote_tlist = true;
- List *remote_tlist = NIL;
- List *orig_local_tlist = NIL;/* Copy original local_tlist, in case it changes */
+ List *remote_tlist = NIL;
ListCell *temp;
- /*
- * 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)
+ if (single_node_grouping)
{
- TargetEntry *local_tle = lfirst(temp);
- Node *expr = (Node *)local_tle->expr;
- bool has_aggs;
+ /* 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;
- /*
- * 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))
+ foreach (lcell, aggs_n_vars)
{
- shippable_remote_tlist = false;
- break;
- }
-
- /*
- * 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);
+ 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;
+ }
+ remote_tlist = copyObject(local_tlist);
+ }
+ else
+ {
/*
- * 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.
+ * 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 (has_aggs)
+ foreach(temp, local_tlist)
{
+ 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);
+
/*
- * 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.
+ * See if there are any aggregates in the current target entry and
+ * whether those aggregates are shippable.
*/
- if (local_tle->ressortgroupref > 0)
+ foreach (lcell, aggs_n_vars)
{
- shippable_remote_tlist = false;
- break;
+ 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;
+ }
}
- 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)
+ /*
+ * 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))
{
- Assert(IsA(lfirst(lcell), Aggref) || IsA(lfirst(lcell), Var));
- remote_tlist = pgxc_add_node_to_grouping_tlist(remote_tlist, lfirst(lcell),
- 0);
+ /*
+ * 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
+ {
+ TargetEntry *remote_tle = copyObject(local_tle);
+ remote_tle->resno = list_length(remote_tlist) + 1;
+ remote_tlist = lappend(remote_tlist, remote_tle);
}
}
- /* 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;
}
@@ -1741,18 +1756,17 @@ pgxc_process_grouping_targetlist(PlannerInfo *root, List **local_tlist)
* 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 expression which can not be evaluated at the data
+ * 3. If qual contains an aggregate 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(PlannerInfo *root, List *remote_tlist, Node *havingQual,
- List **local_qual, List **remote_qual,
- bool *reduce_plan)
+pgxc_process_having_clause(List *remote_tlist, bool single_node_grouping,
+ Node *havingQual, List **local_qual,
+ List **remote_qual)
{
- List *qual;
ListCell *temp;
+ List *quals;
- *reduce_plan = true;
*remote_qual = NIL;
*local_qual = NIL;
@@ -1763,28 +1777,29 @@ pgxc_process_having_clause(PlannerInfo *root, List *remote_tlist, Node *havingQu
* possibility that the quals will be another form?
*/
if (!IsA(havingQual, List))
- {
- *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)
+ return NULL;
+
+ quals = (List *)havingQual;
+ foreach(temp, quals)
{
Node *expr = lfirst(temp);
bool has_aggs;
List *vars_n_aggs;
+ bool shippable_qual;
- if (!pgxc_is_expr_shippable((Expr *)expr, &has_aggs))
- {
- *reduce_plan = false;
- break;
- }
+ shippable_qual = pgxc_is_expr_shippable((Expr *)expr, &has_aggs);
- if (has_aggs)
+ /*
+ * 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))
{
ListCell *lcell;
@@ -1794,19 +1809,30 @@ pgxc_process_having_clause(PlannerInfo *root, List *remote_tlist, Node *havingQu
/* copy the aggregates into the remote target list */
foreach (lcell, vars_n_aggs)
{
- Assert(IsA(lfirst(lcell), Aggref) || IsA(lfirst(lcell), Var));
- remote_tlist = pgxc_add_node_to_grouping_tlist(remote_tlist, lfirst(lcell),
- 0);
+ 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);
}
*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 81243dbc50..d20364e37f 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -26,6 +26,7 @@
#include "utils/lsyscache.h"
#include "utils/syscache.h"
#ifdef PGXC
+#include "pgxc/pgxc.h"
#include "optimizer/pgxcplan.h"
#endif
@@ -151,6 +152,7 @@ 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
@@ -550,6 +552,11 @@ 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;
@@ -2109,3 +2116,94 @@ 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 e76124c3ae..2b5b6966c6 100644
--- a/src/backend/optimizer/util/pgxcship.c
+++ b/src/backend/optimizer/util/pgxcship.c
@@ -114,10 +114,8 @@ 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.
@@ -481,7 +479,7 @@ pgxc_FQS_get_relation_nodes(RangeTblEntry *rte, Index varno, Query *query)
return rel_exec_nodes;
}
-static bool
+bool
pgxc_query_has_distcolgrouping(Query *query)
{
ListCell *lcell;
@@ -740,6 +738,14 @@ 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;
@@ -1224,9 +1230,17 @@ pgxc_is_query_shippable(Query *query, int query_level)
/*
* pgxc_is_expr_shippable
- * 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.
+ * 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.
*/
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 2d9620630c..5abb40ec96 100644
--- a/src/include/optimizer/pgxcplan.h
+++ b/src/include/optimizer/pgxcplan.h
@@ -112,7 +112,6 @@ 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 e9e0ccbd42..7317617751 100644
--- a/src/include/optimizer/pgxcship.h
+++ b/src/include/optimizer/pgxcship.h
@@ -33,6 +33,8 @@ 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);
+/* Check if given Query includes distribution column */
+extern bool pgxc_query_has_distcolgrouping(Query *query);
/* Check the shippability of an index */
extern bool pgxc_check_index_shippability(RelationLocInfo *relLocInfo,
bool is_primary,
diff --git a/src/test/regress/expected/aggregates.out b/src/test/regress/expected/aggregates.out
index b35a78e55c..8f9e32c948 100644
--- a/src/test/regress/expected/aggregates.out
+++ b/src/test/regress/expected/aggregates.out
@@ -309,6 +309,8 @@ 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,
@@ -577,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 tenk1 "_REMOTE_TABLE_QUERY_"
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
(3 rows)
select distinct max(unique2) from tenk1;
@@ -592,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(tenk1.unique2))
+ Sort Key: (max((max(tenk1.unique2))))
-> Aggregate
- -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
(4 rows)
select max(unique2) from tenk1 order by 1;
@@ -608,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(tenk1.unique2))
+ Sort Key: (max((max(tenk1.unique2))))
-> Aggregate
- -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
(4 rows)
select max(unique2) from tenk1 order by max(unique2);
@@ -624,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(tenk1.unique2) + 1))
+ Sort Key: ((max((max(tenk1.unique2))) + 1))
-> Aggregate
- -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
(4 rows)
select max(unique2) from tenk1 order by max(unique2)+1;
@@ -640,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 tenk1 "_REMOTE_TABLE_QUERY_"
+ -> Data Node Scan on "__REMOTE_GROUP_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 db22e478e9..d8c6e862b6 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 tenk1 "_REMOTE_TABLE_QUERY_"
+ -> Data Node Scan on "__REMOTE_GROUP_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(tenk1.unique2))
+ Sort Key: (max((max(tenk1.unique2))))
-> Aggregate
- -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
+ -> Data Node Scan on "__REMOTE_GROUP_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(tenk1.unique2))
+ Sort Key: (max((max(tenk1.unique2))))
-> Aggregate
- -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
+ -> Data Node Scan on "__REMOTE_GROUP_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(tenk1.unique2) + 1))
+ Sort Key: ((max((max(tenk1.unique2))) + 1))
-> Aggregate
- -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_"
+ -> Data Node Scan on "__REMOTE_GROUP_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 tenk1 "_REMOTE_TABLE_QUERY_"
+ -> Data Node Scan on "__REMOTE_GROUP_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 a90ba10273..a988866e31 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 (val2) val, val2 from tab1_hash where val2 = 8;
- QUERY PLAN
-------------------------------------------------------------------------
+explain (costs off, verbose on, nodes off) select distinct on (val2) val, val2 from tab1_hash where val2 = 8;
+ QUERY PLAN
+-----------------------------------------------------------------------------
Unique
- Output: tab1_hash.val2, tab1_hash.val2
+ Output: tab1_hash.val, tab1_hash.val2
-> Data Node Scan on tab1_hash "_REMOTE_TABLE_QUERY_"
- Output: tab1_hash.val2, tab1_hash.val2
- Remote query: SELECT val2 FROM ONLY tab1_hash WHERE (val2 = 8)
+ Output: tab1_hash.val, tab1_hash.val2
+ Remote query: SELECT val, 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 f2122c1cea..36127d1e0e 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 * from (select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2) q order by q.val2;
+select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2;
count | sum | avg | ?column? | val2
-------+-----+--------------------+------------------+------
3 | 6 | 2.0000000000000000 | 2 | 1
@@ -21,21 +21,18 @@ select * from (select count(*), sum(val), avg(val), sum(val)::float8/count(*), v
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(3 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)
+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)
-- joins and group by
-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;
+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;
count | sum | avg | ?column? | gt1_val2 | gt2_val2
-------+-----+---------------------+------------------+----------+----------
9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1
@@ -44,16 +41,16 @@ select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val),
3 | | | | | 4
(4 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 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
+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
-> Hash Full Join
- Output: xc_groupby_tab1.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2, xc_groupby_tab2.val
+ Output: xc_groupby_tab1.val2, xc_groupby_tab2.val2, xc_groupby_tab1.val, 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
@@ -91,7 +88,7 @@ explain (verbose true, costs false, nodes false) select sum(y) from (select sum(
(12 rows)
-- group by without aggregate
-select * from (select val2 from xc_groupby_tab1 group by val2) q order by q.val2;
+select val2 from xc_groupby_tab1 group by val2 order by val2;
val2
------
1
@@ -99,20 +96,17 @@ select * from (select val2 from xc_groupby_tab1 group by val2) q order by q.val2
3
(3 rows)
-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
+explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2;
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------
+ Group
Output: xc_groupby_tab1.val2
- Sort Key: xc_groupby_tab1.val2
- -> HashAggregate
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_groupby_tab1.val2
- -> 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)
+ Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
+(5 rows)
-select * from (select val + val2 from xc_groupby_tab1 group by val + val2) q order by 1;
+select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2;
?column?
----------
2
@@ -123,20 +117,17 @@ select * from (select val + val2 from xc_groupby_tab1 group by val + val2) q ord
9
(6 rows)
-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
+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
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
- Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
- -> HashAggregate
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
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)
+ Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2)
+(5 rows)
-select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2;
+select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2;
?column? | val | val2
----------+-----+------
2 | 1 | 1
@@ -149,20 +140,15 @@ select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, v
9 | 6 | 3
(8 rows)
-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
+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__"
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
- 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)
+ Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2
+(3 rows)
-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 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;
?column? | gt1_val | gt2_val2
----------+---------+----------
2 | 1 | 1
@@ -173,20 +159,15 @@ select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab
6 | 4 | 2
(6 rows)
-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
+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__"
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
- 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)
+ 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)
-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;
+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;
?column?
----------
2
@@ -195,21 +176,18 @@ select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby
7
(4 rows)
-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
+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
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
- Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
- -> HashAggregate
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
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)
+ 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 * from (select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2) q order by q.val2;
+select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2;
?column? | val2
---------------------+------
11.0000000000000000 | 1
@@ -217,21 +195,18 @@ select * from (select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1
17.6666666666666667 | 3
(3 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)
+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)
-- group by with expressions in group by clause
-select * from (select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2) q order by q.expr;
+select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2 order by expr;
sum | avg | expr
-----+--------------------+------
6 | 2.0000000000000000 | 2
@@ -239,18 +214,15 @@ select * from (select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 gro
11 | 3.6666666666666667 | 6
(3 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)
+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)
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -269,7 +241,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 * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
+select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
avg | sum | count | b
--------------------+-----+-------+-------
| | 1 | One
@@ -278,20 +250,17 @@ select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b
4.0000000000000000 | 8 | 3 |
(4 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)
+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)
-select * from (select 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;
b
-------
One
@@ -300,20 +269,17 @@ select * from (select b from xc_groupby_def group by b) q order by q.b;
(4 rows)
-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
+explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------
+ Group
Output: xc_groupby_def.b
- Sort Key: xc_groupby_def.b
- -> HashAggregate
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
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)
+ Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
+(5 rows)
-select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b;
+select b,count(b) from xc_groupby_def group by b order by b;
b | count
-------+-------
One | 1
@@ -322,18 +288,15 @@ select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b;
| 0
(4 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)
+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)
select count(*) from xc_groupby_def where b is null group by b;
count
@@ -355,106 +318,104 @@ 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;
+select sum(a) from xc_groupby_g group by a order by a;
sum
-----
2
2
(2 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)
+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)
-select sum(b) from xc_groupby_g group by b;
+select sum(b) from xc_groupby_g group by b order by b;
sum
-----
- 2.3
4.2
+ 2.3
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b;
- QUERY PLAN
--------------------------------------------------------------------------------------
- HashAggregate
+explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order 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
+ 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;
+select sum(c) from xc_groupby_g group by b order by b;
sum
-----
- 5.2
6.4
+ 5.2
(2 rows)
-explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b;
- QUERY PLAN
--------------------------------------------------------------------------------------
- HashAggregate
+explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order 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
+ 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;
+select avg(a) from xc_groupby_g group by b order by b;
avg
------------------------
- 2.0000000000000000
1.00000000000000000000
+ 2.0000000000000000
(2 rows)
-explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b;
- QUERY PLAN
--------------------------------------------------------------------------------------
- HashAggregate
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order 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
+ 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;
+select avg(b) from xc_groupby_g group by c order by c;
avg
-----
- 2.3
2.1
+ 2.3
(2 rows)
-explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c;
- QUERY PLAN
--------------------------------------------------------------------------------------
- HashAggregate
+explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order 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
+ 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;
+select avg(c) from xc_groupby_g group by c order by c;
avg
--------------------
- 5.2000000000000000
3.2000000000000000
+ 5.2000000000000000
(2 rows)
-explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c;
- QUERY PLAN
--------------------------------------------------------------------------------------
- HashAggregate
+explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order 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
+ 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;
@@ -466,7 +427,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;
+select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2;
count | sum | avg | ?column? | val2
-------+-----+--------------------+------------------+------
3 | 6 | 2.0000000000000000 | 2 | 1
@@ -474,18 +435,16 @@ 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;
- 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)
+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)
-- joins and group by
-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;
+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;
count | sum | avg | ?column? | c1 | c2
-------+-----+---------------------+------------------+----+----
9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1
@@ -494,46 +453,37 @@ select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val),
3 | | | | | 4
(4 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)
+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)
-- aggregates over aggregates
-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;
+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;
sum
-----
8
17
(2 rows)
-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
-------------------------------------------------------------------------------------------------------------------------------
+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
+------------------------------------------------------------------------------------------------------------------
Sort
- 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)
+ 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)
-- group by without aggregate
-select val2 from xc_groupby_tab1 group by val2;
+select val2 from xc_groupby_tab1 group by val2 order by val2;
val2
------
1
@@ -541,17 +491,15 @@ select val2 from xc_groupby_tab1 group by val2;
3
(3 rows)
-explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
- QUERY PLAN
---------------------------------------------------------------------------------------
- HashAggregate
+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__"
Output: xc_groupby_tab1.val2
- -> 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)
+ Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
+(3 rows)
-select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum;
+select val + val2 sum from xc_groupby_tab1 group by val + val2 order by sum;
sum
-----
2
@@ -562,20 +510,15 @@ select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q
9
(6 rows)
-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
+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__"
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
- 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)
+ Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2)
+(3 rows)
-select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2;
+select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2;
?column? | val | val2
----------+-----+------
2 | 1 | 1
@@ -588,20 +531,15 @@ select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, v
9 | 6 | 3
(8 rows)
-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
+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__"
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
- 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)
+ Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2
+(3 rows)
-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 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;
?column? | val | val2
----------+-----+------
2 | 1 | 1
@@ -612,20 +550,15 @@ select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab
6 | 4 | 2
(6 rows)
-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
+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__"
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
- 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)
+ 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)
-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;
+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;
sum
-----
2
@@ -634,21 +567,16 @@ select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_gro
7
(4 rows)
-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
+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__"
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
- 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)
+ 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)
-- group by with aggregates in expression
-select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
+select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by 1;
?column? | val2
---------------------+------
11.0000000000000000 | 1
@@ -656,34 +584,33 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
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;
- 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
+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)))
-> 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)
+ 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)
-- group by with expressions in group by clause
-select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
+select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order 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;
- 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)
+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)
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -702,7 +629,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 * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
+select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
avg | sum | count | b
--------------------+-----+-------+-------
| | 1 | One
@@ -711,20 +638,15 @@ select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b
4.0000000000000000 | 8 | 3 |
(4 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)
+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)
-select * from (select 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;
b
-------
One
@@ -733,20 +655,15 @@ select * from (select b from xc_groupby_def group by b) q order by q.b;
(4 rows)
-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
+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__"
Output: xc_groupby_def.b
- 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)
+ Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
+(3 rows)
-select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b;
+select b,count(b) from xc_groupby_def group by b order by b;
b | count
-------+-------
One | 1
@@ -755,18 +672,13 @@ select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b;
| 0
(4 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)
+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)
select count(*) from xc_groupby_def where b is null group by b;
count
@@ -775,120 +687,106 @@ 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
-------------------------------------------------------------------------------------------------
- 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)
+ 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)
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;
+select sum(a) from xc_groupby_g group by a order by a;
sum
-----
2
2
(2 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)
+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)
-select sum(b) from xc_groupby_g group by b;
+select sum(b) from xc_groupby_g group by b order by b;
sum
-----
- 2.3
4.2
+ 2.3
(2 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)
+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)
-select sum(c) from xc_groupby_g group by b;
+select sum(c) from xc_groupby_g group by b order by b;
sum
-----
- 5.2
6.4
+ 5.2
(2 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)
+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)
-select avg(a) from xc_groupby_g group by b;
+select avg(a) from xc_groupby_g group by b order by b;
avg
------------------------
- 2.0000000000000000
1.00000000000000000000
+ 2.0000000000000000
(2 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)
+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)
-select avg(b) from xc_groupby_g group by c;
+select avg(b) from xc_groupby_g group by c order by c;
avg
-----
- 2.3
2.1
+ 2.3
(2 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)
+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)
-select avg(c) from xc_groupby_g group by c;
+select avg(c) from xc_groupby_g group by c order by c;
avg
--------------------
- 5.2000000000000000
3.2000000000000000
+ 5.2000000000000000
(2 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)
+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)
drop table xc_groupby_def;
drop table xc_groupby_g;
@@ -975,7 +873,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;
+select val2 from xc_groupby_tab1 group by val2 order by val2;
val2
------
1
@@ -983,7 +881,7 @@ select val2 from xc_groupby_tab1 group by val2;
3
(3 rows)
-explain (verbose true, costs false, nodes false) 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 order by val2;
QUERY PLAN
----------------------------------------------------------------------------------------------------
Group
@@ -1028,14 +926,12 @@ 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
----------------------------------------------------------------------------------------------------------------------------------
- Group
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------
+ Data Node Scan on "__REMOTE_GROUP_QUERY__"
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 ORDER BY val, val2
-(5 rows)
+ Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2
+(3 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
@@ -1049,14 +945,12 @@ 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
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Group
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Data Node Scan on "__REMOTE_GROUP_QUERY__"
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 ORDER BY l.a_1, r.a_1
-(5 rows)
+ 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)
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?
@@ -1078,7 +972,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;
+select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2;
?column? | val2
---------------------+------
11.0000000000000000 | 1
@@ -1086,7 +980,7 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
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;
+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
@@ -1097,7 +991,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;
+select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2;
sum | avg | ?column?
-----+--------------------+----------
6 | 2.0000000000000000 | 2
@@ -1105,7 +999,7 @@ select sum(val), avg(val), 2 * val2 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 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 order by 2 * val2;
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------
GroupAggregate
@@ -1132,7 +1026,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 * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
+select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
avg | sum | count | b
--------------------+-----+-------+-------
| | 1 | One
@@ -1141,7 +1035,7 @@ select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b
4.0000000000000000 | 8 | 3 |
(4 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;
+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
@@ -1151,7 +1045,7 @@ explain (verbose true, costs false, nodes false) select * from (select avg(a), s
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;
+select b from xc_groupby_def group by b order by b;
b
-------
One
@@ -1160,7 +1054,7 @@ select b from xc_groupby_def group by b;
(4 rows)
-explain (verbose true, costs false, nodes false) 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 order by b;
QUERY PLAN
------------------------------------------------------------------------------------------
Group
@@ -1170,7 +1064,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;
+select b,count(b) from xc_groupby_def group by b order by b;
b | count
-------+-------
One | 1
@@ -1179,7 +1073,7 @@ select b,count(b) from xc_groupby_def group by b;
| 0
(4 rows)
-explain (verbose true, costs false, nodes false) 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 order by b;
QUERY PLAN
----------------------------------------------------------------------------------------------------
GroupAggregate
@@ -1209,31 +1103,29 @@ 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;
+select sum(a) from xc_groupby_g group by a order by a;
sum
-----
2
2
(2 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)
+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)
-select sum(b) from xc_groupby_g group by b;
+select sum(b) from xc_groupby_g group by b order 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;
+explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b;
QUERY PLAN
------------------------------------------------------------------------------------------------
GroupAggregate
@@ -1243,14 +1135,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;
+select sum(c) from xc_groupby_g group by b order 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;
+explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b;
QUERY PLAN
------------------------------------------------------------------------------------------------
GroupAggregate
@@ -1260,14 +1152,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;
+select avg(a) from xc_groupby_g group by b order 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;
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b;
QUERY PLAN
------------------------------------------------------------------------------------------------
GroupAggregate
@@ -1277,14 +1169,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;
+select avg(b) from xc_groupby_g group by c order 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;
+explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c;
QUERY PLAN
------------------------------------------------------------------------------------------------
GroupAggregate
@@ -1294,14 +1186,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;
+select avg(c) from xc_groupby_g group by c order 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;
+explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c;
QUERY PLAN
------------------------------------------------------------------------------------------------
GroupAggregate
@@ -1320,7 +1212,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;
+select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2;
count | sum | avg | ?column? | val2
-------+-----+--------------------+------------------+------
3 | 6 | 2.0000000000000000 | 2 | 1
@@ -1328,18 +1220,16 @@ 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;
- 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 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)
-- 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;
+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;
count | sum | avg | ?column? | val2 | val2
-------+-----+---------------------+------------------+------+------
9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1
@@ -1348,27 +1238,25 @@ 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;
- 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)
+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)
-- 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;
+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;
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;
- 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 order by x;
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------------------------
GroupAggregate
Output: sum(q1.y), q1.x
-> Sort
@@ -1376,15 +1264,13 @@ 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
- -> 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)
+ -> 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)
-- group by without aggregate
-select val2 from xc_groupby_tab1 group by val2;
+select val2 from xc_groupby_tab1 group by val2 order by val2;
val2
------
1
@@ -1392,17 +1278,15 @@ select val2 from xc_groupby_tab1 group by val2;
3
(3 rows)
-explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
- QUERY PLAN
-----------------------------------------------------------------------------------------------------
- Group
+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__"
Output: xc_groupby_tab1.val2
- -> 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)
+ Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2
+(3 rows)
-select val + val2 from xc_groupby_tab1 group by val + val2;
+select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2;
?column?
----------
2
@@ -1413,17 +1297,15 @@ select val + val2 from xc_groupby_tab1 group by val + val2;
9
(6 rows)
-explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2;
- QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------
- Group
+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__"
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) ORDER BY (val + val2)
-(5 rows)
+ Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2)
+(3 rows)
-select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
+select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2;
?column? | val | val2
----------+-----+------
2 | 1 | 1
@@ -1436,17 +1318,15 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
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;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------
- Group
+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__"
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 ORDER BY val, val2
-(5 rows)
+ Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2
+(3 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;
+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;
?column? | val | val2
----------+-----+------
2 | 1 | 1
@@ -1457,17 +1337,15 @@ 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;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Group
+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__"
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 ORDER BY l.a_1, r.a_1
-(5 rows)
+ 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)
-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;
+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;
?column?
----------
2
@@ -1476,18 +1354,16 @@ 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;
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- Group
+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__"
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) ORDER BY (l.a_1 + r.a_1)
-(5 rows)
+ 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)
-- group by with aggregates in expression
-select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
+select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2;
?column? | val2
---------------------+------
11.0000000000000000 | 1
@@ -1495,18 +1371,16 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
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;
- 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 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)
-- group by with expressions in group by clause
-select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
+select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2;
sum | avg | ?column?
-----+--------------------+----------
6 | 2.0000000000000000 | 2
@@ -1514,15 +1388,13 @@ select sum(val), avg(val), 2 * val2 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 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)
+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)
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -1541,7 +1413,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 * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b;
+select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b;
avg | sum | count | b
--------------------+-----+-------+-------
| | 1 | One
@@ -1550,17 +1422,15 @@ select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b
4.0000000000000000 | 8 | 3 |
(4 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;
+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)
+ 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)
-select b from xc_groupby_def group by b;
+select b from xc_groupby_def group by b order by b;
b
-------
One
@@ -1569,17 +1439,15 @@ select b from xc_groupby_def group by b;
(4 rows)
-explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b;
- QUERY PLAN
-------------------------------------------------------------------------------------------
- Group
+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__"
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 ORDER BY b
-(5 rows)
+ Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b
+(3 rows)
-select b,count(b) from xc_groupby_def group by b;
+select b,count(b) from xc_groupby_def group by b order by b;
b | count
-------+-------
One | 1
@@ -1588,15 +1456,13 @@ select b,count(b) from xc_groupby_def group by b;
| 0
(4 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)
+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)
select count(*) from xc_groupby_def where b is null group by b;
count
@@ -1605,120 +1471,106 @@ 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
------------------------------------------------------------------------------------------------------------
- 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)
+ 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)
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;
+select sum(a) from xc_groupby_g group by a order by a;
sum
-----
2
2
(2 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)
+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)
-select sum(b) from xc_groupby_g group by b;
+select sum(b) from xc_groupby_g group by b order 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;
- 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)
+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)
-select sum(c) from xc_groupby_g group by b;
+select sum(c) from xc_groupby_g group by b order 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;
- 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)
+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)
-select avg(a) from xc_groupby_g group by b;
+select avg(a) from xc_groupby_g group by b order 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;
- 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)
+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)
-select avg(b) from xc_groupby_g group by c;
+select avg(b) from xc_groupby_g group by c order 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;
- 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)
+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)
-select avg(c) from xc_groupby_g group by c;
+select avg(c) from xc_groupby_g group by c order 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;
- 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)
+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)
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 8ff190a121..d5bbdaafa1 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;
+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;
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;
+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
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate
+ 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
+ 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;
@@ -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 * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum;
+select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum;
sum
-----
4
@@ -134,19 +134,16 @@ select * from (select val + val2 sum from xc_having_tab1 group by val + val2 hav
9
(3 rows)
-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
+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
Output: ((xc_having_tab1.val + xc_having_tab1.val2))
- 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)
+ 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;
@@ -183,14 +180,12 @@ 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
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- 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)
+ 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)
-- 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;
@@ -200,33 +195,27 @@ 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
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- 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)
+ 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)
-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 or val2 > 2 order by val2;
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;
- 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)
+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)
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
@@ -236,13 +225,10 @@ 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
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- 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)
+ 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)
-- 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;
@@ -252,14 +238,12 @@ 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
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- 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)
+ 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)
-- group by and having, without aggregate in the target list
select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -269,17 +253,14 @@ 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
------------------------------------------------------------------------------------------------
- HashAggregate
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------
+ Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_having_tab1.val2
- 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)
+ Remote query: SELECT val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (sum(val) > 8)
+(3 rows)
-select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum;
+select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum;
sum
-----
4
@@ -287,19 +268,13 @@ select * from (select val + val2 sum from xc_having_tab1 group by val + val2 hav
9
(3 rows)
-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
+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__"
Output: ((xc_having_tab1.val + xc_having_tab1.val2))
- 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)
+ 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)
-- group by with aggregates in expression
select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
@@ -309,15 +284,12 @@ 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
------------------------------------------------------------------------------------------------------------------------------------------------------------
- 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)
+ 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)
drop table xc_having_tab1;
drop table xc_having_tab2;
@@ -363,14 +335,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;
+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;
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;
+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
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
GroupAggregate
@@ -498,14 +470,12 @@ 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
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- 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)
+ 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)
-- 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;
@@ -515,33 +485,27 @@ 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
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- 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)
+ 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)
-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 or val2 > 2 order by val2;
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;
- 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)
+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)
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
@@ -549,15 +513,12 @@ 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
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- 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)
+ 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)
-- 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;
@@ -567,14 +528,12 @@ 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
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- 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)
+ 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)
-- group by and having, without aggregate in the target list
select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -584,15 +543,12 @@ 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
--------------------------------------------------------------------------------------------------------------
- GroupAggregate
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------
+ Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_having_tab1.val2
- 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)
+ Remote query: SELECT val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (sum(val) > 8) ORDER BY val2
+(3 rows)
select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
?column?
@@ -603,15 +559,12 @@ 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
--------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------
+ Data Node Scan on "__REMOTE_GROUP_QUERY__"
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)
+ 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)
-- group by with aggregates in expression
select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
@@ -621,15 +574,12 @@ 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
------------------------------------------------------------------------------------------------------------------------------------------------------------
- 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)
+ 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)
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 ee879d93f9..c348cabda1 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 (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;
-- 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 602c643258..8ef010dfc5 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 * 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;
+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;
-- joins and group by
-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;
+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;
-- 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 * 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;
+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;
-- group by with aggregates in expression
-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;
+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;
-- group by with expressions in group by clause
-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;
+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;
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -59,13 +59,12 @@ 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 * 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 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 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;
@@ -74,19 +73,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;
-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 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;
-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;
+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;
drop table xc_groupby_def;
drop table xc_groupby_g;
@@ -98,31 +97,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;
-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;
+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;
-- joins and group by
-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;
+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;
-- aggregates over aggregates
-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;
+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;
-- group by without aggregate
-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;
+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;
-- group by with aggregates in expression
-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;
+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;
-- group by with expressions in group by clause
-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;
+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;
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -142,13 +141,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 * 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 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 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 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 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;
@@ -157,19 +156,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;
-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 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;
-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;
+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;
drop table xc_groupby_def;
drop table xc_groupby_g;
@@ -191,8 +190,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;
-explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
+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;
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;
@@ -202,11 +201,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;
-explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
+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;
-- group by with expressions in group by clause
-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;
+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;
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -226,13 +225,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 * 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 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;
-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 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 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;
@@ -241,19 +240,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;
-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 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;
-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;
+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;
drop table xc_groupby_def;
drop table xc_groupby_g;
@@ -265,31 +264,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;
-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;
+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;
-- 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;
-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;
+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;
-- 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;
-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;
+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;
-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;
+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;
-- group by with aggregates in expression
-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;
+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;
-- group by with expressions in group by clause
-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;
+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;
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -309,13 +308,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 * 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 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;
-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 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 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;
@@ -324,19 +323,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;
-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;
+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;
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 061ca3ae1c..41dc79b2da 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;
-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 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 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 * 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;
+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;
-- 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;
-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 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 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 * 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;
+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;
-- 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;
-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 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 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;
-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 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 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