In EXPLAIN command provide following boolean options

1. nodes - to display (data)nodes involved in execution of the RemoteQuery node 2. num_nodes - to display number of (data)nodes involved in execution of RemoteQuery node. In EXPLAIN output for RemoteQuery node, add following 1. Remote query in the RemoteQuery node if verbose is true 2. Names of the (data)nodes in RemoteQuery node, if option nodes is true 3. Number of (data)nodes in RemoteQuery node, if option num_nodes is true Instead of "Filters", for RemoteQuery quals are labeled as "Coordinator quals" since they are applied on coordinator. Changed the aliases used for RTE entry corresponding to the RemoteQuery node to reflect the place where the RemoteQuery node was created. Changed the expected outputs and documentation accordingly.
author: Ashutosh Bapat 2012-01-05 09:46:32 +0000
committer: Ashutosh Bapat 2012-01-05 09:46:32 +0000
commit: 4934c89f160e3c174cec0c3eaef279f458811bb3 (patch)
tree: e362caa382ae8158e89b504bc147e4c428693ae9
parent: 96fa07124d40d112563b635e5ce231dedc209d46 (diff)
11 files changed, 1332 insertions, 1157 deletions
diff --git a/doc-xc/src/sgml/ref/explain.sgmlin b/doc-xc/src/sgml/ref/explain.sgmlin
index 4c5e0b617d..24eae5c167 100644
--- a/doc-xc/src/sgml/ref/explain.sgmlin
+++ b/doc-xc/src/sgml/ref/explain.sgmlin
@@ -40,6 +40,8 @@ EXPLAIN [ ANALYZE ] [ VERBOSE ] <replaceable class="parameter">statement</replac
     VERBOSE [ <replaceable class="parameter">boolean</replaceable> ]
     COSTS [ <replaceable class="parameter">boolean</replaceable> ]
     BUFFERS [ <replaceable class="parameter">boolean</replaceable> ]
+    NODES [ <replaceable class="parameter">boolean</replaceable> ]
+    NUM_NODES [ <replaceable class="parameter">boolean</replaceable> ]
     FORMAT { TEXT | XML | JSON | YAML }
 </synopsis>
  </refsynopsisdiv>
@@ -179,6 +181,28 @@ ROLLBACK;
    </varlistentry>
 
    <varlistentry>
+    <term><literal>NODES</literal></term>
+    <listitem>
+     <para>
+      Include information on the datanodes involved in the execution of Data
+	  Scan Node. This parameter defaults to <literal>TRUE</literal>. This option
+	  is available in <productname>Postgres-XC</productname>.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term><literal>NUM_NODES</literal></term>
+    <listitem>
+     <para>
+      Include information on the number of nodes involved in the execution of
+	  Data Node Scan node.  This parameter defaults to <literal>FALSE</literal>.
+	  This option is available in <productname>Postgres-XC</productname>.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
     <term><literal>FORMAT</literal></term>
     <listitem>
      <para>
diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 887e0c61b7..31205fccdb 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -16,6 +16,7 @@
 #include "access/xact.h"
 #include "catalog/pg_constraint.h"
 #include "catalog/pg_type.h"
+#include "catalog/pgxc_node.h"
 #include "commands/defrem.h"
 #include "commands/explain.h"
 #include "commands/prepare.h"
