Update check multi tests

src/test/regress/expected/citus_local_tables_queries.out

@@ -120,7 +120,7 @@ NOTICE:  executing the command locally: SELECT a, b FROM citus_local_table_queri
 
 -- should fail as we don't support direct joins between distributed/local tables
 SELECT count(*) FROM distributed_table d1, distributed_table d2, citus_local_table;
-ERROR:  direct joins between distributed and local tables are not supported
+ERROR:  complex joins are only supported when all distributed tables are co-located and joined on their distribution columns
 -- local table inside subquery should just work
 SELECT count(*) FROM
 (
@@ -154,7 +154,12 @@ SELECT count(*) FROM
 (
 	SELECT *, random() FROM (SELECT *, random() FROM citus_local_table, distributed_table) as subquery_inner
 ) as subquery_top;
-ERROR:  direct joins between distributed and local tables are not supported
+NOTICE:  executing the command locally: SELECT NULL::integer AS a, NULL::integer AS b FROM citus_local_table_queries.citus_local_table_1509000 citus_local_table WHERE true OFFSET 0
+ count
+---------------------------------------------------------------------
+    36
+(1 row)
+
 -- should fail as we don't support direct joins between distributed/local tables
 SELECT count(*) FROM
 (
@@ -162,7 +167,13 @@ SELECT count(*) FROM
 		FROM (
 				WITH cte_1 AS (SELECT *, random() FROM citus_local_table, distributed_table) SELECT * FROM cte_1) as subquery_inner
 ) as subquery_top;
-ERROR:  direct joins between distributed and local tables are not supported
+NOTICE:  executing the command locally: SELECT a, b FROM citus_local_table_queries.citus_local_table_1509000 citus_local_table WHERE true OFFSET 0
+NOTICE:  executing the command locally: SELECT count(*) AS count FROM (SELECT subquery_inner.a, subquery_inner.b, subquery_inner.a_1 AS a, subquery_inner.b_1 AS b, subquery_inner.random, random() AS random FROM (SELECT cte_1.a, cte_1.b, cte_1.a_1 AS a, cte_1.b_1 AS b, cte_1.random FROM (SELECT intermediate_result.a, intermediate_result.b, intermediate_result.a_1 AS a, intermediate_result.b_1 AS b, intermediate_result.random FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer, b integer, a_1 integer, b_1 integer, random double precision)) cte_1(a, b, a_1, b_1, random)) subquery_inner(a, b, a_1, b_1, random)) subquery_top(a, b, a_1, b_1, random, random_1)
+ count
+---------------------------------------------------------------------
+    36
+(1 row)
+
 -- should be  fine
 SELECT count(*) FROM
 (
@@ -474,7 +485,7 @@ NOTICE:  executing the command locally: SELECT count(*) AS count FROM (((citus_l
 
 -- not supported direct outer join
 SELECT count(*) FROM citus_local_table LEFT JOIN distributed_table ON (true);
-ERROR:  direct joins between distributed and local tables are not supported
+ERROR:  cannot pushdown the subquery
 -- distinct in subquery on CTE
 WITH one_row AS (
 	SELECT a from citus_local_table WHERE b = 1
@@ -516,9 +527,14 @@ NOTICE:  executing the command locally: SELECT a, b FROM citus_local_table_queri
 
 -- join between citus local tables and distributed tables would fail
 SELECT count(*) FROM citus_local_table, distributed_table;
-ERROR:  direct joins between distributed and local tables are not supported
+NOTICE:  executing the command locally: SELECT NULL::integer AS a, NULL::integer AS b FROM citus_local_table_queries.citus_local_table_1509000 citus_local_table WHERE true OFFSET 0
+ count
+---------------------------------------------------------------------
+    36
+(1 row)
+
 SELECT * FROM citus_local_table, distributed_table ORDER BY 1,2,3,4 FOR UPDATE;
-ERROR:  direct joins between distributed and local tables are not supported
+ERROR:  could not run distributed query with FOR UPDATE/SHARE commands
 -- join between citus local tables and postgres local tables are okey
 SELECT count(citus_local_table.b), count(postgres_local_table.a)
 FROM citus_local_table, postgres_local_table
@@ -638,7 +654,8 @@ NOTICE:  executing the copy locally for shard xxxxx
 INSERT INTO citus_local_table
 SELECT distributed_table.* FROM distributed_table
 JOIN citus_local_table ON (true);
-ERROR:  direct joins between distributed and local tables are not supported
+NOTICE:  executing the command locally: SELECT NULL::integer AS a, NULL::integer AS b FROM citus_local_table_queries.citus_local_table_1509000 citus_local_table WHERE true OFFSET 0
+NOTICE:  executing the copy locally for shard xxxxx
 -- .. but when wrapped into a CTE, join works fine
 INSERT INTO citus_local_table
 SELECT distributed_table.* FROM distributed_table
@@ -662,38 +679,38 @@ SELECT clear_and_init_test_tables();
 DELETE FROM citus_local_table
 USING postgres_local_table
 WHERE citus_local_table.b = postgres_local_table.b;
-ERROR:  cannot plan modifications with local tables involving citus tables
+NOTICE:  executing the command locally: DELETE FROM citus_local_table_queries.citus_local_table_1509000 citus_local_table USING citus_local_table_queries.postgres_local_table WHERE (citus_local_table.b OPERATOR(pg_catalog.=) postgres_local_table.b)
 UPDATE citus_local_table
 SET b = 5
 FROM postgres_local_table
 WHERE citus_local_table.a = 3 AND citus_local_table.b = postgres_local_table.b;
-ERROR:  cannot plan modifications with local tables involving citus tables
+NOTICE:  executing the command locally: UPDATE citus_local_table_queries.citus_local_table_1509000 citus_local_table SET b = 5 FROM citus_local_table_queries.postgres_local_table WHERE ((citus_local_table.a OPERATOR(pg_catalog.=) 3) AND (citus_local_table.b OPERATOR(pg_catalog.=) postgres_local_table.b))
 DELETE FROM postgres_local_table
 USING citus_local_table
 WHERE citus_local_table.b = postgres_local_table.b;
-ERROR:  cannot plan modifications with local tables involving citus tables
+ERROR:  relation postgres_local_table is not distributed
 UPDATE postgres_local_table
 SET b = 5
 FROM citus_local_table
 WHERE citus_local_table.a = 3 AND citus_local_table.b = postgres_local_table.b;
-ERROR:  cannot plan modifications with local tables involving citus tables
+ERROR:  relation postgres_local_table is not distributed
 -- no direct joins supported
 UPDATE distributed_table
 SET b = 6
 FROM citus_local_table
 WHERE citus_local_table.a = distributed_table.a;
-ERROR:  cannot plan modifications with citus local tables and distributed tables
+NOTICE:  executing the command locally: SELECT a, NULL::integer AS b FROM citus_local_table_queries.citus_local_table_1509000 citus_local_table WHERE true OFFSET 0
 UPDATE reference_table
 SET b = 6
 FROM citus_local_table
 WHERE citus_local_table.a = reference_table.a;
-ERROR:  cannot plan modifications of reference tables with citus local tables
+NOTICE:  executing the command locally: UPDATE citus_local_table_queries.reference_table_1509002 reference_table SET b = 6 FROM citus_local_table_queries.citus_local_table_1509000 citus_local_table WHERE (citus_local_table.a OPERATOR(pg_catalog.=) reference_table.a)
 -- should not work, add HINT use CTEs
 UPDATE citus_local_table
 SET b = 6
 FROM distributed_table
 WHERE citus_local_table.a = distributed_table.a;
-ERROR:  cannot plan modifications with citus local tables and distributed tables
+NOTICE:  executing the command locally: UPDATE citus_local_table_queries.citus_local_table_1509000 citus_local_table SET b = 6 FROM (SELECT intermediate_result.a, intermediate_result.b FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer, b integer)) distributed_table WHERE (citus_local_table.a OPERATOR(pg_catalog.=) distributed_table.a)
 -- should work, add HINT use CTEs
 UPDATE citus_local_table
 SET b = 6
@@ -704,16 +721,16 @@ NOTICE:  executing the command locally: UPDATE citus_local_table_queries.citus_l
 DELETE FROM distributed_table
 USING citus_local_table
 WHERE citus_local_table.a = distributed_table.a;
-ERROR:  cannot plan modifications with citus local tables and distributed tables
+NOTICE:  executing the command locally: SELECT a, NULL::integer AS b FROM citus_local_table_queries.citus_local_table_1509000 citus_local_table WHERE true OFFSET 0
 -- should not work, add HINT use CTEs
 DELETE FROM citus_local_table
 USING distributed_table
 WHERE citus_local_table.a = distributed_table.a;
-ERROR:  cannot plan modifications with citus local tables and distributed tables
+NOTICE:  executing the command locally: DELETE FROM citus_local_table_queries.citus_local_table_1509000 citus_local_table USING (SELECT intermediate_result.a, intermediate_result.b FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer, b integer)) distributed_table WHERE (citus_local_table.a OPERATOR(pg_catalog.=) distributed_table.a)
 DELETE FROM reference_table
 USING citus_local_table
 WHERE citus_local_table.a = reference_table.a;
-ERROR:  cannot plan modifications of reference tables with citus local tables
+NOTICE:  executing the command locally: DELETE FROM citus_local_table_queries.reference_table_1509002 reference_table USING citus_local_table_queries.citus_local_table_1509000 citus_local_table WHERE (citus_local_table.a OPERATOR(pg_catalog.=) reference_table.a)
 -- should work, add HINT use CTEs
 DELETE FROM citus_local_table
 USING reference_table
@@ -726,7 +743,8 @@ NOTICE:  executing the command locally: DELETE FROM citus_local_table_queries.ci
 -- just works
 DELETE FROM citus_local_table
 WHERE citus_local_table.a IN (SELECT a FROM reference_table);
-NOTICE:  executing the command locally: DELETE FROM citus_local_table_queries.citus_local_table_1509000 citus_local_table WHERE (a OPERATOR(pg_catalog.=) ANY (SELECT reference_table.a FROM citus_local_table_queries.reference_table_1509002 reference_table))
+NOTICE:  executing the command locally: SELECT a FROM citus_local_table_queries.reference_table_1509002 reference_table
+NOTICE:  executing the command locally: DELETE FROM citus_local_table_queries.citus_local_table_1509000 citus_local_table WHERE (a OPERATOR(pg_catalog.=) ANY (SELECT intermediate_result.a FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer)))
 -- just works
 WITH distributed_table_cte AS (SELECT * FROM distributed_table)
 UPDATE citus_local_table
@@ -740,7 +758,8 @@ UPDATE citus_local_table
 SET b = 6
 FROM reference_table_cte
 WHERE citus_local_table.a = reference_table_cte.a;
-NOTICE:  executing the command locally: WITH reference_table_cte AS (SELECT reference_table.a, reference_table.b FROM citus_local_table_queries.reference_table_1509002 reference_table) UPDATE citus_local_table_queries.citus_local_table_1509000 citus_local_table SET b = 6 FROM reference_table_cte WHERE (citus_local_table.a OPERATOR(pg_catalog.=) reference_table_cte.a)
+NOTICE:  executing the command locally: SELECT a, b FROM citus_local_table_queries.reference_table_1509002 reference_table
+NOTICE:  executing the command locally: UPDATE citus_local_table_queries.citus_local_table_1509000 citus_local_table SET b = 6 FROM (SELECT intermediate_result.a, intermediate_result.b FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer, b integer)) reference_table_cte WHERE (citus_local_table.a OPERATOR(pg_catalog.=) reference_table_cte.a)
 ---------------------------------------------------------------------
 ----- VIEW QUERIES -----
 ---------------------------------------------------------------------
@@ -772,7 +791,14 @@ JOIN citus_local_table_2 USING (a)
 JOIN distributed_table USING (a);
 -- should fail as view contains direct local dist join
 SELECT count(*) FROM view_2;
-ERROR:  direct joins between distributed and local tables are not supported
+NOTICE:  executing the command locally: SELECT a, NULL::integer AS b FROM citus_local_table_queries.citus_local_table_1509000 citus_local_table WHERE true OFFSET 0
+NOTICE:  executing the command locally: SELECT a, NULL::integer AS b FROM citus_local_table_queries.citus_local_table_2_1509001 citus_local_table_2 WHERE true OFFSET 0
+NOTICE:  executing the command locally: SELECT count(*) AS count FROM (SELECT intermediate_result.count FROM read_intermediate_result('XXX_3'::text, 'binary'::citus_copy_format) intermediate_result(count bigint)) view_2
+ count
+---------------------------------------------------------------------
+     1
+(1 row)
+
 CREATE VIEW view_3
 AS SELECT count(*)
 FROM citus_local_table_2
@@ -826,7 +852,17 @@ UPDATE citus_local_table lt SET a = mt.a
 FROM distributed_table mt WHERE mt.b = lt.b
 RETURNING lt.b, lt.a
 ) SELECT * FROM cte JOIN distributed_table mt ON mt.b = cte.b ORDER BY 1,2,3,4;
