Fix a few expected output diffs from the testcase 'equivclass'

1 files changed, 125 insertions, 103 deletions

diff --git a/src/test/regress/expected/equivclass.out b/src/test/regress/expected/equivclass.out
index 0391b8eec1..4a91d47258 100644
--- a/src/test/regress/expected/equivclass.out
+++ b/src/test/regress/expected/equivclass.out
@@ -104,99 +104,122 @@ set enable_mergejoin = off;
 --
 explain (costs off)
   select * from ec0 where ff = f1 and f1 = '42'::int8;
-            QUERY PLAN             
------------------------------------
- Index Scan using ec0_pkey on ec0
-   Index Cond: (ff = '42'::bigint)
-   Filter: (f1 = '42'::bigint)
-(3 rows)
+                QUERY PLAN                
+------------------------------------------
+ Remote Subquery Scan on all (datanode_1)
+   ->  Index Scan using ec0_pkey on ec0
+         Index Cond: (ff = '42'::bigint)
+         Filter: (f1 = '42'::bigint)
+(4 rows)
 
 explain (costs off)
   select * from ec0 where ff = f1 and f1 = '42'::int8alias1;
-              QUERY PLAN               
----------------------------------------
- Index Scan using ec0_pkey on ec0
-   Index Cond: (ff = '42'::int8alias1)
-   Filter: (f1 = '42'::int8alias1)
-(3 rows)
+                     QUERY PLAN                      
+-----------------------------------------------------
+ Remote Subquery Scan on all (datanode_1,datanode_2)
+   ->  Index Scan using ec0_pkey on ec0
+         Index Cond: (ff = '42'::int8alias1)
+         Filter: (f1 = '42'::int8alias1)
+(4 rows)
 
 explain (costs off)
   select * from ec1 where ff = f1 and f1 = '42'::int8alias1;
-              QUERY PLAN               
----------------------------------------
- Index Scan using ec1_pkey on ec1
-   Index Cond: (ff = '42'::int8alias1)
-   Filter: (f1 = '42'::int8alias1)
-(3 rows)
+                     QUERY PLAN                      
+-----------------------------------------------------
+ Remote Subquery Scan on all (datanode_1,datanode_2)
+   ->  Index Scan using ec1_pkey on ec1
+         Index Cond: (ff = '42'::int8alias1)
+         Filter: (f1 = '42'::int8alias1)
+(4 rows)
 
 explain (costs off)
   select * from ec1 where ff = f1 and f1 = '42'::int8alias2;
-                    QUERY PLAN                     
----------------------------------------------------
- Seq Scan on ec1
-   Filter: ((ff = f1) AND (f1 = '42'::int8alias2))
-(2 rows)
+                       QUERY PLAN                        
+---------------------------------------------------------
+ Remote Subquery Scan on all (datanode_1,datanode_2)
+   ->  Seq Scan on ec1
+         Filter: ((ff = f1) AND (f1 = '42'::int8alias2))
+(3 rows)
 
 explain (costs off)
   select * from ec1, ec2 where ff = x1 and ff = '42'::int8;
-                            QUERY PLAN                             
--------------------------------------------------------------------
+                               QUERY PLAN                                
+-------------------------------------------------------------------------
  Nested Loop
    Join Filter: (ec1.ff = ec2.x1)
-   ->  Index Scan using ec1_pkey on ec1
-         Index Cond: ((ff = '42'::bigint) AND (ff = '42'::bigint))
-   ->  Seq Scan on ec2
-(5 rows)
+   ->  Remote Subquery Scan on all (datanode_1)
+         ->  Index Scan using ec1_pkey on ec1
+               Index Cond: ((ff = '42'::bigint) AND (ff = '42'::bigint))
+   ->  Materialize
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               ->  Seq Scan on ec2
+(8 rows)
 
 explain (costs off)
   select * from ec1, ec2 where ff = x1 and ff = '42'::int8alias1;
-                 QUERY PLAN                  
----------------------------------------------
+                           QUERY PLAN                            
+-----------------------------------------------------------------
  Nested Loop
-   ->  Index Scan using ec1_pkey on ec1
-         Index Cond: (ff = '42'::int8alias1)
-   ->  Seq Scan on ec2
-         Filter: (x1 = '42'::int8alias1)
-(5 rows)
+   ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+         ->  Index Scan using ec1_pkey on ec1
+               Index Cond: (ff = '42'::int8alias1)
+   ->  Materialize
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               ->  Seq Scan on ec2
+                     Filter: (x1 = '42'::int8alias1)
+(8 rows)
 
 explain (costs off)
   select * from ec1, ec2 where ff = x1 and '42'::int8 = x1;