@@ -135,6 +136,12 @@ ExplainQuery(ExplainStmt *stmt, const char *queryString,
 			es.costs = defGetBoolean(opt);
 		else if (strcmp(opt->defname, "buffers") == 0)
 			es.buffers = defGetBoolean(opt);
+#ifdef PGXC
+		else if (strcmp(opt->defname, "nodes") == 0)
+			es.nodes = defGetBoolean(opt);
+		else if (strcmp(opt->defname, "num_nodes") == 0)
+			es.num_nodes = defGetBoolean(opt);
+#endif /* PGXC */
 		else if (strcmp(opt->defname, "format") == 0)
 		{
 			char	   *p = defGetString(opt);
@@ -231,6 +238,9 @@ ExplainInitState(ExplainState *es)
 	/* Set default options. */
 	memset(es, 0, sizeof(ExplainState));
 	es->costs = true;
+#ifdef PGXC
+	es->nodes = true;
+#endif /* PGXC */
 	/* Prepare output buffer. */
 	es->str = makeStringInfo();
 }
@@ -848,29 +858,23 @@ ExplainNode(PlanState *planstate, List *ancestors,
 			break;
 #ifdef PGXC
 		case T_RemoteQuery:
+			if (es->num_nodes)
 			{
-				RemoteQuery *remote_query = (RemoteQuery *) plan;
-				int pnc, nc;
-	
-				pnc = 0;
-				nc = 0;
-				if (remote_query->exec_nodes != NULL)
+				ExecNodes *en = ((RemoteQuery *)plan)->exec_nodes;
+				int primary_node_count = en ? list_length(en->primarynodelist) : 0;
+				int node_count = en ? list_length(en->nodeList) : 0;
+				if (es->format == EXPLAIN_FORMAT_TEXT)
+					appendStringInfo(es->str, " (primary node count=%d, node count=%d)",
+										primary_node_count, node_count);
+				else
 				{
-					if (remote_query->exec_nodes->primarynodelist != NULL)
-					{
-						pnc = list_length(remote_query->exec_nodes->primarynodelist);
-						appendStringInfo(es->str, " (Primary Node Count [%d])", pnc);
-					}
-					if (remote_query->exec_nodes->nodeList)
-					{
-						nc = list_length(remote_query->exec_nodes->nodeList);
-						appendStringInfo(es->str, " (Node Count [%d])", nc);
-					}
+					ExplainPropertyInteger("Primary node count", primary_node_count, es);
+					ExplainPropertyInteger("Node count", node_count, es);
 				}
-#endif
-				ExplainScanTarget((Scan *) plan, es);
 			}
+			ExplainScanTarget((Scan *) plan, es);
 			break;
+#endif
 		case T_BitmapIndexScan:
 			{
 				BitmapIndexScan *bitmapindexscan = (BitmapIndexScan *) plan;
@@ -1043,6 +1047,50 @@ ExplainNode(PlanState *planstate, List *ancestors,
 			show_scan_qual(((BitmapIndexScan *) plan)->indexqualorig,
 						   "Index Cond", planstate, ancestors, es);
 			break;
+#ifdef PGXC
+		case T_RemoteQuery:
+			{
+				RemoteQuery *remote_query = (RemoteQuery *) plan;
+				/* add names of the nodes if they exist */
+				if (remote_query->exec_nodes && es->nodes)
+				{
+					StringInfo node_names = makeStringInfo();
+					ListCell *lcell;
+					char	*sep;
+					int		node_no;
+					if (remote_query->exec_nodes->primarynodelist)
+					{
+						sep = "";
+						foreach(lcell, remote_query->exec_nodes->primarynodelist)
+						{
+							node_no = lfirst_int(lcell);
+							appendStringInfo(node_names, "%s%s", sep,
+												get_pgxc_nodename(PGXCNodeGetNodeOid(node_no, PGXC_NODE_DATANODE)));
+							sep = ", ";
+						}
+						ExplainPropertyText("Primary node/s", node_names->data, es);
+					}
+					if (remote_query->exec_nodes->nodeList)
+					{
+						resetStringInfo(node_names);
+						sep = "";
+						foreach(lcell, remote_query->exec_nodes->nodeList)
+						{
+							node_no = lfirst_int(lcell);
+							appendStringInfo(node_names, "%s%s", sep,
+												get_pgxc_nodename(PGXCNodeGetNodeOid(node_no, PGXC_NODE_DATANODE)));
+							sep = ", ";
+						}
+						ExplainPropertyText("Node/s", node_names->data, es);
+					}
+				}
+			}
+			if (es->verbose)
+				ExplainPropertyText("Remote query",
+									((RemoteQuery *)plan)->sql_statement, es);
+			show_scan_qual(plan->qual, "Coordinator quals", planstate, ancestors, es);
+			break;
+#endif
 		case T_BitmapHeapScan:
 			show_scan_qual(((BitmapHeapScan *) plan)->bitmapqualorig,
 						   "Recheck Cond", planstate, ancestors, es);
@@ -1051,9 +1099,6 @@ ExplainNode(PlanState *planstate, List *ancestors,
 		case T_ValuesScan:
 		case T_CteScan:
 		case T_WorkTableScan:
-#ifdef PGXC
-		case T_RemoteQuery:
-#endif
 		case T_SubqueryScan:
 			show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
 			break;
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 57420d589a..382e56888c 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -965,8 +965,8 @@ create_remotejoin_plan(PlannerInfo *root, JoinPath *best_path, Plan *parent, Pla
 			dummy_rte->rtekind = RTE_RELATION;
 
 			/* use a dummy relname... */
-			dummy_rte->relname	   = "__FOREIGN_QUERY__";
-			dummy_rte->eref		   = makeAlias("__FOREIGN_QUERY__", NIL);
+			dummy_rte->relname	   = "__REMOTE_JOIN_QUERY__";
+			dummy_rte->eref		   = makeAlias("__REMOTE_JOIN_QUERY__", NIL);
 			/* not sure if we need to set the below explicitly.. */
 			dummy_rte->inh			 = false;
 			dummy_rte->inFromCl		 = false;
@@ -1022,7 +1022,7 @@ create_remotejoin_plan(PlannerInfo *root, JoinPath *best_path, Plan *parent, Pla
 
 			/* set_plan_refs needs this later */
 			result->base_tlist		= base_tlist;
-			result->relname			= "__FOREIGN_QUERY__";
+			result->relname			= "__REMOTE_JOIN_QUERY__";
 			result->partitioned_replicated = join_info.partitioned_replicated;
 
 			/*
@@ -6090,8 +6090,8 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan)
 	dummy_rte->rtekind = RTE_RELATION;
 
 	/* Use a dummy relname... */
-	dummy_rte->relname	   = "__FOREIGN_QUERY__";
-	dummy_rte->eref		   = makeAlias("__FOREIGN_QUERY__", NIL);
+	dummy_rte->relname	   = "__REMOTE_GROUP_QUERY__";
+	dummy_rte->eref		   = makeAlias("__REMOTE_GROUP_QUERY__", NIL);
 
 	/* Rest will be zeroed out in makeNode() */
 	root->parse->rtable = lappend(root->parse->rtable, dummy_rte);
@@ -6108,7 +6108,7 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan)
 	remote_group->sql_statement = remote_sql_stmt->data;
 
 	/* set_plan_refs needs this later */
-	remote_group->relname			= "__FOREIGN_QUERY__";
+	remote_group->relname			= "__REMOTE_GROUP_QUERY__";
 	remote_group->partitioned_replicated = remote_scan->partitioned_replicated;
 	remote_group->read_only = query->commandType == CMD_SELECT;
 
diff --git a/src/backend/pgxc/pool/pgxcnode.c b/src/backend/pgxc/pool/pgxcnode.c
index 423928028c..8df0817972 100644
--- a/src/backend/pgxc/pool/pgxcnode.c
+++ b/src/backend/pgxc/pool/pgxcnode.c
@@ -2275,7 +2275,7 @@ PGXCNodeGetNodeOid(int nodeid, char node_type)
 			return InvalidOid;
 	}
 
-	return handles[nodeid - 1].nodeoid;
+	return handles[nodeid].nodeoid;
 }
 
 /*
diff --git a/src/include/commands/explain.h b/src/include/commands/explain.h
index d7998c3178..84a73f9dec 100644
--- a/src/include/commands/explain.h
+++ b/src/include/commands/explain.h
@@ -31,6 +31,10 @@ typedef struct ExplainState
 	bool		analyze;		/* print actual times */
 	bool		costs;			/* print costs */
 	bool		buffers;		/* print buffer usage */
+#ifdef PGXC
+	bool		nodes;			/* print nodes in RemoteQuery node */
+	bool		num_nodes;		/* print number of nodes in RemoteQuery node */
+#endif /* PGXC */
 	ExplainFormat format;		/* output format */
 	/* other states */
 	PlannedStmt *pstmt;			/* top of plan */
diff --git a/src/test/regress/expected/xc_distkey.out b/src/test/regress/expected/xc_distkey.out
index 461f779e2b..6b6cd29628 100644
--- a/src/test/regress/expected/xc_distkey.out
+++ b/src/test/regress/expected/xc_distkey.out
@@ -38,16 +38,16 @@ select * from nu_tab where 789.412 = a;
  789.41200
 (1 row)
 
-explain select * from nu_tab where a = 123.456;
-                            QUERY PLAN                             
--------------------------------------------------------------------
- Data Node Scan (Node Count [1])  (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from nu_tab where a = 123.456;
+                     QUERY PLAN                      
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
 (1 row)
 
-explain select * from nu_tab where 789.412 = a;
-                            QUERY PLAN                             
--------------------------------------------------------------------
- Data Node Scan (Node Count [1])  (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from nu_tab where 789.412 = a;
+                     QUERY PLAN                      
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
 (1 row)
 
 create table tx_tab(a text) distribute by modulo(a);
@@ -84,16 +84,16 @@ select * from tx_tab where 'Did the quick brown fox jump over the lazy dog?' = a
  Did the quick brown fox jump over the lazy dog?
 (1 row)
 
-explain select * from tx_tab where a = 'hello world';
-                            QUERY PLAN                             
--------------------------------------------------------------------
- Data Node Scan (Node Count [1])  (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from tx_tab where a = 'hello world';
+                     QUERY PLAN                      
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
 (1 row)
 
-explain select * from tx_tab where a = 'Did the quick brown fox jump over the lazy dog?';
-                            QUERY PLAN                             
--------------------------------------------------------------------
- Data Node Scan (Node Count [1])  (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from tx_tab where a = 'Did the quick brown fox jump over the lazy dog?';
+                     QUERY PLAN                      
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
 (1 row)
 
 create table vc_tab(a varchar(255)) distribute by modulo(a);
@@ -127,23 +127,23 @@ select * from vc_tab where 'A quick brown fox' = a;
  A quick brown fox
 (1 row)
 
-explain select * from vc_tab where a = 'abcdefghijklmnopqrstuvwxyz';
-                            QUERY PLAN                             
--------------------------------------------------------------------
- Data Node Scan (Node Count [1])  (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from vc_tab where a = 'abcdefghijklmnopqrstuvwxyz';
+                     QUERY PLAN                      
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
 (1 row)
 
-explain select * from vc_tab where a = 'A quick brown fox';
-                            QUERY PLAN                             
--------------------------------------------------------------------
- Data Node Scan (Node Count [1])  (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from vc_tab where a = 'A quick brown fox';
+                     QUERY PLAN                      
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
 (1 row)
 
 -- This test a bug in examine_conditions_walker where a = constant is optimized but constant = a was not
-explain select * from vc_tab where 'A quick brown fox' = a;
-                            QUERY PLAN                             
--------------------------------------------------------------------
- Data Node Scan (Node Count [1])  (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from vc_tab where 'A quick brown fox' = a;
+                     QUERY PLAN                      
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
 (1 row)
 
 create table f8_tab(a float8) distribute by modulo(a);
@@ -328,16 +328,16 @@ select * from i4_tab where 2147483647 = a;
  2147483647
 (1 row)
 
-explain select * from i4_tab where 65530 = a;
-                            QUERY PLAN                             
--------------------------------------------------------------------
- Data Node Scan (Node Count [1])  (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from i4_tab where 65530 = a;
+                     QUERY PLAN                      
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
 (1 row)
 
-explain select * from i4_tab where a = 2147483647;
-                            QUERY PLAN                             
--------------------------------------------------------------------
- Data Node Scan (Node Count [1])  (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from i4_tab where a = 2147483647;
+                     QUERY PLAN                      
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
 (1 row)
 
 create table bo_tab(a bool) distribute by modulo(a);
diff --git a/src/test/regress/expected/xc_groupby.out b/src/test/regress/expected/xc_groupby.out
index 36a2697cd1..13ce09e31e 100644
--- a/src/test/regress/expected/xc_groupby.out
+++ b/src/test/regress/expected/xc_groupby.out
@@ -18,16 +18,17 @@ 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 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;
                                                                                                                        QUERY PLAN                                                                                                                        
 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.03..1.05 rows=1 width=8)
+ 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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4  
+(7 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;
@@ -39,25 +40,23 @@ select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_
      3 |     |                     |                  |      |    4
 (4 rows)
 
-explain verbose 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;
                                                                                                                                 QUERY PLAN                                                                                                                                 
 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=2.08..2.10 rows=1 width=16)
+ 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  (cost=1.03..2.06 rows=1 width=16)
+   ->  Hash Full Join
          Output: xc_groupby_tab1.val, xc_groupby_tab1.val2, xc_groupby_tab2.val, xc_groupby_tab2.val2
          Hash Cond: (xc_groupby_tab1.val2 = xc_groupby_tab2.val2)
-         ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+         ->  Data Node Scan on xc_groupby_tab1
                Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
-               ->  Data Node Scan (Node Count [2]) on xc_groupby_tab1  (cost=0.00..1.01 rows=1000 width=8)
-                     Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
-         ->  Hash  (cost=1.01..1.01 rows=1 width=8)
+               Remote query: SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1
+         ->  Hash
                Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-               ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+               ->  Data Node Scan on xc_groupby_tab2
                      Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-                     ->  Data Node Scan (Node Count [2]) on xc_groupby_tab2  (cost=0.00..1.01 rows=1000 width=8)
-                           Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-(15 rows)
+                     Remote query: SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2
+(13 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;
@@ -67,18 +66,19 @@ select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by va
   17
 (2 rows)
 
-explain verbose select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
-                                                   QUERY PLAN                                                   
-----------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.05..1.06 rows=1 width=12)
+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                                                                                       
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: sum((pg_catalog.sum((sum(xc_groupby_tab1.val))))), ((xc_groupby_tab1.val2 % 2))
-   ->  HashAggregate  (cost=1.02..1.03 rows=1 width=8)
+   ->  HashAggregate
          Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
-         ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+         ->  Materialize
                Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
-               ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=8)
+               ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                      Output: sum(xc_groupby_tab1.val), (xc_groupby_tab1.val2 % 2), xc_groupby_tab1.val2
-(8 rows)
+                     Remote query: SELECT sum(group_1.val), (group_1.val2 % 2), group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3  
+(9 rows)
 
 -- group by without aggregate
 select val2 from xc_groupby_tab1 group by val2;
@@ -89,16 +89,17 @@ select val2 from xc_groupby_tab1 group by val2;
     3
 (3 rows)
 
-explain verbose select val2 from xc_groupby_tab1 group by val2;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
+                                                                QUERY PLAN                                                                 
+-------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: xc_groupby_tab1.val2
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1  
+(7 rows)
 
 select val + val2 from xc_groupby_tab1 group by val + val2;
  ?column? 
@@ -111,16 +112,17 @@ select val + val2 from xc_groupby_tab1 group by val + val2;
         2
 (6 rows)
 
-explain verbose select val + val2 from xc_groupby_tab1 group by val + val2;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2;
+                                                                        QUERY PLAN                                                                         
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2)
-(6 rows)
+               Remote query: SELECT (group_1.val + group_1.val2)  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1  
+(7 rows)
 
 select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
  ?column? | val | val2 
@@ -135,16 +137,17 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
         9 |   6 |    3
 (8 rows)
 
-explain verbose select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
-                                                  QUERY PLAN                                                   
----------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
+                                                                                       QUERY PLAN                                                                                        
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2), xc_groupby_tab1.val, xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT (group_1.val + group_1.val2), group_1.val, group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 2, 3  
+(7 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 
@@ -157,16 +160,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_group
         7 |   3 |    4
 (6 rows)
 
-explain verbose 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                                                   
----------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=0.00..0.01 rows=1 width=0)
+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                                                                                                                                                                                          
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2
-(6 rows)
+               Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1), group_2.val_1_1_1, group_2.val2_2_2_1  FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM  (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1  ,  (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1  WHERE   (in_1.val = out_1.val)) group_2 GROUP BY 2, 3  
+(7 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? 
@@ -177,16 +181,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_group
         5
 (4 rows)
 
-explain verbose 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                                   
--------------------------------------------------------------------------------
- HashAggregate  (cost=0.00..0.01 rows=1 width=0)
+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                                                                                                                                                                     
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2)
-(6 rows)
+               Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1)  FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM  (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1  ,  (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1  WHERE   (in_1.val = out_1.val)) group_2 GROUP BY 1  
+(7 rows)
 
 -- group by with aggregates in expression
 select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
@@ -197,16 +202,17 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
  17.6666666666666667 |    3
 (3 rows)
 
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
-                                                                          QUERY PLAN                                                                          
---------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.04 rows=1 width=8)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4  
+(7 rows)
 
 -- group by with expressions in group by clause
 select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
@@ -217,16 +223,17 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
    8 | 4.0000000000000000 |        4
 (3 rows)
 
-explain verbose select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
-                                                           QUERY PLAN                                                           
---------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.04 rows=1 width=8)
+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))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2))
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), (2 * xc_groupby_tab1.val2)
-(6 rows)
+               Remote query: SELECT sum(group_1.val), avg(group_1.val), (2 * group_1.val2)  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3  
+(7 rows)
 
 drop table xc_groupby_tab1;
 drop table xc_groupby_tab2;
@@ -261,21 +268,20 @@ select a,count(a) from xc_groupby_def group by a order by a;
     |     0
 (11 rows)
 
-explain verbose select a,count(a) from xc_groupby_def group by a order by a;
-                                          QUERY PLAN                                          
-----------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a;
+                                       QUERY PLAN                                        
+-----------------------------------------------------------------------------------------
+ GroupAggregate
    Output: a, count(a)
-   ->  Sort  (cost=1.02..1.03 rows=1 width=4)
+   ->  Sort
          Output: a
          Sort Key: xc_groupby_def.a
-         ->  Result  (cost=0.00..1.01 rows=1 width=4)
+         ->  Result
                Output: a
-               ->  Materialize  (cost=0.00..1.01 rows=1 width=4)
+               ->  Data Node Scan on xc_groupby_def
                      Output: a, b
-                     ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=4)
-                           Output: a, b
-(11 rows)
+                     Remote query: SELECT a, b FROM public.xc_groupby_def xc_groupby_def
+(10 rows)
 
 select avg(a) from xc_groupby_def group by a; 
           avg           
@@ -309,16 +315,17 @@ select avg(a) from xc_groupby_def group by a;
      4.0000000000000000
 (11 rows)
 
-explain verbose select avg(a) from xc_groupby_def group by a;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a;
+                                                                   QUERY PLAN                                                                    
+-------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.a
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_def.a)), xc_groupby_def.a
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_def.a), xc_groupby_def.a
-(6 rows)
+               Remote query: SELECT avg(group_1.a), group_1.a  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2  
+(7 rows)
 
 select avg(a) from xc_groupby_def group by b;
         avg         
@@ -329,16 +336,17 @@ select avg(a) from xc_groupby_def group by b;
  6.2000000000000000
 (4 rows)
 
-explain verbose select avg(a) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=72)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b;
+                                                                   QUERY PLAN                                                                    
+-------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_def.a)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=72)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT avg(group_1.a), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2  
+(7 rows)
 
 select sum(a) from xc_groupby_def group by b;
  sum 
@@ -349,16 +357,17 @@ select sum(a) from xc_groupby_def group by b;
   31
 (4 rows)
 
-explain verbose select sum(a) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=72)
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b;
+                                                                   QUERY PLAN                                                                    
+-------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: pg_catalog.sum((sum(xc_groupby_def.a))), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_def.a)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=72)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT sum(group_1.a), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2  
+(7 rows)
 
 select count(*) from xc_groupby_def group by b;
  count 
@@ -369,16 +378,17 @@ select count(*) from xc_groupby_def group by b;
      5
 (4 rows)
 
-explain verbose select count(*) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b;
+                                                                QUERY PLAN                                                                 
+-------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: pg_catalog.count(*), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT count(*), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2  
+(7 rows)
 
 select count(*) from xc_groupby_def where a is not null group by a;
  count 
@@ -395,16 +405,17 @@ select count(*) from xc_groupby_def where a is not null group by a;
      1
 (10 rows)
 
-explain verbose select count(*) from xc_groupby_def where a is not null group by a;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a;
+                                                                           QUERY PLAN                                                                            
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: pg_catalog.count(*), xc_groupby_def.a
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), xc_groupby_def.a
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), xc_groupby_def.a
-(6 rows)
+               Remote query: SELECT count(*), group_1.a  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (a IS NOT NULL)) group_1 GROUP BY 2  
+(7 rows)
 
 select b from xc_groupby_def group by b;
    b   
@@ -415,16 +426,17 @@ select b from xc_groupby_def group by b;
  Three
 (4 rows)
 
-explain verbose select b from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b;
+                                                           QUERY PLAN                                                            
+---------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_groupby_def.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1  
+(7 rows)
 
 select b,count(b) from xc_groupby_def group by b;
    b   | count 
@@ -435,16 +447,17 @@ select b,count(b) from xc_groupby_def group by b;
  Three |     5
 (4 rows)
 
-explain verbose select b,count(b) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b;
+                                                                    QUERY PLAN                                                                     
+---------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: xc_groupby_def.b, count((count(xc_groupby_def.b)))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_groupby_def.b, (count(xc_groupby_def.b))
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_groupby_def.b, count(xc_groupby_def.b)
-(6 rows)
+               Remote query: SELECT group_1.b, count(group_1.b)  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1  
+(7 rows)
 
 select count(*) from xc_groupby_def where b is null group by b;
  count 
@@ -452,16 +465,17 @@ select count(*) from xc_groupby_def where b is null group by b;
      3
 (1 row)
 