-ERROR:  cannot plan modifications with citus local tables and distributed tables
+NOTICE:  executing the command locally: UPDATE citus_local_table_queries.citus_local_table_1509000 lt SET a = mt.a FROM (SELECT intermediate_result.a, intermediate_result.b FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer, b integer)) mt WHERE (mt.b OPERATOR(pg_catalog.=) lt.b) RETURNING lt.b, lt.a
+ b | a | a | b
+---------------------------------------------------------------------
+ 0 | 0 | 0 | 0
+ 1 | 1 | 1 | 1
+ 2 | 2 | 2 | 2
+ 3 | 3 | 3 | 3
+ 4 | 4 | 4 | 4
+ 5 | 5 | 5 | 5
+(6 rows)
+
 -- join with CTE just works
 UPDATE citus_local_table
 SET a=5
@@ -852,7 +888,7 @@ UPDATE citus_local_table
 SET a=5
 FROM (SELECT b FROM distributed_table) AS foo
 WHERE foo.b = citus_local_table.b;
-ERROR:  cannot plan modifications with citus local tables and distributed tables
+ERROR:  citus local table citus_local_table cannot be joined with these distributed tables
 ---------------------------------------------------------------------
 -- test different execution paths --
 ---------------------------------------------------------------------

src/test/regress/expected/mixed_relkind_tests.out

