Adjust regression tests post 10.9 merge.

The changes, as usual, are because of:
 - unsupported features
 - known limitations
 - plan changes

15 files changed, 241 insertions, 197 deletions

diff --git a/src/test/regress/expected/aggregates.out b/src/test/regress/expected/aggregates.out
index b1b12d53dd..f54b9a4cde 100644
--- a/src/test/regress/expected/aggregates.out
+++ b/src/test/regress/expected/aggregates.out
@@ -2172,15 +2172,18 @@ select v||'a', case when v||'a' = 'aa' then 1 else 0 end, count(*)
 explain (costs off)
   select 1 from tenk1
    where (hundred, thousand) in (select twothousand, twothousand from onek);
-                         QUERY PLAN                          
--------------------------------------------------------------
- Hash Join
-   Hash Cond: (tenk1.hundred = onek.twothousand)
-   ->  Seq Scan on tenk1
-         Filter: (hundred = thousand)
-   ->  Hash
-         ->  HashAggregate
-               Group Key: onek.twothousand, onek.twothousand
-               ->  Seq Scan on onek
-(8 rows)
+                              QUERY PLAN                               
+-----------------------------------------------------------------------
+ Remote Subquery Scan on all (datanode_1,datanode_2)
+   ->  Hash Semi Join
+         Hash Cond: (tenk1.hundred = onek.twothousand)
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               Distribute results by H: hundred
+               ->  Seq Scan on tenk1
+                     Filter: (hundred = thousand)
+         ->  Hash
+               ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+                     Distribute results by H: twothousand
+                     ->  Seq Scan on onek
+(11 rows)
 
diff --git a/src/test/regress/expected/copy2.out b/src/test/regress/expected/copy2.out
index 85d0a4e514..444bf73d84 100644
--- a/src/test/regress/expected/copy2.out
+++ b/src/test/regress/expected/copy2.out
@@ -608,20 +608,21 @@ SELECT * FROM instead_of_insert_tbl;
 -- Test of COPY optimization with view using INSTEAD OF INSERT
 -- trigger when relation is created in the same transaction as
 -- when COPY is executed.
-BEGIN;
-CREATE VIEW instead_of_insert_tbl_view_2 as select ''::text as str;
-CREATE TRIGGER trig_instead_of_insert_tbl_view_2
-  INSTEAD OF INSERT ON instead_of_insert_tbl_view_2
-  FOR EACH ROW EXECUTE PROCEDURE fun_instead_of_insert_tbl();
-COPY instead_of_insert_tbl_view_2 FROM stdin;
-SELECT * FROM instead_of_insert_tbl;
- id | name  
-----+-------
-  1 | test1
-  2 | test1
-(2 rows)
-
-COMMIT;
+--
+-- XL does not support triggers.
+--
+-- BEGIN;
+-- CREATE VIEW instead_of_insert_tbl_view_2 as select ''::text as str;
+-- CREATE TRIGGER trig_instead_of_insert_tbl_view_2
+--   INSTEAD OF INSERT ON instead_of_insert_tbl_view_2
+--   FOR EACH ROW EXECUTE PROCEDURE fun_instead_of_insert_tbl();
+-- 
+-- COPY instead_of_insert_tbl_view_2 FROM stdin;
+-- test1
+-- \.
+-- 
+-- SELECT * FROM instead_of_insert_tbl;
+-- COMMIT;
 -- clean up
 DROP TABLE forcetest;
 DROP TABLE vistest;
@@ -636,5 +637,5 @@ DROP FUNCTION fn_x_before();
 DROP FUNCTION fn_x_after();
 DROP TABLE instead_of_insert_tbl;
 DROP VIEW instead_of_insert_tbl_view;
-DROP VIEW instead_of_insert_tbl_view_2;
+-- DROP VIEW instead_of_insert_tbl_view_2;
 DROP FUNCTION fun_instead_of_insert_tbl();
