The commit has following changes.

1. If each group according to GROUP BY clause resides completely on a single
datanode i.e. GROUP BY has distribution column in it for distributed underlying
relation or the underlying relation is a replicated relation, finalise the
aggregates on the datanodes. There is no need for a covering Group or Agg node in
the standard planner.
2. All the optimizations related to GROUP BY and aggregation are now available
even if the query has ORDER BY or DISTINCT clauses in it. (Earlier they were
not.)

Implementation details
---------------------------------
We push aggregates to the datanodes to get transition results for each group and
then apply combination and finalization phase at the coordinator. This is done
by substituting Aggref nodes in RemoteQuery targetlist (representing results of
the datanodes aggregation) as arguments to the Aggref nodes in Agg plans and
letting set_plan_refs take care of Var substitution. But since this changed the
Aggref nodes on Agg plan it was not possible for the nodes above Agg node to
find matching Aggref nodes and thus set the plan references correctly. That's
why we were not able to use these optimizations in the presence of ORDER BY or
DISTINCT clauses which require nodes to be added on top of Agg node (if any).
Hence, moved this logic of substitution to set_plan_refs() and is applied only
for Agg node.

15 files changed, 1219 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 97ec9f183e..ec65956ebd 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;
 
@@ -1372,44 +1399,74 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan)
 		}
 	}
 
+	if (pgxc_query_has_distcolgrouping(query) ||
+		list_length(remote_scan->exec_nodes->nodeList) == 1)
+		single_node_grouping = true;
+	/*
+	 * If we are able to completely evaluate the aggregates on datanodes, we
+	 * need to ask datanode/s to finalise the aggregates
+	 */
+	remote_scan->remote_query->qry_finalise_aggs = single_node_grouping;
+
 	/*
-	 * process the targetlist of the grouping plan, also construct the
-	 * targetlist of the query to be shipped to the remote side
+	 * Build the targetlist of the query plan.
 	 */
-	base_tlist = pgxc_process_grouping_targetlist(root, &(local_plan->targetlist));
+	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 +1507,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 +1542,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 +1612,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 +1749,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 +1770,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 +1802,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 44937bafaf..4f8fc65c81 100644
--- a/src/backend/optimizer/util/pgxcship.c
+++ b/src/backend/optimizer/util/pgxcship.c
@@ -113,10 +113,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.
@@ -480,7 +478,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;
@@ -739,6 +737,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;
@@ -1216,9 +1222,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 0f960e1a5a..a14a08d74e 100644
--- a/src/include/optimizer/pgxcship.h
+++ b/src/include/optimizer/pgxcship.h
@@ -33,5 +33,6 @@ extern bool pgxc_qual_has_dist_equijoin(Relids varnos_1,
 /* Merge given execution nodes based on join shippability conditions */
 extern ExecNodes *pgxc_merge_exec_nodes(ExecNodes *en1,
 	ExecNodes *en2, bool merge_dist_equijoin, bool merge_replicated_only);
+extern bool pgxc_query_has_distcolgrouping(Query *query);
 
 #endif
diff --git a/src/test/regress/expected/aggregates.out b/src/test/regress/expected/aggregates.out
index 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