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.
author: Michael Paquier 2012-10-16 08:21:57 +0000
committer: Michael Paquier 2012-10-16 08:21:57 +0000
commit: 9ce38d3bf64c17155a0ca283c56987b7ecd9e218 (patch)
tree: 4344b21b1f54eb86b22710283ce86adc427ba5d2
parent: 945f83fc5d5b2ef1d51438a7dd48dd9532c9d936 (diff)
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
author	Michael Paquier	2012-10-16 08:21:57 +0000
committer	Michael Paquier	2012-10-16 08:21:57 +0000
commit	9ce38d3bf64c17155a0ca283c56987b7ecd9e218 (patch)
tree	4344b21b1f54eb86b22710283ce86adc427ba5d2
parent	945f83fc5d5b2ef1d51438a7dd48dd9532c9d936 (diff)