-               QUERY PLAN                
------------------------------------------
+                           QUERY PLAN                            
+-----------------------------------------------------------------
  Nested Loop
    Join Filter: (ec1.ff = ec2.x1)
-   ->  Index Scan using ec1_pkey on ec1
-         Index Cond: (ff = '42'::bigint)
-   ->  Seq Scan on ec2
-         Filter: ('42'::bigint = x1)
-(6 rows)
+   ->  Remote Subquery Scan on all (datanode_1)
+         ->  Index Scan using ec1_pkey on ec1
+               Index Cond: (ff = '42'::bigint)
+   ->  Materialize
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               ->  Seq Scan on ec2
+                     Filter: ('42'::bigint = x1)
+(9 rows)
 
 explain (costs off)
   select * from ec1, ec2 where ff = x1 and x1 = '42'::int8alias1;
-                 QUERY PLAN                  
----------------------------------------------
+                           QUERY PLAN                            
+-----------------------------------------------------------------
  Nested Loop
-   ->  Index Scan using ec1_pkey on ec1
-         Index Cond: (ff = '42'::int8alias1)
-   ->  Seq Scan on ec2
-         Filter: (x1 = '42'::int8alias1)
-(5 rows)
+   ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+         ->  Index Scan using ec1_pkey on ec1
+               Index Cond: (ff = '42'::int8alias1)
+   ->  Materialize
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               ->  Seq Scan on ec2
+                     Filter: (x1 = '42'::int8alias1)
+(8 rows)
 
 explain (costs off)
   select * from ec1, ec2 where ff = x1 and x1 = '42'::int8alias2;
-               QUERY PLAN                
------------------------------------------
+                           QUERY PLAN                            
+-----------------------------------------------------------------
  Nested Loop
-   ->  Seq Scan on ec2
-         Filter: (x1 = '42'::int8alias2)
-   ->  Index Scan using ec1_pkey on ec1
-         Index Cond: (ff = ec2.x1)
-(5 rows)
+   ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+         ->  Seq Scan on ec2
+               Filter: (x1 = '42'::int8alias2)
+   ->  Materialize
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               ->  Index Scan using ec1_pkey on ec1
+                     Index Cond: (ff = ec2.x1)
+(8 rows)
 
 create unique index ec1_expr1 on ec1((ff + 1));
+ERROR:  Unique index of partitioned table must contain the hash/modulo distribution column.
 create unique index ec1_expr2 on ec1((ff + 2 + 1));
+ERROR:  Unique index of partitioned table must contain the hash/modulo distribution column.
 create unique index ec1_expr3 on ec1((ff + 3 + 1));
+ERROR:  Unique index of partitioned table must contain the hash/modulo distribution column.
 create unique index ec1_expr4 on ec1((ff + 4));
+ERROR:  Unique index of partitioned table must contain the hash/modulo distribution column.
 explain (costs off)
   select * from ec1,
     (select ff + 1 as x from
@@ -206,19 +229,21 @@ explain (costs off)
      union all
      select ff + 4 as x from ec1) as ss1
   where ss1.x = ec1.f1 and ec1.ff = 42::int8;
-                     QUERY PLAN                      
------------------------------------------------------
+                           QUERY PLAN                            
+-----------------------------------------------------------------
  Nested Loop
-   ->  Index Scan using ec1_pkey on ec1
-         Index Cond: (ff = '42'::bigint)
+   Join Filter: ((((ec1_1.ff + 2) + 1)) = ec1.f1)
+   ->  Remote Subquery Scan on all (datanode_1)
+         ->  Index Scan using ec1_pkey on ec1
+               Index Cond: (ff = '42'::bigint)
    ->  Append
-         ->  Index Scan using ec1_expr2 on ec1 ec1_1
-               Index Cond: (((ff + 2) + 1) = ec1.f1)
-         ->  Index Scan using ec1_expr3 on ec1 ec1_2
-               Index Cond: (((ff + 3) + 1) = ec1.f1)
-         ->  Index Scan using ec1_expr4 on ec1 ec1_3
-               Index Cond: ((ff + 4) = ec1.f1)
-(10 rows)
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               ->  Seq Scan on ec1 ec1_1
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               ->  Seq Scan on ec1 ec1_2
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               ->  Seq Scan on ec1 ec1_3
+(12 rows)
 
 explain (costs off)
   select * from ec1,