diff --git a/src/test/regress/expected/inherit.out b/src/test/regress/expected/inherit.out
index 375a867991..12e62150e9 100644
--- a/src/test/regress/expected/inherit.out
+++ b/src/test/regress/expected/inherit.out
@@ -772,27 +772,30 @@ create table some_tab_child () inherits (some_tab);
 insert into some_tab_child values(1,2);
 explain (verbose, costs off)
 update some_tab set a = a + 1 where false;
-            QUERY PLAN            
-----------------------------------
- Update on public.some_tab
-   Update on public.some_tab
-   ->  Result
-         Output: (a + 1), b, ctid
-         One-Time Filter: false
-(5 rows)
+                     QUERY PLAN                      
+-----------------------------------------------------
+ Remote Subquery Scan on all (datanode_1,datanode_2)
+   ->  Update on public.some_tab
+         Update on public.some_tab
+         ->  Result
+               Output: (a + 1), b, xc_node_id, ctid
+               One-Time Filter: false
+(6 rows)
 
 update some_tab set a = a + 1 where false;
 explain (verbose, costs off)
 update some_tab set a = a + 1 where false returning b, a;
-            QUERY PLAN            
-----------------------------------
- Update on public.some_tab
+                     QUERY PLAN                      
+-----------------------------------------------------
+ Remote Subquery Scan on all (datanode_1,datanode_2)
    Output: b, a
-   Update on public.some_tab
-   ->  Result
-         Output: (a + 1), b, ctid
-         One-Time Filter: false
-(6 rows)
+   ->  Update on public.some_tab
+         Output: b, a
+         Update on public.some_tab
+         ->  Result
+               Output: (a + 1), b, xc_node_id, ctid
+               One-Time Filter: false
+(8 rows)
 
 update some_tab set a = a + 1 where false returning b, a;
  b | a 
@@ -907,12 +910,13 @@ select tableoid::regclass::text as relname, parted_tab.* from parted_tab order b
 
 -- modifies partition key, but no rows will actually be updated
 explain update parted_tab set a = 2 where false;
-                       QUERY PLAN                       
---------------------------------------------------------
- Update on parted_tab  (cost=0.00..0.00 rows=0 width=0)
-   ->  Result  (cost=0.00..0.00 rows=0 width=0)
-         One-Time Filter: false
-(3 rows)
+                                      QUERY PLAN                                       
+---------------------------------------------------------------------------------------
+ Remote Subquery Scan on all (datanode_1,datanode_2)  (cost=0.00..0.00 rows=0 width=0)
+   ->  Update on parted_tab  (cost=0.00..0.00 rows=0 width=0)
+         ->  Result  (cost=0.00..0.00 rows=0 width=0)
+               One-Time Filter: false
+(4 rows)
 
 drop table parted_tab;
 drop table some_tab cascade;
diff --git a/src/test/regress/expected/join.out b/src/test/regress/expected/join.out
index 038421efae..2f16b93bda 100644
--- a/src/test/regress/expected/join.out
+++ b/src/test/regress/expected/join.out
@@ -5573,30 +5573,34 @@ select * from
 explain (verbose, costs off)
 select * from int8_tbl i8 left join lateral
   (select *, i8.q2 from int4_tbl where false) ss on true;
-              QUERY PLAN              
---------------------------------------
+                   QUERY PLAN                   
+------------------------------------------------
  Nested Loop Left Join
    Output: i8.q1, i8.q2, f1, (i8.q2)
-   ->  Seq Scan on public.int8_tbl i8
+   ->  Remote Subquery Scan on all (datanode_1)
          Output: i8.q1, i8.q2
+         ->  Seq Scan on public.int8_tbl i8
+               Output: i8.q1, i8.q2
    ->  Result
          Output: f1, i8.q2
          One-Time Filter: false
-(7 rows)
+(9 rows)
 
 explain (verbose, costs off)
 select * from int8_tbl i8 left join lateral
   (select *, i8.q2 from int4_tbl i1, int4_tbl i2 where false) ss on true;