-explain verbose select count(*) from xc_groupby_def where b is null group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b;
+                                                                         QUERY PLAN                                                                          
+-------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: pg_catalog.count(*), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT count(*), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (b IS NULL)) group_1 GROUP BY 2  
+(7 rows)
 
 create table xc_groupby_g(a int, b float, c numeric);
 insert into xc_groupby_g values(1,2.1,3.2);
@@ -474,16 +488,17 @@ select sum(a) from xc_groupby_g group by a;
    2
 (2 rows)
 
-explain verbose select sum(a) from xc_groupby_g group by a;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=4)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_g.a), xc_groupby_g.a
-(6 rows)
+               Remote query: SELECT sum(group_1.a), group_1.a  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2  
+(7 rows)
 
 select sum(b) from xc_groupby_g group by b;
  sum 
@@ -492,16 +507,17 @@ select sum(b) from xc_groupby_g group by b;
  4.2
 (2 rows)
 
-explain verbose select sum(b) from xc_groupby_g group by b;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=8)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_g.b)), xc_groupby_g.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_g.b), xc_groupby_g.b
-(6 rows)
+               Remote query: SELECT sum(group_1.b), group_1.b  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2  
+(7 rows)
 
 select sum(c) from xc_groupby_g group by b;
  sum 
@@ -510,16 +526,17 @@ select sum(c) from xc_groupby_g group by b;
  6.4
 (2 rows)
 
-explain verbose select sum(c) from xc_groupby_g group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=40)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_g.c)), xc_groupby_g.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=40)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_g.c), xc_groupby_g.b
-(6 rows)
+               Remote query: SELECT sum(group_1.c), group_1.b  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2  
+(7 rows)
 
 select avg(a) from xc_groupby_g group by b;
           avg           
@@ -528,16 +545,17 @@ select avg(a) from xc_groupby_g group by b;
  1.00000000000000000000
 (2 rows)
 
-explain verbose select avg(a) from xc_groupby_g group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=12)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_g.a)), xc_groupby_g.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=12)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_g.a), xc_groupby_g.b
-(6 rows)
+               Remote query: SELECT avg(group_1.a), group_1.b  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2  
+(7 rows)
 
 select avg(b) from xc_groupby_g group by c;
  avg 
@@ -546,16 +564,17 @@ select avg(b) from xc_groupby_g group by c;
  2.1
 (2 rows)
 
-explain verbose select avg(b) from xc_groupby_g group by c;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=40)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_g.b)), xc_groupby_g.c
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=40)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_g.b), xc_groupby_g.c
-(6 rows)
+               Remote query: SELECT avg(group_1.b), group_1.c  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2  
+(7 rows)
 
 select avg(c) from xc_groupby_g group by c;
         avg         
@@ -564,16 +583,17 @@ select avg(c) from xc_groupby_g group by c;
  3.2000000000000000
 (2 rows)
 
-explain verbose select avg(c) from xc_groupby_g group by c;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=32)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_g.c)), xc_groupby_g.c
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=32)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_g.c), xc_groupby_g.c
-(6 rows)
+               Remote query: SELECT avg(group_1.c), group_1.c  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2  
+(7 rows)
 
 drop table xc_groupby_def;
 drop table xc_groupby_g;
@@ -592,16 +612,17 @@ 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 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;
                                                                                                                        QUERY PLAN                                                                                                                        
 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.03..1.05 rows=1 width=8)
+ 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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4  
+(7 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;
@@ -613,25 +634,23 @@ select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_
      3 |     |                     |                  |      |    4
 (4 rows)
 
-explain verbose 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;
                                                                                                                                 QUERY PLAN                                                                                                                                 
 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=2.08..2.10 rows=1 width=16)
+ 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  (cost=1.03..2.06 rows=1 width=16)
+   ->  Hash Full Join
          Output: xc_groupby_tab1.val, xc_groupby_tab1.val2, xc_groupby_tab2.val, xc_groupby_tab2.val2
          Hash Cond: (xc_groupby_tab1.val2 = xc_groupby_tab2.val2)
-         ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+         ->  Data Node Scan on xc_groupby_tab1
                Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
-               ->  Data Node Scan (Node Count [1]) on xc_groupby_tab1  (cost=0.00..1.01 rows=1000 width=8)
-                     Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
-         ->  Hash  (cost=1.01..1.01 rows=1 width=8)
+               Remote query: SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1
+         ->  Hash
                Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-               ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+               ->  Data Node Scan on xc_groupby_tab2
                      Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-                     ->  Data Node Scan (Node Count [1]) on xc_groupby_tab2  (cost=0.00..1.01 rows=1000 width=8)
-                           Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-(15 rows)
+                     Remote query: SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2
+(13 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;
@@ -641,18 +660,19 @@ select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by va
   17
 (2 rows)
 
-explain verbose select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
-                                                   QUERY PLAN                                                   
-----------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.05..1.06 rows=1 width=12)
+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                                                                                       
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: sum((pg_catalog.sum((sum(xc_groupby_tab1.val))))), ((xc_groupby_tab1.val2 % 2))
-   ->  HashAggregate  (cost=1.02..1.03 rows=1 width=8)
+   ->  HashAggregate
          Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
-         ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+         ->  Materialize
                Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
-               ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=8)
+               ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                      Output: sum(xc_groupby_tab1.val), (xc_groupby_tab1.val2 % 2), xc_groupby_tab1.val2
-(8 rows)
+                     Remote query: SELECT sum(group_1.val), (group_1.val2 % 2), group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3  
+(9 rows)
 
 -- group by without aggregate
 select val2 from xc_groupby_tab1 group by val2;
@@ -663,16 +683,17 @@ select val2 from xc_groupby_tab1 group by val2;
     3
 (3 rows)
 
-explain verbose select val2 from xc_groupby_tab1 group by val2;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
+                                                                QUERY PLAN                                                                 
+-------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: xc_groupby_tab1.val2
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1  
+(7 rows)
 
 select val + val2 from xc_groupby_tab1 group by val + val2;
  ?column? 
@@ -685,16 +706,17 @@ select val + val2 from xc_groupby_tab1 group by val + val2;
         2
 (6 rows)
 
-explain verbose select val + val2 from xc_groupby_tab1 group by val + val2;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2;
+                                                                        QUERY PLAN                                                                         
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2)
-(6 rows)
+               Remote query: SELECT (group_1.val + group_1.val2)  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1  
+(7 rows)
 
 select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
  ?column? | val | val2 
@@ -709,16 +731,17 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
         9 |   6 |    3
 (8 rows)
 
-explain verbose select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
-                                                  QUERY PLAN                                                   
----------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
+                                                                                       QUERY PLAN                                                                                        
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2), xc_groupby_tab1.val, xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT (group_1.val + group_1.val2), group_1.val, group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 2, 3  
+(7 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 
@@ -731,16 +754,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_group
         7 |   3 |    4
 (6 rows)
 
-explain verbose 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                                                   
----------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=0.00..0.01 rows=1 width=0)
+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                                                                                                                                                                                          
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2
-(6 rows)
+               Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1), group_2.val_1_1_1, group_2.val2_2_2_1  FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM  (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1  ,  (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1  WHERE   (in_1.val = out_1.val)) group_2 GROUP BY 2, 3  
+(7 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? 
@@ -751,16 +775,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_group
         5
 (4 rows)
 
-explain verbose 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                                   
--------------------------------------------------------------------------------
- HashAggregate  (cost=0.00..0.01 rows=1 width=0)
+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                                                                                                                                                                     
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2)
-(6 rows)
+               Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1)  FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM  (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1  ,  (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1  WHERE   (in_1.val = out_1.val)) group_2 GROUP BY 1  
+(7 rows)
 
 -- group by with aggregates in expression
 select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
@@ -771,16 +796,17 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
  17.6666666666666667 |    3
 (3 rows)
 
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
-                                                                          QUERY PLAN                                                                          
---------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.04 rows=1 width=8)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4  
+(7 rows)
 
 -- group by with expressions in group by clause
 select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
@@ -791,16 +817,17 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
    8 | 4.0000000000000000 |        4
 (3 rows)
 
-explain verbose select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
-                                                           QUERY PLAN                                                           
---------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.04 rows=1 width=8)
+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))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2))
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), (2 * xc_groupby_tab1.val2)
-(6 rows)
+               Remote query: SELECT sum(group_1.val), avg(group_1.val), (2 * group_1.val2)  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3  
+(7 rows)
 
 drop table xc_groupby_tab1;
 drop table xc_groupby_tab2;
@@ -835,21 +862,20 @@ select a,count(a) from xc_groupby_def group by a order by a;
     |     0
 (11 rows)
 
-explain verbose select a,count(a) from xc_groupby_def group by a order by a;
-                                          QUERY PLAN                                          
-----------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a;
+                                       QUERY PLAN                                        
+-----------------------------------------------------------------------------------------
+ GroupAggregate
    Output: a, count(a)
-   ->  Sort  (cost=1.02..1.03 rows=1 width=4)
+   ->  Sort
          Output: a
          Sort Key: xc_groupby_def.a
-         ->  Result  (cost=0.00..1.01 rows=1 width=4)
+         ->  Result
                Output: a
-               ->  Materialize  (cost=0.00..1.01 rows=1 width=4)
+               ->  Data Node Scan on xc_groupby_def
                      Output: a, b
-                     ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=4)
-                           Output: a, b
-(11 rows)
+                     Remote query: SELECT a, b FROM public.xc_groupby_def xc_groupby_def
+(10 rows)
 
 select avg(a) from xc_groupby_def group by a; 
           avg           
@@ -867,16 +893,17 @@ select avg(a) from xc_groupby_def group by a;
      4.0000000000000000
 (11 rows)
 
-explain verbose select avg(a) from xc_groupby_def group by a; 
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; 
+                                                                   QUERY PLAN                                                                    
+-------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.a
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_def.a)), xc_groupby_def.a
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_def.a), xc_groupby_def.a
-(6 rows)
+               Remote query: SELECT avg(group_1.a), group_1.a  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2  
+(7 rows)
 
 select avg(a) from xc_groupby_def group by a;
           avg           
@@ -894,16 +921,17 @@ select avg(a) from xc_groupby_def group by a;
      4.0000000000000000
 (11 rows)
 
-explain verbose select avg(a) from xc_groupby_def group by a;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a;
+                                                                   QUERY PLAN                                                                    
+-------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.a
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_def.a)), xc_groupby_def.a
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_def.a), xc_groupby_def.a
-(6 rows)
+               Remote query: SELECT avg(group_1.a), group_1.a  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2  
+(7 rows)
 
 select avg(a) from xc_groupby_def group by b;
         avg         
@@ -914,16 +942,17 @@ select avg(a) from xc_groupby_def group by b;
  6.2000000000000000
 (4 rows)
 
-explain verbose select avg(a) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=72)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b;
+                                                                   QUERY PLAN                                                                    
+-------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_def.a)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=72)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT avg(group_1.a), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2  
+(7 rows)
 
 select sum(a) from xc_groupby_def group by b;
  sum 
@@ -934,16 +963,17 @@ select sum(a) from xc_groupby_def group by b;
   31
 (4 rows)
 
-explain verbose select sum(a) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=72)
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b;
+                                                                   QUERY PLAN                                                                    
+-------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: pg_catalog.sum((sum(xc_groupby_def.a))), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_def.a)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=72)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT sum(group_1.a), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2  
+(7 rows)
 
 select count(*) from xc_groupby_def group by b;
  count 
@@ -954,16 +984,17 @@ select count(*) from xc_groupby_def group by b;
      5
 (4 rows)
 
-explain verbose select count(*) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b;
+                                                                QUERY PLAN                                                                 
+-------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: pg_catalog.count(*), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT count(*), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2  
+(7 rows)
 
 select count(*) from xc_groupby_def where a is not null group by a;
  count 
@@ -980,16 +1011,17 @@ select count(*) from xc_groupby_def where a is not null group by a;
      1
 (10 rows)
 
-explain verbose select count(*) from xc_groupby_def where a is not null group by a;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a;
+                                                                           QUERY PLAN                                                                            
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: pg_catalog.count(*), xc_groupby_def.a
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), xc_groupby_def.a
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), xc_groupby_def.a
-(6 rows)
+               Remote query: SELECT count(*), group_1.a  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (a IS NOT NULL)) group_1 GROUP BY 2  
+(7 rows)
 
 select b from xc_groupby_def group by b;
    b   
@@ -1000,16 +1032,17 @@ select b from xc_groupby_def group by b;
  Three
 (4 rows)
 
-explain verbose select b from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b;
+                                                           QUERY PLAN                                                            
+---------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_groupby_def.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1  
+(7 rows)
 
 select b,count(b) from xc_groupby_def group by b;
    b   | count 
@@ -1020,16 +1053,17 @@ select b,count(b) from xc_groupby_def group by b;
  Three |     5
 (4 rows)
 