@@ -319,28 +319,55 @@ $$);
 (1 row)
 
 SET client_min_messages TO DEBUG1;
--- should fail
+SELECT COUNT(*) FROM partitioned_postgres_local_table JOIN distributed_table ON (true);
-SELECT * FROM partitioned_postgres_local_table JOIN distributed_table ON (true);
+DEBUG:  Wrapping local relation "partitioned_postgres_local_table" to a subquery: SELECT NULL::integer AS a FROM mixed_relkind_tests.partitioned_postgres_local_table WHERE true OFFSET 0
-ERROR:  direct joins between distributed and local tables are not supported
+DEBUG:  generating subplan XXX_1 for subquery SELECT NULL::integer AS a FROM mixed_relkind_tests.partitioned_postgres_local_table WHERE true OFFSET 0
-HINT:  Use CTE's or subqueries to select from local tables and use them in joins
+DEBUG:  Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM ((SELECT intermediate_result.a FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer)) partitioned_postgres_local_table JOIN mixed_relkind_tests.distributed_table ON (true))
-SELECT * FROM partitioned_postgres_local_table JOIN partitioned_distributed_table ON (true);
+ count
-ERROR:  direct joins between distributed and local tables are not supported
+---------------------------------------------------------------------
-HINT:  Use CTE's or subqueries to select from local tables and use them in joins
+    36
-SELECT * FROM distributed_table JOIN partitioned_postgres_local_table ON (true);
+(1 row)
-ERROR:  direct joins between distributed and local tables are not supported
+
-HINT:  Use CTE's or subqueries to select from local tables and use them in joins
+SELECT COUNT(*) FROM partitioned_postgres_local_table JOIN partitioned_distributed_table ON (true);
-SELECT * FROM reference_table LEFT JOIN partitioned_distributed_table ON true;
+DEBUG:  Wrapping local relation "partitioned_postgres_local_table" to a subquery: SELECT NULL::integer AS a FROM mixed_relkind_tests.partitioned_postgres_local_table WHERE true OFFSET 0
-ERROR:  cannot pushdown the subquery
+DEBUG:  generating subplan XXX_1 for subquery SELECT NULL::integer AS a FROM mixed_relkind_tests.partitioned_postgres_local_table WHERE true OFFSET 0
-DETAIL:  There exist a reference table in the outer part of the outer join
+DEBUG:  Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM ((SELECT intermediate_result.a FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer)) partitioned_postgres_local_table JOIN mixed_relkind_tests.partitioned_distributed_table ON (true))
+ count
+---------------------------------------------------------------------
+    36
+(1 row)
+
+SELECT COUNT(*) FROM distributed_table JOIN partitioned_postgres_local_table ON (true);
+DEBUG:  Wrapping local relation "partitioned_postgres_local_table" to a subquery: SELECT NULL::integer AS a FROM mixed_relkind_tests.partitioned_postgres_local_table WHERE true OFFSET 0
+DEBUG:  generating subplan XXX_1 for subquery SELECT NULL::integer AS a FROM mixed_relkind_tests.partitioned_postgres_local_table WHERE true OFFSET 0
+DEBUG:  Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (mixed_relkind_tests.distributed_table JOIN (SELECT intermediate_result.a FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer)) partitioned_postgres_local_table ON (true))
+ count
+---------------------------------------------------------------------
+    36
+(1 row)
+
 INSERT INTO partitioned_distributed_table SELECT foo.* FROM partitioned_distributed_table AS foo JOIN citus_local_table ON (true);
 DEBUG:  distributed INSERT ... SELECT cannot select from distributed tables and local tables at the same time
