Revert "The commit has following changes: GROUP BY optimization patch"

This reverts commit 66c17a5a348a4ed09859be3c45c64e9a99cc2d49.
This patch basically broke HEAD for aggregate pushdown, so
reverting it is the right thing to do to keep a master version
stable.

15 files changed, 1287 insertions, 1219 deletions

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