-explain verbose select b,count(b) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b;
+                                                                    QUERY PLAN                                                                     
+---------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: xc_groupby_def.b, count((count(xc_groupby_def.b)))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_groupby_def.b, (count(xc_groupby_def.b))
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_groupby_def.b, count(xc_groupby_def.b)
-(6 rows)
+               Remote query: SELECT group_1.b, count(group_1.b)  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1  
+(7 rows)
 
 select count(*) from xc_groupby_def where b is null group by b;
  count 
@@ -1037,16 +1071,17 @@ select count(*) from xc_groupby_def where b is null group by b;
      3
 (1 row)
 
-explain verbose select count(*) from xc_groupby_def where b is null group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b;
+                                                                         QUERY PLAN                                                                          
+-------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: pg_catalog.count(*), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT count(*), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (b IS NULL)) group_1 GROUP BY 2  
+(7 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);
@@ -1059,16 +1094,17 @@ select sum(a) from xc_groupby_g group by a;
    2
 (2 rows)
 
-explain verbose select sum(a) from xc_groupby_g group by a;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=4)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_g.a), xc_groupby_g.a
-(6 rows)
+               Remote query: SELECT sum(group_1.a), group_1.a  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2  
+(7 rows)
 
 select sum(b) from xc_groupby_g group by b;
  sum 
@@ -1077,16 +1113,17 @@ select sum(b) from xc_groupby_g group by b;
  4.2
 (2 rows)
 
-explain verbose select sum(b) from xc_groupby_g group by b;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=8)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_g.b)), xc_groupby_g.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_g.b), xc_groupby_g.b
-(6 rows)
+               Remote query: SELECT sum(group_1.b), group_1.b  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2  
+(7 rows)
 
 select sum(c) from xc_groupby_g group by b;
  sum 
@@ -1095,16 +1132,17 @@ select sum(c) from xc_groupby_g group by b;
  6.4
 (2 rows)
 
-explain verbose select sum(c) from xc_groupby_g group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=40)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_g.c)), xc_groupby_g.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=40)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_g.c), xc_groupby_g.b
-(6 rows)
+               Remote query: SELECT sum(group_1.c), group_1.b  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2  
+(7 rows)
 
 select avg(a) from xc_groupby_g group by b;
           avg           
@@ -1113,16 +1151,17 @@ select avg(a) from xc_groupby_g group by b;
  1.00000000000000000000
 (2 rows)
 
-explain verbose select avg(a) from xc_groupby_g group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=12)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_g.a)), xc_groupby_g.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=12)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_g.a), xc_groupby_g.b
-(6 rows)
+               Remote query: SELECT avg(group_1.a), group_1.b  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2  
+(7 rows)
 
 select avg(b) from xc_groupby_g group by c;
  avg 
@@ -1131,16 +1170,17 @@ select avg(b) from xc_groupby_g group by c;
  2.1
 (2 rows)
 
-explain verbose select avg(b) from xc_groupby_g group by c;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=40)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_g.b)), xc_groupby_g.c
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=40)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_g.b), xc_groupby_g.c
-(6 rows)
+               Remote query: SELECT avg(group_1.b), group_1.c  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2  
+(7 rows)
 
 select avg(c) from xc_groupby_g group by c;
         avg         
@@ -1149,16 +1189,17 @@ select avg(c) from xc_groupby_g group by c;
  3.2000000000000000
 (2 rows)
 
-explain verbose select avg(c) from xc_groupby_g group by c;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=32)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_g.c)), xc_groupby_g.c
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=32)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_g.c), xc_groupby_g.c
-(6 rows)
+               Remote query: SELECT avg(group_1.c), group_1.c  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2  
+(7 rows)
 
 drop table xc_groupby_def;
 drop table xc_groupby_g;
@@ -1178,16 +1219,17 @@ 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 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;
                                                                                                                        QUERY PLAN                                                                                                                        
 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.06 rows=1 width=8)
+ 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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4 ORDER BY 4 
+(7 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;
@@ -1199,28 +1241,26 @@ select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_
      3 |     |                     |                  |      |    4
 (4 rows)
 
-explain verbose 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;
                                                                                                                                 QUERY PLAN                                                                                                                                 
 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=2.07..2.12 rows=1 width=16)
+ 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  (cost=2.07..2.07 rows=1 width=16)
+   ->  Sort
          Output: xc_groupby_tab1.val, xc_groupby_tab2.val, xc_groupby_tab1.val2, xc_groupby_tab2.val2
          Sort Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2
-         ->  Hash Full Join  (cost=1.03..2.06 rows=1 width=16)
+         ->  Hash Full Join
                Output: xc_groupby_tab1.val, xc_groupby_tab2.val, xc_groupby_tab1.val2, xc_groupby_tab2.val2
                Hash Cond: (xc_groupby_tab1.val2 = xc_groupby_tab2.val2)
-               ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+               ->  Data Node Scan on xc_groupby_tab1
                      Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
-                     ->  Data Node Scan (Node Count [2]) on xc_groupby_tab1  (cost=0.00..1.01 rows=1000 width=8)
-                           Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
-               ->  Hash  (cost=1.01..1.01 rows=1 width=8)
+                     Remote query: SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1
+               ->  Hash
                      Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-                     ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+                     ->  Data Node Scan on xc_groupby_tab2
                            Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-                           ->  Data Node Scan (Node Count [2]) on xc_groupby_tab2  (cost=0.00..1.01 rows=1000 width=8)
-                                 Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-(18 rows)
+                           Remote query: SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2
+(16 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;
@@ -1230,23 +1270,24 @@ select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by va
   17
 (2 rows)
 
-explain verbose 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  (cost=1.07..1.09 rows=1 width=12)
+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  (cost=1.07..1.07 rows=1 width=12)
+   ->  Sort
          Output: q1.y, q1.x
          Sort Key: q1.x
-         ->  Subquery Scan on q1  (cost=1.02..1.06 rows=1 width=12)
+         ->  Subquery Scan on q1
                Output: q1.y, q1.x
-               ->  GroupAggregate  (cost=1.02..1.05 rows=1 width=8)
+               ->  GroupAggregate
                      Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
-                     ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+                     ->  Materialize
                            Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
-                           ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=8)
+                           ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                                  Output: sum(xc_groupby_tab1.val), (xc_groupby_tab1.val2 % 2), xc_groupby_tab1.val2
-(13 rows)
+                                 Remote query: SELECT sum(group_1.val), (group_1.val2 % 2), group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3 ORDER BY 3 
+(14 rows)
 
 -- group by without aggregate
 select val2 from xc_groupby_tab1 group by val2;
@@ -1257,16 +1298,17 @@ select val2 from xc_groupby_tab1 group by val2;
     3
 (3 rows)
 
-explain verbose select val2 from xc_groupby_tab1 group by val2;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- Group  (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
+                                                                     QUERY PLAN                                                                      
+-----------------------------------------------------------------------------------------------------------------------------------------------------
+ Group
    Output: xc_groupby_tab1.val2
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1 ORDER BY 1 
+(7 rows)
 
 select val + val2 from xc_groupby_tab1 group by val + val2;
  ?column? 
@@ -1279,16 +1321,17 @@ select val + val2 from xc_groupby_tab1 group by val + val2;
         9
 (6 rows)
 
-explain verbose select val + val2 from xc_groupby_tab1 group by val + val2;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- Group  (cost=1.03..1.04 rows=1 width=8)
+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))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2)
-(6 rows)
+               Remote query: SELECT (group_1.val + group_1.val2)  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1 ORDER BY 1 
+(7 rows)
 
 select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
  ?column? | val | val2 
@@ -1303,16 +1346,17 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
         9 |   6 |    3
 (8 rows)
 
-explain verbose select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
-                                                  QUERY PLAN                                                   
----------------------------------------------------------------------------------------------------------------
- Group  (cost=1.02..1.04 rows=1 width=8)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2), xc_groupby_tab1.val, xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT (group_1.val + group_1.val2), group_1.val, group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 2, 3 ORDER BY 2, 3 
+(7 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 
@@ -1325,16 +1369,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_group
         6 |   4 |    2
 (6 rows)
 
-explain verbose 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  (cost=0.01..0.02 rows=1 width=0)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2
-(6 rows)
+               Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1), group_2.val_1_1_1, group_2.val2_2_2_1  FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM  (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1  ,  (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1  WHERE   (in_1.val = out_1.val)) group_2 GROUP BY 2, 3 ORDER BY 2, 3 
+(7 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? 
@@ -1345,16 +1390,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_group
         7
 (4 rows)
 
-explain verbose 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  (cost=0.01..0.02 rows=1 width=0)
+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))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2)
-(6 rows)
+               Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1)  FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM  (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1  ,  (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1  WHERE   (in_1.val = out_1.val)) group_2 GROUP BY 1 ORDER BY 1 
+(7 rows)
 
 -- group by with aggregates in expression
 select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
@@ -1365,16 +1411,17 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
  17.6666666666666667 |    3
 (3 rows)
 
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
-                                                                          QUERY PLAN                                                                          
---------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.06 rows=1 width=8)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4 ORDER BY 4 
+(7 rows)
 
 -- group by with expressions in group by clause
 select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
@@ -1385,16 +1432,17 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
   11 | 3.6666666666666667 |        6
 (3 rows)
 
-explain verbose select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
-                                                           QUERY PLAN                                                           
---------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.03..1.05 rows=1 width=8)
+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))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2))
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), (2 * xc_groupby_tab1.val2)
-(6 rows)
+               Remote query: SELECT sum(group_1.val), avg(group_1.val), (2 * group_1.val2)  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3 ORDER BY 3 
+(7 rows)
 
 drop table xc_groupby_tab1;
 drop table xc_groupby_tab2;
@@ -1429,21 +1477,20 @@ select a,count(a) from xc_groupby_def group by a order by a;
     |     0
 (11 rows)
 
-explain verbose select a,count(a) from xc_groupby_def group by a order by a;
-                                          QUERY PLAN                                          
-----------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a;
+                                       QUERY PLAN                                        
+-----------------------------------------------------------------------------------------
+ GroupAggregate
    Output: a, count(a)
-   ->  Sort  (cost=1.02..1.03 rows=1 width=4)
+   ->  Sort
          Output: a
          Sort Key: xc_groupby_def.a
-         ->  Result  (cost=0.00..1.01 rows=1 width=4)
+         ->  Result
                Output: a
-               ->  Materialize  (cost=0.00..1.01 rows=1 width=4)
+               ->  Data Node Scan on xc_groupby_def
                      Output: a, b
-                     ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=4)
-                           Output: a, b
-(11 rows)
+                     Remote query: SELECT a, b FROM public.xc_groupby_def xc_groupby_def
+(10 rows)
 
 select avg(a) from xc_groupby_def group by a; 
           avg           
@@ -1477,16 +1524,17 @@ select avg(a) from xc_groupby_def group by a;
                        
 (11 rows)
 
-explain verbose select avg(a) from xc_groupby_def group by a;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.05 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a;
+                                                                        QUERY PLAN                                                                         
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.a
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_def.a)), xc_groupby_def.a
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_def.a), xc_groupby_def.a
-(6 rows)
+               Remote query: SELECT avg(group_1.a), group_1.a  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select avg(a) from xc_groupby_def group by b;
         avg         
@@ -1497,16 +1545,17 @@ select avg(a) from xc_groupby_def group by b;
  4.0000000000000000
 (4 rows)
 
-explain verbose select avg(a) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.05 rows=1 width=72)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b;
+                                                                        QUERY PLAN                                                                         
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_def.a)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=72)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT avg(group_1.a), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select sum(a) from xc_groupby_def group by b;
  sum 
@@ -1517,16 +1566,17 @@ select sum(a) from xc_groupby_def group by b;
    8
 (4 rows)
 
-explain verbose select sum(a) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=72)
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b;
+                                                                        QUERY PLAN                                                                         
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: pg_catalog.sum((sum(xc_groupby_def.a))), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_def.a)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=72)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT sum(group_1.a), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select count(*) from xc_groupby_def group by b;
  count 
@@ -1537,16 +1587,17 @@ select count(*) from xc_groupby_def group by b;
      3
 (4 rows)
 
-explain verbose select count(*) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b;
+                                                                     QUERY PLAN                                                                      
+-----------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: pg_catalog.count(*), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT count(*), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select count(*) from xc_groupby_def where a is not null group by a;
  count 
@@ -1563,16 +1614,17 @@ select count(*) from xc_groupby_def where a is not null group by a;
      1
 (10 rows)
 
-explain verbose select count(*) from xc_groupby_def where a is not null group by a;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a;
+                                                                                QUERY PLAN                                                                                 
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: pg_catalog.count(*), xc_groupby_def.a
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), xc_groupby_def.a
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), xc_groupby_def.a
-(6 rows)
+               Remote query: SELECT count(*), group_1.a  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (a IS NOT NULL)) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select b from xc_groupby_def group by b;
    b   
@@ -1583,16 +1635,17 @@ select b from xc_groupby_def group by b;
  
 (4 rows)
 