-ERROR:  direct joins between distributed and local tables are not supported
+DEBUG:  Wrapping local relation "citus_local_table" to a subquery: SELECT NULL::integer AS a FROM mixed_relkind_tests.citus_local_table WHERE true OFFSET 0
+DEBUG:  generating subplan XXX_1 for subquery SELECT NULL::integer AS a FROM mixed_relkind_tests.citus_local_table WHERE true OFFSET 0
+DEBUG:  Plan XXX query after replacing subqueries and CTEs: SELECT foo.a, foo.b FROM (mixed_relkind_tests.partitioned_distributed_table foo JOIN (SELECT intermediate_result.a FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer)) citus_local_table ON (true))
+DEBUG:  performing repartitioned INSERT ... SELECT
 INSERT INTO partitioned_distributed_table SELECT foo.* FROM distributed_table AS foo JOIN citus_local_table ON (true);
 DEBUG:  distributed INSERT ... SELECT cannot select from distributed tables and local tables at the same time
-ERROR:  direct joins between distributed and local tables are not supported
+DEBUG:  Wrapping local relation "citus_local_table" to a subquery: SELECT NULL::integer AS a FROM mixed_relkind_tests.citus_local_table WHERE true OFFSET 0
+DEBUG:  generating subplan XXX_1 for subquery SELECT NULL::integer AS a FROM mixed_relkind_tests.citus_local_table WHERE true OFFSET 0
+DEBUG:  Plan XXX query after replacing subqueries and CTEs: SELECT foo.a FROM (mixed_relkind_tests.distributed_table foo JOIN (SELECT intermediate_result.a FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer)) citus_local_table ON (true))
+DEBUG:  performing repartitioned INSERT ... SELECT
 INSERT INTO distributed_table SELECT foo.a FROM partitioned_distributed_table AS foo JOIN citus_local_table ON (true);
 DEBUG:  distributed INSERT ... SELECT cannot select from distributed tables and local tables at the same time