-               QUERY PLAN                
------------------------------------------
+                   QUERY PLAN                   
+------------------------------------------------
  Nested Loop Left Join
    Output: i8.q1, i8.q2, f1, f1, (i8.q2)
-   ->  Seq Scan on public.int8_tbl i8
+   ->  Remote Subquery Scan on all (datanode_1)
          Output: i8.q1, i8.q2
+         ->  Seq Scan on public.int8_tbl i8
+               Output: i8.q1, i8.q2
    ->  Result
          Output: f1, f1, i8.q2
          One-Time Filter: false
-(7 rows)
+(9 rows)
 
 -- check handling of nested appendrels inside LATERAL
 select * from
diff --git a/src/test/regress/expected/privileges.out b/src/test/regress/expected/privileges.out
index a02f7addc1..ae09607b15 100644
--- a/src/test/regress/expected/privileges.out
+++ b/src/test/regress/expected/privileges.out
@@ -237,16 +237,19 @@ EXPLAIN (COSTS OFF) SELECT * FROM atest12 x, atest12 y
 -- This should also be a nestloop, but the security barrier forces the inner
 -- scan to be materialized
 EXPLAIN (COSTS OFF) SELECT * FROM atest12sbv x, atest12sbv y WHERE x.a = y.b;
-                QUERY PLAN                 
--------------------------------------------
- Nested Loop
-   Join Filter: (atest12.a = atest12_1.b)
-   ->  Seq Scan on atest12
-         Filter: (b <<< 5)
-   ->  Materialize
-         ->  Seq Scan on atest12 atest12_1
+                              QUERY PLAN                               
+-----------------------------------------------------------------------
+ Remote Subquery Scan on all (datanode_1,datanode_2)
+   ->  Nested Loop
+         Join Filter: (atest12.a = b)
+         ->  Seq Scan on atest12
                Filter: (b <<< 5)
-(7 rows)
+         ->  Materialize
+               ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+                     Distribute results by H: b
+                     ->  Seq Scan on atest12 atest12_1
+                           Filter: (b <<< 5)
+(10 rows)
 
 -- Check if regress_user2 can break security.
 SET SESSION AUTHORIZATION regress_user2;
@@ -261,73 +264,84 @@ ERROR:  permission denied for relation atest12
 -- This plan should use hashjoin, as it will expect many rows to be selected.
 SET random_page_cost = 8.5;
 EXPLAIN (COSTS OFF) SELECT * FROM atest12v x, atest12v y WHERE x.a = y.b;
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                           QUERY PLAN                            
+-----------------------------------------------------------------
  Remote Subquery Scan on all (datanode_1,datanode_2)
-   ->  Hash Join
-         Hash Cond: (atest12.a = atest12_1.b)
-         ->  Seq Scan on atest12
+   ->  Nested Loop
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               Distribute results by H: b
+               ->  Seq Scan on atest12 atest12_1
+                     Filter: (b <<< 5)
+         ->  Index Scan using atest12_a_idx on atest12
+               Index Cond: (a = atest12_1.b)
                Filter: (b <<< 5)
-         ->  Hash
-               ->  Remote Subquery Scan on all (datanode_1,datanode_2)
-                     Distribute results by H: b
-                     ->  Seq Scan on atest12 atest12_1
-                           Filter: (b <<< 5)
-(10 rows)
+(9 rows)
 
 RESET random_page_cost;
 -- These plans should continue to use a nestloop, since they execute with the
 -- privileges of the view owner.
 EXPLAIN (COSTS OFF) SELECT * FROM atest12v x, atest12v y WHERE x.a = y.b;