-explain verbose select b from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- Group  (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b;
+                                                                QUERY PLAN                                                                 
+-------------------------------------------------------------------------------------------------------------------------------------------
+ Group
    Output: xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_groupby_def.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1 ORDER BY 1 
+(7 rows)
 
 select b,count(b) from xc_groupby_def group by b;
    b   | count 
@@ -1603,16 +1656,17 @@ select b,count(b) from xc_groupby_def group by b;
        |     0
 (4 rows)
 
-explain verbose select b,count(b) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=68)
+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)))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_groupby_def.b, (count(xc_groupby_def.b))
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_groupby_def.b, count(xc_groupby_def.b)
-(6 rows)
+               Remote query: SELECT group_1.b, count(group_1.b)  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1 ORDER BY 1 
+(7 rows)
 
 select count(*) from xc_groupby_def where b is null group by b;
  count 
@@ -1620,16 +1674,17 @@ select count(*) from xc_groupby_def where b is null group by b;
      3
 (1 row)
 
-explain verbose select count(*) from xc_groupby_def where b is null group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b;
+                                                                              QUERY PLAN                                                                               
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: pg_catalog.count(*), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT count(*), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (b IS NULL)) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 create table xc_groupby_g(a int, b float, c numeric);
 insert into xc_groupby_g values(1,2.1,3.2);
@@ -1642,16 +1697,17 @@ select sum(a) from xc_groupby_g group by a;
    2
 (2 rows)
 
-explain verbose select sum(a) from xc_groupby_g group by a;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=4)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_g.a), xc_groupby_g.a
-(6 rows)
+               Remote query: SELECT sum(group_1.a), group_1.a  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select sum(b) from xc_groupby_g group by b;
  sum 
@@ -1660,16 +1716,17 @@ select sum(b) from xc_groupby_g group by b;
  2.3
 (2 rows)
 
-explain verbose select sum(b) from xc_groupby_g group by b;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=8)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_g.b)), xc_groupby_g.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_g.b), xc_groupby_g.b
-(6 rows)
+               Remote query: SELECT sum(group_1.b), group_1.b  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select sum(c) from xc_groupby_g group by b;
  sum 
@@ -1678,16 +1735,17 @@ select sum(c) from xc_groupby_g group by b;
  5.2
 (2 rows)
 
-explain verbose select sum(c) from xc_groupby_g group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=40)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_g.c)), xc_groupby_g.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=40)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_g.c), xc_groupby_g.b
-(6 rows)
+               Remote query: SELECT sum(group_1.c), group_1.b  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select avg(a) from xc_groupby_g group by b;
           avg           
@@ -1696,16 +1754,17 @@ select avg(a) from xc_groupby_g group by b;
      2.0000000000000000
 (2 rows)
 
-explain verbose select avg(a) from xc_groupby_g group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.05 rows=1 width=12)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_g.a)), xc_groupby_g.b
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=12)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_g.a), xc_groupby_g.b
-(6 rows)
+               Remote query: SELECT avg(group_1.a), group_1.b  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select avg(b) from xc_groupby_g group by c;
  avg 
@@ -1714,16 +1773,17 @@ select avg(b) from xc_groupby_g group by c;
  2.3
 (2 rows)
 
-explain verbose select avg(b) from xc_groupby_g group by c;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.05 rows=1 width=40)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_g.b)), xc_groupby_g.c
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=40)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_g.b), xc_groupby_g.c
-(6 rows)
+               Remote query: SELECT avg(group_1.b), group_1.c  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select avg(c) from xc_groupby_g group by c;
         avg         
@@ -1732,16 +1792,17 @@ select avg(c) from xc_groupby_g group by c;
  5.2000000000000000
 (2 rows)
 
-explain verbose select avg(c) from xc_groupby_g group by c;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.05 rows=1 width=32)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_g.c)), xc_groupby_g.c
-         ->  Data Node Scan (Node Count [2])  (cost=0.00..1.01 rows=1000 width=32)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_g.c), xc_groupby_g.c
-(6 rows)
+               Remote query: SELECT avg(group_1.c), group_1.c  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 drop table xc_groupby_def;
 drop table xc_groupby_g;
@@ -1760,16 +1821,17 @@ 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 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;
                                                                                                                        QUERY PLAN                                                                                                                        
 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.06 rows=1 width=8)
+ 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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4 ORDER BY 4 
+(7 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;
@@ -1781,28 +1843,26 @@ select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_
      3 |     |                     |                  |      |    4
 (4 rows)
 
-explain verbose 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;
                                                                                                                                 QUERY PLAN                                                                                                                                 
 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=2.07..2.12 rows=1 width=16)
+ 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  (cost=2.07..2.07 rows=1 width=16)
+   ->  Sort
          Output: xc_groupby_tab1.val, xc_groupby_tab2.val, xc_groupby_tab1.val2, xc_groupby_tab2.val2
          Sort Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2
-         ->  Hash Full Join  (cost=1.03..2.06 rows=1 width=16)
+         ->  Hash Full Join
                Output: xc_groupby_tab1.val, xc_groupby_tab2.val, xc_groupby_tab1.val2, xc_groupby_tab2.val2
                Hash Cond: (xc_groupby_tab1.val2 = xc_groupby_tab2.val2)
-               ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+               ->  Data Node Scan on xc_groupby_tab1
                      Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
-                     ->  Data Node Scan (Node Count [1]) on xc_groupby_tab1  (cost=0.00..1.01 rows=1000 width=8)
-                           Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
-               ->  Hash  (cost=1.01..1.01 rows=1 width=8)
+                     Remote query: SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1
+               ->  Hash
                      Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-                     ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+                     ->  Data Node Scan on xc_groupby_tab2
                            Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-                           ->  Data Node Scan (Node Count [1]) on xc_groupby_tab2  (cost=0.00..1.01 rows=1000 width=8)
-                                 Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-(18 rows)
+                           Remote query: SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2
+(16 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;
@@ -1812,23 +1872,24 @@ select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by va
   17
 (2 rows)
 
-explain verbose 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  (cost=1.07..1.09 rows=1 width=12)
+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  (cost=1.07..1.07 rows=1 width=12)
+   ->  Sort
          Output: q1.y, q1.x
          Sort Key: q1.x
-         ->  Subquery Scan on q1  (cost=1.02..1.06 rows=1 width=12)
+         ->  Subquery Scan on q1
                Output: q1.y, q1.x
-               ->  GroupAggregate  (cost=1.02..1.05 rows=1 width=8)
+               ->  GroupAggregate
                      Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
-                     ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+                     ->  Materialize
                            Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
-                           ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=8)
+                           ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                                  Output: sum(xc_groupby_tab1.val), (xc_groupby_tab1.val2 % 2), xc_groupby_tab1.val2
-(13 rows)
+                                 Remote query: SELECT sum(group_1.val), (group_1.val2 % 2), group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3 ORDER BY 3 
+(14 rows)
 
 -- group by without aggregate
 select val2 from xc_groupby_tab1 group by val2;
@@ -1839,16 +1900,17 @@ select val2 from xc_groupby_tab1 group by val2;
     3
 (3 rows)
 
-explain verbose select val2 from xc_groupby_tab1 group by val2;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- Group  (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
+                                                                     QUERY PLAN                                                                      
+-----------------------------------------------------------------------------------------------------------------------------------------------------
+ Group
    Output: xc_groupby_tab1.val2
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1 ORDER BY 1 
+(7 rows)
 
 select val + val2 from xc_groupby_tab1 group by val + val2;
  ?column? 
@@ -1861,16 +1923,17 @@ select val + val2 from xc_groupby_tab1 group by val + val2;
         9
 (6 rows)
 
-explain verbose select val + val2 from xc_groupby_tab1 group by val + val2;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- Group  (cost=1.03..1.04 rows=1 width=8)
+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))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2)
-(6 rows)
+               Remote query: SELECT (group_1.val + group_1.val2)  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1 ORDER BY 1 
+(7 rows)
 
 select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
  ?column? | val | val2 
@@ -1885,16 +1948,17 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
         9 |   6 |    3
 (8 rows)
 
-explain verbose select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
-                                                  QUERY PLAN                                                   
----------------------------------------------------------------------------------------------------------------
- Group  (cost=1.02..1.04 rows=1 width=8)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2), xc_groupby_tab1.val, xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT (group_1.val + group_1.val2), group_1.val, group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 2, 3 ORDER BY 2, 3 
+(7 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 
@@ -1907,16 +1971,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_group
         6 |   4 |    2
 (6 rows)
 
-explain verbose 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  (cost=0.01..0.02 rows=1 width=0)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2
-(6 rows)
+               Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1), group_2.val_1_1_1, group_2.val2_2_2_1  FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM  (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1  ,  (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1  WHERE   (in_1.val = out_1.val)) group_2 GROUP BY 2, 3 ORDER BY 2, 3 
+(7 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? 
@@ -1927,16 +1992,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_group
         7
 (4 rows)
 
-explain verbose 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  (cost=0.01..0.02 rows=1 width=0)
+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))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2)
-(6 rows)
+               Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1)  FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM  (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1  ,  (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1  WHERE   (in_1.val = out_1.val)) group_2 GROUP BY 1 ORDER BY 1 
+(7 rows)
 
 -- group by with aggregates in expression
 select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
@@ -1947,16 +2013,17 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
  17.6666666666666667 |    3
 (3 rows)
 
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
-                                                                          QUERY PLAN                                                                          
---------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.06 rows=1 width=8)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4 ORDER BY 4 
+(7 rows)
 
 -- group by with expressions in group by clause
 select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
@@ -1967,16 +2034,17 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
   11 | 3.6666666666666667 |        6
 (3 rows)
 
-explain verbose select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
-                                                           QUERY PLAN                                                           
---------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.03..1.05 rows=1 width=8)
+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))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2))
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), (2 * xc_groupby_tab1.val2)
-(6 rows)
+               Remote query: SELECT sum(group_1.val), avg(group_1.val), (2 * group_1.val2)  FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3 ORDER BY 3 
+(7 rows)
 
 drop table xc_groupby_tab1;
 drop table xc_groupby_tab2;
@@ -2011,21 +2079,20 @@ select a,count(a) from xc_groupby_def group by a order by a;
     |     0
 (11 rows)
 
-explain verbose select a,count(a) from xc_groupby_def group by a order by a;
-                                          QUERY PLAN                                          
-----------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a;
+                                       QUERY PLAN                                        
+-----------------------------------------------------------------------------------------
+ GroupAggregate
    Output: a, count(a)
-   ->  Sort  (cost=1.02..1.03 rows=1 width=4)
+   ->  Sort
          Output: a
          Sort Key: xc_groupby_def.a
-         ->  Result  (cost=0.00..1.01 rows=1 width=4)
+         ->  Result
                Output: a
-               ->  Materialize  (cost=0.00..1.01 rows=1 width=4)
+               ->  Data Node Scan on xc_groupby_def
                      Output: a, b
-                     ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=4)
-                           Output: a, b
-(11 rows)
+                     Remote query: SELECT a, b FROM public.xc_groupby_def xc_groupby_def
+(10 rows)
 
 select avg(a) from xc_groupby_def group by a; 
           avg           
@@ -2043,16 +2110,17 @@ select avg(a) from xc_groupby_def group by a;
                        
 (11 rows)
 
-explain verbose select avg(a) from xc_groupby_def group by a; 
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.05 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; 
+                                                                        QUERY PLAN                                                                         
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.a
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_def.a)), xc_groupby_def.a
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_def.a), xc_groupby_def.a
-(6 rows)
+               Remote query: SELECT avg(group_1.a), group_1.a  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select avg(a) from xc_groupby_def group by a;
           avg           
@@ -2070,16 +2138,17 @@ select avg(a) from xc_groupby_def group by a;
                        
 (11 rows)
 
-explain verbose select avg(a) from xc_groupby_def group by a;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.05 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a;
+                                                                        QUERY PLAN                                                                         
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.a
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_def.a)), xc_groupby_def.a
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_def.a), xc_groupby_def.a
-(6 rows)
+               Remote query: SELECT avg(group_1.a), group_1.a  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select avg(a) from xc_groupby_def group by b;
         avg         
@@ -2090,16 +2159,17 @@ select avg(a) from xc_groupby_def group by b;
  4.0000000000000000
 (4 rows)
 
-explain verbose select avg(a) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.05 rows=1 width=72)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b;
+                                                                        QUERY PLAN                                                                         
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_def.a)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=72)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT avg(group_1.a), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select sum(a) from xc_groupby_def group by b;
  sum 
@@ -2110,16 +2180,17 @@ select sum(a) from xc_groupby_def group by b;
    8
 (4 rows)
 
-explain verbose select sum(a) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=72)
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b;
+                                                                        QUERY PLAN                                                                         
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: pg_catalog.sum((sum(xc_groupby_def.a))), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_def.a)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=72)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT sum(group_1.a), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select count(*) from xc_groupby_def group by b;
  count 
@@ -2130,16 +2201,17 @@ select count(*) from xc_groupby_def group by b;
      3
 (4 rows)
 