-ERROR:  direct joins between distributed and local tables are not supported
+DEBUG:  Wrapping local relation "citus_local_table" to a subquery: SELECT NULL::integer AS a FROM mixed_relkind_tests.citus_local_table WHERE true OFFSET 0
+DEBUG:  generating subplan XXX_1 for subquery SELECT NULL::integer AS a FROM mixed_relkind_tests.citus_local_table WHERE true OFFSET 0
+DEBUG:  Plan XXX query after replacing subqueries and CTEs: SELECT foo.a FROM (mixed_relkind_tests.partitioned_distributed_table foo JOIN (SELECT intermediate_result.a FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer)) citus_local_table ON (true))
+DEBUG:  performing repartitioned INSERT ... SELECT
+-- should fail
+SELECT COUNT(*) FROM reference_table LEFT JOIN partitioned_distributed_table ON true;
+ERROR:  cannot pushdown the subquery
+DETAIL:  There exist a reference table in the outer part of the outer join
 -- non-colocated subquery should work
 SELECT COUNT(*) FROM
   (SELECT *, random() FROM partitioned_distributed_table) AS foo,
@@ -350,7 +377,7 @@ DEBUG:  generating subplan XXX_1 for subquery SELECT a, b, random() AS random FR
 DEBUG:  Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (SELECT partitioned_distributed_table.a, partitioned_distributed_table.b, random() AS random FROM mixed_relkind_tests.partitioned_distributed_table) foo, (SELECT intermediate_result.a, intermediate_result.b, intermediate_result.random FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer, b integer, random double precision)) bar WHERE (foo.a OPERATOR(pg_catalog.=) bar.b)
  count
 ---------------------------------------------------------------------
-     5
+   455
 (1 row)
 
 SELECT COUNT(*) FROM
@@ -364,19 +391,23 @@ DEBUG:  Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS c
      0
 (1 row)
 
--- should fail
 UPDATE partitioned_distributed_table SET b = foo.a FROM citus_local_table AS foo;
-ERROR:  cannot plan modifications with citus local tables and distributed tables
+DEBUG:  Wrapping local relation "citus_local_table" to a subquery: SELECT a FROM mixed_relkind_tests.citus_local_table foo WHERE true OFFSET 0
-HINT:  Use CTE's or subqueries to select from local tables and use them in joins
+DEBUG:  generating subplan XXX_1 for subquery SELECT a FROM mixed_relkind_tests.citus_local_table foo WHERE true OFFSET 0
+DEBUG:  Plan XXX query after replacing subqueries and CTEs: UPDATE mixed_relkind_tests.partitioned_distributed_table SET b = foo.a FROM (SELECT intermediate_result.a FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer)) foo
 UPDATE partitioned_distributed_table SET b = foo.a FROM postgres_local_table AS foo;