-                   QUERY PLAN                    
--------------------------------------------------
- Nested Loop
-   ->  Seq Scan on atest12 atest12_1
-         Filter: (b <<< 5)
-   ->  Index Scan using atest12_a_idx on atest12
-         Index Cond: (a = atest12_1.b)
-         Filter: (b <<< 5)
-(6 rows)
+                           QUERY PLAN                            
+-----------------------------------------------------------------
+ Remote Subquery Scan on all (datanode_1,datanode_2)
+   ->  Nested Loop
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               Distribute results by H: b
+               ->  Seq Scan on atest12 atest12_1
+                     Filter: (b <<< 5)
+         ->  Index Scan using atest12_a_idx on atest12
+               Index Cond: (a = atest12_1.b)
+               Filter: (b <<< 5)
+(9 rows)
 
 EXPLAIN (COSTS OFF) SELECT * FROM atest12sbv x, atest12sbv y WHERE x.a = y.b;
-                QUERY PLAN                 
--------------------------------------------
- Nested Loop
-   Join Filter: (atest12.a = atest12_1.b)
-   ->  Seq Scan on atest12
-         Filter: (b <<< 5)
-   ->  Materialize
-         ->  Seq Scan on atest12 atest12_1
+                              QUERY PLAN                               
+-----------------------------------------------------------------------
+ Remote Subquery Scan on all (datanode_1,datanode_2)
+   ->  Nested Loop
+         Join Filter: (atest12.a = b)
+         ->  Seq Scan on atest12
                Filter: (b <<< 5)
-(7 rows)
+         ->  Materialize
+               ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+                     Distribute results by H: b
+                     ->  Seq Scan on atest12 atest12_1
+                           Filter: (b <<< 5)
+(10 rows)
 
 -- A non-security barrier view does not guard against information leakage.
 EXPLAIN (COSTS OFF) SELECT * FROM atest12v x, atest12v y
   WHERE x.a = y.b and abs(y.a) <<< 5;
-                   QUERY PLAN                    
--------------------------------------------------
- Nested Loop
-   ->  Seq Scan on atest12 atest12_1
-         Filter: ((b <<< 5) AND (abs(a) <<< 5))
-   ->  Index Scan using atest12_a_idx on atest12
-         Index Cond: (a = atest12_1.b)
-         Filter: (b <<< 5)
-(6 rows)
+                           QUERY PLAN                            
+-----------------------------------------------------------------
+ Remote Subquery Scan on all (datanode_1,datanode_2)
+   ->  Nested Loop
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               Distribute results by H: b
+               ->  Seq Scan on atest12 atest12_1
+                     Filter: ((b <<< 5) AND (abs(a) <<< 5))
+         ->  Index Scan using atest12_a_idx on atest12
+               Index Cond: (a = atest12_1.b)
+               Filter: (b <<< 5)
+(9 rows)
 
 -- But a security barrier view isolates the leaky operator.
 EXPLAIN (COSTS OFF) SELECT * FROM atest12sbv x, atest12sbv y
   WHERE x.a = y.b and abs(y.a) <<< 5;
-             QUERY PLAN              
--------------------------------------
- Nested Loop
-   Join Filter: (atest12_1.a = y.b)
-   ->  Subquery Scan on y
-         Filter: (abs(y.a) <<< 5)
-         ->  Seq Scan on atest12
+                           QUERY PLAN                            
+-----------------------------------------------------------------
+ Remote Subquery Scan on all (datanode_1,datanode_2)
+   ->  Nested Loop
+         Join Filter: (atest12_1.a = y.b)
+         ->  Remote Subquery Scan on all (datanode_1,datanode_2)
+               Distribute results by H: b
+               ->  Subquery Scan on y
+                     Filter: (abs(y.a) <<< 5)
+                     ->  Seq Scan on atest12
+                           Filter: (b <<< 5)
+         ->  Seq Scan on atest12 atest12_1
                Filter: (b <<< 5)
-   ->  Seq Scan on atest12 atest12_1
-         Filter: (b <<< 5)
-(8 rows)
+(11 rows)
 
 -- Now regress_user1 grants sufficient access to regress_user2.
 SET SESSION AUTHORIZATION regress_user1;