-explain verbose select count(*) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b;
+                                                                     QUERY PLAN                                                                      
+-----------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: pg_catalog.count(*), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT count(*), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select count(*) from xc_groupby_def where a is not null group by a;
  count 
@@ -2156,16 +2228,17 @@ select count(*) from xc_groupby_def where a is not null group by a;
      1
 (10 rows)
 
-explain verbose select count(*) from xc_groupby_def where a is not null group by a;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a;
+                                                                                QUERY PLAN                                                                                 
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: pg_catalog.count(*), xc_groupby_def.a
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), xc_groupby_def.a
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), xc_groupby_def.a
-(6 rows)
+               Remote query: SELECT count(*), group_1.a  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (a IS NOT NULL)) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select b from xc_groupby_def group by b;
    b   
@@ -2176,16 +2249,17 @@ select b from xc_groupby_def group by b;
  
 (4 rows)
 
-explain verbose select b from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- Group  (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b;
+                                                                QUERY PLAN                                                                 
+-------------------------------------------------------------------------------------------------------------------------------------------
+ Group
    Output: xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_groupby_def.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1 ORDER BY 1 
+(7 rows)
 
 select b,count(b) from xc_groupby_def group by b;
    b   | count 
@@ -2196,16 +2270,17 @@ select b,count(b) from xc_groupby_def group by b;
        |     0
 (4 rows)
 
-explain verbose select b,count(b) from xc_groupby_def group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=68)
+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)))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_groupby_def.b, (count(xc_groupby_def.b))
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_groupby_def.b, count(xc_groupby_def.b)
-(6 rows)
+               Remote query: SELECT group_1.b, count(group_1.b)  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1 ORDER BY 1 
+(7 rows)
 
 select count(*) from xc_groupby_def where b is null group by b;
  count 
@@ -2213,16 +2288,17 @@ select count(*) from xc_groupby_def where b is null group by b;
      3
 (1 row)
 
-explain verbose select count(*) from xc_groupby_def where b is null group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b;
+                                                                              QUERY PLAN                                                                               
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: pg_catalog.count(*), xc_groupby_def.b
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), xc_groupby_def.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=68)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), xc_groupby_def.b
-(6 rows)
+               Remote query: SELECT count(*), group_1.b  FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (b IS NULL)) group_1 GROUP BY 2 ORDER BY 2 
+(7 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);
@@ -2235,16 +2311,17 @@ select sum(a) from xc_groupby_g group by a;
    2
 (2 rows)
 
-explain verbose select sum(a) from xc_groupby_g group by a;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=4)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=4)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_g.a), xc_groupby_g.a
-(6 rows)
+               Remote query: SELECT sum(group_1.a), group_1.a  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select sum(b) from xc_groupby_g group by b;
  sum 
@@ -2253,16 +2330,17 @@ select sum(b) from xc_groupby_g group by b;
  2.3
 (2 rows)
 
-explain verbose select sum(b) from xc_groupby_g group by b;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=8)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_g.b)), xc_groupby_g.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_g.b), xc_groupby_g.b
-(6 rows)
+               Remote query: SELECT sum(group_1.b), group_1.b  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select sum(c) from xc_groupby_g group by b;
  sum 
@@ -2271,16 +2349,17 @@ select sum(c) from xc_groupby_g group by b;
  5.2
 (2 rows)
 
-explain verbose select sum(c) from xc_groupby_g group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.04 rows=1 width=40)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (sum(xc_groupby_g.c)), xc_groupby_g.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=40)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: sum(xc_groupby_g.c), xc_groupby_g.b
-(6 rows)
+               Remote query: SELECT sum(group_1.c), group_1.b  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select avg(a) from xc_groupby_g group by b;
           avg           
@@ -2289,16 +2368,17 @@ select avg(a) from xc_groupby_g group by b;
      2.0000000000000000
 (2 rows)
 
-explain verbose select avg(a) from xc_groupby_g group by b;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.05 rows=1 width=12)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_g.a)), xc_groupby_g.b
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=12)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_g.a), xc_groupby_g.b
-(6 rows)
+               Remote query: SELECT avg(group_1.a), group_1.b  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select avg(b) from xc_groupby_g group by c;
  avg 
@@ -2307,16 +2387,17 @@ select avg(b) from xc_groupby_g group by c;
  2.3
 (2 rows)
 
-explain verbose select avg(b) from xc_groupby_g group by c;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.05 rows=1 width=40)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_g.b)), xc_groupby_g.c
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=40)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_g.b), xc_groupby_g.c
-(6 rows)
+               Remote query: SELECT avg(group_1.b), group_1.c  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2 
+(7 rows)
 
 select avg(c) from xc_groupby_g group by c;
         avg         
@@ -2325,16 +2406,17 @@ select avg(c) from xc_groupby_g group by c;
  5.2000000000000000
 (2 rows)
 
-explain verbose select avg(c) from xc_groupby_g group by c;
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.05 rows=1 width=32)
+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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (avg(xc_groupby_g.c)), xc_groupby_g.c
-         ->  Data Node Scan (Node Count [1])  (cost=0.00..1.01 rows=1000 width=32)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: avg(xc_groupby_g.c), xc_groupby_g.c
-(6 rows)
+               Remote query: SELECT avg(group_1.c), group_1.c  FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2 
+(7 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 2212a79c3e..d8c619a888 100644
--- a/src/test/regress/expected/xc_having.out
+++ b/src/test/regress/expected/xc_having.out
@@ -17,16 +17,17 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
      3 |  11 | 3.6666666666666667 | 3.66666666666667 |    3
 (1 row)
 
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.03..1.05 rows=1 width=8)
+ 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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(6 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE ((val2 + 1) > 3)) group_1 GROUP BY 4  
+(7 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;
@@ -35,17 +36,18 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
      2 |   8 | 4.0000000000000000 |        4 |    2
 (1 row)
 
-explain verbose 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;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.03..1.06 rows=1 width=8)
+ 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)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4  
+(8 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;
  count | sum |        avg         |     ?column?     | val2 
@@ -54,34 +56,36 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
      3 |  11 | 3.6666666666666667 | 3.66666666666667 |    3
 (2 rows)
 
-explain verbose 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;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.03..1.06 rows=1 width=8)
+ 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))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4  
+(8 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 
 -------+-----+-----+----------+------
 (0 rows)
 
-explain verbose 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;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.03..1.06 rows=1 width=8)
+ 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)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE (val2 > 2)) group_1 GROUP BY 4  
+(8 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;
@@ -90,23 +94,21 @@ select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab
      6 |  96 | 16.0000000000000000 |       16 |    2 |    2
 (1 row)
 
-explain verbose 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;
+explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab1.val*xc_having_tab2.val), sum(xc_having_tab1.val*xc_having_tab2.val)::float8/count(*), xc_having_tab1.val2, xc_having_tab2.val2 from xc_having_tab1 full outer join xc_having_tab2 on xc_having_tab1.val2 = xc_having_tab2.val2 group by xc_having_tab1.val2, xc_having_tab2.val2 having xc_having_tab1.val2 + xc_having_tab2.val2 > 2;
                                                                                                                             QUERY PLAN                                                                                                                             
 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=2.07..2.09 rows=1 width=16)
+ HashAggregate
    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
-   ->  Nested Loop  (cost=0.00..2.05 rows=1 width=16)
+   ->  Nested Loop
          Output: xc_having_tab1.val, xc_having_tab1.val2, xc_having_tab2.val, xc_having_tab2.val2
          Join Filter: ((xc_having_tab1.val2 = xc_having_tab2.val2) AND ((xc_having_tab1.val2 + xc_having_tab2.val2) > 2))
-         ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+         ->  Data Node Scan on xc_having_tab1
                Output: xc_having_tab1.val, xc_having_tab1.val2
-               ->  Data Node Scan (Node Count [2]) on xc_having_tab1  (cost=0.00..1.01 rows=1000 width=8)
-                     Output: xc_having_tab1.val, xc_having_tab1.val2
-         ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+               Remote query: SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1
+         ->  Data Node Scan on xc_having_tab2
                Output: xc_having_tab2.val, xc_having_tab2.val2
-               ->  Data Node Scan (Node Count [2]) on xc_having_tab2  (cost=0.00..1.01 rows=1000 width=8)
-                     Output: xc_having_tab2.val, xc_having_tab2.val2
-(13 rows)
+               Remote query: SELECT val, val2 FROM public.xc_having_tab2 xc_having_tab2
+(11 rows)
 
 -- group by and having, without aggregate in the target list
 select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -115,17 +117,18 @@ select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
     3
 (1 row)
 
-explain verbose select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
-                                               QUERY PLAN                                                
----------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
+                                                                        QUERY PLAN                                                                         
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: xc_having_tab1.val2
    Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_having_tab1.val2, (sum(xc_having_tab1.val))
-         ->  Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_having_tab1.val2, sum(xc_having_tab1.val)
-(7 rows)
+               Remote query: SELECT group_1.val2, sum(group_1.val)  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1  
+(8 rows)
 
 select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
  ?column? 
@@ -135,17 +138,18 @@ select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
         9
 (3 rows)
 
-explain verbose select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
-                                               QUERY PLAN                                                
----------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.04 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
+                                                                                QUERY PLAN                                                                                 
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: ((xc_having_tab1.val + xc_having_tab1.val2))
    Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val))
-         ->  Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_having_tab1.val + xc_having_tab1.val2), sum(xc_having_tab1.val)
-(7 rows)
+               Remote query: SELECT (group_1.val + group_1.val2), sum(group_1.val)  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1  
+(8 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;
@@ -154,17 +158,18 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha
  17.6666666666666667 |    3
 (1 row)
 
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
-                                                                        QUERY PLAN                                                                         
------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.03..1.05 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
+                                                                                               QUERY PLAN                                                                                                
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(xc_having_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_having_tab1.val)))), xc_having_tab1.val2
    Filter: (min((min(xc_having_tab1.val))) < xc_having_tab1.val2)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2, (min(xc_having_tab1.val))
-         ->  Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  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)
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2, min(group_1.val)  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4  
+(8 rows)
 
 drop table xc_having_tab1;
 drop table xc_having_tab2;
@@ -182,16 +187,17 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
      3 |  11 | 3.6666666666666667 | 3.66666666666667 |    3
 (1 row)
 
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.03..1.05 rows=1 width=8)
+ 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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(6 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE ((val2 + 1) > 3)) group_1 GROUP BY 4  
+(7 rows)
 
 -- having clause containing aggregate
 select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
@@ -200,17 +206,18 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
      2 |   8 | 4.0000000000000000 |        4 |    2
 (1 row)
 
-explain verbose 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;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.03..1.06 rows=1 width=8)
+ 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)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4  
+(8 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;
  count | sum |        avg         |     ?column?     | val2 
@@ -219,34 +226,36 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
      3 |  11 | 3.6666666666666667 | 3.66666666666667 |    3
 (2 rows)
 
-explain verbose 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;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.03..1.06 rows=1 width=8)
+ 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))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4  
+(8 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 
 -------+-----+-----+----------+------
 (0 rows)
 
-explain verbose 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;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.03..1.06 rows=1 width=8)
+ 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)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE (val2 > 2)) group_1 GROUP BY 4  
+(8 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;
@@ -255,23 +264,21 @@ select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab
      6 |  96 | 16.0000000000000000 |       16 |    2 |    2
 (1 row)
 
-explain verbose 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;
+explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab1.val*xc_having_tab2.val), sum(xc_having_tab1.val*xc_having_tab2.val)::float8/count(*), xc_having_tab1.val2, xc_having_tab2.val2 from xc_having_tab1 full outer join xc_having_tab2 on xc_having_tab1.val2 = xc_having_tab2.val2 group by xc_having_tab1.val2, xc_having_tab2.val2 having xc_having_tab1.val2 + xc_having_tab2.val2 > 2;
                                                                                                                             QUERY PLAN                                                                                                                             
 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=2.07..2.09 rows=1 width=16)
+ HashAggregate
    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
-   ->  Nested Loop  (cost=0.00..2.05 rows=1 width=16)
+   ->  Nested Loop
          Output: xc_having_tab1.val, xc_having_tab1.val2, xc_having_tab2.val, xc_having_tab2.val2
          Join Filter: ((xc_having_tab1.val2 = xc_having_tab2.val2) AND ((xc_having_tab1.val2 + xc_having_tab2.val2) > 2))
-         ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+         ->  Data Node Scan on xc_having_tab1
                Output: xc_having_tab1.val, xc_having_tab1.val2
-               ->  Data Node Scan (Node Count [1]) on xc_having_tab1  (cost=0.00..1.01 rows=1000 width=8)
-                     Output: xc_having_tab1.val, xc_having_tab1.val2
-         ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+               Remote query: SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1
+         ->  Data Node Scan on xc_having_tab2
                Output: xc_having_tab2.val, xc_having_tab2.val2