-ERROR:  cannot plan modifications with local tables involving citus tables
+DEBUG:  Wrapping local relation "postgres_local_table" to a subquery: SELECT a FROM mixed_relkind_tests.postgres_local_table foo WHERE true OFFSET 0
-HINT:  Use CTE's or subqueries to select from local tables and use them in joins
+DEBUG:  generating subplan XXX_1 for subquery SELECT a FROM mixed_relkind_tests.postgres_local_table foo WHERE true OFFSET 0
+DEBUG:  Plan XXX query after replacing subqueries and CTEs: UPDATE mixed_relkind_tests.partitioned_distributed_table SET b = foo.a FROM (SELECT intermediate_result.a FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer)) foo
 UPDATE partitioned_distributed_table SET a = foo.a FROM postgres_local_table AS foo WHERE foo.a = partitioned_distributed_table.a;
-ERROR:  cannot plan modifications with local tables involving citus tables
+DEBUG:  Wrapping local relation "postgres_local_table" to a subquery: SELECT a FROM mixed_relkind_tests.postgres_local_table foo WHERE true OFFSET 0
-HINT:  Use CTE's or subqueries to select from local tables and use them in joins
+DEBUG:  generating subplan XXX_1 for subquery SELECT a FROM mixed_relkind_tests.postgres_local_table foo WHERE true OFFSET 0
+DEBUG:  Plan XXX query after replacing subqueries and CTEs: UPDATE mixed_relkind_tests.partitioned_distributed_table SET a = foo.a FROM (SELECT intermediate_result.a FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer)) foo WHERE (foo.a OPERATOR(pg_catalog.=) partitioned_distributed_table.a)
 UPDATE partitioned_distributed_table SET a = foo.a FROM citus_local_table AS foo WHERE foo.a = partitioned_distributed_table.a;
-ERROR:  cannot plan modifications with citus local tables and distributed tables
+DEBUG:  Wrapping local relation "citus_local_table" to a subquery: SELECT a FROM mixed_relkind_tests.citus_local_table foo WHERE true OFFSET 0
-HINT:  Use CTE's or subqueries to select from local tables and use them in joins
+DEBUG:  generating subplan XXX_1 for subquery SELECT a FROM mixed_relkind_tests.citus_local_table foo WHERE true OFFSET 0
+DEBUG:  Plan XXX query after replacing subqueries and CTEs: UPDATE mixed_relkind_tests.partitioned_distributed_table SET a = foo.a FROM (SELECT intermediate_result.a FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer)) foo WHERE (foo.a OPERATOR(pg_catalog.=) partitioned_distributed_table.a)
+-- should fail
 UPDATE partitioned_distributed_table SET a = foo.a FROM mat_view_on_part_dist AS foo WHERE foo.a = partitioned_distributed_table.a;
 ERROR:  materialized views in modify queries are not supported
 UPDATE partitioned_distributed_table SET a = foo.a FROM partitioned_distributed_table AS foo WHERE foo.a < partitioned_distributed_table.a;
@@ -392,33 +423,33 @@ UPDATE partitioned_distributed_table SET a = foo.a FROM view_on_ref AS foo WHERE
 SELECT COUNT(*) FROM partitioned_distributed_table p1 JOIN partitioned_distributed_table p2 USING (a);
  count
 ---------------------------------------------------------------------
-     6
+  1014
 (1 row)
 
 SELECT COUNT(*) FROM unlogged_distributed_table u1 JOIN partitioned_distributed_table p2 USING (a);
  count
 ---------------------------------------------------------------------
-     6
+    78
 (1 row)
 
 SELECT COUNT(*) FROM partitioned_distributed_table p1 LEFT JOIN partitioned_distributed_table p2 USING (a);
  count
 ---------------------------------------------------------------------
-     6
+  1014
 (1 row)
 
 -- lateral JOIN
 SELECT COUNT(*) FROM partitioned_distributed_table p1 JOIN LATERAL (SELECT * FROM partitioned_distributed_table p2 WHERE p1.a = p2.a) AS foo ON (true);
  count
 ---------------------------------------------------------------------
-     6
+  1014
 (1 row)
 
 -- router query
 SELECT COUNT(*) FROM partitioned_distributed_table p1 JOIN partitioned_distributed_table p2 USING (a) WHERE a = 1;
  count
 ---------------------------------------------------------------------
-     1
+   169
 (1 row)
 
 -- repartition query
@@ -426,13 +457,13 @@ SET citus.enable_repartition_joins TO ON;
 SELECT COUNT(*) FROM partitioned_distributed_table p1 JOIN partitioned_distributed_table p2 USING (b) WHERE b = 1;
  count
 ---------------------------------------------------------------------
