Fix expected output for the testcase 'xc_having'

Most diffs were because of the plan showing the grouping key

1 files changed, 127 insertions, 75 deletions

diff --git a/src/test/regress/expected/xc_having_1.out b/src/test/regress/expected/xc_having_1.out
index 2901a5f432..4f4c4b80d1 100644
--- a/src/test/regress/expected/xc_having_1.out
+++ b/src/test/regress/expected/xc_having_1.out
@@ -26,14 +26,16 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  HashAggregate
    Output: pg_catalog.count(*), pg_catalog.sum((sum(val))), pg_catalog.avg((avg(val))), ((pg_catalog.sum((sum(val))))::double precision / (pg_catalog.count(*))::double precision), val2
+   Group Key: xc_having_tab1.val2
    ->  Remote Subquery Scan on all
          Output: count(*), sum(val), avg(val), val2
          ->  HashAggregate
                Output: count(*), sum(val), avg(val), val2
+               Group Key: xc_having_tab1.val2
                ->  Seq Scan on public.xc_having_tab1
                      Output: val, val2
                      Filter: ((xc_having_tab1.val2 + 1) > 3)
-(9 rows)
+(11 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;
@@ -47,14 +49,16 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  HashAggregate
    Output: pg_catalog.count(*), pg_catalog.sum((sum(val))), pg_catalog.avg((avg(val))), ((pg_catalog.sum((sum(val))))::double precision / (pg_catalog.count(*))::double precision), val2
+   Group Key: xc_having_tab1.val2
    Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
    ->  Remote Subquery Scan on all
          Output: count(*), sum(val), avg(val), val2
          ->  HashAggregate
                Output: count(*), sum(val), avg(val), val2
+               Group Key: xc_having_tab1.val2
                ->  Seq Scan on public.xc_having_tab1
                      Output: val, val2
-(9 rows)
+(11 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 
@@ -68,14 +72,16 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  HashAggregate
    Output: pg_catalog.count(*), pg_catalog.sum((sum(val))), pg_catalog.avg((avg(val))), ((pg_catalog.sum((sum(val))))::double precision / (pg_catalog.count(*))::double precision), val2
+   Group Key: xc_having_tab1.val2
    Filter: ((pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75) OR (xc_having_tab1.val2 > 2))
    ->  Remote Subquery Scan on all
          Output: count(*), sum(val), avg(val), val2, val2
          ->  HashAggregate
                Output: count(*), sum(val), avg(val), val2, val2
+               Group Key: xc_having_tab1.val2
                ->  Seq Scan on public.xc_having_tab1
                      Output: val, val2
-(9 rows)
+(11 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 
@@ -87,15 +93,17 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  HashAggregate
    Output: pg_catalog.count(*), pg_catalog.sum((sum(val))), pg_catalog.avg((avg(val))), ((pg_catalog.sum((sum(val))))::double precision / (pg_catalog.count(*))::double precision), val2
+   Group Key: xc_having_tab1.val2
    Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
    ->  Remote Subquery Scan on all
          Output: count(*), sum(val), avg(val), val2
          ->  HashAggregate
                Output: count(*), sum(val), avg(val), val2
+               Group Key: xc_having_tab1.val2
                ->  Seq Scan on public.xc_having_tab1
                      Output: val, val2
                      Filter: (xc_having_tab1.val2 > 2)
-(10 rows)
+(12 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;
@@ -105,32 +113,36 @@ select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab
 (1 row)
 
 explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab1.val*xc_having_tab2.val), sum(xc_having_tab1.val*xc_having_tab2.val)::float8/count(*), xc_having_tab1.val2, xc_having_tab2.val2 from xc_having_tab1 full outer join xc_having_tab2 on xc_having_tab1.val2 = xc_having_tab2.val2 group by xc_having_tab1.val2, xc_having_tab2.val2 having xc_having_tab1.val2 + xc_having_tab2.val2 > 2;
-                                                                                                                                                                  QUERY PLAN                                                                                                                                                                   
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate
-   Output: pg_catalog.count(*), pg_catalog.sum((sum((xc_having_tab1.val * xc_having_tab2.val)))), pg_catalog.avg((avg((xc_having_tab1.val * xc_having_tab2.val)))), ((pg_catalog.sum((sum((xc_having_tab1.val * xc_having_tab2.val)))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2, xc_having_tab2.val2
-   ->  Remote Subquery Scan on all
-         Output: count(*), sum((xc_having_tab1.val * xc_having_tab2.val)), avg((xc_having_tab1.val * xc_having_tab2.val)), xc_having_tab1.val2, xc_having_tab2.val2
-         ->  GroupAggregate
-               Output: count(*), sum((xc_having_tab1.val * xc_having_tab2.val)), avg((xc_having_tab1.val * xc_having_tab2.val)), xc_having_tab1.val2, xc_having_tab2.val2
-               ->  Merge Join
-                     Output: xc_having_tab1.val2, xc_having_tab1.val, xc_having_tab2.val2, xc_having_tab2.val
-                     Merge Cond: (xc_having_tab1.val2 = xc_having_tab2.val2)
-                     Join Filter: ((xc_having_tab1.val2 + xc_having_tab2.val2) > 2)
-                     ->  Remote Subquery Scan on all
+                                                                                                                               QUERY PLAN                                                                                                                                
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Remote Subquery Scan on all
+   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
+   ->  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
+         Group Key: xc_having_tab1.val2, xc_having_tab2.val2
+         ->  Merge Join
+               Output: xc_having_tab1.val2, xc_having_tab1.val, xc_having_tab2.val2, xc_having_tab2.val
+               Merge Cond: (xc_having_tab1.val2 = xc_having_tab2.val2)
+               Join Filter: ((xc_having_tab1.val2 + xc_having_tab2.val2) > 2)
+               ->  Remote Subquery Scan on all
+                     Output: xc_having_tab1.val2, xc_having_tab1.val
+                     Distribute results by H: val2
+                     ->  Sort
                            Output: xc_having_tab1.val2, xc_having_tab1.val
-                           Distribute results by R
-                           ->  Sort
+                           Sort Key: xc_having_tab1.val2
+                           ->  Seq Scan on public.xc_having_tab1
                                  Output: xc_having_tab1.val2, xc_having_tab1.val
-                                 Sort Key: xc_having_tab1.val2
-                                 ->  Seq Scan on public.xc_having_tab1
-                                       Output: xc_having_tab1.val2, xc_having_tab1.val
-                     ->  Sort
+               ->  Materialize
+                     Output: xc_having_tab2.val2, xc_having_tab2.val
+                     ->  Remote Subquery Scan on all
                            Output: xc_having_tab2.val2, xc_having_tab2.val
-                           Sort Key: xc_having_tab2.val2
-                           ->  Seq Scan on public.xc_having_tab2
+                           Distribute results by H: val2
+                           ->  Sort
                                  Output: xc_having_tab2.val2, xc_having_tab2.val
-(23 rows)
+                                 Sort Key: xc_having_tab2.val2
+                                 ->  Seq Scan on public.xc_having_tab2
+                                       Output: xc_having_tab2.val2, xc_having_tab2.val
+(27 rows)
 
 -- group by and having, without aggregate in the target list
 select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -144,14 +156,16 @@ explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1
 -----------------------------------------------------------
  HashAggregate
    Output: val2
+   Group Key: xc_having_tab1.val2
    Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8)
    ->  Remote Subquery Scan on all
          Output: val2, sum(val)
          ->  HashAggregate
                Output: val2, sum(val)
+               Group Key: xc_having_tab1.val2
                ->  Seq Scan on public.xc_having_tab1
                      Output: val, val2
-(9 rows)
+(11 rows)
 
 select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum;
  sum 
@@ -169,14 +183,16 @@ explain (verbose true, costs false, nodes false) select * from (select val + val
    Sort Key: ((xc_having_tab1.val + xc_having_tab1.val2))
    ->  HashAggregate
          Output: ((xc_having_tab1.val + xc_having_tab1.val2))
+         Group Key: (xc_having_tab1.val + xc_having_tab1.val2)
          Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5)
          ->  Remote Subquery Scan on all
                Output: (xc_having_tab1.val + xc_having_tab1.val2), sum(xc_having_tab1.val)
                ->  HashAggregate
                      Output: ((xc_having_tab1.val + xc_having_tab1.val2)), sum(xc_having_tab1.val)
+                     Group Key: (xc_having_tab1.val + xc_having_tab1.val2)
                      ->  Seq Scan on public.xc_having_tab1
                            Output: (xc_having_tab1.val + xc_having_tab1.val2), xc_having_tab1.val
-(12 rows)
+(14 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;
@@ -190,14 +206,16 @@ explain (verbose true, costs false, nodes false) select count(*) + sum(val) + av
 --------------------------------------------------------------------------------------------------------------
  HashAggregate
    Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(val)))))::numeric + pg_catalog.avg((avg(val)))), val2
+   Group Key: xc_having_tab1.val2
    Filter: (min((min(xc_having_tab1.val))) < xc_having_tab1.val2)
    ->  Remote Subquery Scan on all
          Output: count(*), sum(val), avg(val), val2, min(val), val2
          ->  HashAggregate
                Output: count(*), sum(val), avg(val), val2, min(val), val2
+               Group Key: xc_having_tab1.val2
                ->  Seq Scan on public.xc_having_tab1
                      Output: val, val2
-(9 rows)
+(11 rows)
 
 drop table xc_having_tab1;
 drop table xc_having_tab2;
@@ -222,10 +240,11 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
    Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
    ->  HashAggregate
          Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
+         Group Key: xc_having_tab1.val2
          ->  Seq Scan on public.xc_having_tab1
                Output: val, val2
                Filter: ((xc_having_tab1.val2 + 1) > 3)
-(7 rows)
+(8 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;
@@ -241,10 +260,11 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
    Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
    ->  HashAggregate
          Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
+         Group Key: xc_having_tab1.val2
          Filter: (avg(xc_having_tab1.val) > 3.75)
          ->  Seq Scan on public.xc_having_tab1
                Output: val, val2
-(7 rows)
+(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 
@@ -260,10 +280,11 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
    Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
    ->  HashAggregate
          Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
+         Group Key: xc_having_tab1.val2
          Filter: ((avg(xc_having_tab1.val) > 3.75) OR (xc_having_tab1.val2 > 2))
          ->  Seq Scan on public.xc_having_tab1
                Output: val, val2
-(7 rows)
+(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 
@@ -277,11 +298,12 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
    Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
    ->  HashAggregate
          Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
+         Group Key: xc_having_tab1.val2
          Filter: (avg(xc_having_tab1.val) > 3.75)
          ->  Seq Scan on public.xc_having_tab1
                Output: val, val2
                Filter: (xc_having_tab1.val2 > 2)
-(8 rows)
+(9 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;
@@ -297,6 +319,7 @@ explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_
    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
    ->  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
+         Group Key: xc_having_tab1.val2, xc_having_tab2.val2
          ->  Merge Join
                Output: xc_having_tab1.val2, xc_having_tab1.val, xc_having_tab2.val2, xc_having_tab2.val
                Merge Cond: (xc_having_tab1.val2 = xc_having_tab2.val2)
@@ -311,7 +334,7 @@ explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_
                      Sort Key: xc_having_tab2.val2
                      ->  Seq Scan on public.xc_having_tab2
                            Output: xc_having_tab2.val2, xc_having_tab2.val
-(18 rows)
+(19 rows)
 
 -- group by and having, without aggregate in the target list
 select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -327,10 +350,11 @@ explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1
    Output: val2
    ->  HashAggregate
          Output: val2
+         Group Key: xc_having_tab1.val2
          Filter: (sum(xc_having_tab1.val) > 8)
          ->  Seq Scan on public.xc_having_tab1
                Output: val, val2
-(7 rows)
+(8 rows)
 
 select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum;
  sum 
@@ -344,16 +368,17 @@ explain (verbose true, costs false, nodes false) select * from (select val + val
                                          QUERY PLAN                                         
 --------------------------------------------------------------------------------------------
  Remote Subquery Scan on all
-   Output: q.sum
+   Output: sum
    ->  Sort
          Output: ((xc_having_tab1.val + xc_having_tab1.val2))
          Sort Key: ((xc_having_tab1.val + xc_having_tab1.val2))
          ->  HashAggregate
                Output: ((xc_having_tab1.val + xc_having_tab1.val2))
+               Group Key: (xc_having_tab1.val + xc_having_tab1.val2)
                Filter: (sum(xc_having_tab1.val) > 5)
                ->  Seq Scan on public.xc_having_tab1
                      Output: (xc_having_tab1.val + xc_having_tab1.val2), xc_having_tab1.val
-(10 rows)
+(11 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;
@@ -369,10 +394,11 @@ explain (verbose true, costs false, nodes false) select count(*) + sum(val) + av
    Output: (((count(*) + sum(val)))::numeric + avg(val)), val2
    ->  HashAggregate
          Output: (((count(*) + sum(val)))::numeric + avg(val)), val2
+         Group Key: xc_having_tab1.val2
          Filter: (min(xc_having_tab1.val) < xc_having_tab1.val2)
          ->  Seq Scan on public.xc_having_tab1
                Output: val, val2
-(7 rows)
+(8 rows)
 
 drop table xc_having_tab1;
 drop table xc_having_tab2;
@@ -395,17 +421,19 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  GroupAggregate
    Output: pg_catalog.count(*), pg_catalog.sum((sum(val))), pg_catalog.avg((avg(val))), ((pg_catalog.sum((sum(val))))::double precision / (pg_catalog.count(*))::double precision), val2
+   Group Key: xc_having_tab1.val2
    ->  Remote Subquery Scan on all
          Output: count(*), sum(val), avg(val), val2
          ->  GroupAggregate
                Output: count(*), sum(val), avg(val), val2
+               Group Key: xc_having_tab1.val2
                ->  Sort
                      Output: val2, val
                      Sort Key: xc_having_tab1.val2
                      ->  Seq Scan on public.xc_having_tab1
                            Output: val2, val
                            Filter: ((xc_having_tab1.val2 + 1) > 3)
-(12 rows)
+(14 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;
@@ -419,17 +447,19 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  GroupAggregate
    Output: pg_catalog.count(*), pg_catalog.sum((sum(val))), pg_catalog.avg((avg(val))), ((pg_catalog.sum((sum(val))))::double precision / (pg_catalog.count(*))::double precision), val2
+   Group Key: xc_having_tab1.val2
    Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
    ->  Remote Subquery Scan on all
          Output: count(*), sum(val), avg(val), val2
          ->  GroupAggregate
                Output: count(*), sum(val), avg(val), val2
+               Group Key: xc_having_tab1.val2
                ->  Sort
                      Output: val2, val
                      Sort Key: xc_having_tab1.val2
                      ->  Seq Scan on public.xc_having_tab1
                            Output: val2, val
-(12 rows)
+(14 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 
@@ -443,17 +473,19 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  GroupAggregate
    Output: pg_catalog.count(*), pg_catalog.sum((sum(val))), pg_catalog.avg((avg(val))), ((pg_catalog.sum((sum(val))))::double precision / (pg_catalog.count(*))::double precision), val2
+   Group Key: xc_having_tab1.val2
    Filter: ((pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75) OR (xc_having_tab1.val2 > 2))
    ->  Remote Subquery Scan on all
          Output: count(*), sum(val), avg(val), val2, val2
          ->  GroupAggregate
                Output: count(*), sum(val), avg(val), val2, val2
+               Group Key: xc_having_tab1.val2
                ->  Sort
                      Output: val2, val
                      Sort Key: xc_having_tab1.val2
                      ->  Seq Scan on public.xc_having_tab1
                            Output: val2, val
-(12 rows)
+(14 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 
@@ -465,18 +497,20 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  GroupAggregate
    Output: pg_catalog.count(*), pg_catalog.sum((sum(val))), pg_catalog.avg((avg(val))), ((pg_catalog.sum((sum(val))))::double precision / (pg_catalog.count(*))::double precision), val2
+   Group Key: xc_having_tab1.val2
    Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
    ->  Remote Subquery Scan on all
          Output: count(*), sum(val), avg(val), val2
          ->  GroupAggregate
                Output: count(*), sum(val), avg(val), val2
+               Group Key: xc_having_tab1.val2
                ->  Sort
                      Output: val2, val
                      Sort Key: xc_having_tab1.val2
                      ->  Seq Scan on public.xc_having_tab1
                            Output: val2, val
                            Filter: (xc_having_tab1.val2 > 2)
-(13 rows)
+(15 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;
@@ -486,32 +520,36 @@ select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab
 (1 row)
 
 explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab1.val*xc_having_tab2.val), sum(xc_having_tab1.val*xc_having_tab2.val)::float8/count(*), xc_having_tab1.val2, xc_having_tab2.val2 from xc_having_tab1 full outer join xc_having_tab2 on xc_having_tab1.val2 = xc_having_tab2.val2 group by xc_having_tab1.val2, xc_having_tab2.val2 having xc_having_tab1.val2 + xc_having_tab2.val2 > 2;
-                                                                                                                                                                  QUERY PLAN                                                                                                                                                                   
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate
-   Output: pg_catalog.count(*), pg_catalog.sum((sum((xc_having_tab1.val * xc_having_tab2.val)))), pg_catalog.avg((avg((xc_having_tab1.val * xc_having_tab2.val)))), ((pg_catalog.sum((sum((xc_having_tab1.val * xc_having_tab2.val)))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2, xc_having_tab2.val2
-   ->  Remote Subquery Scan on all
-         Output: count(*), sum((xc_having_tab1.val * xc_having_tab2.val)), avg((xc_having_tab1.val * xc_having_tab2.val)), xc_having_tab1.val2, xc_having_tab2.val2
-         ->  GroupAggregate
-               Output: count(*), sum((xc_having_tab1.val * xc_having_tab2.val)), avg((xc_having_tab1.val * xc_having_tab2.val)), xc_having_tab1.val2, xc_having_tab2.val2
-               ->  Merge Join
-                     Output: xc_having_tab1.val2, xc_having_tab1.val, xc_having_tab2.val2, xc_having_tab2.val
-                     Merge Cond: (xc_having_tab1.val2 = xc_having_tab2.val2)
-                     Join Filter: ((xc_having_tab1.val2 + xc_having_tab2.val2) > 2)
-                     ->  Remote Subquery Scan on all
+                                                                                                                               QUERY PLAN                                                                                                                                
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Remote Subquery Scan on all
+   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
+   ->  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
+         Group Key: xc_having_tab1.val2, xc_having_tab2.val2
+         ->  Merge Join
+               Output: xc_having_tab1.val2, xc_having_tab1.val, xc_having_tab2.val2, xc_having_tab2.val
+               Merge Cond: (xc_having_tab1.val2 = xc_having_tab2.val2)
+               Join Filter: ((xc_having_tab1.val2 + xc_having_tab2.val2) > 2)
+               ->  Remote Subquery Scan on all
+                     Output: xc_having_tab1.val2, xc_having_tab1.val
+                     Distribute results by H: val2
+                     ->  Sort
                            Output: xc_having_tab1.val2, xc_having_tab1.val
-                           Distribute results by R
-                           ->  Sort
+                           Sort Key: xc_having_tab1.val2
+                           ->  Seq Scan on public.xc_having_tab1
                                  Output: xc_having_tab1.val2, xc_having_tab1.val
-                                 Sort Key: xc_having_tab1.val2
-                                 ->  Seq Scan on public.xc_having_tab1
-                                       Output: xc_having_tab1.val2, xc_having_tab1.val
-                     ->  Sort
+               ->  Materialize
+                     Output: xc_having_tab2.val2, xc_having_tab2.val
+                     ->  Remote Subquery Scan on all
                            Output: xc_having_tab2.val2, xc_having_tab2.val
-                           Sort Key: xc_having_tab2.val2
-                           ->  Seq Scan on public.xc_having_tab2
+                           Distribute results by H: val2
+                           ->  Sort
                                  Output: xc_having_tab2.val2, xc_having_tab2.val
-(23 rows)
+                                 Sort Key: xc_having_tab2.val2
+                                 ->  Seq Scan on public.xc_having_tab2
+                                       Output: xc_having_tab2.val2, xc_having_tab2.val
+(27 rows)
 
 -- group by and having, without aggregate in the target list
 select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -525,17 +563,19 @@ explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1
 -----------------------------------------------------------
  GroupAggregate
    Output: val2
+   Group Key: xc_having_tab1.val2
    Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8)
    ->  Remote Subquery Scan on all
          Output: val2, sum(val)
          ->  GroupAggregate
                Output: val2, sum(val)
+               Group Key: xc_having_tab1.val2
                ->  Sort
                      Output: val2, val
                      Sort Key: xc_having_tab1.val2
                      ->  Seq Scan on public.xc_having_tab1
                            Output: val2, val
-(12 rows)
+(14 rows)
 
 select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
  ?column? 
@@ -550,17 +590,19 @@ explain (verbose true, costs false, nodes false) select val + val2 from xc_havin
 ----------------------------------------------------------------------------
  GroupAggregate
    Output: ((val + val2))
+   Group Key: (xc_having_tab1.val + xc_having_tab1.val2)
    Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5)
    ->  Remote Subquery Scan on all
          Output: (val + val2), sum(val)
          ->  GroupAggregate
                Output: ((val + val2)), sum(val)
+               Group Key: ((xc_having_tab1.val + xc_having_tab1.val2))
                ->  Sort
                      Output: ((val + val2)), val
                      Sort Key: ((xc_having_tab1.val + xc_having_tab1.val2))
                      ->  Seq Scan on public.xc_having_tab1
                            Output: (val + val2), val
-(12 rows)
+(14 rows)
 
 -- group by with aggregates in expression
 select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
@@ -574,17 +616,19 @@ explain (verbose true, costs false, nodes false) select count(*) + sum(val) + av
 --------------------------------------------------------------------------------------------------------------
  GroupAggregate
    Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(val)))))::numeric + pg_catalog.avg((avg(val)))), val2
+   Group Key: xc_having_tab1.val2
    Filter: (min((min(xc_having_tab1.val))) < xc_having_tab1.val2)
    ->  Remote Subquery Scan on all
          Output: count(*), sum(val), avg(val), val2, min(val), val2
          ->  GroupAggregate
                Output: count(*), sum(val), avg(val), val2, min(val), val2
+               Group Key: xc_having_tab1.val2
                ->  Sort
                      Output: val2, val
                      Sort Key: xc_having_tab1.val2
                      ->  Seq Scan on public.xc_having_tab1
                            Output: val2, val
-(12 rows)
+(14 rows)
 
 drop table xc_having_tab1;
 drop table xc_having_tab2;
@@ -609,13 +653,14 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
    Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
    ->  GroupAggregate
          Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
+         Group Key: xc_having_tab1.val2
          ->  Sort
                Output: val2, val
                Sort Key: xc_having_tab1.val2
                ->  Seq Scan on public.xc_having_tab1
                      Output: val2, val
                      Filter: ((xc_having_tab1.val2 + 1) > 3)
-(10 rows)
+(11 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;
@@ -631,13 +676,14 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
    Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
    ->  GroupAggregate
          Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
+         Group Key: xc_having_tab1.val2
          Filter: (avg(xc_having_tab1.val) > 3.75)
          ->  Sort
                Output: val2, val
                Sort Key: xc_having_tab1.val2
                ->  Seq Scan on public.xc_having_tab1
                      Output: val2, val
-(10 rows)
+(11 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 
@@ -653,13 +699,14 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
    Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
    ->  GroupAggregate
          Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
+         Group Key: xc_having_tab1.val2
          Filter: ((avg(xc_having_tab1.val) > 3.75) OR (xc_having_tab1.val2 > 2))
          ->  Sort
                Output: val2, val
                Sort Key: xc_having_tab1.val2
                ->  Seq Scan on public.xc_having_tab1
                      Output: val2, val
-(10 rows)
+(11 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 
@@ -673,6 +720,7 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
    Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
    ->  GroupAggregate
          Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2
+         Group Key: xc_having_tab1.val2
          Filter: (avg(xc_having_tab1.val) > 3.75)
          ->  Sort
                Output: val2, val
@@ -680,7 +728,7 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(
                ->  Seq Scan on public.xc_having_tab1
                      Output: val2, val
                      Filter: (xc_having_tab1.val2 > 2)
-(11 rows)
+(12 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;
@@ -696,6 +744,7 @@ explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_
    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
    ->  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
+         Group Key: xc_having_tab1.val2, xc_having_tab2.val2
          ->  Merge Join
                Output: xc_having_tab1.val2, xc_having_tab1.val, xc_having_tab2.val2, xc_having_tab2.val
                Merge Cond: (xc_having_tab1.val2 = xc_having_tab2.val2)
@@ -710,7 +759,7 @@ explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_
                      Sort Key: xc_having_tab2.val2
                      ->  Seq Scan on public.xc_having_tab2
                            Output: xc_having_tab2.val2, xc_having_tab2.val
-(18 rows)
+(19 rows)
 
 -- group by and having, without aggregate in the target list
 select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -726,13 +775,14 @@ explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1
    Output: val2
    ->  GroupAggregate
          Output: val2
+         Group Key: xc_having_tab1.val2
          Filter: (sum(xc_having_tab1.val) > 8)
          ->  Sort
                Output: val2, val
                Sort Key: xc_having_tab1.val2
                ->  Seq Scan on public.xc_having_tab1
                      Output: val2, val
-(10 rows)
+(11 rows)
 
 select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
  ?column? 
@@ -749,13 +799,14 @@ explain (verbose true, costs false, nodes false) select val + val2 from xc_havin
    Output: (val + val2)
    ->  GroupAggregate
          Output: ((val + val2))
+         Group Key: ((xc_having_tab1.val + xc_having_tab1.val2))
          Filter: (sum(xc_having_tab1.val) > 5)
          ->  Sort
                Output: ((val + val2)), val
                Sort Key: ((xc_having_tab1.val + xc_having_tab1.val2))
                ->  Seq Scan on public.xc_having_tab1
                      Output: (val + val2), val
-(10 rows)
+(11 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;
@@ -771,13 +822,14 @@ explain (verbose true, costs false, nodes false) select count(*) + sum(val) + av
    Output: (((count(*) + sum(val)))::numeric + avg(val)), val2
    ->  GroupAggregate
          Output: (((count(*) + sum(val)))::numeric + avg(val)), val2
+         Group Key: xc_having_tab1.val2
          Filter: (min(xc_having_tab1.val) < xc_having_tab1.val2)
          ->  Sort
                Output: val2, val
                Sort Key: xc_having_tab1.val2
                ->  Seq Scan on public.xc_having_tab1
                      Output: val2, val
-(10 rows)
+(11 rows)
 
 drop table xc_having_tab1;
 drop table xc_having_tab2;