diff --git a/src/test/regress/expected/triggers.out b/src/test/regress/expected/triggers.out
index c92923e77f..37822fb07c 100644
--- a/src/test/regress/expected/triggers.out
+++ b/src/test/regress/expected/triggers.out
@@ -1548,19 +1548,21 @@ $$ language plpgsql;
 create trigger before_stmt_trigger
 	before update on stmt_trig_on_empty_upd
 	execute procedure update_stmt_notice();
+ERROR:  Postgres-XL does not support TRIGGER yet
+DETAIL:  The feature is not currently supported
 create trigger before_stmt_trigger
 	before update on stmt_trig_on_empty_upd1
 	execute procedure update_stmt_notice();
+ERROR:  Postgres-XL does not support TRIGGER yet
+DETAIL:  The feature is not currently supported
 -- inherited no-op update
 update stmt_trig_on_empty_upd set a = a where false returning a+1 as aa;
-NOTICE:  updating stmt_trig_on_empty_upd
  aa 
 ----
 (0 rows)
 
 -- simple no-op update
 update stmt_trig_on_empty_upd1 set a = a where false returning a+1 as aa;
-NOTICE:  updating stmt_trig_on_empty_upd1
  aa 
 ----
 (0 rows)
diff --git a/src/test/regress/expected/tsrf.out b/src/test/regress/expected/tsrf.out
index 2270fdefe6..8c8e739c1c 100644
--- a/src/test/regress/expected/tsrf.out
+++ b/src/test/regress/expected/tsrf.out
@@ -86,13 +86,17 @@ INSERT INTO few VALUES(1, 'a', 'foo'),(2, 'a', 'bar'),(3, 'b', 'bar');
 -- SRF with a provably-dummy relation
 explain (verbose, costs off)
 SELECT unnest(ARRAY[1, 2]) FROM few WHERE false;
-              QUERY PLAN              
---------------------------------------
- ProjectSet
-   Output: unnest('{1,2}'::integer[])
-   ->  Result
-         One-Time Filter: false
-(4 rows)
+                                QUERY PLAN                                 
+---------------------------------------------------------------------------
+ Remote Fast Query Execution
+   Output: unnest(ARRAY[1, 2])
+   Node/s: datanode_1, datanode_2
+   Remote query: SELECT unnest(ARRAY[1, 2]) AS unnest FROM few WHERE false
+   ->  ProjectSet
+         Output: unnest('{1,2}'::integer[])
+         ->  Result
+               One-Time Filter: false
+(8 rows)
 
 SELECT unnest(ARRAY[1, 2]) FROM few WHERE false;
  unnest 
diff --git a/src/test/regress/expected/union.out b/src/test/regress/expected/union.out
index 276ee807f5..328d3eb1c4 100644
--- a/src/test/regress/expected/union.out
+++ b/src/test/regress/expected/union.out
@@ -942,24 +942,25 @@ select distinct q1 from
    union all
    select distinct * from int8_tbl i82) ss
 where q2 = q2;
-                       QUERY PLAN                       
---------------------------------------------------------
- Unique
-   ->  Merge Append
-         Sort Key: "*SELECT* 1".q1
-         ->  Subquery Scan on "*SELECT* 1"
-               ->  Unique
-                     ->  Sort
-                           Sort Key: i81.q1, i81.q2
-                           ->  Seq Scan on int8_tbl i81
-                                 Filter: (q2 = q2)
-         ->  Subquery Scan on "*SELECT* 2"
-               ->  Unique
-                     ->  Sort
-                           Sort Key: i82.q1, i82.q2
-                           ->  Seq Scan on int8_tbl i82
-                                 Filter: (q2 = q2)
-(15 rows)
+                          QUERY PLAN                          
+--------------------------------------------------------------
+ Remote Subquery Scan on all (datanode_1)
+   ->  Unique
+         ->  Merge Append
+               Sort Key: "*SELECT* 1".q1
+               ->  Subquery Scan on "*SELECT* 1"
+                     ->  Unique
+                           ->  Sort
+                                 Sort Key: i81.q1, i81.q2
+                                 ->  Seq Scan on int8_tbl i81
+                                       Filter: (q2 = q2)
+               ->  Subquery Scan on "*SELECT* 2"
+                     ->  Unique
+                           ->  Sort
+                                 Sort Key: i82.q1, i82.q2
+                                 ->  Seq Scan on int8_tbl i82
+                                       Filter: (q2 = q2)
+(16 rows)
 
 select distinct q1 from
   (select distinct * from int8_tbl i81
@@ -978,24 +979,25 @@ select distinct q1 from
    union all
    select distinct * from int8_tbl i82) ss
 where -q1 = q2;