-     1
+     0
 (1 row)
 
 SELECT COUNT(*) FROM unlogged_distributed_table u1 JOIN partitioned_distributed_table p2 USING (b) WHERE b = 1;
  count
 ---------------------------------------------------------------------
-     1
+     0
 (1 row)
 
 RESET citus.enable_repartition_joins;
@@ -443,7 +474,7 @@ DEBUG:  generating subplan XXX_1 for CTE cte_1: SELECT a, b FROM mixed_relkind_t
 DEBUG:  Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (SELECT intermediate_result.a, intermediate_result.b FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer, b integer)) cte_1
  count
 ---------------------------------------------------------------------
-     6
+    78
 (1 row)
 
 WITH cte_1 AS (SELECT * FROM partitioned_distributed_table)
@@ -452,7 +483,7 @@ DEBUG:  generating subplan XXX_1 for CTE cte_1: SELECT a, b FROM mixed_relkind_t
 DEBUG:  Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM ((SELECT intermediate_result.a, intermediate_result.b FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer, b integer)) cte_1 JOIN mixed_relkind_tests.partitioned_distributed_table USING (a))
  count
 ---------------------------------------------------------------------
-     6
+  1014
 (1 row)
 
 WITH cte_1 AS (SELECT * FROM foreign_distributed_table)
@@ -470,7 +501,7 @@ DEBUG:  generating subplan XXX_1 for CTE cte_1: SELECT a, b FROM mixed_relkind_t
 DEBUG:  Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM ((SELECT intermediate_result.a, intermediate_result.b FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(a integer, b integer)) cte_1 JOIN mixed_relkind_tests.partitioned_distributed_table USING (b))
  count
 ---------------------------------------------------------------------
-     6
+  6084
 (1 row)
 
 -- multi shard colocated update
@@ -599,13 +630,13 @@ SET client_min_messages TO DEBUG1;
 SELECT sum(a) FROM partitioned_distributed_table;
  sum
 ---------------------------------------------------------------------
-  15
+ 195
 (1 row)
 
 SELECT ceil(regr_syy(a, b)) FROM partitioned_distributed_table;
  ceil
 ---------------------------------------------------------------------
-   18
+  228
 (1 row)
 
 SELECT ceil(regr_syy(a, b)) FROM unlogged_distributed_table;
@@ -674,8 +705,20 @@ $Q$);
 SELECT * FROM partitioned_distributed_table WHERE a = 1 ORDER BY 1,2 FOR UPDATE;
  a | b
 ---------------------------------------------------------------------
- 1 | 2
+ 1 | 0
-(1 row)
+ 1 | 0
+ 1 | 0
+ 1 | 0
+ 1 | 0
+ 1 | 0
+ 1 | 0
+ 1 | 0
+ 1 | 0
+ 1 | 0
+ 1 | 0
+ 1 | 0
+ 1 | 0
+(13 rows)
 
 SELECT * FROM unlogged_distributed_table WHERE a = 1 ORDER BY 1,2 FOR UPDATE;
  a | b

src/test/regress/expected/recursive_relation_planning_restirction_pushdown.out

@@ -235,8 +235,8 @@ JOIN local_table u2 USING(value)
 WHERE u2.value >
     (SELECT avg(key)
      FROM distributed_table);
-DEBUG:  Wrapping local relation "local_table" to a subquery: SELECT NULL::integer AS key, value, NULL::timestamp with time zone AS "time" FROM push_down_filters.local_table u2 WHERE true OFFSET 0
 DEBUG:  generating subplan XXX_1 for subquery SELECT avg(key) AS avg FROM push_down_filters.distributed_table
+DEBUG:  Wrapping local relation "local_table" to a subquery: SELECT NULL::integer AS key, value, NULL::timestamp with time zone AS "time" FROM push_down_filters.local_table u2 WHERE true OFFSET 0
 DEBUG:  generating subplan XXX_2 for subquery SELECT NULL::integer AS key, value, NULL::timestamp with time zone AS "time" FROM push_down_filters.local_table u2 WHERE true OFFSET 0
 DEBUG:  Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (push_down_filters.distributed_table u1 JOIN (SELECT intermediate_result.key, intermediate_result.value, intermediate_result."time" FROM read_intermediate_result('XXX_2'::text, 'binary'::citus_copy_format) intermediate_result(key integer, value integer, "time" timestamp with time zone)) u2 USING (value)) WHERE ((u2.value)::numeric OPERATOR(pg_catalog.>) (SELECT intermediate_result.avg FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(avg numeric)))
  count

src/test/regress/expected/subqueries_not_supported.out