-               ->  Data Node Scan (Node Count [1]) on xc_having_tab2  (cost=0.00..1.01 rows=1000 width=8)
-                     Output: xc_having_tab2.val, xc_having_tab2.val2
-(13 rows)
+               Remote query: SELECT val, val2 FROM public.xc_having_tab2 xc_having_tab2
+(11 rows)
 
 -- group by and having, without aggregate in the target list
 select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -280,17 +287,18 @@ select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
     3
 (1 row)
 
-explain verbose select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
-                                               QUERY PLAN                                                
----------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.03 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
+                                                                        QUERY PLAN                                                                         
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: xc_having_tab1.val2
    Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_having_tab1.val2, (sum(xc_having_tab1.val))
-         ->  Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_having_tab1.val2, sum(xc_having_tab1.val)
-(7 rows)
+               Remote query: SELECT group_1.val2, sum(group_1.val)  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1  
+(8 rows)
 
 select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
  ?column? 
@@ -300,17 +308,18 @@ select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
         9
 (3 rows)
 
-explain verbose select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
-                                               QUERY PLAN                                                
----------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.02..1.04 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
+                                                                                QUERY PLAN                                                                                 
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: ((xc_having_tab1.val + xc_having_tab1.val2))
    Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val))
-         ->  Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_having_tab1.val + xc_having_tab1.val2), sum(xc_having_tab1.val)
-(7 rows)
+               Remote query: SELECT (group_1.val + group_1.val2), sum(group_1.val)  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1  
+(8 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;
@@ -319,17 +328,18 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha
  17.6666666666666667 |    3
 (1 row)
 
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
-                                                                        QUERY PLAN                                                                         
------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate  (cost=1.03..1.05 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
+                                                                                               QUERY PLAN                                                                                                
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
    Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(xc_having_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_having_tab1.val)))), xc_having_tab1.val2
    Filter: (min((min(xc_having_tab1.val))) < xc_having_tab1.val2)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2, (min(xc_having_tab1.val))
-         ->  Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  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)
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2, min(group_1.val)  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4  
+(8 rows)
 
 drop table xc_having_tab1;
 drop table xc_having_tab2;
@@ -347,16 +357,17 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
      3 |  11 | 3.6666666666666667 | 3.66666666666667 |    3
 (1 row)
 
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.03..1.07 rows=1 width=8)
+ 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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(6 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE ((val2 + 1) > 3)) group_1 GROUP BY 4 ORDER BY 4 
+(7 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;
@@ -365,17 +376,18 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
      2 |   8 | 4.0000000000000000 |        4 |    2
 (1 row)
 
-explain verbose 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;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.07 rows=1 width=8)
+ 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)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4 ORDER BY 4 
+(8 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;
  count | sum |        avg         |     ?column?     | val2 
@@ -384,34 +396,36 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
      3 |  11 | 3.6666666666666667 | 3.66666666666667 |    3
 (2 rows)
 
-explain verbose 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;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.07 rows=1 width=8)
+ 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))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4 ORDER BY 4 
+(8 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 
 -------+-----+-----+----------+------
 (0 rows)
 
-explain verbose 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;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.03..1.07 rows=1 width=8)
+ 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)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE (val2 > 2)) group_1 GROUP BY 4 ORDER BY 4 
+(8 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;
@@ -420,26 +434,24 @@ select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab
      6 |  96 | 16.0000000000000000 |       16 |    2 |    2
 (1 row)
 
-explain verbose 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;
+explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab1.val*xc_having_tab2.val), sum(xc_having_tab1.val*xc_having_tab2.val)::float8/count(*), xc_having_tab1.val2, xc_having_tab2.val2 from xc_having_tab1 full outer join xc_having_tab2 on xc_having_tab1.val2 = xc_having_tab2.val2 group by xc_having_tab1.val2, xc_having_tab2.val2 having xc_having_tab1.val2 + xc_having_tab2.val2 > 2;
                                                                                                                             QUERY PLAN                                                                                                                             
 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=2.06..2.11 rows=1 width=16)
+ GroupAggregate
    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
-   ->  Sort  (cost=2.06..2.06 rows=1 width=16)
+   ->  Sort
          Output: xc_having_tab1.val, xc_having_tab2.val, xc_having_tab1.val2, xc_having_tab2.val2
          Sort Key: xc_having_tab1.val2, xc_having_tab2.val2
-         ->  Nested Loop  (cost=0.00..2.05 rows=1 width=16)
+         ->  Nested Loop
                Output: xc_having_tab1.val, xc_having_tab2.val, xc_having_tab1.val2, xc_having_tab2.val2
                Join Filter: ((xc_having_tab1.val2 = xc_having_tab2.val2) AND ((xc_having_tab1.val2 + xc_having_tab2.val2) > 2))
-               ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+               ->  Data Node Scan on xc_having_tab1
                      Output: xc_having_tab1.val, xc_having_tab1.val2
-                     ->  Data Node Scan (Node Count [2]) on xc_having_tab1  (cost=0.00..1.01 rows=1000 width=8)
-                           Output: xc_having_tab1.val, xc_having_tab1.val2
-               ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+                     Remote query: SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1
+               ->  Data Node Scan on xc_having_tab2
                      Output: xc_having_tab2.val, xc_having_tab2.val2
-                     ->  Data Node Scan (Node Count [2]) on xc_having_tab2  (cost=0.00..1.01 rows=1000 width=8)
-                           Output: xc_having_tab2.val, xc_having_tab2.val2
-(16 rows)
+                     Remote query: SELECT val, val2 FROM public.xc_having_tab2 xc_having_tab2
+(14 rows)
 
 -- group by and having, without aggregate in the target list
 select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -448,17 +460,18 @@ select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
     3
 (1 row)
 
-explain verbose select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
-                                               QUERY PLAN                                                
----------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.05 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
+                                                                             QUERY PLAN                                                                              
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: xc_having_tab1.val2
    Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_having_tab1.val2, (sum(xc_having_tab1.val))
-         ->  Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_having_tab1.val2, sum(xc_having_tab1.val)
-(7 rows)
+               Remote query: SELECT group_1.val2, sum(group_1.val)  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1 ORDER BY 1 
+(8 rows)
 
 select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
  ?column? 
@@ -468,17 +481,18 @@ select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
         9
 (3 rows)
 
-explain verbose select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
-                                               QUERY PLAN                                                
----------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.03..1.05 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
+                                                                                     QUERY PLAN                                                                                      
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: ((xc_having_tab1.val + xc_having_tab1.val2))
    Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val))
-         ->  Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_having_tab1.val + xc_having_tab1.val2), sum(xc_having_tab1.val)
-(7 rows)
+               Remote query: SELECT (group_1.val + group_1.val2), sum(group_1.val)  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1 ORDER BY 1 
+(8 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;
@@ -487,17 +501,18 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha
  17.6666666666666667 |    3
 (1 row)
 
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
-                                                                        QUERY PLAN                                                                         
------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.06 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
+                                                                                                    QUERY PLAN                                                                                                     
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(xc_having_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_having_tab1.val)))), xc_having_tab1.val2
    Filter: (min((min(xc_having_tab1.val))) < xc_having_tab1.val2)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2, (min(xc_having_tab1.val))
-         ->  Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  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)
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2, min(group_1.val)  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4 ORDER BY 4 
+(8 rows)
 
 drop table xc_having_tab1;
 drop table xc_having_tab2;
@@ -515,16 +530,17 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
      3 |  11 | 3.6666666666666667 | 3.66666666666667 |    3
 (1 row)
 
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.03..1.07 rows=1 width=8)
+ 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
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(6 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE ((val2 + 1) > 3)) group_1 GROUP BY 4 ORDER BY 4 
+(7 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;
@@ -533,17 +549,18 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
      2 |   8 | 4.0000000000000000 |        4 |    2
 (1 row)
 
-explain verbose 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;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.07 rows=1 width=8)
+ 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)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4 ORDER BY 4 
+(8 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;
  count | sum |        avg         |     ?column?     | val2 
@@ -552,34 +569,36 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
      3 |  11 | 3.6666666666666667 | 3.66666666666667 |    3
 (2 rows)
 
-explain verbose 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;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.07 rows=1 width=8)
+ 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))
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4 ORDER BY 4 
+(8 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 
 -------+-----+-----+----------+------
 (0 rows)
 
-explain verbose 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;
                                                                                                                      QUERY PLAN                                                                                                                      
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.03..1.07 rows=1 width=8)
+ 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)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
-         ->  Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE (val2 > 2)) group_1 GROUP BY 4 ORDER BY 4 
+(8 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;
@@ -588,26 +607,24 @@ select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab
      6 |  96 | 16.0000000000000000 |       16 |    2 |    2
 (1 row)
 
-explain verbose 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;
+explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab1.val*xc_having_tab2.val), sum(xc_having_tab1.val*xc_having_tab2.val)::float8/count(*), xc_having_tab1.val2, xc_having_tab2.val2 from xc_having_tab1 full outer join xc_having_tab2 on xc_having_tab1.val2 = xc_having_tab2.val2 group by xc_having_tab1.val2, xc_having_tab2.val2 having xc_having_tab1.val2 + xc_having_tab2.val2 > 2;
                                                                                                                             QUERY PLAN                                                                                                                             
 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=2.06..2.11 rows=1 width=16)
+ GroupAggregate
    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
-   ->  Sort  (cost=2.06..2.06 rows=1 width=16)
+   ->  Sort
          Output: xc_having_tab1.val, xc_having_tab2.val, xc_having_tab1.val2, xc_having_tab2.val2
          Sort Key: xc_having_tab1.val2, xc_having_tab2.val2
-         ->  Nested Loop  (cost=0.00..2.05 rows=1 width=16)
+         ->  Nested Loop
                Output: xc_having_tab1.val, xc_having_tab2.val, xc_having_tab1.val2, xc_having_tab2.val2
                Join Filter: ((xc_having_tab1.val2 = xc_having_tab2.val2) AND ((xc_having_tab1.val2 + xc_having_tab2.val2) > 2))
-               ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+               ->  Data Node Scan on xc_having_tab1
                      Output: xc_having_tab1.val, xc_having_tab1.val2
-                     ->  Data Node Scan (Node Count [1]) on xc_having_tab1  (cost=0.00..1.01 rows=1000 width=8)
-                           Output: xc_having_tab1.val, xc_having_tab1.val2
-               ->  Materialize  (cost=0.00..1.01 rows=1 width=8)
+                     Remote query: SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1
+               ->  Data Node Scan on xc_having_tab2
                      Output: xc_having_tab2.val, xc_having_tab2.val2
-                     ->  Data Node Scan (Node Count [1]) on xc_having_tab2  (cost=0.00..1.01 rows=1000 width=8)
-                           Output: xc_having_tab2.val, xc_having_tab2.val2
-(16 rows)
+                     Remote query: SELECT val, val2 FROM public.xc_having_tab2 xc_having_tab2
+(14 rows)
 
 -- group by and having, without aggregate in the target list
 select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -616,17 +633,18 @@ select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
     3
 (1 row)
 
-explain verbose select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
-                                               QUERY PLAN                                                
----------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.05 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
+                                                                             QUERY PLAN                                                                              
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: xc_having_tab1.val2
    Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: xc_having_tab1.val2, (sum(xc_having_tab1.val))
-         ->  Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: xc_having_tab1.val2, sum(xc_having_tab1.val)
-(7 rows)
+               Remote query: SELECT group_1.val2, sum(group_1.val)  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1 ORDER BY 1 
+(8 rows)
 
 select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
  ?column? 
@@ -636,17 +654,18 @@ select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
         9
 (3 rows)
 
-explain verbose select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
-                                               QUERY PLAN                                                
----------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.03..1.05 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
+                                                                                     QUERY PLAN                                                                                      
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: ((xc_having_tab1.val + xc_having_tab1.val2))
    Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val))
-         ->  Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  Data Node Scan on "__REMOTE_GROUP_QUERY__"
                Output: (xc_having_tab1.val + xc_having_tab1.val2), sum(xc_having_tab1.val)
-(7 rows)
+               Remote query: SELECT (group_1.val + group_1.val2), sum(group_1.val)  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1 ORDER BY 1 
+(8 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;
@@ -655,17 +674,18 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha
  17.6666666666666667 |    3
 (1 row)
 
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
-                                                                        QUERY PLAN                                                                         
------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate  (cost=1.02..1.06 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
+                                                                                                    QUERY PLAN                                                                                                     
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
    Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(xc_having_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_having_tab1.val)))), xc_having_tab1.val2
    Filter: (min((min(xc_having_tab1.val))) < xc_having_tab1.val2)
-   ->  Materialize  (cost=0.00..0.00 rows=0 width=0)
+   ->  Materialize
          Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2, (min(xc_having_tab1.val))
-         ->  Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__"  (cost=0.00..1.01 rows=1000 width=8)
+         ->  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)
-(7 rows)
+               Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2, min(group_1.val)  FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4 ORDER BY 4 
+(8 rows)
 
 drop table xc_having_tab1;
 drop table xc_having_tab2;