@@ -229,21 +254,25 @@ explain (costs off)
      union all
      select ff + 4 as x from ec1) as ss1
   where ss1.x = ec1.f1 and ec1.ff = 42::int8 and ec1.ff = ec1.f1;
-                            QUERY PLAN                             
--------------------------------------------------------------------
+                               QUERY PLAN                                
+-------------------------------------------------------------------------
  Nested Loop
    Join Filter: ((((ec1_1.ff + 2) + 1)) = ec1.f1)
-   ->  Index Scan using ec1_pkey on ec1
-         Index Cond: ((ff = '42'::bigint) AND (ff = '42'::bigint))
-         Filter: (ff = f1)
+   ->  Remote Subquery Scan on all (datanode_1)
+         ->  Index Scan using ec1_pkey on ec1
+               Index Cond: ((ff = '42'::bigint) AND (ff = '42'::bigint))
+               Filter: (ff = f1)
    ->  Append
-         ->  Index Scan using ec1_expr2 on ec1 ec1_1
-               Index Cond: (((ff + 2) + 1) = '42'::bigint)
-         ->  Index Scan using ec1_expr3 on ec1 ec1_2
-               Index Cond: (((ff + 3) + 1) = '42'::bigint)
-         ->  Index Scan using ec1_expr4 on ec1 ec1_3
-               Index Cond: ((ff + 4) = '42'::bigint)
-(12 rows)
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               ->  Seq Scan on ec1 ec1_1
+                     Filter: (((ff + 2) + 1) = '42'::bigint)
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               ->  Seq Scan on ec1 ec1_2
+                     Filter: (((ff + 3) + 1) = '42'::bigint)
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               ->  Seq Scan on ec1 ec1_3
+                     Filter: ((ff + 4) = '42'::bigint)
+(16 rows)
 
 explain (costs off)
   select * from ec1,
@@ -260,19 +289,10 @@ explain (costs off)
      union all
      select ff + 4 as x from ec1) as ss2
   where ss1.x = ec1.f1 and ss1.x = ss2.x and ec1.ff = 42::int8;
-                             QUERY PLAN                              
----------------------------------------------------------------------
+                                 QUERY PLAN                                  
+-----------------------------------------------------------------------------
  Nested Loop
-   ->  Nested Loop
-         ->  Index Scan using ec1_pkey on ec1
-               Index Cond: (ff = '42'::bigint)
-         ->  Append
-               ->  Index Scan using ec1_expr2 on ec1 ec1_1
-                     Index Cond: (((ff + 2) + 1) = ec1.f1)
-               ->  Index Scan using ec1_expr3 on ec1 ec1_2
-                     Index Cond: (((ff + 3) + 1) = ec1.f1)
-               ->  Index Scan using ec1_expr4 on ec1 ec1_3
-                     Index Cond: ((ff + 4) = ec1.f1)
+   Join Filter: ((((ec1_1.ff + 2) + 1)) = (((ec1_4.ff + 2) + 1)))
    ->  Append
          ->  Index Scan using ec1_expr2 on ec1 ec1_4
                Index Cond: (((ff + 2) + 1) = (((ec1_1.ff + 2) + 1)))
@@ -337,19 +357,21 @@ explain (costs off)
      union all
      select ff + 4 as x from ec1) as ss1
   where ss1.x = ec1.f1 and ec1.ff = 42::int8;
-                     QUERY PLAN                      
------------------------------------------------------
+                           QUERY PLAN                            
+-----------------------------------------------------------------
  Nested Loop
-   ->  Index Scan using ec1_pkey on ec1
-         Index Cond: (ff = '42'::bigint)
+   Join Filter: ((((ec1_1.ff + 2) + 1)) = ec1.f1)
+   ->  Remote Subquery Scan on all (datanode_1)
+         ->  Index Scan using ec1_pkey on ec1
+               Index Cond: (ff = '42'::bigint)
    ->  Append
-         ->  Index Scan using ec1_expr2 on ec1 ec1_1
-               Index Cond: (((ff + 2) + 1) = ec1.f1)
-         ->  Seq Scan on ec1 ec1_2
-               Filter: (((ff + 3) + 1) = ec1.f1)
-         ->  Index Scan using ec1_expr4 on ec1 ec1_3
-               Index Cond: ((ff + 4) = ec1.f1)
-(10 rows)
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               ->  Seq Scan on ec1 ec1_1
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               ->  Seq Scan on ec1 ec1_2
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               ->  Seq Scan on ec1 ec1_3
+(12 rows)
 
 -- let's try that as a mergejoin
 set enable_mergejoin = on;