@@ -6,22 +6,9 @@ SET search_path TO not_supported, public;
 SET citus.coordinator_aggregation_strategy TO 'disabled';
 SET client_min_messages TO DEBUG1;
 CREATE TABLE users_table_local AS SELECT * FROM users_table;
--- we don't support subqueries with local tables when they are not leaf queries
-SELECT
-	*
-FROM
-	(
-		SELECT
-			users_table_local.user_id
-		FROM
-			users_table_local, (SELECT user_id FROM events_table) as evs
-		WHERE users_table_local.user_id = evs.user_id
-	) as foo;
-ERROR:  direct joins between distributed and local tables are not supported
-HINT:  Use CTE's or subqueries to select from local tables and use them in joins
 RESET client_min_messages;
 -- we don't support subqueries with local tables when they are not leaf queries
-SELECT user_id FROM users_table WHERE user_id IN
+SELECT COUNT(user_id) FROM users_table WHERE user_id IN
 	(SELECT
 		user_id
 	 FROM

src/test/regress/sql/mixed_relkind_tests.sql

@@ -101,15 +101,17 @@ INSERT INTO partitioned_distributed_table SELECT * FROM partitioned_distributed_
 $$);
 SET client_min_messages TO DEBUG1;
 
--- should fail
+SELECT COUNT(*) FROM partitioned_postgres_local_table JOIN distributed_table ON (true);
-SELECT * FROM partitioned_postgres_local_table JOIN distributed_table ON (true);
+SELECT COUNT(*) FROM partitioned_postgres_local_table JOIN partitioned_distributed_table ON (true);
-SELECT * FROM partitioned_postgres_local_table JOIN partitioned_distributed_table ON (true);
+SELECT COUNT(*) FROM distributed_table JOIN partitioned_postgres_local_table ON (true);
-SELECT * FROM distributed_table JOIN partitioned_postgres_local_table ON (true);
-SELECT * FROM reference_table LEFT JOIN partitioned_distributed_table ON true;
 INSERT INTO partitioned_distributed_table SELECT foo.* FROM partitioned_distributed_table AS foo JOIN citus_local_table ON (true);
 INSERT INTO partitioned_distributed_table SELECT foo.* FROM distributed_table AS foo JOIN citus_local_table ON (true);
 INSERT INTO distributed_table SELECT foo.a FROM partitioned_distributed_table AS foo JOIN citus_local_table ON (true);
 
+-- should fail
+SELECT COUNT(*) FROM reference_table LEFT JOIN partitioned_distributed_table ON true;
+
+
 -- non-colocated subquery should work
 SELECT COUNT(*) FROM
   (SELECT *, random() FROM partitioned_distributed_table) AS foo,
@@ -121,11 +123,11 @@ SELECT COUNT(*) FROM
   (SELECT *, random() FROM foreign_distributed_table) AS bar
 WHERE foo.a = bar.b;
 
--- should fail
 UPDATE partitioned_distributed_table SET b = foo.a FROM citus_local_table AS foo;
 UPDATE partitioned_distributed_table SET b = foo.a FROM postgres_local_table AS foo;
 UPDATE partitioned_distributed_table SET a = foo.a FROM postgres_local_table AS foo WHERE foo.a = partitioned_distributed_table.a;
 UPDATE partitioned_distributed_table SET a = foo.a FROM citus_local_table AS foo WHERE foo.a = partitioned_distributed_table.a;
+-- should fail
 UPDATE partitioned_distributed_table SET a = foo.a FROM mat_view_on_part_dist AS foo WHERE foo.a = partitioned_distributed_table.a;
 UPDATE partitioned_distributed_table SET a = foo.a FROM partitioned_distributed_table AS foo WHERE foo.a < partitioned_distributed_table.a;
 UPDATE partitioned_distributed_table SET a = foo.a FROM distributed_table AS foo WHERE foo.a < partitioned_distributed_table.a;

src/test/regress/sql/subqueries_not_supported.sql

@@ -9,18 +9,6 @@ SET client_min_messages TO DEBUG1;
 
 CREATE TABLE users_table_local AS SELECT * FROM users_table;
 
--- TODO:: Move this out of this file
-SELECT
-	COUNT(*)
-FROM
-	(
-		SELECT
-			users_table_local.user_id
-		FROM
-			users_table_local, (SELECT user_id FROM events_table) as evs
-		WHERE users_table_local.user_id = evs.user_id
-	) as foo;
-
 RESET client_min_messages;
 -- we don't support subqueries with local tables when they are not leaf queries
 SELECT COUNT(user_id) FROM users_table WHERE user_id IN