-                       QUERY PLAN                       
---------------------------------------------------------
- Unique
-   ->  Merge Append
-         Sort Key: "*SELECT* 1".q1
-         ->  Subquery Scan on "*SELECT* 1"
-               ->  Unique
-                     ->  Sort
-                           Sort Key: i81.q1, i81.q2
-                           ->  Seq Scan on int8_tbl i81
-                                 Filter: ((- q1) = q2)
-         ->  Subquery Scan on "*SELECT* 2"
-               ->  Unique
-                     ->  Sort
-                           Sort Key: i82.q1, i82.q2
-                           ->  Seq Scan on int8_tbl i82
-                                 Filter: ((- q1) = q2)
-(15 rows)
+                          QUERY PLAN                          
+--------------------------------------------------------------
+ Remote Subquery Scan on all (datanode_1)
+   ->  Unique
+         ->  Merge Append
+               Sort Key: "*SELECT* 1".q1
+               ->  Subquery Scan on "*SELECT* 1"
+                     ->  Unique
+                           ->  Sort
+                                 Sort Key: i81.q1, i81.q2
+                                 ->  Seq Scan on int8_tbl i81
+                                       Filter: ((- q1) = q2)
+               ->  Subquery Scan on "*SELECT* 2"
+                     ->  Unique
+                           ->  Sort
+                                 Sort Key: i82.q1, i82.q2
+                                 ->  Seq Scan on int8_tbl i82
+                                       Filter: ((- q1) = q2)
+(16 rows)
 
 select distinct q1 from
   (select distinct * from int8_tbl i81
diff --git a/src/test/regress/expected/updatable_views.out b/src/test/regress/expected/updatable_views.out
index 6a331fdd08..9850f42a8c 100644
--- a/src/test/regress/expected/updatable_views.out
+++ b/src/test/regress/expected/updatable_views.out
@@ -2660,6 +2660,8 @@ $$
 language plpgsql;
 create trigger base_tab_def_view_instrig instead of insert on base_tab_def_view
   for each row execute procedure base_tab_def_view_instrig_func();
+ERROR:  Postgres-XL does not support TRIGGER yet
+DETAIL:  The feature is not currently supported
 truncate base_tab_def;
 insert into base_tab_def values (1);
 insert into base_tab_def values (2), (3);
@@ -2681,19 +2683,20 @@ select * from base_tab_def order by a;
   4 | Table default | Table default |              | 
   5 | Table default | Table default |              | 
   6 | Table default | Table default |              | 
- 11 | View default  |               | View default | 
- 12 | View default  |               | View default | 
- 13 | View default  |               | View default | 
- 14 | View default  |               | View default | 
- 15 | View default  |               | View default | 
- 16 | View default  |               | View default | 
- 17 | View default  |               | View default | 
-    | View default  |               | View default | 
+ 11 | View default  | Table default | View default | 
+ 12 | View default  | Table default | View default | 
+ 13 | View default  | Table default | View default | 
+ 14 | View default  | Table default | View default | 
+ 15 | View default  | Table default | View default | 
+ 16 | View default  | Table default | View default | 
+ 17 | View default  | Table default | View default | 
+    | View default  | Table default | View default | 
 (14 rows)
 
 -- Using an unconditional DO INSTEAD rule should also cause NULLs to be
 -- inserted where there are no view defaults.
 drop trigger base_tab_def_view_instrig on base_tab_def_view;
+ERROR:  trigger "base_tab_def_view_instrig" for table "base_tab_def_view" does not exist
 drop function base_tab_def_view_instrig_func;
 create rule base_tab_def_view_ins_rule as on insert to base_tab_def_view
   do instead insert into base_tab_def values (new.a, new.b, new.c, new.d, new.e);
diff --git a/src/test/regress/expected/update.out b/src/test/regress/expected/update.out
index 5191c007f4..4b5ad9a1da 100644
--- a/src/test/regress/expected/update.out
+++ b/src/test/regress/expected/update.out
@@ -172,19 +172,22 @@ EXPLAIN (VERBOSE, COSTS OFF)
 UPDATE update_test t
   SET (a, b) = (SELECT b, a FROM update_test s WHERE s.a = t.a)
   WHERE CURRENT_USER = SESSION_USER;
-                               QUERY PLAN                               
-------------------------------------------------------------------------
- Update on public.update_test t
-   ->  Result
-         Output: ($1), ($2), t.c, ((SubPlan 1 (returns $1,$2))), t.ctid
-         One-Time Filter: (CURRENT_USER = SESSION_USER)
-         ->  Seq Scan on public.update_test t
-               Output: $1, $2, t.c, (SubPlan 1 (returns $1,$2)), t.ctid
-               SubPlan 1 (returns $1,$2)
-                 ->  Seq Scan on public.update_test s
-                       Output: s.b, s.a
-                       Filter: (s.a = t.a)
-(10 rows)
+                                  QUERY PLAN                                  
+------------------------------------------------------------------------------
+ Remote Subquery Scan on any (datanode_1,datanode_2)
+   ->  Update on public.update_test t
+         ->  Result
+               Output: ($1), ($2), t.c, ((SubPlan 1 (returns $1,$2))), t.ctid
+               One-Time Filter: (CURRENT_USER = SESSION_USER)
+               ->  Seq Scan on public.update_test t
+                     Output: $1, $2, t.c, (SubPlan 1 (returns $1,$2)), t.ctid
+                     SubPlan 1 (returns $1,$2)
+                       ->  Remote Subquery Scan on all (datanode_1)
+                             Output: s.b, s.a
+                             ->  Seq Scan on public.update_test s
+                                   Output: s.b, s.a
+                                   Filter: (s.a = t.a)
+(13 rows)
 
 UPDATE update_test t
   SET (a, b) = (SELECT b, a FROM update_test s WHERE s.a = t.a)
diff --git a/src/test/regress/input/copy.source b/src/test/regress/input/copy.source
index ce285a8f31..a4c088277b 100644
--- a/src/test/regress/input/copy.source
+++ b/src/test/regress/input/copy.source
@@ -141,8 +141,8 @@ create table parted_copytest (
 	c text
 ) partition by list (b);
 
-create table parted_copytest_a1 (c text, b int, a int);
-create table parted_copytest_a2 (a int, c text, b int);
+create table parted_copytest_a1 (a int, c text, b int) distribute by hash(a);
+create table parted_copytest_a2 (a int, c text, b int) distribute by hash(a);
 
 alter table parted_copytest attach partition parted_copytest_a1 for values in(1);
 alter table parted_copytest attach partition parted_copytest_a2 for values in(2);
diff --git a/src/test/regress/input/largeobject.source b/src/test/regress/input/largeobject.source
index 17d940476c..2e05379c04 100644
--- a/src/test/regress/input/largeobject.source
+++ b/src/test/regress/input/largeobject.source
@@ -203,6 +203,7 @@ SELECT lo_close(fd) FROM lotest_stash_values;
 END;
 
 SELECT lo_export(loid, '@abs_builddir@/results/lotest.txt') FROM lotest_stash_values;
+COPY lotest_stash_values TO '@abs_builddir@/results/lotest.txt';
 \lo_import '@abs_builddir@/results/lotest.txt'
 
 \set newloid :LASTOID
diff --git a/src/test/regress/output/copy.source b/src/test/regress/output/copy.source
index cd65f13b46..49d44a6d35 100644
--- a/src/test/regress/output/copy.source
+++ b/src/test/regress/output/copy.source
@@ -101,8 +101,8 @@ create table parted_copytest (
 	b int,
 	c text
 ) partition by list (b);
-create table parted_copytest_a1 (c text, b int, a int);
-create table parted_copytest_a2 (a int, c text, b int);
+create table parted_copytest_a1 (a int, c text, b int) distribute by hash(a);
+create table parted_copytest_a2 (a int, c text, b int) distribute by hash(a);
 alter table parted_copytest attach partition parted_copytest_a1 for values in(1);
 alter table parted_copytest attach partition parted_copytest_a2 for values in(2);
 -- We must insert enough rows to trigger multi-inserts.  These are only
diff --git a/src/test/regress/output/largeobject_3.source b/src/test/regress/output/largeobject_3.source
index abfa16ea90..595bf19dc9 100644
--- a/src/test/regress/output/largeobject_3.source
+++ b/src/test/regress/output/largeobject_3.source
@@ -378,7 +378,7 @@ TRUNCATE lotest_stash_values;
 \lo_unlink :newloid
 ERROR:  Postgres-XL does not yet support large objects
 DETAIL:  The feature is not currently supported
-\lo_import 'results/lotest.txt'
+\lo_import '@abs_builddir@/results/lotest.txt'
 ERROR:  Postgres-XL does not yet support large objects
 DETAIL:  The feature is not currently supported
 \set newloid_1 :LASTOID
diff --git a/src/test/regress/sql/copy2.sql b/src/test/regress/sql/copy2.sql
index bb347d0d75..9d441b0711 100644
--- a/src/test/regress/sql/copy2.sql
+++ b/src/test/regress/sql/copy2.sql
@@ -414,18 +414,21 @@ SELECT * FROM instead_of_insert_tbl;
 -- Test of COPY optimization with view using INSTEAD OF INSERT
 -- trigger when relation is created in the same transaction as
 -- when COPY is executed.
-BEGIN;
-CREATE VIEW instead_of_insert_tbl_view_2 as select ''::text as str;
-CREATE TRIGGER trig_instead_of_insert_tbl_view_2
-  INSTEAD OF INSERT ON instead_of_insert_tbl_view_2
-  FOR EACH ROW EXECUTE PROCEDURE fun_instead_of_insert_tbl();
-
-COPY instead_of_insert_tbl_view_2 FROM stdin;
-test1
-\.
-
-SELECT * FROM instead_of_insert_tbl;
-COMMIT;
+--
+-- XL does not support triggers.
+--
+-- BEGIN;
+-- CREATE VIEW instead_of_insert_tbl_view_2 as select ''::text as str;
+-- CREATE TRIGGER trig_instead_of_insert_tbl_view_2
+--   INSTEAD OF INSERT ON instead_of_insert_tbl_view_2
+--   FOR EACH ROW EXECUTE PROCEDURE fun_instead_of_insert_tbl();
+-- 
+-- COPY instead_of_insert_tbl_view_2 FROM stdin;
+-- test1
+-- \.
+-- 
+-- SELECT * FROM instead_of_insert_tbl;
+-- COMMIT;
 
 -- clean up
 DROP TABLE forcetest;
@@ -439,5 +442,5 @@ DROP FUNCTION fn_x_before();
 DROP FUNCTION fn_x_after();
 DROP TABLE instead_of_insert_tbl;
 DROP VIEW instead_of_insert_tbl_view;
-DROP VIEW instead_of_insert_tbl_view_2;
+-- DROP VIEW instead_of_insert_tbl_view_2;
 DROP FUNCTION fun_instead_of_insert_tbl();