diff --git a/src/test/regress/sql/xc_distkey.sql b/src/test/regress/sql/xc_distkey.sql
index b57502d26f..e3f5849c24 100644
--- a/src/test/regress/sql/xc_distkey.sql
+++ b/src/test/regress/sql/xc_distkey.sql
@@ -18,8 +18,8 @@ select * from nu_tab order by a;
 select * from nu_tab where a = 123.456;
 select * from nu_tab where 789.412 = a;
 
-explain select * from nu_tab where a = 123.456;
-explain select * from nu_tab where 789.412 = a;
+explain (costs false, num_nodes true, nodes false) select * from nu_tab where a = 123.456;
+explain (costs false, num_nodes true, nodes false) select * from nu_tab where 789.412 = a;
 
 
 create table tx_tab(a text) distribute by modulo(a);
@@ -32,8 +32,8 @@ select * from tx_tab where a = 'Did the quick brown fox jump over the lazy dog?'
 select * from tx_tab where 'hello world' = a;
 select * from tx_tab where 'Did the quick brown fox jump over the lazy dog?' = a;
 
-explain select * from tx_tab where a = 'hello world';
-explain select * from tx_tab where a = 'Did the quick brown fox jump over the lazy dog?';
+explain (costs false, num_nodes true, nodes false) select * from tx_tab where a = 'hello world';
+explain (costs false, num_nodes true, nodes false) select * from tx_tab where a = 'Did the quick brown fox jump over the lazy dog?';
 
 
 
@@ -47,10 +47,10 @@ select * from vc_tab where a = 'A quick brown fox';
 -- This test a bug in examine_conditions_walker where a = constant is optimized but constant = a was not
 select * from vc_tab where 'A quick brown fox' = a;
 
-explain select * from vc_tab where a = 'abcdefghijklmnopqrstuvwxyz';
-explain select * from vc_tab where a = 'A quick brown fox';
+explain (costs false, num_nodes true, nodes false) select * from vc_tab where a = 'abcdefghijklmnopqrstuvwxyz';
+explain (costs false, num_nodes true, nodes false) select * from vc_tab where a = 'A quick brown fox';
 -- This test a bug in examine_conditions_walker where a = constant is optimized but constant = a was not
-explain select * from vc_tab where 'A quick brown fox' = a;
+explain (costs false, num_nodes true, nodes false) select * from vc_tab where 'A quick brown fox' = a;
 
 
 
@@ -118,8 +118,8 @@ select * from i4_tab where a = 2147483647;
 select * from i4_tab where 65530 = a;
 select * from i4_tab where 2147483647 = a;
 
-explain select * from i4_tab where 65530 = a;
-explain select * from i4_tab where a = 2147483647;
+explain (costs false, num_nodes true, nodes false) select * from i4_tab where 65530 = a;
+explain (costs false, num_nodes true, nodes false) select * from i4_tab where a = 2147483647;
 
 
 create table bo_tab(a bool) distribute by modulo(a);
diff --git a/src/test/regress/sql/xc_groupby.sql b/src/test/regress/sql/xc_groupby.sql
index 896ea7fad1..d3827f1303 100644
--- a/src/test/regress/sql/xc_groupby.sql
+++ b/src/test/regress/sql/xc_groupby.sql
@@ -12,30 +12,30 @@ 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;
-explain verbose 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;
-explain verbose 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;
-explain verbose select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
+explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
 -- group by without aggregate
 select val2 from xc_groupby_tab1 group by val2;
-explain verbose 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 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 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 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 select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2;
+explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2;
 -- group by with aggregates in expression
 select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
-explain verbose 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;
-explain verbose 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;
 
@@ -56,25 +56,25 @@ insert into xc_groupby_def VALUES (9, 'Three');
 insert into xc_groupby_def VALUES (10, 'Three');
 
 select a,count(a) from xc_groupby_def group by a order by a;
-explain verbose select a,count(a) from xc_groupby_def group by a order by a;
+explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a;
 select avg(a) from xc_groupby_def group by a; 
 select avg(a) from xc_groupby_def group by a;
-explain verbose select avg(a) from xc_groupby_def group by a;
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a;
 select avg(a) from xc_groupby_def group by b;
-explain verbose select avg(a) from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b;
 select sum(a) from xc_groupby_def group by b;
-explain verbose select sum(a) from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b;
 select count(*) from xc_groupby_def group by b;
-explain verbose select count(*) from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b;
 select count(*) from xc_groupby_def where a is not null group by a;
-explain verbose select count(*) from xc_groupby_def where a is not null group by a;
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a;
 
 select b from xc_groupby_def group by b;
-explain verbose 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 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 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;
 
 create table xc_groupby_g(a int, b float, c numeric);
 insert into xc_groupby_g values(1,2.1,3.2);
@@ -82,18 +82,18 @@ insert into xc_groupby_g values(1,2.1,3.2);
 insert into xc_groupby_g values(2,2.3,5.2);
 
 select sum(a) from xc_groupby_g group by a;
-explain verbose 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 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 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 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 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 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;
@@ -106,30 +106,30 @@ create table xc_groupby_tab2 (val int, val2 int) distribute by replication;
 insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3);
 insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
 select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2;
-explain verbose 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;
-explain verbose 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;
-explain verbose select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
+explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
 -- group by without aggregate
 select val2 from xc_groupby_tab1 group by val2;
-explain verbose 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 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 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 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 select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2;
+explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2;
 -- group by with aggregates in expression
 select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
-explain verbose 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;
-explain verbose 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;
 
@@ -150,26 +150,26 @@ insert into xc_groupby_def VALUES (9, 'Three');
 insert into xc_groupby_def VALUES (10, 'Three');
 
 select a,count(a) from xc_groupby_def group by a order by a;
-explain verbose select a,count(a) from xc_groupby_def group by a order by a;
+explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a;
 select avg(a) from xc_groupby_def group by a; 
-explain verbose select avg(a) from xc_groupby_def group by a; 
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; 
 select avg(a) from xc_groupby_def group by a;
-explain verbose select avg(a) from xc_groupby_def group by a;
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a;
 select avg(a) from xc_groupby_def group by b;
-explain verbose select avg(a) from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b;
 select sum(a) from xc_groupby_def group by b;
-explain verbose select sum(a) from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b;
 select count(*) from xc_groupby_def group by b;
-explain verbose select count(*) from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b;
 select count(*) from xc_groupby_def where a is not null group by a;
-explain verbose select count(*) from xc_groupby_def where a is not null group by a;
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a;
 
 select b from xc_groupby_def group by b;
-explain verbose 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 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 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;
 
 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);
@@ -177,18 +177,18 @@ insert into xc_groupby_g values(1,2.1,3.2);
 insert into xc_groupby_g values(2,2.3,5.2);
 
 select sum(a) from xc_groupby_g group by a;
-explain verbose 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 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 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 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 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 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;
@@ -202,30 +202,30 @@ 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;
-explain verbose 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;
-explain verbose 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;
-explain verbose select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
+explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
 -- group by without aggregate
 select val2 from xc_groupby_tab1 group by val2;
-explain verbose 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 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 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 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 select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2;
+explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2;
 -- group by with aggregates in expression
 select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
-explain verbose 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;
-explain verbose 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;
 
@@ -246,25 +246,25 @@ insert into xc_groupby_def VALUES (9, 'Three');
 insert into xc_groupby_def VALUES (10, 'Three');
 
 select a,count(a) from xc_groupby_def group by a order by a;
-explain verbose select a,count(a) from xc_groupby_def group by a order by a;
+explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a;
 select avg(a) from xc_groupby_def group by a; 
 select avg(a) from xc_groupby_def group by a;
-explain verbose select avg(a) from xc_groupby_def group by a;
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a;
 select avg(a) from xc_groupby_def group by b;
-explain verbose select avg(a) from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b;
 select sum(a) from xc_groupby_def group by b;
-explain verbose select sum(a) from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b;
 select count(*) from xc_groupby_def group by b;
-explain verbose select count(*) from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b;
 select count(*) from xc_groupby_def where a is not null group by a;
-explain verbose select count(*) from xc_groupby_def where a is not null group by a;
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a;
 
 select b from xc_groupby_def group by b;
-explain verbose 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 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 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;
 
 create table xc_groupby_g(a int, b float, c numeric);
 insert into xc_groupby_g values(1,2.1,3.2);
@@ -272,18 +272,18 @@ insert into xc_groupby_g values(1,2.1,3.2);
 insert into xc_groupby_g values(2,2.3,5.2);
 
 select sum(a) from xc_groupby_g group by a;
-explain verbose 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 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 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 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 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 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;
@@ -296,30 +296,30 @@ create table xc_groupby_tab2 (val int, val2 int) distribute by replication;
 insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3);
 insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
 select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2;
-explain verbose 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;
-explain verbose 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;
-explain verbose select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
+explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x;
 -- group by without aggregate
 select val2 from xc_groupby_tab1 group by val2;
-explain verbose 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 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 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 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 select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2;
+explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2;
 -- group by with aggregates in expression
 select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
-explain verbose 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;
-explain verbose 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;
 
@@ -340,26 +340,26 @@ insert into xc_groupby_def VALUES (9, 'Three');
 insert into xc_groupby_def VALUES (10, 'Three');
 
 select a,count(a) from xc_groupby_def group by a order by a;
-explain verbose select a,count(a) from xc_groupby_def group by a order by a;
+explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a;
 select avg(a) from xc_groupby_def group by a; 
-explain verbose select avg(a) from xc_groupby_def group by a; 
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; 
 select avg(a) from xc_groupby_def group by a;
-explain verbose select avg(a) from xc_groupby_def group by a;
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a;
 select avg(a) from xc_groupby_def group by b;
-explain verbose select avg(a) from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b;
 select sum(a) from xc_groupby_def group by b;
-explain verbose select sum(a) from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b;
 select count(*) from xc_groupby_def group by b;
-explain verbose select count(*) from xc_groupby_def group by b;
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b;
 select count(*) from xc_groupby_def where a is not null group by a;
-explain verbose select count(*) from xc_groupby_def where a is not null group by a;
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a;
 
 select b from xc_groupby_def group by b;
-explain verbose 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 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 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;
 
 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);
@@ -367,18 +367,18 @@ insert into xc_groupby_g values(1,2.1,3.2);
 insert into xc_groupby_g values(2,2.3,5.2);
 
 select sum(a) from xc_groupby_g group by a;
-explain verbose 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 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 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 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 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 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 97c2f9310e..c525a29b88 100644
--- a/src/test/regress/sql/xc_having.sql
+++ b/src/test/regress/sql/xc_having.sql
@@ -13,25 +13,25 @@ insert into xc_having_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3)
 insert into xc_having_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
 -- having clause not containing any aggregate
 select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+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;
 -- 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 select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
 select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
-explain verbose 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 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
 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;
-explain verbose 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;
+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;
 -- 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 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 from xc_having_tab1 group by val + val2 having sum(val) > 5;
-explain verbose select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
+explain (verbose true, costs false, nodes false) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
 -- 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 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;
 drop table xc_having_tab1;
 drop table xc_having_tab2;
 
@@ -44,25 +44,25 @@ insert into xc_having_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3)
 insert into xc_having_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
 -- having clause not containing any aggregate
 select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+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;
 -- 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 select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
 select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
-explain verbose 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 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
 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;
-explain verbose 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;
+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;
 -- 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 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 from xc_having_tab1 group by val + val2 having sum(val) > 5;
-explain verbose select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
+explain (verbose true, costs false, nodes false) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
 -- 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 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;
 drop table xc_having_tab1;
 drop table xc_having_tab2;
 
@@ -75,25 +75,25 @@ insert into xc_having_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3)
 insert into xc_having_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
 -- having clause not containing any aggregate
 select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+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;
 -- 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 select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
 select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
-explain verbose 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 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
 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;
-explain verbose 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;
+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;
 -- 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 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 from xc_having_tab1 group by val + val2 having sum(val) > 5;
-explain verbose select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
+explain (verbose true, costs false, nodes false) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
 -- 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 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;
 drop table xc_having_tab1;
 drop table xc_having_tab2;
 
@@ -106,25 +106,25 @@ insert into xc_having_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3)
 insert into xc_having_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
 -- having clause not containing any aggregate
 select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+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;
 -- 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 select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
+explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
 select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2;
-explain verbose 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 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
 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;
-explain verbose 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;
+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;
 -- 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 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 from xc_having_tab1 group by val + val2 having sum(val) > 5;
-explain verbose select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
+explain (verbose true, costs false, nodes false) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
 -- 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 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;
 drop table xc_having_tab1;
 drop table xc_having_tab2;
author	Ashutosh Bapat	2012-01-05 09:46:32 +0000
committer	Ashutosh Bapat	2012-01-05 09:46:32 +0000
commit	4934c89f160e3c174cec0c3eaef279f458811bb3 (patch)
tree	e362caa382ae8158e89b504bc147e4c428693ae9
parent	96fa07124d40d112563b635e5ce231dedc209d46 (diff)