From 05653518ac1483d5913b59927d8c535e59171d4b Mon Sep 17 00:00:00 2001 From: Pavan Deolasee Date: Wed, 10 Jun 2015 15:10:06 +0530 Subject: [PATCH] Fix most expected output diffs in test case 'join' Most of these changes are related to plan changes. Also remove the alternate expected output file and adjust the original file acoordingly --- src/test/regress/expected/join.out | 1094 +++++---- src/test/regress/expected/join_1.out | 3045 -------------------------- 2 files changed, 619 insertions(+), 3520 deletions(-) delete mode 100644 src/test/regress/expected/join_1.out diff --git a/src/test/regress/expected/join.out b/src/test/regress/expected/join.out index a9bc6876e1..65ca5b2570 100644 --- a/src/test/regress/expected/join.out +++ b/src/test/regress/expected/join.out @@ -2338,33 +2338,45 @@ where not exists ( ) a1 on t3.c2 = a1.c1 where t1.c1 = t2.c2 ); - QUERY PLAN ---------------------------------------------------------- - Hash Anti Join - Hash Cond: (t1.c1 = t2.c2) - -> Seq Scan on tt4x t1 - -> Hash - -> Merge Right Join - Merge Cond: (t5.c1 = t3.c2) - -> Merge Join - Merge Cond: (t4.c2 = t5.c1) - -> Sort - Sort Key: t4.c2 - -> Seq Scan on tt4x t4 - -> Sort - Sort Key: t5.c1 - -> Seq Scan on tt4x t5 - -> Sort - Sort Key: t3.c2 + QUERY PLAN +----------------------------------------------------------------------------------------------------- + Remote Subquery Scan on all (datanode_1,datanode_2) + -> Hash Anti Join + Hash Cond: (t1.c1 = t2.c2) + -> Seq Scan on tt4x t1 + -> Hash + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Distribute results by H: c2 -> Merge Left Join - Merge Cond: (t2.c3 = t3.c1) - -> Sort - Sort Key: t2.c3 - -> Seq Scan on tt4x t2 - -> Sort - Sort Key: t3.c1 - -> Seq Scan on tt4x t3 -(24 rows) + Merge Cond: (t3.c2 = t5.c1) + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Distribute results by H: c2 + -> Sort + Sort Key: t3.c2 + -> Merge Left Join + Merge Cond: (t2.c3 = t3.c1) + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Distribute results by H: c3 + -> Sort + Sort Key: t2.c3 + -> Seq Scan on tt4x t2 + -> Sort + Sort Key: t3.c1 + -> Seq Scan on tt4x t3 + -> Materialize + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Distribute results by H: c1 + -> Merge Join + Merge Cond: (t4.c2 = t5.c1) + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Distribute results by H: c2 + -> Sort + Sort Key: t4.c2 + -> Seq Scan on tt4x t4 + -> Sort + Sort Key: t5.c1 + -> Seq Scan on tt4x t5 +(36 rows) -- -- regression test for problems of the sort depicted in bug #3494 @@ -2631,17 +2643,19 @@ SELECT qq, unique1 ( SELECT COALESCE(q2, -1) AS qq FROM int8_tbl b ) AS ss2 USING (qq) INNER JOIN tenk1 c ON qq = unique2; - QUERY PLAN ---------------------------------------------------------------------------------------------------------- - Nested Loop - -> Hash Full Join - Hash Cond: (COALESCE(a.q1, '0'::bigint) = COALESCE(b.q2, '-1'::bigint)) - -> Seq Scan on int8_tbl a + QUERY PLAN +---------------------------------------------------------------------------------------------------------- + Remote Subquery Scan on all + -> Hash Join + Hash Cond: (c.unique2 = COALESCE((COALESCE(a.q1, '0'::bigint)), (COALESCE(b.q2, '-1'::bigint)))) + -> Seq Scan on tenk1 c -> Hash - -> Seq Scan on int8_tbl b - -> Index Scan using tenk1_unique2 on tenk1 c - Index Cond: (unique2 = COALESCE((COALESCE(a.q1, '0'::bigint)), (COALESCE(b.q2, '-1'::bigint)))) -(8 rows) + -> Hash Full Join + Hash Cond: (COALESCE(a.q1, '0'::bigint) = COALESCE(b.q2, '-1'::bigint)) + -> Seq Scan on int8_tbl a + -> Hash + -> Seq Scan on int8_tbl b +(10 rows) SELECT qq, unique1 FROM @@ -2909,25 +2923,27 @@ select * from int4(sin(1)) q1, int4(sin(0)) q2 where q1 = thousand or q2 = thousand; - QUERY PLAN ------------------------------------------------------------------------------- - Remote Subquery Scan on all - -> Hash Join - Hash Cond: (tenk1.twothousand = int4_tbl.f1) + QUERY PLAN +------------------------------------------------------------------------------------ + Hash Join + Hash Cond: (tenk1.twothousand = int4_tbl.f1) + -> Nested Loop -> Nested Loop - -> Nested Loop - -> Function Scan on q1 - -> Function Scan on q2 - -> Bitmap Heap Scan on tenk1 - Recheck Cond: ((q1.q1 = thousand) OR (q2.q2 = thousand)) - -> BitmapOr - -> Bitmap Index Scan on tenk1_thous_tenthous - Index Cond: (q1.q1 = thousand) - -> Bitmap Index Scan on tenk1_thous_tenthous - Index Cond: (q2.q2 = thousand) - -> Hash + -> Function Scan on q1 + -> Function Scan on q2 + -> Materialize + -> Remote Subquery Scan on all + -> Bitmap Heap Scan on tenk1 + Recheck Cond: ((q1.q1 = thousand) OR (q2.q2 = thousand)) + -> BitmapOr + -> Bitmap Index Scan on tenk1_thous_tenthous + Index Cond: (q1.q1 = thousand) + -> Bitmap Index Scan on tenk1_thous_tenthous + Index Cond: (q2.q2 = thousand) + -> Hash + -> Remote Subquery Scan on all -> Seq Scan on int4_tbl -(16 rows) +(18 rows) explain (num_nodes off, nodes off, costs off) select * from @@ -2935,22 +2951,24 @@ select * from int4(sin(1)) q1, int4(sin(0)) q2 where thousand = (q1 + q2); - QUERY PLAN --------------------------------------------------------------------- - Remote Subquery Scan on all - -> Hash Join - Hash Cond: (tenk1.twothousand = int4_tbl.f1) + QUERY PLAN +-------------------------------------------------------------------------- + Hash Join + Hash Cond: (tenk1.twothousand = int4_tbl.f1) + -> Nested Loop -> Nested Loop - -> Nested Loop - -> Function Scan on q1 - -> Function Scan on q2 - -> Bitmap Heap Scan on tenk1 - Recheck Cond: (thousand = (q1.q1 + q2.q2)) - -> Bitmap Index Scan on tenk1_thous_tenthous - Index Cond: (thousand = (q1.q1 + q2.q2)) - -> Hash + -> Function Scan on q1 + -> Function Scan on q2 + -> Materialize + -> Remote Subquery Scan on all + -> Bitmap Heap Scan on tenk1 + Recheck Cond: (thousand = (q1.q1 + q2.q2)) + -> Bitmap Index Scan on tenk1_thous_tenthous + Index Cond: (thousand = (q1.q1 + q2.q2)) + -> Hash + -> Remote Subquery Scan on all -> Seq Scan on int4_tbl -(13 rows) +(15 rows) -- -- test ability to generate a suitable plan for a star-schema query @@ -2959,17 +2977,18 @@ explain (costs off) select * from tenk1, int8_tbl a, int8_tbl b where thousand = a.q1 and tenthous = b.q1 and a.q2 = 1 and b.q2 = 2; - QUERY PLAN ---------------------------------------------------------------------- - Nested Loop - -> Seq Scan on int8_tbl b - Filter: (q2 = 2) + QUERY PLAN +--------------------------------------------------------------------------- + Remote Subquery Scan on all (datanode_1,datanode_2) -> Nested Loop - -> Seq Scan on int8_tbl a - Filter: (q2 = 1) - -> Index Scan using tenk1_thous_tenthous on tenk1 - Index Cond: ((thousand = a.q1) AND (tenthous = b.q1)) -(8 rows) + -> Seq Scan on int8_tbl b + Filter: (q2 = 2) + -> Nested Loop + -> Seq Scan on int8_tbl a + Filter: (q2 = 1) + -> Index Scan using tenk1_thous_tenthous on tenk1 + Index Cond: ((thousand = a.q1) AND (tenthous = b.q1)) +(9 rows) -- -- test extraction of restriction OR clauses from join OR clause @@ -2982,14 +3001,7 @@ select * from tenk1 a join tenk1 b on ------------------------------------------------------------------------------------------------- Nested Loop Join Filter: (((a.unique1 = 1) AND (b.unique1 = 2)) OR ((a.unique2 = 3) AND (b.hundred = 4))) - -> Bitmap Heap Scan on tenk1 b - Recheck Cond: ((unique1 = 2) OR (hundred = 4)) - -> BitmapOr - -> Bitmap Index Scan on tenk1_unique1 - Index Cond: (unique1 = 2) - -> Bitmap Index Scan on tenk1_hundred - Index Cond: (hundred = 4) - -> Materialize + -> Remote Subquery Scan on all (datanode_1,datanode_2) -> Bitmap Heap Scan on tenk1 a Recheck Cond: ((unique1 = 1) OR (unique2 = 3)) -> BitmapOr @@ -2997,7 +3009,16 @@ select * from tenk1 a join tenk1 b on Index Cond: (unique1 = 1) -> Bitmap Index Scan on tenk1_unique2 Index Cond: (unique2 = 3) -(17 rows) + -> Materialize + -> Remote Subquery Scan on all (datanode_1,datanode_2) + -> Bitmap Heap Scan on tenk1 b + Recheck Cond: ((unique1 = 2) OR (hundred = 4)) + -> BitmapOr + -> Bitmap Index Scan on tenk1_unique1 + Index Cond: (unique1 = 2) + -> Bitmap Index Scan on tenk1_hundred + Index Cond: (hundred = 4) +(19 rows) explain (costs off) select * from tenk1 a join tenk1 b on @@ -3006,9 +3027,7 @@ select * from tenk1 a join tenk1 b on --------------------------------------------------------------------------------------------- Nested Loop Join Filter: (((a.unique1 = 1) AND (b.unique1 = 2)) OR ((a.unique2 = 3) AND (b.ten = 4))) - -> Seq Scan on tenk1 b - Filter: ((unique1 = 2) OR (ten = 4)) - -> Materialize + -> Remote Subquery Scan on all (datanode_1,datanode_2) -> Bitmap Heap Scan on tenk1 a Recheck Cond: ((unique1 = 1) OR (unique2 = 3)) -> BitmapOr @@ -3016,7 +3035,11 @@ select * from tenk1 a join tenk1 b on Index Cond: (unique1 = 1) -> Bitmap Index Scan on tenk1_unique2 Index Cond: (unique2 = 3) -(12 rows) + -> Materialize + -> Remote Subquery Scan on all (datanode_1,datanode_2) + -> Seq Scan on tenk1 b + Filter: ((unique1 = 2) OR (ten = 4)) +(14 rows) explain (costs off) select * from tenk1 a join tenk1 b on @@ -3026,14 +3049,7 @@ select * from tenk1 a join tenk1 b on ---------------------------------------------------------------------------------------------------------------------- Nested Loop Join Filter: (((a.unique1 = 1) AND (b.unique1 = 2)) OR (((a.unique2 = 3) OR (a.unique2 = 7)) AND (b.hundred = 4))) - -> Bitmap Heap Scan on tenk1 b - Recheck Cond: ((unique1 = 2) OR (hundred = 4)) - -> BitmapOr - -> Bitmap Index Scan on tenk1_unique1 - Index Cond: (unique1 = 2) - -> Bitmap Index Scan on tenk1_hundred - Index Cond: (hundred = 4) - -> Materialize + -> Remote Subquery Scan on all (datanode_1,datanode_2) -> Bitmap Heap Scan on tenk1 a Recheck Cond: ((unique1 = 1) OR (unique2 = 3) OR (unique2 = 7)) -> BitmapOr @@ -3043,7 +3059,16 @@ select * from tenk1 a join tenk1 b on Index Cond: (unique2 = 3) -> Bitmap Index Scan on tenk1_unique2 Index Cond: (unique2 = 7) -(19 rows) + -> Materialize + -> Remote Subquery Scan on all (datanode_1,datanode_2) + -> Bitmap Heap Scan on tenk1 b + Recheck Cond: ((unique1 = 2) OR (hundred = 4)) + -> BitmapOr + -> Bitmap Index Scan on tenk1_unique1 + Index Cond: (unique1 = 2) + -> Bitmap Index Scan on tenk1_hundred + Index Cond: (hundred = 4) +(21 rows) -- -- test placement of movable quals in a parameterized join tree @@ -3053,44 +3078,48 @@ select * from tenk1 t1 left join (tenk1 t2 join tenk1 t3 on t2.thousand = t3.unique2) on t1.hundred = t2.hundred and t1.ten = t3.ten where t1.unique1 = 1; - QUERY PLAN --------------------------------------------------------------------------- - Remote Subquery Scan on all - -> Nested Loop Left Join - -> Index Scan using tenk1_unique1 on tenk1 t1 - Index Cond: (unique1 = 1) - -> Nested Loop - Join Filter: (t1.ten = t3.ten) + QUERY PLAN +-------------------------------------------------------------------- + Nested Loop Left Join + -> Remote Subquery Scan on all + -> Bitmap Heap Scan on tenk1 t1 + Recheck Cond: (unique1 = 1) + -> Bitmap Index Scan on tenk1_unique1 + Index Cond: (unique1 = 1) + -> Nested Loop + Join Filter: (t1.ten = t3.ten) + -> Remote Subquery Scan on all + -> Index Scan using tenk1_hundred on tenk1 t2 + Index Cond: (t1.hundred = hundred) + -> Materialize -> Remote Subquery Scan on all - -> Index Scan using tenk1_hundred on tenk1 t2 - Index Cond: (t1.hundred = hundred) - -> Materialize - -> Remote Subquery Scan on all - -> Index Scan using tenk1_unique2 on tenk1 t3 - Index Cond: (unique2 = t2.thousand) -(13 rows) + -> Index Scan using tenk1_unique2 on tenk1 t3 + Index Cond: (unique2 = t2.thousand) +(15 rows) explain (num_nodes off, nodes off, costs off) select * from tenk1 t1 left join (tenk1 t2 join tenk1 t3 on t2.thousand = t3.unique2) on t1.hundred = t2.hundred and t1.ten + t2.ten = t3.ten where t1.unique1 = 1; - QUERY PLAN --------------------------------------------------------------------------- - Remote Subquery Scan on all - -> Nested Loop Left Join - -> Index Scan using tenk1_unique1 on tenk1 t1 - Index Cond: (unique1 = 1) - -> Nested Loop - Join Filter: ((t1.ten + t2.ten) = t3.ten) + QUERY PLAN +-------------------------------------------------------------------- + Nested Loop Left Join + -> Remote Subquery Scan on all + -> Bitmap Heap Scan on tenk1 t1 + Recheck Cond: (unique1 = 1) + -> Bitmap Index Scan on tenk1_unique1 + Index Cond: (unique1 = 1) + -> Nested Loop + Join Filter: ((t1.ten + t2.ten) = t3.ten) + -> Remote Subquery Scan on all + -> Index Scan using tenk1_hundred on tenk1 t2 + Index Cond: (t1.hundred = hundred) + -> Materialize -> Remote Subquery Scan on all - -> Index Scan using tenk1_hundred on tenk1 t2 - Index Cond: (t1.hundred = hundred) - -> Materialize - -> Remote Subquery Scan on all - -> Index Scan using tenk1_unique2 on tenk1 t3 - Index Cond: (unique2 = t2.thousand) -(13 rows) + -> Index Scan using tenk1_unique2 on tenk1 t3 + Index Cond: (unique2 = t2.thousand) +(15 rows) explain (num_nodes off, nodes off, costs off) select count(*) from @@ -3139,29 +3168,29 @@ select b.unique1 from join int4_tbl i1 on b.thousand = f1 right join int4_tbl i2 on i2.f1 = b.tenthous order by 1; - QUERY PLAN ------------------------------------------------------------------------------------------------------ - Remote Subquery Scan on all - -> Sort - Sort Key: b.unique1 - -> Nested Loop Left Join + QUERY PLAN +----------------------------------------------------------------------------------------------- + Sort + Sort Key: b.unique1 + -> Nested Loop Left Join + -> Remote Subquery Scan on all -> Seq Scan on int4_tbl i2 - -> Nested Loop Left Join - Join Filter: (b.unique1 = 42) - -> Nested Loop - -> Remote Subquery Scan on all - -> Nested Loop - -> Seq Scan on int4_tbl i1 - -> Index Scan using tenk1_thous_tenthous on tenk1 b - Index Cond: ((thousand = i1.f1) AND (i2.f1 = tenthous)) - -> Materialize - -> Remote Subquery Scan on all - -> Index Scan using tenk1_unique1 on tenk1 a - Index Cond: (unique1 = b.unique2) + -> Nested Loop Left Join + Join Filter: (b.unique1 = 42) + -> Nested Loop + -> Remote Subquery Scan on all + -> Nested Loop + -> Seq Scan on int4_tbl i1 + -> Index Scan using tenk1_thous_tenthous on tenk1 b + Index Cond: ((thousand = i1.f1) AND (i2.f1 = tenthous)) -> Materialize -> Remote Subquery Scan on all - -> Index Only Scan using tenk1_thous_tenthous on tenk1 c - Index Cond: (thousand = a.thousand) + -> Index Scan using tenk1_unique1 on tenk1 a + Index Cond: (unique1 = b.unique2) + -> Materialize + -> Remote Subquery Scan on all + -> Index Only Scan using tenk1_thous_tenthous on tenk1 c + Index Cond: (thousand = a.thousand) (21 rows) select b.unique1 from @@ -3189,12 +3218,15 @@ where fault = 122 order by fault; QUERY PLAN -------------------------------------------------------------------------- - Nested Loop Left Join + Hash Right Join + Hash Cond: (tenk1.unique2 = int8_tbl.q2) Filter: ((COALESCE(tenk1.unique1, '-1'::integer) + int8_tbl.q1) = 122) - -> Seq Scan on int8_tbl - -> Index Scan using tenk1_unique2 on tenk1 - Index Cond: (int8_tbl.q2 = unique2) -(5 rows) + -> Remote Subquery Scan on all (datanode_1,datanode_2) + -> Seq Scan on tenk1 + -> Hash + -> Remote Subquery Scan on all (datanode_1) + -> Seq Scan on int8_tbl +(8 rows) select * from ( @@ -3217,12 +3249,15 @@ select q1, unique2, thousand, hundred where coalesce(thousand,123) = q1 and q1 = coalesce(hundred,123); QUERY PLAN -------------------------------------------------------------------------------------- - Nested Loop Left Join + Hash Right Join + Hash Cond: (b.unique2 = a.q1) Filter: ((COALESCE(b.thousand, 123) = a.q1) AND (a.q1 = COALESCE(b.hundred, 123))) - -> Seq Scan on int8_tbl a - -> Index Scan using tenk1_unique2 on tenk1 b - Index Cond: (a.q1 = unique2) -(5 rows) + -> Remote Subquery Scan on all (datanode_1,datanode_2) + -> Seq Scan on tenk1 b + -> Hash + -> Remote Subquery Scan on all (datanode_1) + -> Seq Scan on int8_tbl a +(8 rows) select q1, unique2, thousand, hundred from int8_tbl a left join tenk1 b on q1 = unique2 @@ -3235,14 +3270,20 @@ explain (costs off) select f1, unique2, case when unique2 is null then f1 else 0 end from int4_tbl a left join tenk1 b on f1 = unique2 where (case when unique2 is null then f1 else 0 end) = 0; - QUERY PLAN --------------------------------------------------------------------- - Nested Loop Left Join - Filter: (CASE WHEN (b.unique2 IS NULL) THEN a.f1 ELSE 0 END = 0) - -> Seq Scan on int4_tbl a - -> Index Only Scan using tenk1_unique2 on tenk1 b - Index Cond: (unique2 = a.f1) -(5 rows) + QUERY PLAN +-------------------------------------------------------------------------- + Remote Subquery Scan on all (datanode_1,datanode_2) + -> Hash Right Join + Hash Cond: (b.unique2 = a.f1) + Filter: (CASE WHEN (b.unique2 IS NULL) THEN a.f1 ELSE 0 END = 0) + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Distribute results by H: unique2 + -> Seq Scan on tenk1 b + -> Hash + -> Remote Subquery Scan on all (datanode_1) + Distribute results by H: f1 + -> Seq Scan on int4_tbl a +(11 rows) select f1, unique2, case when unique2 is null then f1 else 0 end from int4_tbl a left join tenk1 b on f1 = unique2 @@ -3259,20 +3300,36 @@ explain (costs off) select a.unique1, b.unique1, c.unique1, coalesce(b.twothousand, a.twothousand) from tenk1 a left join tenk1 b on b.thousand = a.unique1 left join tenk1 c on c.unique2 = coalesce(b.twothousand, a.twothousand) where a.unique2 < 10 and coalesce(b.twothousand, a.twothousand) = 44; - QUERY PLAN ---------------------------------------------------------------------------------------------- - Nested Loop Left Join - -> Nested Loop Left Join - Filter: (COALESCE(b.twothousand, a.twothousand) = 44) - -> Index Scan using tenk1_unique2 on tenk1 a - Index Cond: (unique2 < 10) - -> Bitmap Heap Scan on tenk1 b - Recheck Cond: (thousand = a.unique1) - -> Bitmap Index Scan on tenk1_thous_tenthous - Index Cond: (thousand = a.unique1) - -> Index Scan using tenk1_unique2 on tenk1 c - Index Cond: ((unique2 = COALESCE(b.twothousand, a.twothousand)) AND (unique2 = 44)) -(11 rows) + QUERY PLAN +----------------------------------------------------------------------------------- + Remote Subquery Scan on all (datanode_1,datanode_2) + -> Hash Left Join + Hash Cond: ((COALESCE(b.twothousand, a.twothousand)) = c.unique2) + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Distribute results by H: COALESCE(twothousand, twothousand) + -> Merge Left Join + Merge Cond: (a.unique1 = b.thousand) + Filter: (COALESCE(b.twothousand, a.twothousand) = 44) + -> Sort + Sort Key: a.unique1 + -> Bitmap Heap Scan on tenk1 a + Recheck Cond: (unique2 < 10) + -> Bitmap Index Scan on tenk1_unique2 + Index Cond: (unique2 < 10) + -> Materialize + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Distribute results by H: thousand + -> Sort + Sort Key: b.thousand + -> Seq Scan on tenk1 b + -> Hash + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Distribute results by H: unique2 + -> Bitmap Heap Scan on tenk1 c + Recheck Cond: (unique2 = 44) + -> Bitmap Index Scan on tenk1_unique2 + Index Cond: (unique2 = 44) +(27 rows) select a.unique1, b.unique1, c.unique1, coalesce(b.twothousand, a.twothousand) from tenk1 a left join tenk1 b on b.thousand = a.unique1 left join tenk1 c on c.unique2 = coalesce(b.twothousand, a.twothousand) @@ -3297,23 +3354,33 @@ left join using (join_key) ) foo3 using (join_key); - QUERY PLAN --------------------------------------------------------------------------- - Nested Loop Left Join + QUERY PLAN +----------------------------------------------------------------------- + Hash Right Join Output: "*VALUES*".column1, i1.f1, (666) - Join Filter: ("*VALUES*".column1 = i1.f1) - -> Values Scan on "*VALUES*" - Output: "*VALUES*".column1 - -> Materialize - Output: i1.f1, (666) - -> Nested Loop Left Join + Hash Cond: (i1.f1 = "*VALUES*".column1) + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Output: i1.f1, 666 + -> Hash Right Join Output: i1.f1, 666 - -> Seq Scan on public.int4_tbl i1 - Output: i1.f1 - -> Index Only Scan using tenk1_unique2 on public.tenk1 i2 + Hash Cond: (i2.unique2 = i1.f1) + -> Remote Subquery Scan on all (datanode_1,datanode_2) Output: i2.unique2 - Index Cond: (i2.unique2 = i1.f1) -(14 rows) + Distribute results by H: unique2 + -> Seq Scan on public.tenk1 i2 + Output: i2.unique2 + -> Hash + Output: i1.f1 + -> Remote Subquery Scan on all (datanode_2) + Output: i1.f1 + Distribute results by H: f1 + -> Seq Scan on public.int4_tbl i1 + Output: i1.f1 + -> Hash + Output: "*VALUES*".column1 + -> Values Scan on "*VALUES*" + Output: "*VALUES*".column1 +(24 rows) select foo1.join_key as foo1_id, foo3.join_key AS foo3_id, bug_field from (values (0),(1)) foo1(join_key) @@ -3338,27 +3405,45 @@ using (join_key); -- explain (costs off) select * from int4_tbl a left join tenk1 b on f1 = unique2 where f1 = 0; - QUERY PLAN -------------------------------------------------- - Nested Loop Left Join - Join Filter: (a.f1 = b.unique2) - -> Seq Scan on int4_tbl a - Filter: (f1 = 0) - -> Index Scan using tenk1_unique2 on tenk1 b - Index Cond: (unique2 = 0) -(6 rows) + QUERY PLAN +----------------------------------------------------------------------- + Remote Subquery Scan on all (datanode_1,datanode_2) + -> Nested Loop Left Join + Join Filter: (a.f1 = b.unique2) + -> Remote Subquery Scan on all (datanode_1) + Distribute results by H: f1 + -> Seq Scan on int4_tbl a + Filter: (f1 = 0) + -> Materialize + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Distribute results by H: unique2 + -> Bitmap Heap Scan on tenk1 b + Recheck Cond: (unique2 = 0) + -> Bitmap Index Scan on tenk1_unique2 + Index Cond: (unique2 = 0) +(14 rows) explain (costs off) select * from tenk1 a full join tenk1 b using(unique2) where unique2 = 42; - QUERY PLAN -------------------------------------------------- - Merge Full Join - Merge Cond: (a.unique2 = b.unique2) - -> Index Scan using tenk1_unique2 on tenk1 a - Index Cond: (unique2 = 42) - -> Index Scan using tenk1_unique2 on tenk1 b - Index Cond: (unique2 = 42) -(6 rows) + QUERY PLAN +----------------------------------------------------------------------- + Remote Subquery Scan on all (datanode_1,datanode_2) + -> Hash Full Join + Hash Cond: (a.unique2 = b.unique2) + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Distribute results by H: unique2 + -> Bitmap Heap Scan on tenk1 a + Recheck Cond: (unique2 = 42) + -> Bitmap Index Scan on tenk1_unique2 + Index Cond: (unique2 = 42) + -> Hash + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Distribute results by H: unique2 + -> Bitmap Heap Scan on tenk1 b + Recheck Cond: (unique2 = 42) + -> Bitmap Index Scan on tenk1_unique2 + Index Cond: (unique2 = 42) +(16 rows) -- -- test that quals attached to an outer join have correct semantics, @@ -3371,23 +3456,25 @@ explain (verbose, costs off) select a.q2, b.q1 from int8_tbl a left join int8_tbl b on a.q2 = coalesce(b.q1, 1) where coalesce(b.q1, 1) > 0; - QUERY PLAN ---------------------------------------------------------- - Merge Left Join + QUERY PLAN +--------------------------------------------------------------- + Remote Subquery Scan on all (datanode_1) Output: a.q2, b.q1 - Merge Cond: (a.q2 = (COALESCE(b.q1, '1'::bigint))) - Filter: (COALESCE(b.q1, '1'::bigint) > 0) - -> Sort - Output: a.q2 - Sort Key: a.q2 - -> Seq Scan on public.int8_tbl a + -> Merge Left Join + Output: a.q2, b.q1 + Merge Cond: (a.q2 = (COALESCE(b.q1, '1'::bigint))) + Filter: (COALESCE(b.q1, '1'::bigint) > 0) + -> Sort Output: a.q2 - -> Sort - Output: b.q1, (COALESCE(b.q1, '1'::bigint)) - Sort Key: (COALESCE(b.q1, '1'::bigint)) - -> Seq Scan on public.int8_tbl b - Output: b.q1, COALESCE(b.q1, '1'::bigint) -(14 rows) + Sort Key: a.q2 + -> Seq Scan on public.int8_tbl a + Output: a.q2 + -> Sort + Output: b.q1, (COALESCE(b.q1, '1'::bigint)) + Sort Key: (COALESCE(b.q1, '1'::bigint)) + -> Seq Scan on public.int8_tbl b + Output: b.q1, COALESCE(b.q1, '1'::bigint) +(16 rows) select a.q2, b.q1 from int8_tbl a left join int8_tbl b on a.q2 = coalesce(b.q1, 1) @@ -3475,77 +3562,83 @@ select id from a where id in ( explain (costs off) select d.* from d left join (select * from b group by b.id, b.c_id) s on d.a = s.id and d.b = s.c_id; - QUERY PLAN ---------------- - Seq Scan on d -(1 row) + QUERY PLAN +----------------------------------------------------- + Remote Subquery Scan on all (datanode_1,datanode_2) + -> Seq Scan on d +(2 rows) -- similarly, but keying off a DISTINCT clause explain (costs off) select d.* from d left join (select distinct * from b) s on d.a = s.id and d.b = s.c_id; - QUERY PLAN ---------------- - Seq Scan on d -(1 row) + QUERY PLAN +----------------------------------------------------- + Remote Subquery Scan on all (datanode_1,datanode_2) + -> Seq Scan on d +(2 rows) -- join removal is not possible when the GROUP BY contains a column that is -- not in the join condition explain (costs off) select d.* from d left join (select * from b group by b.id, b.c_id) s on d.a = s.id; - QUERY PLAN ---------------------------------------------- - Merge Left Join - Merge Cond: (d.a = s.id) - -> Sort - Sort Key: d.a - -> Seq Scan on d - -> Sort - Sort Key: s.id - -> Subquery Scan on s - -> HashAggregate - Group Key: b.id, b.c_id - -> Seq Scan on b -(11 rows) + QUERY PLAN +----------------------------------------------------- + Remote Subquery Scan on all (datanode_1,datanode_2) + -> Merge Left Join + Merge Cond: (d.a = s.id) + -> Sort + Sort Key: d.a + -> Seq Scan on d + -> Sort + Sort Key: s.id + -> Subquery Scan on s + -> HashAggregate + Group Key: b.id, b.c_id + -> Seq Scan on b +(12 rows) -- similarly, but keying off a DISTINCT clause explain (costs off) select d.* from d left join (select distinct * from b) s on d.a = s.id; - QUERY PLAN ---------------------------------------------- - Merge Left Join - Merge Cond: (d.a = s.id) - -> Sort - Sort Key: d.a - -> Seq Scan on d - -> Sort - Sort Key: s.id - -> Subquery Scan on s - -> HashAggregate - Group Key: b.id, b.c_id - -> Seq Scan on b -(11 rows) + QUERY PLAN +----------------------------------------------------- + Remote Subquery Scan on all (datanode_1,datanode_2) + -> Merge Left Join + Merge Cond: (d.a = s.id) + -> Sort + Sort Key: d.a + -> Seq Scan on d + -> Sort + Sort Key: s.id + -> Subquery Scan on s + -> HashAggregate + Group Key: b.id, b.c_id + -> Seq Scan on b +(12 rows) -- check join removal works when uniqueness of the join condition is enforced -- by a UNION explain (costs off) select d.* from d left join (select id from a union select id from b) s on d.a = s.id; - QUERY PLAN ---------------- - Seq Scan on d -(1 row) + QUERY PLAN +----------------------------------------------------- + Remote Subquery Scan on all (datanode_1,datanode_2) + -> Seq Scan on d +(2 rows) -- check join removal with a cross-type comparison operator explain (costs off) select i8.* from int8_tbl i8 left join (select f1 from int4_tbl group by f1) i4 on i8.q1 = i4.f1; - QUERY PLAN -------------------------- - Seq Scan on int8_tbl i8 -(1 row) + QUERY PLAN +------------------------------------------ + Remote Subquery Scan on all (datanode_1) + -> Seq Scan on int8_tbl i8 +(2 rows) rollback; create temp table parent (k int primary key, pd int); @@ -3746,13 +3839,15 @@ from tenk1 a, lateral (select * from int4_tbl b where f1 = a.unique1) x; explain (costs off) select unique2, x.* from tenk1 a, lateral (select * from int4_tbl b where f1 = a.unique1) x; - QUERY PLAN -------------------------------------------------- - Nested Loop - -> Seq Scan on int4_tbl b - -> Index Scan using tenk1_unique1 on tenk1 a - Index Cond: (unique1 = b.f1) -(4 rows) + QUERY PLAN +----------------------------------------------------- + Remote Subquery Scan on all (datanode_1,datanode_2) + -> Hash Join + Hash Cond: (a.unique1 = b.f1) + -> Seq Scan on tenk1 a + -> Hash + -> Seq Scan on int4_tbl b +(6 rows) select unique2, x.* from int4_tbl x, lateral (select unique2 from tenk1 where f1 = unique1) ss; @@ -3764,46 +3859,54 @@ from int4_tbl x, lateral (select unique2 from tenk1 where f1 = unique1) ss; explain (costs off) select unique2, x.* from int4_tbl x, lateral (select unique2 from tenk1 where f1 = unique1) ss; - QUERY PLAN ------------------------------------------------ - Nested Loop - -> Seq Scan on int4_tbl x - -> Index Scan using tenk1_unique1 on tenk1 - Index Cond: (unique1 = x.f1) -(4 rows) + QUERY PLAN +----------------------------------------------------- + Remote Subquery Scan on all (datanode_1,datanode_2) + -> Hash Join + Hash Cond: (tenk1.unique1 = x.f1) + -> Seq Scan on tenk1 + -> Hash + -> Seq Scan on int4_tbl x +(6 rows) explain (costs off) select unique2, x.* from int4_tbl x cross join lateral (select unique2 from tenk1 where f1 = unique1) ss; - QUERY PLAN ------------------------------------------------ - Nested Loop - -> Seq Scan on int4_tbl x - -> Index Scan using tenk1_unique1 on tenk1 - Index Cond: (unique1 = x.f1) -(4 rows) + QUERY PLAN +----------------------------------------------------- + Remote Subquery Scan on all (datanode_1,datanode_2) + -> Hash Join + Hash Cond: (tenk1.unique1 = x.f1) + -> Seq Scan on tenk1 + -> Hash + -> Seq Scan on int4_tbl x +(6 rows) select unique2, x.* from int4_tbl x left join lateral (select unique1, unique2 from tenk1 where f1 = unique1) ss on true; unique2 | f1 ---------+------------- - 9998 | 0 + | -2147483647 | 123456 - | -123456 + 9998 | 0 | 2147483647 - | -2147483647 + | -123456 (5 rows) explain (costs off) select unique2, x.* from int4_tbl x left join lateral (select unique1, unique2 from tenk1 where f1 = unique1) ss on true; - QUERY PLAN ------------------------------------------------ - Nested Loop Left Join - -> Seq Scan on int4_tbl x - -> Index Scan using tenk1_unique1 on tenk1 - Index Cond: (x.f1 = unique1) -(4 rows) + QUERY PLAN +------------------------------------------------------------ + Remote Subquery Scan on all (datanode_1,datanode_2) + -> Hash Right Join + Hash Cond: (tenk1.unique1 = x.f1) + -> Seq Scan on tenk1 + -> Hash + -> Remote Subquery Scan on all (datanode_2) + Distribute results by H: f1 + -> Seq Scan on int4_tbl x +(8 rows) -- check scoping of lateral versus parent references -- the first of these should return int8_tbl.q2, the second int8_tbl.q1 @@ -3836,50 +3939,55 @@ select count(*) from tenk1 a, lateral generate_series(1,two) g; explain (costs off) select count(*) from tenk1 a, lateral generate_series(1,two) g; - QUERY PLAN ------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------- Aggregate -> Nested Loop - -> Seq Scan on tenk1 a + -> Remote Subquery Scan on all (datanode_1,datanode_2) + -> Seq Scan on tenk1 a -> Function Scan on generate_series g -(4 rows) +(5 rows) explain (costs off) select count(*) from tenk1 a cross join lateral generate_series(1,two) g; - QUERY PLAN ------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------- Aggregate -> Nested Loop - -> Seq Scan on tenk1 a + -> Remote Subquery Scan on all (datanode_1,datanode_2) + -> Seq Scan on tenk1 a -> Function Scan on generate_series g -(4 rows) +(5 rows) -- don't need the explicit LATERAL keyword for functions explain (costs off) select count(*) from tenk1 a, generate_series(1,two) g; - QUERY PLAN ------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------- Aggregate -> Nested Loop - -> Seq Scan on tenk1 a + -> Remote Subquery Scan on all (datanode_1,datanode_2) + -> Seq Scan on tenk1 a -> Function Scan on generate_series g -(4 rows) +(5 rows) -- lateral with UNION ALL subselect explain (costs off) select * from generate_series(100,200) g, lateral (select * from int8_tbl a where g = q1 union all select * from int8_tbl b where g = q2) ss; - QUERY PLAN ------------------------------------------- + QUERY PLAN +------------------------------------------------------ Nested Loop -> Function Scan on generate_series g - -> Append - -> Seq Scan on int8_tbl a - Filter: (g.g = q1) - -> Seq Scan on int8_tbl b - Filter: (g.g = q2) -(7 rows) + -> Materialize + -> Remote Subquery Scan on all (datanode_1) + -> Append + -> Seq Scan on int8_tbl a + Filter: (g.g = q1) + -> Seq Scan on int8_tbl b + Filter: (g.g = q2) +(9 rows) select * from generate_series(100,200) g, lateral (select * from int8_tbl a where g = q1 union all @@ -3895,14 +4003,22 @@ select * from generate_series(100,200) g, explain (costs off) select count(*) from tenk1 a, tenk1 b join lateral (values(a.unique1)) ss(x) on b.unique2 = ss.x; - QUERY PLAN ------------------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------- Aggregate - -> Merge Join - Merge Cond: (a.unique1 = b.unique2) - -> Index Only Scan using tenk1_unique1 on tenk1 a - -> Index Only Scan using tenk1_unique2 on tenk1 b -(5 rows) + -> Remote Subquery Scan on all (datanode_1,datanode_2) + -> Aggregate + -> Merge Join + Merge Cond: (b.unique2 = a.unique1) + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Distribute results by H: unique2 + -> Sort + Sort Key: b.unique2 + -> Seq Scan on tenk1 b + -> Sort + Sort Key: a.unique1 + -> Seq Scan on tenk1 a +(13 rows) select count(*) from tenk1 a, tenk1 b join lateral (values(a.unique1)) ss(x) on b.unique2 = ss.x; @@ -3915,17 +4031,22 @@ select count(*) from tenk1 a, explain (costs off) select count(*) from tenk1 a, tenk1 b join lateral (values(a.unique1),(-1)) ss(x) on b.unique2 = ss.x; - QUERY PLAN ------------------------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------- Aggregate - -> Hash Join - Hash Cond: ("*VALUES*".column1 = b.unique2) - -> Nested Loop - -> Index Only Scan using tenk1_unique1 on tenk1 a - -> Values Scan on "*VALUES*" - -> Hash - -> Index Only Scan using tenk1_unique2 on tenk1 b -(8 rows) + -> Merge Join + Merge Cond: (b.unique2 = "*VALUES*".column1) + -> Remote Subquery Scan on all (datanode_1,datanode_2) + -> Sort + Sort Key: b.unique2 + -> Seq Scan on tenk1 b + -> Sort + Sort Key: "*VALUES*".column1 + -> Nested Loop + -> Remote Subquery Scan on all (datanode_1,datanode_2) + -> Seq Scan on tenk1 a + -> Values Scan on "*VALUES*" +(13 rows) select count(*) from tenk1 a, tenk1 b join lateral (values(a.unique1),(-1)) ss(x) on b.unique2 = ss.x; @@ -3939,16 +4060,17 @@ explain (costs off) select * from int8_tbl a, int8_tbl x left join lateral (select a.q1 from int4_tbl y) ss(z) on x.q2 = ss.z; - QUERY PLAN ------------------------------------------- - Nested Loop - -> Seq Scan on int8_tbl a - -> Hash Right Join - Hash Cond: ((a.q1) = x.q2) - -> Seq Scan on int4_tbl y - -> Hash - -> Seq Scan on int8_tbl x -(7 rows) + QUERY PLAN +------------------------------------------------ + Remote Subquery Scan on all (datanode_1) + -> Nested Loop + -> Seq Scan on int8_tbl a + -> Hash Right Join + Hash Cond: ((a.q1) = x.q2) + -> Seq Scan on int4_tbl y + -> Hash + -> Seq Scan on int8_tbl x +(8 rows) select * from int8_tbl a, int8_tbl x left join lateral (select a.q1 from int4_tbl y) ss(z) @@ -4242,16 +4364,18 @@ explain (verbose, costs off) select * from int8_tbl a left join lateral (select *, a.q2 as x from int8_tbl b) ss on a.q2 = ss.q1; - QUERY PLAN ------------------------------------------- - Nested Loop Left Join - Output: a.q1, a.q2, b.q1, b.q2, (a.q2) - -> Seq Scan on public.int8_tbl a - Output: a.q1, a.q2 - -> Seq Scan on public.int8_tbl b - Output: b.q1, b.q2, a.q2 - Filter: (a.q2 = b.q1) -(7 rows) + QUERY PLAN +------------------------------------------------ + Remote Subquery Scan on all (datanode_1) + Output: a.q1, a.q2, b.q1, b.q2, a.q2 + -> Nested Loop Left Join + Output: a.q1, a.q2, b.q1, b.q2, (a.q2) + -> Seq Scan on public.int8_tbl a + Output: a.q1, a.q2 + -> Seq Scan on public.int8_tbl b + Output: b.q1, b.q2, a.q2 + Filter: (a.q2 = b.q1) +(9 rows) select * from int8_tbl a left join @@ -4274,16 +4398,18 @@ explain (verbose, costs off) select * from int8_tbl a left join lateral (select *, coalesce(a.q2, 42) as x from int8_tbl b) ss on a.q2 = ss.q1; - QUERY PLAN ------------------------------------------------------------------- - Nested Loop Left Join - Output: a.q1, a.q2, b.q1, b.q2, (COALESCE(a.q2, '42'::bigint)) - -> Seq Scan on public.int8_tbl a - Output: a.q1, a.q2 - -> Seq Scan on public.int8_tbl b - Output: b.q1, b.q2, COALESCE(a.q2, '42'::bigint) - Filter: (a.q2 = b.q1) -(7 rows) + QUERY PLAN +------------------------------------------------------------------------ + Remote Subquery Scan on all (datanode_1) + Output: a.q1, a.q2, b.q1, b.q2, COALESCE(a.q2, '42'::bigint) + -> Nested Loop Left Join + Output: a.q1, a.q2, b.q1, b.q2, (COALESCE(a.q2, '42'::bigint)) + -> Seq Scan on public.int8_tbl a + Output: a.q1, a.q2 + -> Seq Scan on public.int8_tbl b + Output: b.q1, b.q2, COALESCE(a.q2, '42'::bigint) + Filter: (a.q2 = b.q1) +(9 rows) select * from int8_tbl a left join @@ -4307,43 +4433,53 @@ select * from explain (verbose, costs off) select * from int4_tbl i left join lateral (select * from int2_tbl j where i.f1 = j.f1) k on true; - QUERY PLAN -------------------------------------------- - Hash Left Join + QUERY PLAN +----------------------------------------------------------- + Hash Right Join Output: i.f1, j.f1 - Hash Cond: (i.f1 = j.f1) - -> Seq Scan on public.int4_tbl i - Output: i.f1 - -> Hash + Hash Cond: (j.f1 = i.f1) + -> Remote Subquery Scan on all (datanode_1,datanode_2) Output: j.f1 -> Seq Scan on public.int2_tbl j Output: j.f1 -(9 rows) + -> Hash + Output: i.f1 + -> Remote Subquery Scan on all (datanode_1) + Output: i.f1 + -> Seq Scan on public.int4_tbl i + Output: i.f1 +(13 rows) select * from int4_tbl i left join lateral (select * from int2_tbl j where i.f1 = j.f1) k on true; f1 | f1 -------------+---- 0 | 0 - 123456 | - -123456 | - 2147483647 | -2147483647 | + 2147483647 | + -123456 | + 123456 | (5 rows) explain (verbose, costs off) select * from int4_tbl i left join lateral (select coalesce(i) from int2_tbl j where i.f1 = j.f1) k on true; - QUERY PLAN -------------------------------------- + QUERY PLAN +----------------------------------------------------------------- Nested Loop Left Join Output: i.f1, (COALESCE(i.*)) - -> Seq Scan on public.int4_tbl i + -> Remote Subquery Scan on all (datanode_2) Output: i.f1, i.* - -> Seq Scan on public.int2_tbl j - Output: j.f1, COALESCE(i.*) - Filter: (i.f1 = j.f1) -(7 rows) + -> Seq Scan on public.int4_tbl i + Output: i.f1, i.* + -> Materialize + Output: j.f1, (COALESCE(i.*)) + -> Remote Subquery Scan on all (datanode_1,datanode_2) + Output: j.f1, COALESCE(i.*) + -> Seq Scan on public.int2_tbl j + Output: j.f1, COALESCE(i.*) + Filter: (i.f1 = j.f1) +(13 rows) select * from int4_tbl i left join lateral (select coalesce(i) from int2_tbl j where i.f1 = j.f1) k on true; @@ -4361,23 +4497,25 @@ select * from int4_tbl a, lateral ( select * from int4_tbl b left join int8_tbl c on (b.f1 = q1 and a.f1 = q2) ) ss; - QUERY PLAN -------------------------------------------------- - Nested Loop - Output: a.f1, b.f1, c.q1, c.q2 - -> Seq Scan on public.int4_tbl a - Output: a.f1 - -> Hash Left Join - Output: b.f1, c.q1, c.q2 - Hash Cond: (b.f1 = c.q1) - -> Seq Scan on public.int4_tbl b - Output: b.f1 - -> Hash - Output: c.q1, c.q2 - -> Seq Scan on public.int8_tbl c + QUERY PLAN +------------------------------------------------------- + Remote Subquery Scan on all (datanode_1) + Output: a.f1, f1, q1, q2 + -> Nested Loop + Output: a.f1, b.f1, c.q1, c.q2 + -> Seq Scan on public.int4_tbl a + Output: a.f1 + -> Hash Left Join + Output: b.f1, c.q1, c.q2 + Hash Cond: (b.f1 = c.q1) + -> Seq Scan on public.int4_tbl b + Output: b.f1 + -> Hash Output: c.q1, c.q2 - Filter: (a.f1 = c.q2) -(14 rows) + -> Seq Scan on public.int8_tbl c + Output: c.q1, c.q2 + Filter: (a.f1 = c.q2) +(16 rows) select * from int4_tbl a, lateral ( @@ -4419,22 +4557,24 @@ select * from (select b.q1 as bq1, c.q1 as cq1, least(a.q1,b.q1,c.q1) from int8_tbl b cross join int8_tbl c) ss on a.q2 = ss.bq1; - QUERY PLAN -------------------------------------------------------------- - Nested Loop Left Join - Output: a.q1, a.q2, b.q1, c.q1, (LEAST(a.q1, b.q1, c.q1)) - -> Seq Scan on public.int8_tbl a - Output: a.q1, a.q2 - -> Nested Loop - Output: b.q1, c.q1, LEAST(a.q1, b.q1, c.q1) - Join Filter: (a.q2 = b.q1) - -> Seq Scan on public.int8_tbl b - Output: b.q1, b.q2 - -> Materialize - Output: c.q1 - -> Seq Scan on public.int8_tbl c + QUERY PLAN +------------------------------------------------------------------- + Remote Subquery Scan on all (datanode_2) + Output: a.q1, a.q2, b.q1, c.q1, LEAST(a.q1, b.q1, c.q1) + -> Nested Loop Left Join + Output: a.q1, a.q2, b.q1, c.q1, (LEAST(a.q1, b.q1, c.q1)) + -> Seq Scan on public.int8_tbl a + Output: a.q1, a.q2 + -> Nested Loop + Output: b.q1, c.q1, LEAST(a.q1, b.q1, c.q1) + Join Filter: (a.q2 = b.q1) + -> Seq Scan on public.int8_tbl b + Output: b.q1, b.q2 + -> Materialize Output: c.q1 -(13 rows) + -> Seq Scan on public.int8_tbl c + Output: c.q1 +(15 rows) select * from int8_tbl a left join lateral @@ -4497,33 +4637,35 @@ select * from lateral (select q1, coalesce(ss1.x,q2) as y from int8_tbl d) ss2 ) on c.q2 = ss2.q1, lateral (select ss2.y offset 0) ss3; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Nested Loop - Output: c.q1, c.q2, a.q1, a.q2, b.q1, (COALESCE(b.q2, '42'::bigint)), d.q1, (COALESCE((COALESCE(b.q2, '42'::bigint)), d.q2)), ((COALESCE((COALESCE(b.q2, '42'::bigint)), d.q2))) - -> Hash Right Join - Output: c.q1, c.q2, a.q1, a.q2, b.q1, d.q1, (COALESCE(b.q2, '42'::bigint)), (COALESCE((COALESCE(b.q2, '42'::bigint)), d.q2)) - Hash Cond: (d.q1 = c.q2) - -> Nested Loop - Output: a.q1, a.q2, b.q1, d.q1, (COALESCE(b.q2, '42'::bigint)), (COALESCE((COALESCE(b.q2, '42'::bigint)), d.q2)) - -> Hash Left Join - Output: a.q1, a.q2, b.q1, (COALESCE(b.q2, '42'::bigint)) - Hash Cond: (a.q2 = b.q1) - -> Seq Scan on public.int8_tbl a - Output: a.q1, a.q2 - -> Hash - Output: b.q1, (COALESCE(b.q2, '42'::bigint)) - -> Seq Scan on public.int8_tbl b - Output: b.q1, COALESCE(b.q2, '42'::bigint) - -> Seq Scan on public.int8_tbl d - Output: d.q1, COALESCE((COALESCE(b.q2, '42'::bigint)), d.q2) - -> Hash - Output: c.q1, c.q2 - -> Seq Scan on public.int8_tbl c + Output: c.q1, c.q2, a.q1, a.q2, b.q1, (COALESCE(b.q2, '42'::bigint)), d.q1, (COALESCE(COALESCE(b.q2, '42'::bigint), d.q2)), ((COALESCE(COALESCE(b.q2, '42'::bigint), d.q2))) + -> Remote Subquery Scan on all (datanode_1) + Output: c.q1, c.q2, a.q1, a.q2, b.q1, d.q1, COALESCE(b.q2, '42'::bigint), COALESCE(COALESCE(b.q2, '42'::bigint), d.q2) + -> Hash Right Join + Output: c.q1, c.q2, a.q1, a.q2, b.q1, d.q1, (COALESCE(b.q2, '42'::bigint)), (COALESCE((COALESCE(b.q2, '42'::bigint)), d.q2)) + Hash Cond: (d.q1 = c.q2) + -> Nested Loop + Output: a.q1, a.q2, b.q1, d.q1, (COALESCE(b.q2, '42'::bigint)), (COALESCE((COALESCE(b.q2, '42'::bigint)), d.q2)) + -> Hash Left Join + Output: a.q1, a.q2, b.q1, (COALESCE(b.q2, '42'::bigint)) + Hash Cond: (a.q2 = b.q1) + -> Seq Scan on public.int8_tbl a + Output: a.q1, a.q2 + -> Hash + Output: b.q1, (COALESCE(b.q2, '42'::bigint)) + -> Seq Scan on public.int8_tbl b + Output: b.q1, COALESCE(b.q2, '42'::bigint) + -> Seq Scan on public.int8_tbl d + Output: d.q1, COALESCE((COALESCE(b.q2, '42'::bigint)), d.q2) + -> Hash Output: c.q1, c.q2 + -> Seq Scan on public.int8_tbl c + Output: c.q1, c.q2 -> Result - Output: (COALESCE((COALESCE(b.q2, '42'::bigint)), d.q2)) -(24 rows) + Output: (COALESCE(COALESCE(b.q2, '42'::bigint), d.q2)) +(26 rows) -- case that breaks the old ph_may_need optimization explain (verbose, costs off) @@ -4537,43 +4679,45 @@ select c.*,a.*,ss1.q1,ss2.q1,ss3.* from lateral (select q1, coalesce(ss1.x,q2) as y from int8_tbl d) ss2 ) on c.q2 = ss2.q1, lateral (select * from int4_tbl i where ss2.y > f1) ss3; - QUERY PLAN ---------------------------------------------------------------------------------------------------------- - Nested Loop + QUERY PLAN +--------------------------------------------------------------------------------------------------------------- + Remote Subquery Scan on all (datanode_1) Output: c.q1, c.q2, a.q1, a.q2, b.q1, d.q1, i.f1 - Join Filter: ((COALESCE((COALESCE(b.q2, (b2.f1)::bigint)), d.q2)) > i.f1) - -> Hash Right Join - Output: c.q1, c.q2, a.q1, a.q2, b.q1, d.q1, (COALESCE((COALESCE(b.q2, (b2.f1)::bigint)), d.q2)) - Hash Cond: (d.q1 = c.q2) - -> Nested Loop - Output: a.q1, a.q2, b.q1, d.q1, (COALESCE((COALESCE(b.q2, (b2.f1)::bigint)), d.q2)) - -> Hash Right Join - Output: a.q1, a.q2, b.q1, (COALESCE(b.q2, (b2.f1)::bigint)) - Hash Cond: (b.q1 = a.q2) - -> Nested Loop - Output: b.q1, COALESCE(b.q2, (b2.f1)::bigint) - Join Filter: (b.q1 < b2.f1) - -> Seq Scan on public.int8_tbl b - Output: b.q1, b.q2 - -> Materialize - Output: b2.f1 - -> Seq Scan on public.int4_tbl b2 + -> Nested Loop + Output: c.q1, c.q2, a.q1, a.q2, b.q1, d.q1, i.f1 + Join Filter: ((COALESCE((COALESCE(b.q2, (b2.f1)::bigint)), d.q2)) > i.f1) + -> Hash Right Join + Output: c.q1, c.q2, a.q1, a.q2, b.q1, d.q1, (COALESCE((COALESCE(b.q2, (b2.f1)::bigint)), d.q2)) + Hash Cond: (d.q1 = c.q2) + -> Nested Loop + Output: a.q1, a.q2, b.q1, d.q1, (COALESCE((COALESCE(b.q2, (b2.f1)::bigint)), d.q2)) + -> Hash Right Join + Output: a.q1, a.q2, b.q1, (COALESCE(b.q2, (b2.f1)::bigint)) + Hash Cond: (b.q1 = a.q2) + -> Nested Loop + Output: b.q1, COALESCE(b.q2, (b2.f1)::bigint) + Join Filter: (b.q1 < b2.f1) + -> Seq Scan on public.int8_tbl b + Output: b.q1, b.q2 + -> Materialize Output: b2.f1 - -> Hash - Output: a.q1, a.q2 - -> Seq Scan on public.int8_tbl a + -> Seq Scan on public.int4_tbl b2 + Output: b2.f1 + -> Hash Output: a.q1, a.q2 - -> Seq Scan on public.int8_tbl d - Output: d.q1, COALESCE((COALESCE(b.q2, (b2.f1)::bigint)), d.q2) - -> Hash - Output: c.q1, c.q2 - -> Seq Scan on public.int8_tbl c + -> Seq Scan on public.int8_tbl a + Output: a.q1, a.q2 + -> Seq Scan on public.int8_tbl d + Output: d.q1, COALESCE((COALESCE(b.q2, (b2.f1)::bigint)), d.q2) + -> Hash Output: c.q1, c.q2 - -> Materialize - Output: i.f1 - -> Seq Scan on public.int4_tbl i + -> Seq Scan on public.int8_tbl c + Output: c.q1, c.q2 + -> Materialize Output: i.f1 -(34 rows) + -> Seq Scan on public.int4_tbl i + Output: i.f1 +(36 rows) -- check processing of postponed quals (bug #9041) explain (verbose, costs off) diff --git a/src/test/regress/expected/join_1.out b/src/test/regress/expected/join_1.out deleted file mode 100644 index 54d7d9fb60..0000000000 --- a/src/test/regress/expected/join_1.out +++ /dev/null @@ -1,3045 +0,0 @@ --- --- JOIN --- Test JOIN clauses --- -CREATE TABLE J1_TBL ( - i integer, - j integer, - t text -); -CREATE TABLE J2_TBL ( - i integer, - k integer -); -INSERT INTO J1_TBL VALUES (1, 4, 'one'); -INSERT INTO J1_TBL VALUES (2, 3, 'two'); -INSERT INTO J1_TBL VALUES (3, 2, 'three'); -INSERT INTO J1_TBL VALUES (4, 1, 'four'); -INSERT INTO J1_TBL VALUES (5, 0, 'five'); -INSERT INTO J1_TBL VALUES (6, 6, 'six'); -INSERT INTO J1_TBL VALUES (7, 7, 'seven'); -INSERT INTO J1_TBL VALUES (8, 8, 'eight'); -INSERT INTO J1_TBL VALUES (0, NULL, 'zero'); -INSERT INTO J1_TBL VALUES (NULL, NULL, 'null'); -INSERT INTO J1_TBL VALUES (NULL, 0, 'zero'); -INSERT INTO J2_TBL VALUES (1, -1); -INSERT INTO J2_TBL VALUES (2, 2); -INSERT INTO J2_TBL VALUES (3, -3); -INSERT INTO J2_TBL VALUES (2, 4); -INSERT INTO J2_TBL VALUES (5, -5); -INSERT INTO J2_TBL VALUES (5, -5); -INSERT INTO J2_TBL VALUES (0, NULL); -INSERT INTO J2_TBL VALUES (NULL, NULL); -INSERT INTO J2_TBL VALUES (NULL, 0); --- --- CORRELATION NAMES --- Make sure that table/column aliases are supported --- before diving into more complex join syntax. --- -SELECT '' AS "xxx", * - FROM J1_TBL AS tx - ORDER BY i, j, t; - xxx | i | j | t ------+---+---+------- - | 0 | | zero - | 1 | 4 | one - | 2 | 3 | two - | 3 | 2 | three - | 4 | 1 | four - | 5 | 0 | five - | 6 | 6 | six - | 7 | 7 | seven - | 8 | 8 | eight - | | 0 | zero - | | | null -(11 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL tx - ORDER BY i, j, t; - xxx | i | j | t ------+---+---+------- - | 0 | | zero - | 1 | 4 | one - | 2 | 3 | two - | 3 | 2 | three - | 4 | 1 | four - | 5 | 0 | five - | 6 | 6 | six - | 7 | 7 | seven - | 8 | 8 | eight - | | 0 | zero - | | | null -(11 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL AS t1 (a, b, c) - ORDER BY a, b, c; - xxx | a | b | c ------+---+---+------- - | 0 | | zero - | 1 | 4 | one - | 2 | 3 | two - | 3 | 2 | three - | 4 | 1 | four - | 5 | 0 | five - | 6 | 6 | six - | 7 | 7 | seven - | 8 | 8 | eight - | | 0 | zero - | | | null -(11 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL t1 (a, b, c) - ORDER BY a, b, c; - xxx | a | b | c ------+---+---+------- - | 0 | | zero - | 1 | 4 | one - | 2 | 3 | two - | 3 | 2 | three - | 4 | 1 | four - | 5 | 0 | five - | 6 | 6 | six - | 7 | 7 | seven - | 8 | 8 | eight - | | 0 | zero - | | | null -(11 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL t1 (a, b, c), J2_TBL t2 (d, e) - ORDER BY a, b, c, d, e; - xxx | a | b | c | d | e ------+---+---+-------+---+---- - | 0 | | zero | 0 | - | 0 | | zero | 1 | -1 - | 0 | | zero | 2 | 2 - | 0 | | zero | 2 | 4 - | 0 | | zero | 3 | -3 - | 0 | | zero | 5 | -5 - | 0 | | zero | 5 | -5 - | 0 | | zero | | 0 - | 0 | | zero | | - | 1 | 4 | one | 0 | - | 1 | 4 | one | 1 | -1 - | 1 | 4 | one | 2 | 2 - | 1 | 4 | one | 2 | 4 - | 1 | 4 | one | 3 | -3 - | 1 | 4 | one | 5 | -5 - | 1 | 4 | one | 5 | -5 - | 1 | 4 | one | | 0 - | 1 | 4 | one | | - | 2 | 3 | two | 0 | - | 2 | 3 | two | 1 | -1 - | 2 | 3 | two | 2 | 2 - | 2 | 3 | two | 2 | 4 - | 2 | 3 | two | 3 | -3 - | 2 | 3 | two | 5 | -5 - | 2 | 3 | two | 5 | -5 - | 2 | 3 | two | | 0 - | 2 | 3 | two | | - | 3 | 2 | three | 0 | - | 3 | 2 | three | 1 | -1 - | 3 | 2 | three | 2 | 2 - | 3 | 2 | three | 2 | 4 - | 3 | 2 | three | 3 | -3 - | 3 | 2 | three | 5 | -5 - | 3 | 2 | three | 5 | -5 - | 3 | 2 | three | | 0 - | 3 | 2 | three | | - | 4 | 1 | four | 0 | - | 4 | 1 | four | 1 | -1 - | 4 | 1 | four | 2 | 2 - | 4 | 1 | four | 2 | 4 - | 4 | 1 | four | 3 | -3 - | 4 | 1 | four | 5 | -5 - | 4 | 1 | four | 5 | -5 - | 4 | 1 | four | | 0 - | 4 | 1 | four | | - | 5 | 0 | five | 0 | - | 5 | 0 | five | 1 | -1 - | 5 | 0 | five | 2 | 2 - | 5 | 0 | five | 2 | 4 - | 5 | 0 | five | 3 | -3 - | 5 | 0 | five | 5 | -5 - | 5 | 0 | five | 5 | -5 - | 5 | 0 | five | | 0 - | 5 | 0 | five | | - | 6 | 6 | six | 0 | - | 6 | 6 | six | 1 | -1 - | 6 | 6 | six | 2 | 2 - | 6 | 6 | six | 2 | 4 - | 6 | 6 | six | 3 | -3 - | 6 | 6 | six | 5 | -5 - | 6 | 6 | six | 5 | -5 - | 6 | 6 | six | | 0 - | 6 | 6 | six | | - | 7 | 7 | seven | 0 | - | 7 | 7 | seven | 1 | -1 - | 7 | 7 | seven | 2 | 2 - | 7 | 7 | seven | 2 | 4 - | 7 | 7 | seven | 3 | -3 - | 7 | 7 | seven | 5 | -5 - | 7 | 7 | seven | 5 | -5 - | 7 | 7 | seven | | 0 - | 7 | 7 | seven | | - | 8 | 8 | eight | 0 | - | 8 | 8 | eight | 1 | -1 - | 8 | 8 | eight | 2 | 2 - | 8 | 8 | eight | 2 | 4 - | 8 | 8 | eight | 3 | -3 - | 8 | 8 | eight | 5 | -5 - | 8 | 8 | eight | 5 | -5 - | 8 | 8 | eight | | 0 - | 8 | 8 | eight | | - | | 0 | zero | 0 | - | | 0 | zero | 1 | -1 - | | 0 | zero | 2 | 2 - | | 0 | zero | 2 | 4 - | | 0 | zero | 3 | -3 - | | 0 | zero | 5 | -5 - | | 0 | zero | 5 | -5 - | | 0 | zero | | 0 - | | 0 | zero | | - | | | null | 0 | - | | | null | 1 | -1 - | | | null | 2 | 2 - | | | null | 2 | 4 - | | | null | 3 | -3 - | | | null | 5 | -5 - | | | null | 5 | -5 - | | | null | | 0 - | | | null | | -(99 rows) - -SELECT '' AS "xxx", t1.a, t2.e - FROM J1_TBL t1 (a, b, c), J2_TBL t2 (d, e) - WHERE t1.a = t2.d - ORDER BY a, e; - xxx | a | e ------+---+---- - | 0 | - | 1 | -1 - | 2 | 2 - | 2 | 4 - | 3 | -3 - | 5 | -5 - | 5 | -5 -(7 rows) - --- --- CROSS JOIN --- Qualifications are not allowed on cross joins, --- which degenerate into a standard unqualified inner join. --- -SELECT '' AS "xxx", * - FROM J1_TBL CROSS JOIN J2_TBL - ORDER BY J1_TBL.i, J1_TBL.j, J1_TBL.t, J2_TBL.i, J2_TBL.k; - xxx | i | j | t | i | k ------+---+---+-------+---+---- - | 0 | | zero | 0 | - | 0 | | zero | 1 | -1 - | 0 | | zero | 2 | 2 - | 0 | | zero | 2 | 4 - | 0 | | zero | 3 | -3 - | 0 | | zero | 5 | -5 - | 0 | | zero | 5 | -5 - | 0 | | zero | | 0 - | 0 | | zero | | - | 1 | 4 | one | 0 | - | 1 | 4 | one | 1 | -1 - | 1 | 4 | one | 2 | 2 - | 1 | 4 | one | 2 | 4 - | 1 | 4 | one | 3 | -3 - | 1 | 4 | one | 5 | -5 - | 1 | 4 | one | 5 | -5 - | 1 | 4 | one | | 0 - | 1 | 4 | one | | - | 2 | 3 | two | 0 | - | 2 | 3 | two | 1 | -1 - | 2 | 3 | two | 2 | 2 - | 2 | 3 | two | 2 | 4 - | 2 | 3 | two | 3 | -3 - | 2 | 3 | two | 5 | -5 - | 2 | 3 | two | 5 | -5 - | 2 | 3 | two | | 0 - | 2 | 3 | two | | - | 3 | 2 | three | 0 | - | 3 | 2 | three | 1 | -1 - | 3 | 2 | three | 2 | 2 - | 3 | 2 | three | 2 | 4 - | 3 | 2 | three | 3 | -3 - | 3 | 2 | three | 5 | -5 - | 3 | 2 | three | 5 | -5 - | 3 | 2 | three | | 0 - | 3 | 2 | three | | - | 4 | 1 | four | 0 | - | 4 | 1 | four | 1 | -1 - | 4 | 1 | four | 2 | 2 - | 4 | 1 | four | 2 | 4 - | 4 | 1 | four | 3 | -3 - | 4 | 1 | four | 5 | -5 - | 4 | 1 | four | 5 | -5 - | 4 | 1 | four | | 0 - | 4 | 1 | four | | - | 5 | 0 | five | 0 | - | 5 | 0 | five | 1 | -1 - | 5 | 0 | five | 2 | 2 - | 5 | 0 | five | 2 | 4 - | 5 | 0 | five | 3 | -3 - | 5 | 0 | five | 5 | -5 - | 5 | 0 | five | 5 | -5 - | 5 | 0 | five | | 0 - | 5 | 0 | five | | - | 6 | 6 | six | 0 | - | 6 | 6 | six | 1 | -1 - | 6 | 6 | six | 2 | 2 - | 6 | 6 | six | 2 | 4 - | 6 | 6 | six | 3 | -3 - | 6 | 6 | six | 5 | -5 - | 6 | 6 | six | 5 | -5 - | 6 | 6 | six | | 0 - | 6 | 6 | six | | - | 7 | 7 | seven | 0 | - | 7 | 7 | seven | 1 | -1 - | 7 | 7 | seven | 2 | 2 - | 7 | 7 | seven | 2 | 4 - | 7 | 7 | seven | 3 | -3 - | 7 | 7 | seven | 5 | -5 - | 7 | 7 | seven | 5 | -5 - | 7 | 7 | seven | | 0 - | 7 | 7 | seven | | - | 8 | 8 | eight | 0 | - | 8 | 8 | eight | 1 | -1 - | 8 | 8 | eight | 2 | 2 - | 8 | 8 | eight | 2 | 4 - | 8 | 8 | eight | 3 | -3 - | 8 | 8 | eight | 5 | -5 - | 8 | 8 | eight | 5 | -5 - | 8 | 8 | eight | | 0 - | 8 | 8 | eight | | - | | 0 | zero | 0 | - | | 0 | zero | 1 | -1 - | | 0 | zero | 2 | 2 - | | 0 | zero | 2 | 4 - | | 0 | zero | 3 | -3 - | | 0 | zero | 5 | -5 - | | 0 | zero | 5 | -5 - | | 0 | zero | | 0 - | | 0 | zero | | - | | | null | 0 | - | | | null | 1 | -1 - | | | null | 2 | 2 - | | | null | 2 | 4 - | | | null | 3 | -3 - | | | null | 5 | -5 - | | | null | 5 | -5 - | | | null | | 0 - | | | null | | -(99 rows) - --- ambiguous column -SELECT '' AS "xxx", i, k, t - FROM J1_TBL CROSS JOIN J2_TBL; -ERROR: column reference "i" is ambiguous -LINE 1: SELECT '' AS "xxx", i, k, t - ^ --- resolve previous ambiguity by specifying the table name -SELECT '' AS "xxx", t1.i, k, t - FROM J1_TBL t1 CROSS JOIN J2_TBL t2 - ORDER BY i, k, t; - xxx | i | k | t ------+---+----+------- - | 0 | -5 | zero - | 0 | -5 | zero - | 0 | -3 | zero - | 0 | -1 | zero - | 0 | 0 | zero - | 0 | 2 | zero - | 0 | 4 | zero - | 0 | | zero - | 0 | | zero - | 1 | -5 | one - | 1 | -5 | one - | 1 | -3 | one - | 1 | -1 | one - | 1 | 0 | one - | 1 | 2 | one - | 1 | 4 | one - | 1 | | one - | 1 | | one - | 2 | -5 | two - | 2 | -5 | two - | 2 | -3 | two - | 2 | -1 | two - | 2 | 0 | two - | 2 | 2 | two - | 2 | 4 | two - | 2 | | two - | 2 | | two - | 3 | -5 | three - | 3 | -5 | three - | 3 | -3 | three - | 3 | -1 | three - | 3 | 0 | three - | 3 | 2 | three - | 3 | 4 | three - | 3 | | three - | 3 | | three - | 4 | -5 | four - | 4 | -5 | four - | 4 | -3 | four - | 4 | -1 | four - | 4 | 0 | four - | 4 | 2 | four - | 4 | 4 | four - | 4 | | four - | 4 | | four - | 5 | -5 | five - | 5 | -5 | five - | 5 | -3 | five - | 5 | -1 | five - | 5 | 0 | five - | 5 | 2 | five - | 5 | 4 | five - | 5 | | five - | 5 | | five - | 6 | -5 | six - | 6 | -5 | six - | 6 | -3 | six - | 6 | -1 | six - | 6 | 0 | six - | 6 | 2 | six - | 6 | 4 | six - | 6 | | six - | 6 | | six - | 7 | -5 | seven - | 7 | -5 | seven - | 7 | -3 | seven - | 7 | -1 | seven - | 7 | 0 | seven - | 7 | 2 | seven - | 7 | 4 | seven - | 7 | | seven - | 7 | | seven - | 8 | -5 | eight - | 8 | -5 | eight - | 8 | -3 | eight - | 8 | -1 | eight - | 8 | 0 | eight - | 8 | 2 | eight - | 8 | 4 | eight - | 8 | | eight - | 8 | | eight - | | -5 | null - | | -5 | null - | | -5 | zero - | | -5 | zero - | | -3 | null - | | -3 | zero - | | -1 | null - | | -1 | zero - | | 0 | null - | | 0 | zero - | | 2 | null - | | 2 | zero - | | 4 | null - | | 4 | zero - | | | null - | | | null - | | | zero - | | | zero -(99 rows) - -SELECT '' AS "xxx", ii, tt, kk - FROM (J1_TBL CROSS JOIN J2_TBL) - AS tx (ii, jj, tt, ii2, kk) - ORDER BY ii, tt, kk; - xxx | ii | tt | kk ------+----+-------+---- - | 0 | zero | -5 - | 0 | zero | -5 - | 0 | zero | -3 - | 0 | zero | -1 - | 0 | zero | 0 - | 0 | zero | 2 - | 0 | zero | 4 - | 0 | zero | - | 0 | zero | - | 1 | one | -5 - | 1 | one | -5 - | 1 | one | -3 - | 1 | one | -1 - | 1 | one | 0 - | 1 | one | 2 - | 1 | one | 4 - | 1 | one | - | 1 | one | - | 2 | two | -5 - | 2 | two | -5 - | 2 | two | -3 - | 2 | two | -1 - | 2 | two | 0 - | 2 | two | 2 - | 2 | two | 4 - | 2 | two | - | 2 | two | - | 3 | three | -5 - | 3 | three | -5 - | 3 | three | -3 - | 3 | three | -1 - | 3 | three | 0 - | 3 | three | 2 - | 3 | three | 4 - | 3 | three | - | 3 | three | - | 4 | four | -5 - | 4 | four | -5 - | 4 | four | -3 - | 4 | four | -1 - | 4 | four | 0 - | 4 | four | 2 - | 4 | four | 4 - | 4 | four | - | 4 | four | - | 5 | five | -5 - | 5 | five | -5 - | 5 | five | -3 - | 5 | five | -1 - | 5 | five | 0 - | 5 | five | 2 - | 5 | five | 4 - | 5 | five | - | 5 | five | - | 6 | six | -5 - | 6 | six | -5 - | 6 | six | -3 - | 6 | six | -1 - | 6 | six | 0 - | 6 | six | 2 - | 6 | six | 4 - | 6 | six | - | 6 | six | - | 7 | seven | -5 - | 7 | seven | -5 - | 7 | seven | -3 - | 7 | seven | -1 - | 7 | seven | 0 - | 7 | seven | 2 - | 7 | seven | 4 - | 7 | seven | - | 7 | seven | - | 8 | eight | -5 - | 8 | eight | -5 - | 8 | eight | -3 - | 8 | eight | -1 - | 8 | eight | 0 - | 8 | eight | 2 - | 8 | eight | 4 - | 8 | eight | - | 8 | eight | - | | null | -5 - | | null | -5 - | | null | -3 - | | null | -1 - | | null | 0 - | | null | 2 - | | null | 4 - | | null | - | | null | - | | zero | -5 - | | zero | -5 - | | zero | -3 - | | zero | -1 - | | zero | 0 - | | zero | 2 - | | zero | 4 - | | zero | - | | zero | -(99 rows) - -SELECT '' AS "xxx", tx.ii, tx.jj, tx.kk - FROM (J1_TBL t1 (a, b, c) CROSS JOIN J2_TBL t2 (d, e)) - AS tx (ii, jj, tt, ii2, kk) - ORDER BY ii, jj, kk; - xxx | ii | jj | kk ------+----+----+---- - | 0 | | -5 - | 0 | | -5 - | 0 | | -3 - | 0 | | -1 - | 0 | | 0 - | 0 | | 2 - | 0 | | 4 - | 0 | | - | 0 | | - | 1 | 4 | -5 - | 1 | 4 | -5 - | 1 | 4 | -3 - | 1 | 4 | -1 - | 1 | 4 | 0 - | 1 | 4 | 2 - | 1 | 4 | 4 - | 1 | 4 | - | 1 | 4 | - | 2 | 3 | -5 - | 2 | 3 | -5 - | 2 | 3 | -3 - | 2 | 3 | -1 - | 2 | 3 | 0 - | 2 | 3 | 2 - | 2 | 3 | 4 - | 2 | 3 | - | 2 | 3 | - | 3 | 2 | -5 - | 3 | 2 | -5 - | 3 | 2 | -3 - | 3 | 2 | -1 - | 3 | 2 | 0 - | 3 | 2 | 2 - | 3 | 2 | 4 - | 3 | 2 | - | 3 | 2 | - | 4 | 1 | -5 - | 4 | 1 | -5 - | 4 | 1 | -3 - | 4 | 1 | -1 - | 4 | 1 | 0 - | 4 | 1 | 2 - | 4 | 1 | 4 - | 4 | 1 | - | 4 | 1 | - | 5 | 0 | -5 - | 5 | 0 | -5 - | 5 | 0 | -3 - | 5 | 0 | -1 - | 5 | 0 | 0 - | 5 | 0 | 2 - | 5 | 0 | 4 - | 5 | 0 | - | 5 | 0 | - | 6 | 6 | -5 - | 6 | 6 | -5 - | 6 | 6 | -3 - | 6 | 6 | -1 - | 6 | 6 | 0 - | 6 | 6 | 2 - | 6 | 6 | 4 - | 6 | 6 | - | 6 | 6 | - | 7 | 7 | -5 - | 7 | 7 | -5 - | 7 | 7 | -3 - | 7 | 7 | -1 - | 7 | 7 | 0 - | 7 | 7 | 2 - | 7 | 7 | 4 - | 7 | 7 | - | 7 | 7 | - | 8 | 8 | -5 - | 8 | 8 | -5 - | 8 | 8 | -3 - | 8 | 8 | -1 - | 8 | 8 | 0 - | 8 | 8 | 2 - | 8 | 8 | 4 - | 8 | 8 | - | 8 | 8 | - | | 0 | -5 - | | 0 | -5 - | | 0 | -3 - | | 0 | -1 - | | 0 | 0 - | | 0 | 2 - | | 0 | 4 - | | 0 | - | | 0 | - | | | -5 - | | | -5 - | | | -3 - | | | -1 - | | | 0 - | | | 2 - | | | 4 - | | | - | | | -(99 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL CROSS JOIN J2_TBL a CROSS JOIN J2_TBL b - ORDER BY J1_TBL.i,J1_TBL.j,J1_TBL.t,a.i,a.k,b.i,b.k; - xxx | i | j | t | i | k | i | k ------+---+---+-------+---+----+---+---- - | 0 | | zero | 0 | | 0 | - | 0 | | zero | 0 | | 1 | -1 - | 0 | | zero | 0 | | 2 | 2 - | 0 | | zero | 0 | | 2 | 4 - | 0 | | zero | 0 | | 3 | -3 - | 0 | | zero | 0 | | 5 | -5 - | 0 | | zero | 0 | | 5 | -5 - | 0 | | zero | 0 | | | 0 - | 0 | | zero | 0 | | | - | 0 | | zero | 1 | -1 | 0 | - | 0 | | zero | 1 | -1 | 1 | -1 - | 0 | | zero | 1 | -1 | 2 | 2 - | 0 | | zero | 1 | -1 | 2 | 4 - | 0 | | zero | 1 | -1 | 3 | -3 - | 0 | | zero | 1 | -1 | 5 | -5 - | 0 | | zero | 1 | -1 | 5 | -5 - | 0 | | zero | 1 | -1 | | 0 - | 0 | | zero | 1 | -1 | | - | 0 | | zero | 2 | 2 | 0 | - | 0 | | zero | 2 | 2 | 1 | -1 - | 0 | | zero | 2 | 2 | 2 | 2 - | 0 | | zero | 2 | 2 | 2 | 4 - | 0 | | zero | 2 | 2 | 3 | -3 - | 0 | | zero | 2 | 2 | 5 | -5 - | 0 | | zero | 2 | 2 | 5 | -5 - | 0 | | zero | 2 | 2 | | 0 - | 0 | | zero | 2 | 2 | | - | 0 | | zero | 2 | 4 | 0 | - | 0 | | zero | 2 | 4 | 1 | -1 - | 0 | | zero | 2 | 4 | 2 | 2 - | 0 | | zero | 2 | 4 | 2 | 4 - | 0 | | zero | 2 | 4 | 3 | -3 - | 0 | | zero | 2 | 4 | 5 | -5 - | 0 | | zero | 2 | 4 | 5 | -5 - | 0 | | zero | 2 | 4 | | 0 - | 0 | | zero | 2 | 4 | | - | 0 | | zero | 3 | -3 | 0 | - | 0 | | zero | 3 | -3 | 1 | -1 - | 0 | | zero | 3 | -3 | 2 | 2 - | 0 | | zero | 3 | -3 | 2 | 4 - | 0 | | zero | 3 | -3 | 3 | -3 - | 0 | | zero | 3 | -3 | 5 | -5 - | 0 | | zero | 3 | -3 | 5 | -5 - | 0 | | zero | 3 | -3 | | 0 - | 0 | | zero | 3 | -3 | | - | 0 | | zero | 5 | -5 | 0 | - | 0 | | zero | 5 | -5 | 0 | - | 0 | | zero | 5 | -5 | 1 | -1 - | 0 | | zero | 5 | -5 | 1 | -1 - | 0 | | zero | 5 | -5 | 2 | 2 - | 0 | | zero | 5 | -5 | 2 | 2 - | 0 | | zero | 5 | -5 | 2 | 4 - | 0 | | zero | 5 | -5 | 2 | 4 - | 0 | | zero | 5 | -5 | 3 | -3 - | 0 | | zero | 5 | -5 | 3 | -3 - | 0 | | zero | 5 | -5 | 5 | -5 - | 0 | | zero | 5 | -5 | 5 | -5 - | 0 | | zero | 5 | -5 | 5 | -5 - | 0 | | zero | 5 | -5 | 5 | -5 - | 0 | | zero | 5 | -5 | | 0 - | 0 | | zero | 5 | -5 | | 0 - | 0 | | zero | 5 | -5 | | - | 0 | | zero | 5 | -5 | | - | 0 | | zero | | 0 | 0 | - | 0 | | zero | | 0 | 1 | -1 - | 0 | | zero | | 0 | 2 | 2 - | 0 | | zero | | 0 | 2 | 4 - | 0 | | zero | | 0 | 3 | -3 - | 0 | | zero | | 0 | 5 | -5 - | 0 | | zero | | 0 | 5 | -5 - | 0 | | zero | | 0 | | 0 - | 0 | | zero | | 0 | | - | 0 | | zero | | | 0 | - | 0 | | zero | | | 1 | -1 - | 0 | | zero | | | 2 | 2 - | 0 | | zero | | | 2 | 4 - | 0 | | zero | | | 3 | -3 - | 0 | | zero | | | 5 | -5 - | 0 | | zero | | | 5 | -5 - | 0 | | zero | | | | 0 - | 0 | | zero | | | | - | 1 | 4 | one | 0 | | 0 | - | 1 | 4 | one | 0 | | 1 | -1 - | 1 | 4 | one | 0 | | 2 | 2 - | 1 | 4 | one | 0 | | 2 | 4 - | 1 | 4 | one | 0 | | 3 | -3 - | 1 | 4 | one | 0 | | 5 | -5 - | 1 | 4 | one | 0 | | 5 | -5 - | 1 | 4 | one | 0 | | | 0 - | 1 | 4 | one | 0 | | | - | 1 | 4 | one | 1 | -1 | 0 | - | 1 | 4 | one | 1 | -1 | 1 | -1 - | 1 | 4 | one | 1 | -1 | 2 | 2 - | 1 | 4 | one | 1 | -1 | 2 | 4 - | 1 | 4 | one | 1 | -1 | 3 | -3 - | 1 | 4 | one | 1 | -1 | 5 | -5 - | 1 | 4 | one | 1 | -1 | 5 | -5 - | 1 | 4 | one | 1 | -1 | | 0 - | 1 | 4 | one | 1 | -1 | | - | 1 | 4 | one | 2 | 2 | 0 | - | 1 | 4 | one | 2 | 2 | 1 | -1 - | 1 | 4 | one | 2 | 2 | 2 | 2 - | 1 | 4 | one | 2 | 2 | 2 | 4 - | 1 | 4 | one | 2 | 2 | 3 | -3 - | 1 | 4 | one | 2 | 2 | 5 | -5 - | 1 | 4 | one | 2 | 2 | 5 | -5 - | 1 | 4 | one | 2 | 2 | | 0 - | 1 | 4 | one | 2 | 2 | | - | 1 | 4 | one | 2 | 4 | 0 | - | 1 | 4 | one | 2 | 4 | 1 | -1 - | 1 | 4 | one | 2 | 4 | 2 | 2 - | 1 | 4 | one | 2 | 4 | 2 | 4 - | 1 | 4 | one | 2 | 4 | 3 | -3 - | 1 | 4 | one | 2 | 4 | 5 | -5 - | 1 | 4 | one | 2 | 4 | 5 | -5 - | 1 | 4 | one | 2 | 4 | | 0 - | 1 | 4 | one | 2 | 4 | | - | 1 | 4 | one | 3 | -3 | 0 | - | 1 | 4 | one | 3 | -3 | 1 | -1 - | 1 | 4 | one | 3 | -3 | 2 | 2 - | 1 | 4 | one | 3 | -3 | 2 | 4 - | 1 | 4 | one | 3 | -3 | 3 | -3 - | 1 | 4 | one | 3 | -3 | 5 | -5 - | 1 | 4 | one | 3 | -3 | 5 | -5 - | 1 | 4 | one | 3 | -3 | | 0 - | 1 | 4 | one | 3 | -3 | | - | 1 | 4 | one | 5 | -5 | 0 | - | 1 | 4 | one | 5 | -5 | 0 | - | 1 | 4 | one | 5 | -5 | 1 | -1 - | 1 | 4 | one | 5 | -5 | 1 | -1 - | 1 | 4 | one | 5 | -5 | 2 | 2 - | 1 | 4 | one | 5 | -5 | 2 | 2 - | 1 | 4 | one | 5 | -5 | 2 | 4 - | 1 | 4 | one | 5 | -5 | 2 | 4 - | 1 | 4 | one | 5 | -5 | 3 | -3 - | 1 | 4 | one | 5 | -5 | 3 | -3 - | 1 | 4 | one | 5 | -5 | 5 | -5 - | 1 | 4 | one | 5 | -5 | 5 | -5 - | 1 | 4 | one | 5 | -5 | 5 | -5 - | 1 | 4 | one | 5 | -5 | 5 | -5 - | 1 | 4 | one | 5 | -5 | | 0 - | 1 | 4 | one | 5 | -5 | | 0 - | 1 | 4 | one | 5 | -5 | | - | 1 | 4 | one | 5 | -5 | | - | 1 | 4 | one | | 0 | 0 | - | 1 | 4 | one | | 0 | 1 | -1 - | 1 | 4 | one | | 0 | 2 | 2 - | 1 | 4 | one | | 0 | 2 | 4 - | 1 | 4 | one | | 0 | 3 | -3 - | 1 | 4 | one | | 0 | 5 | -5 - | 1 | 4 | one | | 0 | 5 | -5 - | 1 | 4 | one | | 0 | | 0 - | 1 | 4 | one | | 0 | | - | 1 | 4 | one | | | 0 | - | 1 | 4 | one | | | 1 | -1 - | 1 | 4 | one | | | 2 | 2 - | 1 | 4 | one | | | 2 | 4 - | 1 | 4 | one | | | 3 | -3 - | 1 | 4 | one | | | 5 | -5 - | 1 | 4 | one | | | 5 | -5 - | 1 | 4 | one | | | | 0 - | 1 | 4 | one | | | | - | 2 | 3 | two | 0 | | 0 | - | 2 | 3 | two | 0 | | 1 | -1 - | 2 | 3 | two | 0 | | 2 | 2 - | 2 | 3 | two | 0 | | 2 | 4 - | 2 | 3 | two | 0 | | 3 | -3 - | 2 | 3 | two | 0 | | 5 | -5 - | 2 | 3 | two | 0 | | 5 | -5 - | 2 | 3 | two | 0 | | | 0 - | 2 | 3 | two | 0 | | | - | 2 | 3 | two | 1 | -1 | 0 | - | 2 | 3 | two | 1 | -1 | 1 | -1 - | 2 | 3 | two | 1 | -1 | 2 | 2 - | 2 | 3 | two | 1 | -1 | 2 | 4 - | 2 | 3 | two | 1 | -1 | 3 | -3 - | 2 | 3 | two | 1 | -1 | 5 | -5 - | 2 | 3 | two | 1 | -1 | 5 | -5 - | 2 | 3 | two | 1 | -1 | | 0 - | 2 | 3 | two | 1 | -1 | | - | 2 | 3 | two | 2 | 2 | 0 | - | 2 | 3 | two | 2 | 2 | 1 | -1 - | 2 | 3 | two | 2 | 2 | 2 | 2 - | 2 | 3 | two | 2 | 2 | 2 | 4 - | 2 | 3 | two | 2 | 2 | 3 | -3 - | 2 | 3 | two | 2 | 2 | 5 | -5 - | 2 | 3 | two | 2 | 2 | 5 | -5 - | 2 | 3 | two | 2 | 2 | | 0 - | 2 | 3 | two | 2 | 2 | | - | 2 | 3 | two | 2 | 4 | 0 | - | 2 | 3 | two | 2 | 4 | 1 | -1 - | 2 | 3 | two | 2 | 4 | 2 | 2 - | 2 | 3 | two | 2 | 4 | 2 | 4 - | 2 | 3 | two | 2 | 4 | 3 | -3 - | 2 | 3 | two | 2 | 4 | 5 | -5 - | 2 | 3 | two | 2 | 4 | 5 | -5 - | 2 | 3 | two | 2 | 4 | | 0 - | 2 | 3 | two | 2 | 4 | | - | 2 | 3 | two | 3 | -3 | 0 | - | 2 | 3 | two | 3 | -3 | 1 | -1 - | 2 | 3 | two | 3 | -3 | 2 | 2 - | 2 | 3 | two | 3 | -3 | 2 | 4 - | 2 | 3 | two | 3 | -3 | 3 | -3 - | 2 | 3 | two | 3 | -3 | 5 | -5 - | 2 | 3 | two | 3 | -3 | 5 | -5 - | 2 | 3 | two | 3 | -3 | | 0 - | 2 | 3 | two | 3 | -3 | | - | 2 | 3 | two | 5 | -5 | 0 | - | 2 | 3 | two | 5 | -5 | 0 | - | 2 | 3 | two | 5 | -5 | 1 | -1 - | 2 | 3 | two | 5 | -5 | 1 | -1 - | 2 | 3 | two | 5 | -5 | 2 | 2 - | 2 | 3 | two | 5 | -5 | 2 | 2 - | 2 | 3 | two | 5 | -5 | 2 | 4 - | 2 | 3 | two | 5 | -5 | 2 | 4 - | 2 | 3 | two | 5 | -5 | 3 | -3 - | 2 | 3 | two | 5 | -5 | 3 | -3 - | 2 | 3 | two | 5 | -5 | 5 | -5 - | 2 | 3 | two | 5 | -5 | 5 | -5 - | 2 | 3 | two | 5 | -5 | 5 | -5 - | 2 | 3 | two | 5 | -5 | 5 | -5 - | 2 | 3 | two | 5 | -5 | | 0 - | 2 | 3 | two | 5 | -5 | | 0 - | 2 | 3 | two | 5 | -5 | | - | 2 | 3 | two | 5 | -5 | | - | 2 | 3 | two | | 0 | 0 | - | 2 | 3 | two | | 0 | 1 | -1 - | 2 | 3 | two | | 0 | 2 | 2 - | 2 | 3 | two | | 0 | 2 | 4 - | 2 | 3 | two | | 0 | 3 | -3 - | 2 | 3 | two | | 0 | 5 | -5 - | 2 | 3 | two | | 0 | 5 | -5 - | 2 | 3 | two | | 0 | | 0 - | 2 | 3 | two | | 0 | | - | 2 | 3 | two | | | 0 | - | 2 | 3 | two | | | 1 | -1 - | 2 | 3 | two | | | 2 | 2 - | 2 | 3 | two | | | 2 | 4 - | 2 | 3 | two | | | 3 | -3 - | 2 | 3 | two | | | 5 | -5 - | 2 | 3 | two | | | 5 | -5 - | 2 | 3 | two | | | | 0 - | 2 | 3 | two | | | | - | 3 | 2 | three | 0 | | 0 | - | 3 | 2 | three | 0 | | 1 | -1 - | 3 | 2 | three | 0 | | 2 | 2 - | 3 | 2 | three | 0 | | 2 | 4 - | 3 | 2 | three | 0 | | 3 | -3 - | 3 | 2 | three | 0 | | 5 | -5 - | 3 | 2 | three | 0 | | 5 | -5 - | 3 | 2 | three | 0 | | | 0 - | 3 | 2 | three | 0 | | | - | 3 | 2 | three | 1 | -1 | 0 | - | 3 | 2 | three | 1 | -1 | 1 | -1 - | 3 | 2 | three | 1 | -1 | 2 | 2 - | 3 | 2 | three | 1 | -1 | 2 | 4 - | 3 | 2 | three | 1 | -1 | 3 | -3 - | 3 | 2 | three | 1 | -1 | 5 | -5 - | 3 | 2 | three | 1 | -1 | 5 | -5 - | 3 | 2 | three | 1 | -1 | | 0 - | 3 | 2 | three | 1 | -1 | | - | 3 | 2 | three | 2 | 2 | 0 | - | 3 | 2 | three | 2 | 2 | 1 | -1 - | 3 | 2 | three | 2 | 2 | 2 | 2 - | 3 | 2 | three | 2 | 2 | 2 | 4 - | 3 | 2 | three | 2 | 2 | 3 | -3 - | 3 | 2 | three | 2 | 2 | 5 | -5 - | 3 | 2 | three | 2 | 2 | 5 | -5 - | 3 | 2 | three | 2 | 2 | | 0 - | 3 | 2 | three | 2 | 2 | | - | 3 | 2 | three | 2 | 4 | 0 | - | 3 | 2 | three | 2 | 4 | 1 | -1 - | 3 | 2 | three | 2 | 4 | 2 | 2 - | 3 | 2 | three | 2 | 4 | 2 | 4 - | 3 | 2 | three | 2 | 4 | 3 | -3 - | 3 | 2 | three | 2 | 4 | 5 | -5 - | 3 | 2 | three | 2 | 4 | 5 | -5 - | 3 | 2 | three | 2 | 4 | | 0 - | 3 | 2 | three | 2 | 4 | | - | 3 | 2 | three | 3 | -3 | 0 | - | 3 | 2 | three | 3 | -3 | 1 | -1 - | 3 | 2 | three | 3 | -3 | 2 | 2 - | 3 | 2 | three | 3 | -3 | 2 | 4 - | 3 | 2 | three | 3 | -3 | 3 | -3 - | 3 | 2 | three | 3 | -3 | 5 | -5 - | 3 | 2 | three | 3 | -3 | 5 | -5 - | 3 | 2 | three | 3 | -3 | | 0 - | 3 | 2 | three | 3 | -3 | | - | 3 | 2 | three | 5 | -5 | 0 | - | 3 | 2 | three | 5 | -5 | 0 | - | 3 | 2 | three | 5 | -5 | 1 | -1 - | 3 | 2 | three | 5 | -5 | 1 | -1 - | 3 | 2 | three | 5 | -5 | 2 | 2 - | 3 | 2 | three | 5 | -5 | 2 | 2 - | 3 | 2 | three | 5 | -5 | 2 | 4 - | 3 | 2 | three | 5 | -5 | 2 | 4 - | 3 | 2 | three | 5 | -5 | 3 | -3 - | 3 | 2 | three | 5 | -5 | 3 | -3 - | 3 | 2 | three | 5 | -5 | 5 | -5 - | 3 | 2 | three | 5 | -5 | 5 | -5 - | 3 | 2 | three | 5 | -5 | 5 | -5 - | 3 | 2 | three | 5 | -5 | 5 | -5 - | 3 | 2 | three | 5 | -5 | | 0 - | 3 | 2 | three | 5 | -5 | | 0 - | 3 | 2 | three | 5 | -5 | | - | 3 | 2 | three | 5 | -5 | | - | 3 | 2 | three | | 0 | 0 | - | 3 | 2 | three | | 0 | 1 | -1 - | 3 | 2 | three | | 0 | 2 | 2 - | 3 | 2 | three | | 0 | 2 | 4 - | 3 | 2 | three | | 0 | 3 | -3 - | 3 | 2 | three | | 0 | 5 | -5 - | 3 | 2 | three | | 0 | 5 | -5 - | 3 | 2 | three | | 0 | | 0 - | 3 | 2 | three | | 0 | | - | 3 | 2 | three | | | 0 | - | 3 | 2 | three | | | 1 | -1 - | 3 | 2 | three | | | 2 | 2 - | 3 | 2 | three | | | 2 | 4 - | 3 | 2 | three | | | 3 | -3 - | 3 | 2 | three | | | 5 | -5 - | 3 | 2 | three | | | 5 | -5 - | 3 | 2 | three | | | | 0 - | 3 | 2 | three | | | | - | 4 | 1 | four | 0 | | 0 | - | 4 | 1 | four | 0 | | 1 | -1 - | 4 | 1 | four | 0 | | 2 | 2 - | 4 | 1 | four | 0 | | 2 | 4 - | 4 | 1 | four | 0 | | 3 | -3 - | 4 | 1 | four | 0 | | 5 | -5 - | 4 | 1 | four | 0 | | 5 | -5 - | 4 | 1 | four | 0 | | | 0 - | 4 | 1 | four | 0 | | | - | 4 | 1 | four | 1 | -1 | 0 | - | 4 | 1 | four | 1 | -1 | 1 | -1 - | 4 | 1 | four | 1 | -1 | 2 | 2 - | 4 | 1 | four | 1 | -1 | 2 | 4 - | 4 | 1 | four | 1 | -1 | 3 | -3 - | 4 | 1 | four | 1 | -1 | 5 | -5 - | 4 | 1 | four | 1 | -1 | 5 | -5 - | 4 | 1 | four | 1 | -1 | | 0 - | 4 | 1 | four | 1 | -1 | | - | 4 | 1 | four | 2 | 2 | 0 | - | 4 | 1 | four | 2 | 2 | 1 | -1 - | 4 | 1 | four | 2 | 2 | 2 | 2 - | 4 | 1 | four | 2 | 2 | 2 | 4 - | 4 | 1 | four | 2 | 2 | 3 | -3 - | 4 | 1 | four | 2 | 2 | 5 | -5 - | 4 | 1 | four | 2 | 2 | 5 | -5 - | 4 | 1 | four | 2 | 2 | | 0 - | 4 | 1 | four | 2 | 2 | | - | 4 | 1 | four | 2 | 4 | 0 | - | 4 | 1 | four | 2 | 4 | 1 | -1 - | 4 | 1 | four | 2 | 4 | 2 | 2 - | 4 | 1 | four | 2 | 4 | 2 | 4 - | 4 | 1 | four | 2 | 4 | 3 | -3 - | 4 | 1 | four | 2 | 4 | 5 | -5 - | 4 | 1 | four | 2 | 4 | 5 | -5 - | 4 | 1 | four | 2 | 4 | | 0 - | 4 | 1 | four | 2 | 4 | | - | 4 | 1 | four | 3 | -3 | 0 | - | 4 | 1 | four | 3 | -3 | 1 | -1 - | 4 | 1 | four | 3 | -3 | 2 | 2 - | 4 | 1 | four | 3 | -3 | 2 | 4 - | 4 | 1 | four | 3 | -3 | 3 | -3 - | 4 | 1 | four | 3 | -3 | 5 | -5 - | 4 | 1 | four | 3 | -3 | 5 | -5 - | 4 | 1 | four | 3 | -3 | | 0 - | 4 | 1 | four | 3 | -3 | | - | 4 | 1 | four | 5 | -5 | 0 | - | 4 | 1 | four | 5 | -5 | 0 | - | 4 | 1 | four | 5 | -5 | 1 | -1 - | 4 | 1 | four | 5 | -5 | 1 | -1 - | 4 | 1 | four | 5 | -5 | 2 | 2 - | 4 | 1 | four | 5 | -5 | 2 | 2 - | 4 | 1 | four | 5 | -5 | 2 | 4 - | 4 | 1 | four | 5 | -5 | 2 | 4 - | 4 | 1 | four | 5 | -5 | 3 | -3 - | 4 | 1 | four | 5 | -5 | 3 | -3 - | 4 | 1 | four | 5 | -5 | 5 | -5 - | 4 | 1 | four | 5 | -5 | 5 | -5 - | 4 | 1 | four | 5 | -5 | 5 | -5 - | 4 | 1 | four | 5 | -5 | 5 | -5 - | 4 | 1 | four | 5 | -5 | | 0 - | 4 | 1 | four | 5 | -5 | | 0 - | 4 | 1 | four | 5 | -5 | | - | 4 | 1 | four | 5 | -5 | | - | 4 | 1 | four | | 0 | 0 | - | 4 | 1 | four | | 0 | 1 | -1 - | 4 | 1 | four | | 0 | 2 | 2 - | 4 | 1 | four | | 0 | 2 | 4 - | 4 | 1 | four | | 0 | 3 | -3 - | 4 | 1 | four | | 0 | 5 | -5 - | 4 | 1 | four | | 0 | 5 | -5 - | 4 | 1 | four | | 0 | | 0 - | 4 | 1 | four | | 0 | | - | 4 | 1 | four | | | 0 | - | 4 | 1 | four | | | 1 | -1 - | 4 | 1 | four | | | 2 | 2 - | 4 | 1 | four | | | 2 | 4 - | 4 | 1 | four | | | 3 | -3 - | 4 | 1 | four | | | 5 | -5 - | 4 | 1 | four | | | 5 | -5 - | 4 | 1 | four | | | | 0 - | 4 | 1 | four | | | | - | 5 | 0 | five | 0 | | 0 | - | 5 | 0 | five | 0 | | 1 | -1 - | 5 | 0 | five | 0 | | 2 | 2 - | 5 | 0 | five | 0 | | 2 | 4 - | 5 | 0 | five | 0 | | 3 | -3 - | 5 | 0 | five | 0 | | 5 | -5 - | 5 | 0 | five | 0 | | 5 | -5 - | 5 | 0 | five | 0 | | | 0 - | 5 | 0 | five | 0 | | | - | 5 | 0 | five | 1 | -1 | 0 | - | 5 | 0 | five | 1 | -1 | 1 | -1 - | 5 | 0 | five | 1 | -1 | 2 | 2 - | 5 | 0 | five | 1 | -1 | 2 | 4 - | 5 | 0 | five | 1 | -1 | 3 | -3 - | 5 | 0 | five | 1 | -1 | 5 | -5 - | 5 | 0 | five | 1 | -1 | 5 | -5 - | 5 | 0 | five | 1 | -1 | | 0 - | 5 | 0 | five | 1 | -1 | | - | 5 | 0 | five | 2 | 2 | 0 | - | 5 | 0 | five | 2 | 2 | 1 | -1 - | 5 | 0 | five | 2 | 2 | 2 | 2 - | 5 | 0 | five | 2 | 2 | 2 | 4 - | 5 | 0 | five | 2 | 2 | 3 | -3 - | 5 | 0 | five | 2 | 2 | 5 | -5 - | 5 | 0 | five | 2 | 2 | 5 | -5 - | 5 | 0 | five | 2 | 2 | | 0 - | 5 | 0 | five | 2 | 2 | | - | 5 | 0 | five | 2 | 4 | 0 | - | 5 | 0 | five | 2 | 4 | 1 | -1 - | 5 | 0 | five | 2 | 4 | 2 | 2 - | 5 | 0 | five | 2 | 4 | 2 | 4 - | 5 | 0 | five | 2 | 4 | 3 | -3 - | 5 | 0 | five | 2 | 4 | 5 | -5 - | 5 | 0 | five | 2 | 4 | 5 | -5 - | 5 | 0 | five | 2 | 4 | | 0 - | 5 | 0 | five | 2 | 4 | | - | 5 | 0 | five | 3 | -3 | 0 | - | 5 | 0 | five | 3 | -3 | 1 | -1 - | 5 | 0 | five | 3 | -3 | 2 | 2 - | 5 | 0 | five | 3 | -3 | 2 | 4 - | 5 | 0 | five | 3 | -3 | 3 | -3 - | 5 | 0 | five | 3 | -3 | 5 | -5 - | 5 | 0 | five | 3 | -3 | 5 | -5 - | 5 | 0 | five | 3 | -3 | | 0 - | 5 | 0 | five | 3 | -3 | | - | 5 | 0 | five | 5 | -5 | 0 | - | 5 | 0 | five | 5 | -5 | 0 | - | 5 | 0 | five | 5 | -5 | 1 | -1 - | 5 | 0 | five | 5 | -5 | 1 | -1 - | 5 | 0 | five | 5 | -5 | 2 | 2 - | 5 | 0 | five | 5 | -5 | 2 | 2 - | 5 | 0 | five | 5 | -5 | 2 | 4 - | 5 | 0 | five | 5 | -5 | 2 | 4 - | 5 | 0 | five | 5 | -5 | 3 | -3 - | 5 | 0 | five | 5 | -5 | 3 | -3 - | 5 | 0 | five | 5 | -5 | 5 | -5 - | 5 | 0 | five | 5 | -5 | 5 | -5 - | 5 | 0 | five | 5 | -5 | 5 | -5 - | 5 | 0 | five | 5 | -5 | 5 | -5 - | 5 | 0 | five | 5 | -5 | | 0 - | 5 | 0 | five | 5 | -5 | | 0 - | 5 | 0 | five | 5 | -5 | | - | 5 | 0 | five | 5 | -5 | | - | 5 | 0 | five | | 0 | 0 | - | 5 | 0 | five | | 0 | 1 | -1 - | 5 | 0 | five | | 0 | 2 | 2 - | 5 | 0 | five | | 0 | 2 | 4 - | 5 | 0 | five | | 0 | 3 | -3 - | 5 | 0 | five | | 0 | 5 | -5 - | 5 | 0 | five | | 0 | 5 | -5 - | 5 | 0 | five | | 0 | | 0 - | 5 | 0 | five | | 0 | | - | 5 | 0 | five | | | 0 | - | 5 | 0 | five | | | 1 | -1 - | 5 | 0 | five | | | 2 | 2 - | 5 | 0 | five | | | 2 | 4 - | 5 | 0 | five | | | 3 | -3 - | 5 | 0 | five | | | 5 | -5 - | 5 | 0 | five | | | 5 | -5 - | 5 | 0 | five | | | | 0 - | 5 | 0 | five | | | | - | 6 | 6 | six | 0 | | 0 | - | 6 | 6 | six | 0 | | 1 | -1 - | 6 | 6 | six | 0 | | 2 | 2 - | 6 | 6 | six | 0 | | 2 | 4 - | 6 | 6 | six | 0 | | 3 | -3 - | 6 | 6 | six | 0 | | 5 | -5 - | 6 | 6 | six | 0 | | 5 | -5 - | 6 | 6 | six | 0 | | | 0 - | 6 | 6 | six | 0 | | | - | 6 | 6 | six | 1 | -1 | 0 | - | 6 | 6 | six | 1 | -1 | 1 | -1 - | 6 | 6 | six | 1 | -1 | 2 | 2 - | 6 | 6 | six | 1 | -1 | 2 | 4 - | 6 | 6 | six | 1 | -1 | 3 | -3 - | 6 | 6 | six | 1 | -1 | 5 | -5 - | 6 | 6 | six | 1 | -1 | 5 | -5 - | 6 | 6 | six | 1 | -1 | | 0 - | 6 | 6 | six | 1 | -1 | | - | 6 | 6 | six | 2 | 2 | 0 | - | 6 | 6 | six | 2 | 2 | 1 | -1 - | 6 | 6 | six | 2 | 2 | 2 | 2 - | 6 | 6 | six | 2 | 2 | 2 | 4 - | 6 | 6 | six | 2 | 2 | 3 | -3 - | 6 | 6 | six | 2 | 2 | 5 | -5 - | 6 | 6 | six | 2 | 2 | 5 | -5 - | 6 | 6 | six | 2 | 2 | | 0 - | 6 | 6 | six | 2 | 2 | | - | 6 | 6 | six | 2 | 4 | 0 | - | 6 | 6 | six | 2 | 4 | 1 | -1 - | 6 | 6 | six | 2 | 4 | 2 | 2 - | 6 | 6 | six | 2 | 4 | 2 | 4 - | 6 | 6 | six | 2 | 4 | 3 | -3 - | 6 | 6 | six | 2 | 4 | 5 | -5 - | 6 | 6 | six | 2 | 4 | 5 | -5 - | 6 | 6 | six | 2 | 4 | | 0 - | 6 | 6 | six | 2 | 4 | | - | 6 | 6 | six | 3 | -3 | 0 | - | 6 | 6 | six | 3 | -3 | 1 | -1 - | 6 | 6 | six | 3 | -3 | 2 | 2 - | 6 | 6 | six | 3 | -3 | 2 | 4 - | 6 | 6 | six | 3 | -3 | 3 | -3 - | 6 | 6 | six | 3 | -3 | 5 | -5 - | 6 | 6 | six | 3 | -3 | 5 | -5 - | 6 | 6 | six | 3 | -3 | | 0 - | 6 | 6 | six | 3 | -3 | | - | 6 | 6 | six | 5 | -5 | 0 | - | 6 | 6 | six | 5 | -5 | 0 | - | 6 | 6 | six | 5 | -5 | 1 | -1 - | 6 | 6 | six | 5 | -5 | 1 | -1 - | 6 | 6 | six | 5 | -5 | 2 | 2 - | 6 | 6 | six | 5 | -5 | 2 | 2 - | 6 | 6 | six | 5 | -5 | 2 | 4 - | 6 | 6 | six | 5 | -5 | 2 | 4 - | 6 | 6 | six | 5 | -5 | 3 | -3 - | 6 | 6 | six | 5 | -5 | 3 | -3 - | 6 | 6 | six | 5 | -5 | 5 | -5 - | 6 | 6 | six | 5 | -5 | 5 | -5 - | 6 | 6 | six | 5 | -5 | 5 | -5 - | 6 | 6 | six | 5 | -5 | 5 | -5 - | 6 | 6 | six | 5 | -5 | | 0 - | 6 | 6 | six | 5 | -5 | | 0 - | 6 | 6 | six | 5 | -5 | | - | 6 | 6 | six | 5 | -5 | | - | 6 | 6 | six | | 0 | 0 | - | 6 | 6 | six | | 0 | 1 | -1 - | 6 | 6 | six | | 0 | 2 | 2 - | 6 | 6 | six | | 0 | 2 | 4 - | 6 | 6 | six | | 0 | 3 | -3 - | 6 | 6 | six | | 0 | 5 | -5 - | 6 | 6 | six | | 0 | 5 | -5 - | 6 | 6 | six | | 0 | | 0 - | 6 | 6 | six | | 0 | | - | 6 | 6 | six | | | 0 | - | 6 | 6 | six | | | 1 | -1 - | 6 | 6 | six | | | 2 | 2 - | 6 | 6 | six | | | 2 | 4 - | 6 | 6 | six | | | 3 | -3 - | 6 | 6 | six | | | 5 | -5 - | 6 | 6 | six | | | 5 | -5 - | 6 | 6 | six | | | | 0 - | 6 | 6 | six | | | | - | 7 | 7 | seven | 0 | | 0 | - | 7 | 7 | seven | 0 | | 1 | -1 - | 7 | 7 | seven | 0 | | 2 | 2 - | 7 | 7 | seven | 0 | | 2 | 4 - | 7 | 7 | seven | 0 | | 3 | -3 - | 7 | 7 | seven | 0 | | 5 | -5 - | 7 | 7 | seven | 0 | | 5 | -5 - | 7 | 7 | seven | 0 | | | 0 - | 7 | 7 | seven | 0 | | | - | 7 | 7 | seven | 1 | -1 | 0 | - | 7 | 7 | seven | 1 | -1 | 1 | -1 - | 7 | 7 | seven | 1 | -1 | 2 | 2 - | 7 | 7 | seven | 1 | -1 | 2 | 4 - | 7 | 7 | seven | 1 | -1 | 3 | -3 - | 7 | 7 | seven | 1 | -1 | 5 | -5 - | 7 | 7 | seven | 1 | -1 | 5 | -5 - | 7 | 7 | seven | 1 | -1 | | 0 - | 7 | 7 | seven | 1 | -1 | | - | 7 | 7 | seven | 2 | 2 | 0 | - | 7 | 7 | seven | 2 | 2 | 1 | -1 - | 7 | 7 | seven | 2 | 2 | 2 | 2 - | 7 | 7 | seven | 2 | 2 | 2 | 4 - | 7 | 7 | seven | 2 | 2 | 3 | -3 - | 7 | 7 | seven | 2 | 2 | 5 | -5 - | 7 | 7 | seven | 2 | 2 | 5 | -5 - | 7 | 7 | seven | 2 | 2 | | 0 - | 7 | 7 | seven | 2 | 2 | | - | 7 | 7 | seven | 2 | 4 | 0 | - | 7 | 7 | seven | 2 | 4 | 1 | -1 - | 7 | 7 | seven | 2 | 4 | 2 | 2 - | 7 | 7 | seven | 2 | 4 | 2 | 4 - | 7 | 7 | seven | 2 | 4 | 3 | -3 - | 7 | 7 | seven | 2 | 4 | 5 | -5 - | 7 | 7 | seven | 2 | 4 | 5 | -5 - | 7 | 7 | seven | 2 | 4 | | 0 - | 7 | 7 | seven | 2 | 4 | | - | 7 | 7 | seven | 3 | -3 | 0 | - | 7 | 7 | seven | 3 | -3 | 1 | -1 - | 7 | 7 | seven | 3 | -3 | 2 | 2 - | 7 | 7 | seven | 3 | -3 | 2 | 4 - | 7 | 7 | seven | 3 | -3 | 3 | -3 - | 7 | 7 | seven | 3 | -3 | 5 | -5 - | 7 | 7 | seven | 3 | -3 | 5 | -5 - | 7 | 7 | seven | 3 | -3 | | 0 - | 7 | 7 | seven | 3 | -3 | | - | 7 | 7 | seven | 5 | -5 | 0 | - | 7 | 7 | seven | 5 | -5 | 0 | - | 7 | 7 | seven | 5 | -5 | 1 | -1 - | 7 | 7 | seven | 5 | -5 | 1 | -1 - | 7 | 7 | seven | 5 | -5 | 2 | 2 - | 7 | 7 | seven | 5 | -5 | 2 | 2 - | 7 | 7 | seven | 5 | -5 | 2 | 4 - | 7 | 7 | seven | 5 | -5 | 2 | 4 - | 7 | 7 | seven | 5 | -5 | 3 | -3 - | 7 | 7 | seven | 5 | -5 | 3 | -3 - | 7 | 7 | seven | 5 | -5 | 5 | -5 - | 7 | 7 | seven | 5 | -5 | 5 | -5 - | 7 | 7 | seven | 5 | -5 | 5 | -5 - | 7 | 7 | seven | 5 | -5 | 5 | -5 - | 7 | 7 | seven | 5 | -5 | | 0 - | 7 | 7 | seven | 5 | -5 | | 0 - | 7 | 7 | seven | 5 | -5 | | - | 7 | 7 | seven | 5 | -5 | | - | 7 | 7 | seven | | 0 | 0 | - | 7 | 7 | seven | | 0 | 1 | -1 - | 7 | 7 | seven | | 0 | 2 | 2 - | 7 | 7 | seven | | 0 | 2 | 4 - | 7 | 7 | seven | | 0 | 3 | -3 - | 7 | 7 | seven | | 0 | 5 | -5 - | 7 | 7 | seven | | 0 | 5 | -5 - | 7 | 7 | seven | | 0 | | 0 - | 7 | 7 | seven | | 0 | | - | 7 | 7 | seven | | | 0 | - | 7 | 7 | seven | | | 1 | -1 - | 7 | 7 | seven | | | 2 | 2 - | 7 | 7 | seven | | | 2 | 4 - | 7 | 7 | seven | | | 3 | -3 - | 7 | 7 | seven | | | 5 | -5 - | 7 | 7 | seven | | | 5 | -5 - | 7 | 7 | seven | | | | 0 - | 7 | 7 | seven | | | | - | 8 | 8 | eight | 0 | | 0 | - | 8 | 8 | eight | 0 | | 1 | -1 - | 8 | 8 | eight | 0 | | 2 | 2 - | 8 | 8 | eight | 0 | | 2 | 4 - | 8 | 8 | eight | 0 | | 3 | -3 - | 8 | 8 | eight | 0 | | 5 | -5 - | 8 | 8 | eight | 0 | | 5 | -5 - | 8 | 8 | eight | 0 | | | 0 - | 8 | 8 | eight | 0 | | | - | 8 | 8 | eight | 1 | -1 | 0 | - | 8 | 8 | eight | 1 | -1 | 1 | -1 - | 8 | 8 | eight | 1 | -1 | 2 | 2 - | 8 | 8 | eight | 1 | -1 | 2 | 4 - | 8 | 8 | eight | 1 | -1 | 3 | -3 - | 8 | 8 | eight | 1 | -1 | 5 | -5 - | 8 | 8 | eight | 1 | -1 | 5 | -5 - | 8 | 8 | eight | 1 | -1 | | 0 - | 8 | 8 | eight | 1 | -1 | | - | 8 | 8 | eight | 2 | 2 | 0 | - | 8 | 8 | eight | 2 | 2 | 1 | -1 - | 8 | 8 | eight | 2 | 2 | 2 | 2 - | 8 | 8 | eight | 2 | 2 | 2 | 4 - | 8 | 8 | eight | 2 | 2 | 3 | -3 - | 8 | 8 | eight | 2 | 2 | 5 | -5 - | 8 | 8 | eight | 2 | 2 | 5 | -5 - | 8 | 8 | eight | 2 | 2 | | 0 - | 8 | 8 | eight | 2 | 2 | | - | 8 | 8 | eight | 2 | 4 | 0 | - | 8 | 8 | eight | 2 | 4 | 1 | -1 - | 8 | 8 | eight | 2 | 4 | 2 | 2 - | 8 | 8 | eight | 2 | 4 | 2 | 4 - | 8 | 8 | eight | 2 | 4 | 3 | -3 - | 8 | 8 | eight | 2 | 4 | 5 | -5 - | 8 | 8 | eight | 2 | 4 | 5 | -5 - | 8 | 8 | eight | 2 | 4 | | 0 - | 8 | 8 | eight | 2 | 4 | | - | 8 | 8 | eight | 3 | -3 | 0 | - | 8 | 8 | eight | 3 | -3 | 1 | -1 - | 8 | 8 | eight | 3 | -3 | 2 | 2 - | 8 | 8 | eight | 3 | -3 | 2 | 4 - | 8 | 8 | eight | 3 | -3 | 3 | -3 - | 8 | 8 | eight | 3 | -3 | 5 | -5 - | 8 | 8 | eight | 3 | -3 | 5 | -5 - | 8 | 8 | eight | 3 | -3 | | 0 - | 8 | 8 | eight | 3 | -3 | | - | 8 | 8 | eight | 5 | -5 | 0 | - | 8 | 8 | eight | 5 | -5 | 0 | - | 8 | 8 | eight | 5 | -5 | 1 | -1 - | 8 | 8 | eight | 5 | -5 | 1 | -1 - | 8 | 8 | eight | 5 | -5 | 2 | 2 - | 8 | 8 | eight | 5 | -5 | 2 | 2 - | 8 | 8 | eight | 5 | -5 | 2 | 4 - | 8 | 8 | eight | 5 | -5 | 2 | 4 - | 8 | 8 | eight | 5 | -5 | 3 | -3 - | 8 | 8 | eight | 5 | -5 | 3 | -3 - | 8 | 8 | eight | 5 | -5 | 5 | -5 - | 8 | 8 | eight | 5 | -5 | 5 | -5 - | 8 | 8 | eight | 5 | -5 | 5 | -5 - | 8 | 8 | eight | 5 | -5 | 5 | -5 - | 8 | 8 | eight | 5 | -5 | | 0 - | 8 | 8 | eight | 5 | -5 | | 0 - | 8 | 8 | eight | 5 | -5 | | - | 8 | 8 | eight | 5 | -5 | | - | 8 | 8 | eight | | 0 | 0 | - | 8 | 8 | eight | | 0 | 1 | -1 - | 8 | 8 | eight | | 0 | 2 | 2 - | 8 | 8 | eight | | 0 | 2 | 4 - | 8 | 8 | eight | | 0 | 3 | -3 - | 8 | 8 | eight | | 0 | 5 | -5 - | 8 | 8 | eight | | 0 | 5 | -5 - | 8 | 8 | eight | | 0 | | 0 - | 8 | 8 | eight | | 0 | | - | 8 | 8 | eight | | | 0 | - | 8 | 8 | eight | | | 1 | -1 - | 8 | 8 | eight | | | 2 | 2 - | 8 | 8 | eight | | | 2 | 4 - | 8 | 8 | eight | | | 3 | -3 - | 8 | 8 | eight | | | 5 | -5 - | 8 | 8 | eight | | | 5 | -5 - | 8 | 8 | eight | | | | 0 - | 8 | 8 | eight | | | | - | | 0 | zero | 0 | | 0 | - | | 0 | zero | 0 | | 1 | -1 - | | 0 | zero | 0 | | 2 | 2 - | | 0 | zero | 0 | | 2 | 4 - | | 0 | zero | 0 | | 3 | -3 - | | 0 | zero | 0 | | 5 | -5 - | | 0 | zero | 0 | | 5 | -5 - | | 0 | zero | 0 | | | 0 - | | 0 | zero | 0 | | | - | | 0 | zero | 1 | -1 | 0 | - | | 0 | zero | 1 | -1 | 1 | -1 - | | 0 | zero | 1 | -1 | 2 | 2 - | | 0 | zero | 1 | -1 | 2 | 4 - | | 0 | zero | 1 | -1 | 3 | -3 - | | 0 | zero | 1 | -1 | 5 | -5 - | | 0 | zero | 1 | -1 | 5 | -5 - | | 0 | zero | 1 | -1 | | 0 - | | 0 | zero | 1 | -1 | | - | | 0 | zero | 2 | 2 | 0 | - | | 0 | zero | 2 | 2 | 1 | -1 - | | 0 | zero | 2 | 2 | 2 | 2 - | | 0 | zero | 2 | 2 | 2 | 4 - | | 0 | zero | 2 | 2 | 3 | -3 - | | 0 | zero | 2 | 2 | 5 | -5 - | | 0 | zero | 2 | 2 | 5 | -5 - | | 0 | zero | 2 | 2 | | 0 - | | 0 | zero | 2 | 2 | | - | | 0 | zero | 2 | 4 | 0 | - | | 0 | zero | 2 | 4 | 1 | -1 - | | 0 | zero | 2 | 4 | 2 | 2 - | | 0 | zero | 2 | 4 | 2 | 4 - | | 0 | zero | 2 | 4 | 3 | -3 - | | 0 | zero | 2 | 4 | 5 | -5 - | | 0 | zero | 2 | 4 | 5 | -5 - | | 0 | zero | 2 | 4 | | 0 - | | 0 | zero | 2 | 4 | | - | | 0 | zero | 3 | -3 | 0 | - | | 0 | zero | 3 | -3 | 1 | -1 - | | 0 | zero | 3 | -3 | 2 | 2 - | | 0 | zero | 3 | -3 | 2 | 4 - | | 0 | zero | 3 | -3 | 3 | -3 - | | 0 | zero | 3 | -3 | 5 | -5 - | | 0 | zero | 3 | -3 | 5 | -5 - | | 0 | zero | 3 | -3 | | 0 - | | 0 | zero | 3 | -3 | | - | | 0 | zero | 5 | -5 | 0 | - | | 0 | zero | 5 | -5 | 0 | - | | 0 | zero | 5 | -5 | 1 | -1 - | | 0 | zero | 5 | -5 | 1 | -1 - | | 0 | zero | 5 | -5 | 2 | 2 - | | 0 | zero | 5 | -5 | 2 | 2 - | | 0 | zero | 5 | -5 | 2 | 4 - | | 0 | zero | 5 | -5 | 2 | 4 - | | 0 | zero | 5 | -5 | 3 | -3 - | | 0 | zero | 5 | -5 | 3 | -3 - | | 0 | zero | 5 | -5 | 5 | -5 - | | 0 | zero | 5 | -5 | 5 | -5 - | | 0 | zero | 5 | -5 | 5 | -5 - | | 0 | zero | 5 | -5 | 5 | -5 - | | 0 | zero | 5 | -5 | | 0 - | | 0 | zero | 5 | -5 | | 0 - | | 0 | zero | 5 | -5 | | - | | 0 | zero | 5 | -5 | | - | | 0 | zero | | 0 | 0 | - | | 0 | zero | | 0 | 1 | -1 - | | 0 | zero | | 0 | 2 | 2 - | | 0 | zero | | 0 | 2 | 4 - | | 0 | zero | | 0 | 3 | -3 - | | 0 | zero | | 0 | 5 | -5 - | | 0 | zero | | 0 | 5 | -5 - | | 0 | zero | | 0 | | 0 - | | 0 | zero | | 0 | | - | | 0 | zero | | | 0 | - | | 0 | zero | | | 1 | -1 - | | 0 | zero | | | 2 | 2 - | | 0 | zero | | | 2 | 4 - | | 0 | zero | | | 3 | -3 - | | 0 | zero | | | 5 | -5 - | | 0 | zero | | | 5 | -5 - | | 0 | zero | | | | 0 - | | 0 | zero | | | | - | | | null | 0 | | 0 | - | | | null | 0 | | 1 | -1 - | | | null | 0 | | 2 | 2 - | | | null | 0 | | 2 | 4 - | | | null | 0 | | 3 | -3 - | | | null | 0 | | 5 | -5 - | | | null | 0 | | 5 | -5 - | | | null | 0 | | | 0 - | | | null | 0 | | | - | | | null | 1 | -1 | 0 | - | | | null | 1 | -1 | 1 | -1 - | | | null | 1 | -1 | 2 | 2 - | | | null | 1 | -1 | 2 | 4 - | | | null | 1 | -1 | 3 | -3 - | | | null | 1 | -1 | 5 | -5 - | | | null | 1 | -1 | 5 | -5 - | | | null | 1 | -1 | | 0 - | | | null | 1 | -1 | | - | | | null | 2 | 2 | 0 | - | | | null | 2 | 2 | 1 | -1 - | | | null | 2 | 2 | 2 | 2 - | | | null | 2 | 2 | 2 | 4 - | | | null | 2 | 2 | 3 | -3 - | | | null | 2 | 2 | 5 | -5 - | | | null | 2 | 2 | 5 | -5 - | | | null | 2 | 2 | | 0 - | | | null | 2 | 2 | | - | | | null | 2 | 4 | 0 | - | | | null | 2 | 4 | 1 | -1 - | | | null | 2 | 4 | 2 | 2 - | | | null | 2 | 4 | 2 | 4 - | | | null | 2 | 4 | 3 | -3 - | | | null | 2 | 4 | 5 | -5 - | | | null | 2 | 4 | 5 | -5 - | | | null | 2 | 4 | | 0 - | | | null | 2 | 4 | | - | | | null | 3 | -3 | 0 | - | | | null | 3 | -3 | 1 | -1 - | | | null | 3 | -3 | 2 | 2 - | | | null | 3 | -3 | 2 | 4 - | | | null | 3 | -3 | 3 | -3 - | | | null | 3 | -3 | 5 | -5 - | | | null | 3 | -3 | 5 | -5 - | | | null | 3 | -3 | | 0 - | | | null | 3 | -3 | | - | | | null | 5 | -5 | 0 | - | | | null | 5 | -5 | 0 | - | | | null | 5 | -5 | 1 | -1 - | | | null | 5 | -5 | 1 | -1 - | | | null | 5 | -5 | 2 | 2 - | | | null | 5 | -5 | 2 | 2 - | | | null | 5 | -5 | 2 | 4 - | | | null | 5 | -5 | 2 | 4 - | | | null | 5 | -5 | 3 | -3 - | | | null | 5 | -5 | 3 | -3 - | | | null | 5 | -5 | 5 | -5 - | | | null | 5 | -5 | 5 | -5 - | | | null | 5 | -5 | 5 | -5 - | | | null | 5 | -5 | 5 | -5 - | | | null | 5 | -5 | | 0 - | | | null | 5 | -5 | | 0 - | | | null | 5 | -5 | | - | | | null | 5 | -5 | | - | | | null | | 0 | 0 | - | | | null | | 0 | 1 | -1 - | | | null | | 0 | 2 | 2 - | | | null | | 0 | 2 | 4 - | | | null | | 0 | 3 | -3 - | | | null | | 0 | 5 | -5 - | | | null | | 0 | 5 | -5 - | | | null | | 0 | | 0 - | | | null | | 0 | | - | | | null | | | 0 | - | | | null | | | 1 | -1 - | | | null | | | 2 | 2 - | | | null | | | 2 | 4 - | | | null | | | 3 | -3 - | | | null | | | 5 | -5 - | | | null | | | 5 | -5 - | | | null | | | | 0 - | | | null | | | | -(891 rows) - --- --- --- Inner joins (equi-joins) --- --- --- --- Inner joins (equi-joins) with USING clause --- The USING syntax changes the shape of the resulting table --- by including a column in the USING clause only once in the result. --- --- Inner equi-join on specified column -SELECT '' AS "xxx", * - FROM J1_TBL INNER JOIN J2_TBL USING (i) - ORDER BY i, j, k, t; - xxx | i | j | t | k ------+---+---+-------+---- - | 0 | | zero | - | 1 | 4 | one | -1 - | 2 | 3 | two | 2 - | 2 | 3 | two | 4 - | 3 | 2 | three | -3 - | 5 | 0 | five | -5 - | 5 | 0 | five | -5 -(7 rows) - --- Same as above, slightly different syntax -SELECT '' AS "xxx", * - FROM J1_TBL JOIN J2_TBL USING (i) - ORDER BY i, j, k, t; - xxx | i | j | t | k ------+---+---+-------+---- - | 0 | | zero | - | 1 | 4 | one | -1 - | 2 | 3 | two | 2 - | 2 | 3 | two | 4 - | 3 | 2 | three | -3 - | 5 | 0 | five | -5 - | 5 | 0 | five | -5 -(7 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL t1 (a, b, c) JOIN J2_TBL t2 (a, d) USING (a) - ORDER BY a, d; - xxx | a | b | c | d ------+---+---+-------+---- - | 0 | | zero | - | 1 | 4 | one | -1 - | 2 | 3 | two | 2 - | 2 | 3 | two | 4 - | 3 | 2 | three | -3 - | 5 | 0 | five | -5 - | 5 | 0 | five | -5 -(7 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL t1 (a, b, c) JOIN J2_TBL t2 (a, b) USING (b) - ORDER BY b, t1.a; - xxx | b | a | c | a ------+---+---+-------+--- - | 0 | 5 | five | - | 0 | | zero | - | 2 | 3 | three | 2 - | 4 | 1 | one | 2 -(4 rows) - --- --- NATURAL JOIN --- Inner equi-join on all columns with the same name --- -SELECT '' AS "xxx", * - FROM J1_TBL NATURAL JOIN J2_TBL - ORDER BY i, j, k, t; - xxx | i | j | t | k ------+---+---+-------+---- - | 0 | | zero | - | 1 | 4 | one | -1 - | 2 | 3 | two | 2 - | 2 | 3 | two | 4 - | 3 | 2 | three | -3 - | 5 | 0 | five | -5 - | 5 | 0 | five | -5 -(7 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL t1 (a, b, c) NATURAL JOIN J2_TBL t2 (a, d) - ORDER BY a, b, c, d; - xxx | a | b | c | d ------+---+---+-------+---- - | 0 | | zero | - | 1 | 4 | one | -1 - | 2 | 3 | two | 2 - | 2 | 3 | two | 4 - | 3 | 2 | three | -3 - | 5 | 0 | five | -5 - | 5 | 0 | five | -5 -(7 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL t1 (a, b, c) NATURAL JOIN J2_TBL t2 (d, a) - ORDER BY a, b, c, d; - xxx | a | b | c | d ------+---+---+------+--- - | 0 | | zero | - | 2 | 3 | two | 2 - | 4 | 1 | four | 2 -(3 rows) - --- mismatch number of columns --- currently, Postgres will fill in with underlying names -SELECT '' AS "xxx", * - FROM J1_TBL t1 (a, b) NATURAL JOIN J2_TBL t2 (a) - ORDER BY a, b, t, k; - xxx | a | b | t | k ------+---+---+-------+---- - | 0 | | zero | - | 1 | 4 | one | -1 - | 2 | 3 | two | 2 - | 2 | 3 | two | 4 - | 3 | 2 | three | -3 - | 5 | 0 | five | -5 - | 5 | 0 | five | -5 -(7 rows) - --- --- Inner joins (equi-joins) --- -SELECT '' AS "xxx", * - FROM J1_TBL JOIN J2_TBL ON (J1_TBL.i = J2_TBL.i) - ORDER BY J1_TBL.i, J1_TBL.j, J1_TBL.t, J2_TBL.i, J2_TBL.k; - xxx | i | j | t | i | k ------+---+---+-------+---+---- - | 0 | | zero | 0 | - | 1 | 4 | one | 1 | -1 - | 2 | 3 | two | 2 | 2 - | 2 | 3 | two | 2 | 4 - | 3 | 2 | three | 3 | -3 - | 5 | 0 | five | 5 | -5 - | 5 | 0 | five | 5 | -5 -(7 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL JOIN J2_TBL ON (J1_TBL.i = J2_TBL.k) - ORDER BY J1_TBL.i, J1_TBL.j, J1_TBL.t, J2_TBL.i, J2_TBL.k; - xxx | i | j | t | i | k ------+---+---+------+---+--- - | 0 | | zero | | 0 - | 2 | 3 | two | 2 | 2 - | 4 | 1 | four | 2 | 4 -(3 rows) - --- --- Non-equi-joins --- -SELECT '' AS "xxx", * - FROM J1_TBL JOIN J2_TBL ON (J1_TBL.i <= J2_TBL.k) - ORDER BY J1_TBL.i, J1_TBL.j, J1_TBL.t, J2_TBL.i, J2_TBL.k; - xxx | i | j | t | i | k ------+---+---+-------+---+--- - | 0 | | zero | 2 | 2 - | 0 | | zero | 2 | 4 - | 0 | | zero | | 0 - | 1 | 4 | one | 2 | 2 - | 1 | 4 | one | 2 | 4 - | 2 | 3 | two | 2 | 2 - | 2 | 3 | two | 2 | 4 - | 3 | 2 | three | 2 | 4 - | 4 | 1 | four | 2 | 4 -(9 rows) - --- --- Outer joins --- Note that OUTER is a noise word --- -SELECT '' AS "xxx", * - FROM J1_TBL LEFT OUTER JOIN J2_TBL USING (i) - ORDER BY i, k, t; - xxx | i | j | t | k ------+---+---+-------+---- - | 0 | | zero | - | 1 | 4 | one | -1 - | 2 | 3 | two | 2 - | 2 | 3 | two | 4 - | 3 | 2 | three | -3 - | 4 | 1 | four | - | 5 | 0 | five | -5 - | 5 | 0 | five | -5 - | 6 | 6 | six | - | 7 | 7 | seven | - | 8 | 8 | eight | - | | | null | - | | 0 | zero | -(13 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL LEFT JOIN J2_TBL USING (i) - ORDER BY i, k, t; - xxx | i | j | t | k ------+---+---+-------+---- - | 0 | | zero | - | 1 | 4 | one | -1 - | 2 | 3 | two | 2 - | 2 | 3 | two | 4 - | 3 | 2 | three | -3 - | 4 | 1 | four | - | 5 | 0 | five | -5 - | 5 | 0 | five | -5 - | 6 | 6 | six | - | 7 | 7 | seven | - | 8 | 8 | eight | - | | | null | - | | 0 | zero | -(13 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL RIGHT OUTER JOIN J2_TBL USING (i) - ORDER BY i, j, k, t; - xxx | i | j | t | k ------+---+---+-------+---- - | 0 | | zero | - | 1 | 4 | one | -1 - | 2 | 3 | two | 2 - | 2 | 3 | two | 4 - | 3 | 2 | three | -3 - | 5 | 0 | five | -5 - | 5 | 0 | five | -5 - | | | | 0 - | | | | -(9 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL RIGHT JOIN J2_TBL USING (i) - ORDER BY i, j, k, t; - xxx | i | j | t | k ------+---+---+-------+---- - | 0 | | zero | - | 1 | 4 | one | -1 - | 2 | 3 | two | 2 - | 2 | 3 | two | 4 - | 3 | 2 | three | -3 - | 5 | 0 | five | -5 - | 5 | 0 | five | -5 - | | | | 0 - | | | | -(9 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL FULL OUTER JOIN J2_TBL USING (i) - ORDER BY i, k, t; - xxx | i | j | t | k ------+---+---+-------+---- - | 0 | | zero | - | 1 | 4 | one | -1 - | 2 | 3 | two | 2 - | 2 | 3 | two | 4 - | 3 | 2 | three | -3 - | 4 | 1 | four | - | 5 | 0 | five | -5 - | 5 | 0 | five | -5 - | 6 | 6 | six | - | 7 | 7 | seven | - | 8 | 8 | eight | - | | | | 0 - | | | null | - | | 0 | zero | - | | | | -(15 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL FULL JOIN J2_TBL USING (i) - ORDER BY i, k, t; - xxx | i | j | t | k ------+---+---+-------+---- - | 0 | | zero | - | 1 | 4 | one | -1 - | 2 | 3 | two | 2 - | 2 | 3 | two | 4 - | 3 | 2 | three | -3 - | 4 | 1 | four | - | 5 | 0 | five | -5 - | 5 | 0 | five | -5 - | 6 | 6 | six | - | 7 | 7 | seven | - | 8 | 8 | eight | - | | | | 0 - | | | null | - | | 0 | zero | - | | | | -(15 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL LEFT JOIN J2_TBL USING (i) WHERE (k = 1); - xxx | i | j | t | k ------+---+---+---+--- -(0 rows) - -SELECT '' AS "xxx", * - FROM J1_TBL LEFT JOIN J2_TBL USING (i) WHERE (i = 1); - xxx | i | j | t | k ------+---+---+-----+---- - | 1 | 4 | one | -1 -(1 row) - --- --- More complicated constructs --- --- --- Multiway full join --- -CREATE TABLE t1 (name TEXT, n INTEGER); -CREATE TABLE t2 (name TEXT, n INTEGER); -CREATE TABLE t3 (name TEXT, n INTEGER); -INSERT INTO t1 VALUES ( 'bb', 11 ); -INSERT INTO t2 VALUES ( 'bb', 12 ); -INSERT INTO t2 VALUES ( 'cc', 22 ); -INSERT INTO t2 VALUES ( 'ee', 42 ); -INSERT INTO t3 VALUES ( 'bb', 13 ); -INSERT INTO t3 VALUES ( 'cc', 23 ); -INSERT INTO t3 VALUES ( 'dd', 33 ); -SELECT * FROM t1 FULL JOIN t2 USING (name) FULL JOIN t3 USING (name) -ORDER BY name,t1.n, t2.n, t3.n; - name | n | n | n -------+----+----+---- - bb | 11 | 12 | 13 - cc | | 22 | 23 - dd | | | 33 - ee | | 42 | -(4 rows) - --- --- Test interactions of join syntax and subqueries --- --- Basic cases (we expect planner to pull up the subquery here) -SELECT * FROM -(SELECT * FROM t2) as s2 -INNER JOIN -(SELECT * FROM t3) s3 -USING (name) -ORDER BY name, s2.n, s3.n; - name | n | n -------+----+---- - bb | 12 | 13 - cc | 22 | 23 -(2 rows) - -SELECT * FROM -(SELECT * FROM t2) as s2 -LEFT JOIN -(SELECT * FROM t3) s3 -USING (name) -ORDER BY name, s2.n, s3.n; - name | n | n -------+----+---- - bb | 12 | 13 - cc | 22 | 23 - ee | 42 | -(3 rows) - -SELECT * FROM -(SELECT * FROM t2) as s2 -FULL JOIN -(SELECT * FROM t3) s3 -USING (name) -ORDER BY name, s2.n, s3.n; - name | n | n -------+----+---- - bb | 12 | 13 - cc | 22 | 23 - dd | | 33 - ee | 42 | -(4 rows) - --- Cases with non-nullable expressions in subquery results; --- make sure these go to null as expected -SELECT * FROM -(SELECT name, n as s2_n, 2 as s2_2 FROM t2) as s2 -NATURAL INNER JOIN -(SELECT name, n as s3_n, 3 as s3_2 FROM t3) s3 -ORDER BY name, s2_n, s3_n; - name | s2_n | s2_2 | s3_n | s3_2 -------+------+------+------+------ - bb | 12 | 2 | 13 | 3 - cc | 22 | 2 | 23 | 3 -(2 rows) - -SELECT * FROM -(SELECT name, n as s2_n, 2 as s2_2 FROM t2) as s2 -NATURAL LEFT JOIN -(SELECT name, n as s3_n, 3 as s3_2 FROM t3) s3 -ORDER BY name, s2_n, s3_n; - name | s2_n | s2_2 | s3_n | s3_2 -------+------+------+------+------ - bb | 12 | 2 | 13 | 3 - cc | 22 | 2 | 23 | 3 - ee | 42 | 2 | | -(3 rows) - -SELECT * FROM -(SELECT name, n as s2_n, 2 as s2_2 FROM t2) as s2 -NATURAL FULL JOIN -(SELECT name, n as s3_n, 3 as s3_2 FROM t3) s3 -ORDER BY name, s2_n, s3_n; - name | s2_n | s2_2 | s3_n | s3_2 -------+------+------+------+------ - bb | 12 | 2 | 13 | 3 - cc | 22 | 2 | 23 | 3 - dd | | | 33 | 3 - ee | 42 | 2 | | -(4 rows) - -SELECT * FROM -(SELECT name, n as s1_n, 1 as s1_1 FROM t1) as s1 -NATURAL INNER JOIN -(SELECT name, n as s2_n, 2 as s2_2 FROM t2) as s2 -NATURAL INNER JOIN -(SELECT name, n as s3_n, 3 as s3_2 FROM t3) s3 -ORDER BY name, s1_n, s2_n, s3_n; - name | s1_n | s1_1 | s2_n | s2_2 | s3_n | s3_2 -------+------+------+------+------+------+------ - bb | 11 | 1 | 12 | 2 | 13 | 3 -(1 row) - -SELECT * FROM -(SELECT name, n as s1_n, 1 as s1_1 FROM t1) as s1 -NATURAL FULL JOIN -(SELECT name, n as s2_n, 2 as s2_2 FROM t2) as s2 -NATURAL FULL JOIN -(SELECT name, n as s3_n, 3 as s3_2 FROM t3) s3 -ORDER BY name, s1_n, s2_n, s3_n; - name | s1_n | s1_1 | s2_n | s2_2 | s3_n | s3_2 -------+------+------+------+------+------+------ - bb | 11 | 1 | 12 | 2 | 13 | 3 - cc | | | 22 | 2 | 23 | 3 - dd | | | | | 33 | 3 - ee | | | 42 | 2 | | -(4 rows) - -SELECT * FROM -(SELECT name, n as s1_n FROM t1) as s1 -NATURAL FULL JOIN - (SELECT * FROM - (SELECT name, n as s2_n FROM t2) as s2 - NATURAL FULL JOIN - (SELECT name, n as s3_n FROM t3) as s3 - ) ss2 - ORDER BY name, s1_n, s2_n, s3_n; - name | s1_n | s2_n | s3_n -------+------+------+------ - bb | 11 | 12 | 13 - cc | | 22 | 23 - dd | | | 33 - ee | | 42 | -(4 rows) - -SELECT * FROM -(SELECT name, n as s1_n FROM t1) as s1 -NATURAL FULL JOIN - (SELECT * FROM - (SELECT name, n as s2_n, 2 as s2_2 FROM t2) as s2 - NATURAL FULL JOIN - (SELECT name, n as s3_n FROM t3) as s3 - ) ss2 - ORDER BY name, s1_n, s2_n, s3_n; - name | s1_n | s2_n | s2_2 | s3_n -------+------+------+------+------ - bb | 11 | 12 | 2 | 13 - cc | | 22 | 2 | 23 - dd | | | | 33 - ee | | 42 | 2 | -(4 rows) - --- Test for propagation of nullability constraints into sub-joins -create temp table x (x1 int, x2 int); -insert into x values (1,11); -insert into x values (2,22); -insert into x values (3,null); -insert into x values (4,44); -insert into x values (5,null); -create temp table y (y1 int, y2 int); -insert into y values (1,111); -insert into y values (2,222); -insert into y values (3,333); -insert into y values (4,null); -select * from x ORDER BY x1; - x1 | x2 -----+---- - 1 | 11 - 2 | 22 - 3 | - 4 | 44 - 5 | -(5 rows) - -select * from y ORDER BY y1; - y1 | y2 -----+----- - 1 | 111 - 2 | 222 - 3 | 333 - 4 | -(4 rows) - -select * from x left join y on (x1 = y1 and x2 is not null) ORDER BY x1, x2, y1, y2; - x1 | x2 | y1 | y2 -----+----+----+----- - 1 | 11 | 1 | 111 - 2 | 22 | 2 | 222 - 3 | | | - 4 | 44 | 4 | - 5 | | | -(5 rows) - -select * from x left join y on (x1 = y1 and y2 is not null) ORDER BY x1, x2, y1, y2; - x1 | x2 | y1 | y2 -----+----+----+----- - 1 | 11 | 1 | 111 - 2 | 22 | 2 | 222 - 3 | | 3 | 333 - 4 | 44 | | - 5 | | | -(5 rows) - -select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) -on (x1 = xx1) ORDER BY x1, x2, y1, y2; - x1 | x2 | y1 | y2 | xx1 | xx2 -----+----+----+-----+-----+----- - 1 | 11 | 1 | 111 | 1 | 11 - 2 | 22 | 2 | 222 | 2 | 22 - 3 | | 3 | 333 | 3 | - 4 | 44 | 4 | | 4 | 44 - 5 | | | | 5 | -(5 rows) - -select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) -on (x1 = xx1 and x2 is not null) ORDER BY x1, x2, y1, y2; - x1 | x2 | y1 | y2 | xx1 | xx2 -----+----+----+-----+-----+----- - 1 | 11 | 1 | 111 | 1 | 11 - 2 | 22 | 2 | 222 | 2 | 22 - 3 | | 3 | 333 | | - 4 | 44 | 4 | | 4 | 44 - 5 | | | | | -(5 rows) - -select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) -on (x1 = xx1 and y2 is not null) ORDER BY x1, x2, y1, y2; - x1 | x2 | y1 | y2 | xx1 | xx2 -----+----+----+-----+-----+----- - 1 | 11 | 1 | 111 | 1 | 11 - 2 | 22 | 2 | 222 | 2 | 22 - 3 | | 3 | 333 | 3 | - 4 | 44 | 4 | | | - 5 | | | | | -(5 rows) - -select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) -on (x1 = xx1 and xx2 is not null) ORDER BY x1, x2, y1, y2; - x1 | x2 | y1 | y2 | xx1 | xx2 -----+----+----+-----+-----+----- - 1 | 11 | 1 | 111 | 1 | 11 - 2 | 22 | 2 | 222 | 2 | 22 - 3 | | 3 | 333 | | - 4 | 44 | 4 | | 4 | 44 - 5 | | | | | -(5 rows) - --- these should NOT give the same answers as above -select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) -on (x1 = xx1) where (x2 is not null) -ORDER BY x1, x2, y1, y2; - x1 | x2 | y1 | y2 | xx1 | xx2 -----+----+----+-----+-----+----- - 1 | 11 | 1 | 111 | 1 | 11 - 2 | 22 | 2 | 222 | 2 | 22 - 4 | 44 | 4 | | 4 | 44 -(3 rows) - -select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) -on (x1 = xx1) where (y2 is not null) -ORDER BY x1, x2, y1, y2; - x1 | x2 | y1 | y2 | xx1 | xx2 -----+----+----+-----+-----+----- - 1 | 11 | 1 | 111 | 1 | 11 - 2 | 22 | 2 | 222 | 2 | 22 - 3 | | 3 | 333 | 3 | -(3 rows) - -select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) -on (x1 = xx1) where (xx2 is not null) -ORDER BY x1, x2, y1, y2; - x1 | x2 | y1 | y2 | xx1 | xx2 -----+----+----+-----+-----+----- - 1 | 11 | 1 | 111 | 1 | 11 - 2 | 22 | 2 | 222 | 2 | 22 - 4 | 44 | 4 | | 4 | 44 -(3 rows) - --- --- regression test: check for bug with propagation of implied equality --- to outside an IN --- -analyze tenk1; -- ensure we get consistent plans here -select count(*) from tenk1 a where unique1 in - (select unique1 from tenk1 b join tenk1 c using (unique1) - where b.unique2 = 42); - count -------- - 1 -(1 row) - --- --- regression test: check for failure to generate a plan with multiple --- degenerate IN clauses --- -select count(*) from tenk1 x where - x.unique1 in (select a.f1 from int4_tbl a,float8_tbl b where a.f1=b.f1) and - x.unique1 = 0 and - x.unique1 in (select aa.f1 from int4_tbl aa,float8_tbl bb where aa.f1=bb.f1); - count -------- - 1 -(1 row) - --- try that with GEQO too -begin; -set geqo = on; -set geqo_threshold = 2; -select count(*) from tenk1 x where - x.unique1 in (select a.f1 from int4_tbl a,float8_tbl b where a.f1=b.f1) and - x.unique1 = 0 and - x.unique1 in (select aa.f1 from int4_tbl aa,float8_tbl bb where aa.f1=bb.f1); - count -------- - 1 -(1 row) - -rollback; --- --- Clean up --- -DROP TABLE t1; -DROP TABLE t2; -DROP TABLE t3; -DROP TABLE J1_TBL; -DROP TABLE J2_TBL; --- Both DELETE and UPDATE allow the specification of additional tables --- to "join" against to determine which rows should be modified. -CREATE TEMP TABLE t1 (a int, b int); -CREATE TEMP TABLE t2 (a int, b int); -CREATE TEMP TABLE t3 (x int, y int); -INSERT INTO t1 VALUES (5, 10); -INSERT INTO t1 VALUES (15, 20); -INSERT INTO t1 VALUES (100, 100); -INSERT INTO t1 VALUES (200, 1000); -INSERT INTO t2 VALUES (200, 2000); -INSERT INTO t3 VALUES (5, 20); -INSERT INTO t3 VALUES (6, 7); -INSERT INTO t3 VALUES (7, 8); -INSERT INTO t3 VALUES (500, 100); -DELETE FROM t3 USING t1 table1 WHERE t3.x = table1.a; -SELECT * FROM t3 ORDER By x, y; - x | y ------+----- - 6 | 7 - 7 | 8 - 500 | 100 -(3 rows) - -DELETE FROM t3 USING t1 JOIN t2 USING (a) WHERE t3.x > t1.a; -SELECT * FROM t3 ORDER By x, y; - x | y ----+--- - 6 | 7 - 7 | 8 -(2 rows) - -DELETE FROM t3 USING t3 t3_other WHERE t3.x = t3_other.x AND t3.y = t3_other.y; -SELECT * FROM t3 ORDER By x, y; - x | y ----+--- -(0 rows) - --- Test join against inheritance tree -create temp table t2a () inherits (t2); -insert into t2a values (200, 2001); -select * from t1 left join t2 on (t1.a = t2.a) order by 1,2,3,4; - a | b | a | b ------+------+-----+------ - 5 | 10 | | - 15 | 20 | | - 100 | 100 | | - 200 | 1000 | 200 | 2000 - 200 | 1000 | 200 | 2001 -(5 rows) - --- --- regression test for 8.1 merge right join bug --- -CREATE TEMP TABLE tt1 ( tt1_id int4, joincol int4 ); -INSERT INTO tt1 VALUES (1, 11); -INSERT INTO tt1 VALUES (2, NULL); -CREATE TEMP TABLE tt2 ( tt2_id int4, joincol int4 ); -INSERT INTO tt2 VALUES (21, 11); -INSERT INTO tt2 VALUES (22, 11); -set enable_hashjoin to off; -set enable_nestloop to off; --- these should give the same results -select tt1.*, tt2.* from tt1 left join tt2 on tt1.joincol = tt2.joincol - ORDER BY tt1_id, tt2_id; - tt1_id | joincol | tt2_id | joincol ---------+---------+--------+--------- - 1 | 11 | 21 | 11 - 1 | 11 | 22 | 11 - 2 | | | -(3 rows) - -select tt1.*, tt2.* from tt2 right join tt1 on tt1.joincol = tt2.joincol - ORDER BY tt1_id, tt2_id; - tt1_id | joincol | tt2_id | joincol ---------+---------+--------+--------- - 1 | 11 | 21 | 11 - 1 | 11 | 22 | 11 - 2 | | | -(3 rows) - -reset enable_hashjoin; -reset enable_nestloop; --- --- regression test for 8.2 bug with improper re-ordering of left joins --- -create temp table tt3(f1 int, f2 text); -insert into tt3 select x, repeat('xyzzy', 100) from generate_series(1,10000) x; -create index tt3i on tt3(f1); -analyze tt3; -create temp table tt4(f1 int); -insert into tt4 values (0),(1),(9999); -analyze tt4; -SELECT a.f1 -FROM tt4 a -LEFT JOIN ( - SELECT b.f1 - FROM tt3 b LEFT JOIN tt3 c ON (b.f1 = c.f1) - WHERE c.f1 IS NULL -) AS d ON (a.f1 = d.f1) -WHERE d.f1 IS NULL ORDER BY f1; - f1 ------- - 0 - 1 - 9999 -(3 rows) - --- --- regression test for problems of the sort depicted in bug #3494 --- -create temp table tt5(f1 int, f2 int); -create temp table tt6(f1 int, f2 int); -insert into tt5 values(1, 10); -insert into tt5 values(1, 11); -insert into tt6 values(1, 9); -insert into tt6 values(1, 2); -insert into tt6 values(2, 9); -select * from tt5,tt6 where tt5.f1 = tt6.f1 and tt5.f1 = tt5.f2 - tt6.f2 - ORDER BY tt5.f1, tt5.f2, tt6.f1, tt6.f2; - f1 | f2 | f1 | f2 -----+----+----+---- - 1 | 10 | 1 | 9 -(1 row) - --- --- regression test for problems of the sort depicted in bug #3588 --- -create temp table xx (pkxx int); -create temp table yy (pkyy int, pkxx int); -insert into xx values (1); -insert into xx values (2); -insert into xx values (3); -insert into yy values (101, 1); -insert into yy values (201, 2); -insert into yy values (301, NULL); -select yy.pkyy as yy_pkyy, yy.pkxx as yy_pkxx, yya.pkyy as yya_pkyy, - xxa.pkxx as xxa_pkxx, xxb.pkxx as xxb_pkxx -from yy - left join (SELECT * FROM yy where pkyy = 101) as yya ON yy.pkyy = yya.pkyy - left join xx xxa on yya.pkxx = xxa.pkxx - left join xx xxb on coalesce (xxa.pkxx, 1) = xxb.pkxx - ORDER BY yy_pkyy, yy_pkxx, yya_pkyy, xxa_pkxx, xxb_pkxx; - yy_pkyy | yy_pkxx | yya_pkyy | xxa_pkxx | xxb_pkxx ----------+---------+----------+----------+---------- - 101 | 1 | 101 | 1 | 1 - 201 | 2 | | | 1 - 301 | | | | 1 -(3 rows) - --- --- regression test for improper pushing of constants across outer-join clauses --- (as seen in early 8.2.x releases) --- -create temp table zt1 (f1 int primary key); -NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "zt1_pkey" for table "zt1" -create temp table zt2 (f2 int primary key); -NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "zt2_pkey" for table "zt2" -create temp table zt3 (f3 int primary key); -NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "zt3_pkey" for table "zt3" -insert into zt1 values(53); -insert into zt2 values(53); -select * from - zt2 left join zt3 on (f2 = f3) - left join zt1 on (f3 = f1) -where f2 = 53 -ORDER BY f1, f2, f3; - f2 | f3 | f1 -----+----+---- - 53 | | -(1 row) - -create temp view zv1 as select *,'dummy'::text AS junk from zt1; -select * from - zt2 left join zt3 on (f2 = f3) - left join zv1 on (f3 = f1) -where f2 = 53 -ORDER BY f1, f2, f3; - f2 | f3 | f1 | junk -----+----+----+------ - 53 | | | -(1 row) - --- --- regression test for improper extraction of OR indexqual conditions --- (as seen in early 8.3.x releases) --- -select a.unique2, a.ten, b.tenthous, b.unique2, b.hundred -from tenk1 a left join tenk1 b on a.unique2 = b.tenthous -where a.unique1 = 42 and - ((b.unique2 is null and a.ten = 2) or b.hundred = 3); - unique2 | ten | tenthous | unique2 | hundred ----------+-----+----------+---------+--------- -(0 rows) - --- --- test proper positioning of one-time quals in EXISTS (8.4devel bug) --- -prepare foo(bool) as - select count(*) from tenk1 a left join tenk1 b - on (a.unique2 = b.unique1 and exists - (select 1 from tenk1 c where c.thousand = b.unique2 and $1)); --- PGXCTODO: execution takes a long time --- execute foo(true); --- execute foo(false); --- --- test for sane behavior with noncanonical merge clauses, per bug #4926 --- -begin; -set enable_mergejoin = 1; -set enable_hashjoin = 0; -set enable_nestloop = 0; -create temp table a (i integer); -create temp table b (x integer, y integer); -select * from a left join b on i = x and i = y and x = i; - i | x | y ----+---+--- -(0 rows) - -rollback; --- --- test NULL behavior of whole-row Vars, per bug #5025 --- -select t1.q2, count(t2.*) -from int8_tbl t1 left join int8_tbl t2 on (t1.q2 = t2.q1) -group by t1.q2 order by 1; - q2 | count --------------------+------- - -4567890123456789 | 0 - 123 | 2 - 456 | 0 - 4567890123456789 | 6 -(4 rows) - -select t1.q2, count(t2.*) -from int8_tbl t1 left join (select * from int8_tbl) t2 on (t1.q2 = t2.q1) -group by t1.q2 order by 1; - q2 | count --------------------+------- - -4567890123456789 | 0 - 123 | 2 - 456 | 0 - 4567890123456789 | 6 -(4 rows) - -select t1.q2, count(t2.*) -from int8_tbl t1 left join (select * from int8_tbl offset 0) t2 on (t1.q2 = t2.q1) -group by t1.q2 order by 1; - q2 | count --------------------+------- - -4567890123456789 | 0 - 123 | 2 - 456 | 0 - 4567890123456789 | 6 -(4 rows) - -select t1.q2, count(t2.*) -from int8_tbl t1 left join - (select q1, case when q2=1 then 1 else q2 end as q2 from int8_tbl) t2 - on (t1.q2 = t2.q1) -group by t1.q2 order by 1; - q2 | count --------------------+------- - -4567890123456789 | 0 - 123 | 2 - 456 | 0 - 4567890123456789 | 6 -(4 rows) - --- --- test incorrect failure to NULL pulled-up subexpressions --- -begin; -create temp table a ( - code char not null, - constraint a_pk primary key (code) -); -NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "a_pk" for table "a" -create temp table b ( - a char not null, - num integer not null, - constraint b_pk primary key (a, num) -); -NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "b_pk" for table "b" -create temp table c ( - name char not null, - a char, - constraint c_pk primary key (name) -); -NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "c_pk" for table "c" -insert into a (code) values ('p'); -insert into a (code) values ('q'); -insert into b (a, num) values ('p', 1); -insert into b (a, num) values ('p', 2); -insert into c (name, a) values ('A', 'p'); -insert into c (name, a) values ('B', 'q'); -insert into c (name, a) values ('C', null); -select c.name, ss.code, ss.b_cnt, ss.const -from c left join - (select a.code, coalesce(b_grp.cnt, 0) as b_cnt, -1 as const - from a left join - (select count(1) as cnt, b.a from b group by b.a) as b_grp - on a.code = b_grp.a - ) as ss - on (c.a = ss.code) -order by c.name; - name | code | b_cnt | const -------+------+-------+------- - A | p | 2 | -1 - B | q | 0 | -1 - C | | | -(3 rows) - -rollback; --- --- test incorrect handling of placeholders that only appear in targetlists, --- per bug #6154 --- -SELECT * FROM -( SELECT 1 as key1 ) sub1 -LEFT JOIN -( SELECT sub3.key3, sub4.value2, COALESCE(sub4.value2, 66) as value3 FROM - ( SELECT 1 as key3 ) sub3 - LEFT JOIN - ( SELECT sub5.key5, COALESCE(sub6.value1, 1) as value2 FROM - ( SELECT 1 as key5 ) sub5 - LEFT JOIN - ( SELECT 2 as key6, 42 as value1 ) sub6 - ON sub5.key5 = sub6.key6 - ) sub4 - ON sub4.key5 = sub3.key3 -) sub2 -ON sub1.key1 = sub2.key3; - key1 | key3 | value2 | value3 -------+------+--------+-------- - 1 | 1 | 1 | 1 -(1 row) - --- test the path using join aliases, too -SELECT * FROM -( SELECT 1 as key1 ) sub1 -LEFT JOIN -( SELECT sub3.key3, value2, COALESCE(value2, 66) as value3 FROM - ( SELECT 1 as key3 ) sub3 - LEFT JOIN - ( SELECT sub5.key5, COALESCE(sub6.value1, 1) as value2 FROM - ( SELECT 1 as key5 ) sub5 - LEFT JOIN - ( SELECT 2 as key6, 42 as value1 ) sub6 - ON sub5.key5 = sub6.key6 - ) sub4 - ON sub4.key5 = sub3.key3 -) sub2 -ON sub1.key1 = sub2.key3; - key1 | key3 | value2 | value3 -------+------+--------+-------- - 1 | 1 | 1 | 1 -(1 row) - --- --- test case where a PlaceHolderVar is used as a nestloop parameter --- -EXPLAIN (NUM_NODES OFF, NODES OFF, COSTS OFF) -SELECT qq, unique1 - FROM - ( SELECT COALESCE(q1, 0) AS qq FROM int8_tbl a ) AS ss1 - FULL OUTER JOIN - ( SELECT COALESCE(q2, -1) AS qq FROM int8_tbl b ) AS ss2 - USING (qq) - INNER JOIN tenk1 c ON qq = unique2; - QUERY PLAN ----------------------------------------------------------------------------------------------------- - Nested Loop - Join Filter: (COALESCE((COALESCE(a.q1, 0::bigint)), (COALESCE(b.q2, (-1)::bigint))) = c.unique2) - -> Hash Full Join - Hash Cond: (COALESCE(a.q1, 0::bigint) = COALESCE(b.q2, (-1)::bigint)) - -> Data Node Scan on int8_tbl "_REMOTE_TABLE_QUERY_" - -> Hash - -> Data Node Scan on int8_tbl "_REMOTE_TABLE_QUERY_" - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" -(8 rows) - -SELECT qq, unique1 - FROM - ( SELECT COALESCE(q1, 0) AS qq FROM int8_tbl a ) AS ss1 - FULL OUTER JOIN - ( SELECT COALESCE(q2, -1) AS qq FROM int8_tbl b ) AS ss2 - USING (qq) - INNER JOIN tenk1 c ON qq = unique2; - qq | unique1 ------+--------- - 123 | 4596 - 123 | 4596 - 456 | 7318 -(3 rows) - --- --- test case where a PlaceHolderVar is propagated into a subquery --- -explain (num_nodes off, nodes off, costs off) -select * from - int8_tbl t1 left join - (select q1 as x, 42 as y from int8_tbl t2) ss - on t1.q2 = ss.x -where - 1 = (select 1 from int8_tbl t3 where ss.y is not null limit 1) -order by 1,2; - QUERY PLAN ------------------------------------------------------------------------------ - Sort - Sort Key: t1.q1, t1.q2 - -> Nested Loop Left Join - Join Filter: (t1.q2 = t2.q1) - Filter: (1 = (SubPlan 1)) - -> Data Node Scan on int8_tbl "_REMOTE_TABLE_QUERY_" - -> Data Node Scan on int8_tbl "_REMOTE_TABLE_QUERY_" - SubPlan 1 - -> Limit - -> Result - One-Time Filter: ((42) IS NOT NULL) - -> Data Node Scan on int8_tbl "_REMOTE_TABLE_QUERY_" -(12 rows) - -select * from - int8_tbl t1 left join - (select q1 as x, 42 as y from int8_tbl t2) ss - on t1.q2 = ss.x -where - 1 = (select 1 from int8_tbl t3 where ss.y is not null limit 1) -order by 1,2; - q1 | q2 | x | y -------------------+------------------+------------------+---- - 123 | 4567890123456789 | 4567890123456789 | 42 - 123 | 4567890123456789 | 4567890123456789 | 42 - 123 | 4567890123456789 | 4567890123456789 | 42 - 4567890123456789 | 123 | 123 | 42 - 4567890123456789 | 123 | 123 | 42 - 4567890123456789 | 4567890123456789 | 4567890123456789 | 42 - 4567890123456789 | 4567890123456789 | 4567890123456789 | 42 - 4567890123456789 | 4567890123456789 | 4567890123456789 | 42 -(8 rows) - --- --- test the corner cases FULL JOIN ON TRUE and FULL JOIN ON FALSE --- -select * from int4_tbl a full join int4_tbl b on true order by 1,2; - f1 | f1 --------------+------------- - -2147483647 | -2147483647 - -2147483647 | -123456 - -2147483647 | 0 - -2147483647 | 123456 - -2147483647 | 2147483647 - -123456 | -2147483647 - -123456 | -123456 - -123456 | 0 - -123456 | 123456 - -123456 | 2147483647 - 0 | -2147483647 - 0 | -123456 - 0 | 0 - 0 | 123456 - 0 | 2147483647 - 123456 | -2147483647 - 123456 | -123456 - 123456 | 0 - 123456 | 123456 - 123456 | 2147483647 - 2147483647 | -2147483647 - 2147483647 | -123456 - 2147483647 | 0 - 2147483647 | 123456 - 2147483647 | 2147483647 -(25 rows) - -select * from int4_tbl a full join int4_tbl b on false order by 1,2; - f1 | f1 --------------+------------- - -2147483647 | - -123456 | - 0 | - 123456 | - 2147483647 | - | -2147483647 - | -123456 - | 0 - | 123456 - | 2147483647 -(10 rows) - --- --- test for ability to use a cartesian join when necessary --- -explain (num_nodes off, nodes off, costs off) -select * from - tenk1 join int4_tbl on f1 = twothousand, - int4(sin(1)) q1, - int4(sin(0)) q2 -where q1 = thousand or q2 = thousand; - QUERY PLAN ------------------------------------------------------------------------ - Nested Loop - Join Filter: ((q1.q1 = tenk1.thousand) OR (q2.q2 = tenk1.thousand)) - -> Nested Loop - -> Nested Loop - Join Filter: (tenk1.twothousand = int4_tbl.f1) - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" - -> Data Node Scan on int4_tbl "_REMOTE_TABLE_QUERY_" - -> Function Scan on q1 - -> Function Scan on q2 -(9 rows) - -explain (num_nodes off, nodes off, costs off) -select * from - tenk1 join int4_tbl on f1 = twothousand, - int4(sin(1)) q1, - int4(sin(0)) q2 -where thousand = (q1 + q2); - QUERY PLAN ---------------------------------------------------------------------- - Nested Loop - Join Filter: ((q1.q1 + q2.q2) = tenk1.thousand) - -> Nested Loop - -> Nested Loop - Join Filter: (tenk1.twothousand = int4_tbl.f1) - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" - -> Data Node Scan on int4_tbl "_REMOTE_TABLE_QUERY_" - -> Function Scan on q1 - -> Function Scan on q2 -(9 rows) - --- --- test placement of movable quals in a parameterized join tree --- -explain (num_nodes off, nodes off, costs off) -select * from tenk1 t1 left join - (tenk1 t2 join tenk1 t3 on t2.thousand = t3.unique2) - on t1.hundred = t2.hundred and t1.ten = t3.ten -where t1.unique1 = 1; - QUERY PLAN ------------------------------------------------------------------- - Nested Loop Left Join - Join Filter: ((t1.hundred = t2.hundred) AND (t1.ten = t3.ten)) - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" - -> Nested Loop - Join Filter: (t2.thousand = t3.unique2) - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" -(7 rows) - -explain (num_nodes off, nodes off, costs off) -select * from tenk1 t1 left join - (tenk1 t2 join tenk1 t3 on t2.thousand = t3.unique2) - on t1.hundred = t2.hundred and t1.ten + t2.ten = t3.ten -where t1.unique1 = 1; - QUERY PLAN ------------------------------------------------------------------------------ - Nested Loop Left Join - Join Filter: ((t1.hundred = t2.hundred) AND ((t1.ten + t2.ten) = t3.ten)) - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" - -> Nested Loop - Join Filter: (t2.thousand = t3.unique2) - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" -(7 rows) - -explain (num_nodes off, nodes off, costs off) -select count(*) from - tenk1 a join tenk1 b on a.unique1 = b.unique2 - left join tenk1 c on a.unique2 = b.unique1 and c.thousand = a.thousand - join int4_tbl on b.thousand = f1; - QUERY PLAN ------------------------------------------------------------------------------------- - Aggregate - -> Nested Loop - Join Filter: (b.thousand = int4_tbl.f1) - -> Nested Loop Left Join - Join Filter: ((a.unique2 = b.unique1) AND (c.thousand = a.thousand)) - -> Nested Loop - Join Filter: (a.unique1 = b.unique2) - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" - -> Data Node Scan on int4_tbl "_REMOTE_TABLE_QUERY_" -(11 rows) - -select count(*) from - tenk1 a join tenk1 b on a.unique1 = b.unique2 - left join tenk1 c on a.unique2 = b.unique1 and c.thousand = a.thousand - join int4_tbl on b.thousand = f1; - count -------- - 10 -(1 row) - -explain (num_nodes off, nodes off, costs off) -select b.unique1 from - tenk1 a join tenk1 b on a.unique1 = b.unique2 - left join tenk1 c on b.unique1 = 42 and c.thousand = a.thousand - join int4_tbl i1 on b.thousand = f1 - right join int4_tbl i2 on i2.f1 = b.tenthous - order by 1; - QUERY PLAN ------------------------------------------------------------------------------------ - Sort - Sort Key: b.unique1 - -> Nested Loop Left Join - Join Filter: (i2.f1 = b.tenthous) - -> Data Node Scan on int4_tbl "_REMOTE_TABLE_QUERY_" - -> Nested Loop - Join Filter: (b.thousand = i1.f1) - -> Nested Loop Left Join - Join Filter: ((b.unique1 = 42) AND (c.thousand = a.thousand)) - -> Nested Loop - Join Filter: (a.unique1 = b.unique2) - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" - -> Data Node Scan on int4_tbl "_REMOTE_TABLE_QUERY_" -(15 rows) - -select b.unique1 from - tenk1 a join tenk1 b on a.unique1 = b.unique2 - left join tenk1 c on b.unique1 = 42 and c.thousand = a.thousand - join int4_tbl i1 on b.thousand = f1 - right join int4_tbl i2 on i2.f1 = b.tenthous - order by 1; - unique1 ---------- - 0 - - - - -(5 rows) - --- --- test join removal --- -begin; -CREATE TEMP TABLE a (id int PRIMARY KEY, b_id int); -NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "a_pkey" for table "a" -CREATE TEMP TABLE b (id int PRIMARY KEY, c_id int); -NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "b_pkey" for table "b" -CREATE TEMP TABLE c (id int PRIMARY KEY); -NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "c_pkey" for table "c" -INSERT INTO a VALUES (0, 0), (1, NULL); -INSERT INTO b VALUES (0, 0), (1, NULL); -INSERT INTO c VALUES (0), (1); --- all three cases should be optimizable into a simple seqscan -explain (verbose true, costs false, nodes false) SELECT a.* FROM a LEFT JOIN b ON a.b_id = b.id; - QUERY PLAN --------------------------------------------------------- - Data Node Scan on a "_REMOTE_TABLE_QUERY_" - Output: a.id, a.b_id - Remote query: SELECT id, b_id FROM ONLY a WHERE true -(3 rows) - -explain (verbose true, costs false, nodes false) SELECT b.* FROM b LEFT JOIN c ON b.c_id = c.id; - QUERY PLAN --------------------------------------------------------- - Data Node Scan on b "_REMOTE_TABLE_QUERY_" - Output: b.id, b.c_id - Remote query: SELECT id, c_id FROM ONLY b WHERE true -(3 rows) - -explain (verbose true, costs false, nodes false) - SELECT a.* FROM a LEFT JOIN (b left join c on b.c_id = c.id) - ON (a.b_id = b.id); - QUERY PLAN --------------------------------------------------------- - Data Node Scan on a "_REMOTE_TABLE_QUERY_" - Output: a.id, a.b_id - Remote query: SELECT id, b_id FROM ONLY a WHERE true -(3 rows) - --- check optimization of outer join within another special join -explain (verbose true, costs false, nodes false) -select id from a where id in ( - select b.id from b left join c on b.id = c.id -); - QUERY PLAN --------------------------------------------------------- - Nested Loop Semi Join - Output: a.id - Join Filter: (a.id = b.id) - -> Data Node Scan on a "_REMOTE_TABLE_QUERY_" - Output: a.id - Remote query: SELECT id FROM ONLY a WHERE true - -> Data Node Scan on b "_REMOTE_TABLE_QUERY_" - Output: b.id - Remote query: SELECT id FROM ONLY b WHERE true -(9 rows) - -rollback; -create temp table parent (k int primary key, pd int); -NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "parent_pkey" for table "parent" -create temp table child (k int unique, cd int); -NOTICE: CREATE TABLE / UNIQUE will create implicit index "child_k_key" for table "child" -insert into parent values (1, 10), (2, 20), (3, 30); -insert into child values (1, 100), (4, 400); --- this case is optimizable -select p.* from parent p left join child c on (p.k = c.k) order by 1,2; - k | pd ----+---- - 1 | 10 - 2 | 20 - 3 | 30 -(3 rows) - -explain (verbose true, costs false, nodes false) - select p.* from parent p left join child c on (p.k = c.k) order by 1,2; - QUERY PLAN ------------------------------------------------------------------- - Sort - Output: p.k, p.pd - Sort Key: p.k, p.pd - -> Data Node Scan on parent "_REMOTE_TABLE_QUERY_" - Output: p.k, p.pd - Remote query: SELECT k, pd FROM ONLY parent p WHERE true -(6 rows) - --- this case is not -select p.*, linked from parent p - left join (select c.*, true as linked from child c) as ss - on (p.k = ss.k) order by p.k; - k | pd | linked ----+----+-------- - 1 | 10 | t - 2 | 20 | - 3 | 30 | -(3 rows) - -explain (verbose true, costs false, nodes false) - select p.*, linked from parent p - left join (select c.*, true as linked from child c) as ss - on (p.k = ss.k) order by p.k; - QUERY PLAN ------------------------------------------------------------------------- - Sort - Output: p.k, p.pd, (true) - Sort Key: p.k - -> Nested Loop Left Join - Output: p.k, p.pd, (true) - Join Filter: (p.k = c.k) - -> Data Node Scan on parent "_REMOTE_TABLE_QUERY_" - Output: p.k, p.pd - Remote query: SELECT k, pd FROM ONLY parent p WHERE true - -> Data Node Scan on child "_REMOTE_TABLE_QUERY_" - Output: c.k, true - Remote query: SELECT k FROM ONLY child c WHERE true -(12 rows) - --- check for a 9.0rc1 bug: join removal breaks pseudoconstant qual handling -select p.* from - parent p left join child c on (p.k = c.k) - where p.k = 1 and p.k = 2; - k | pd ----+---- -(0 rows) - -explain (verbose true, costs false, nodes false) -select p.* from - parent p left join child c on (p.k = c.k) - where p.k = 1 and p.k = 2; - QUERY PLAN ---------------------------------------------------------------------- - Result - Output: p.k, p.pd - One-Time Filter: false - -> Data Node Scan on parent "_REMOTE_TABLE_QUERY_" - Output: p.k, p.pd - Remote query: SELECT k, pd FROM ONLY parent p WHERE (k = 1) -(6 rows) - -select p.* from - (parent p left join child c on (p.k = c.k)) join parent x on p.k = x.k - where p.k = 1 and p.k = 2; - k | pd ----+---- -(0 rows) - -explain (verbose true, costs false, nodes false) -select p.* from - (parent p left join child c on (p.k = c.k)) join parent x on p.k = x.k - where p.k = 1 and p.k = 2; - QUERY PLAN --------------------------- - Result - Output: p.k, p.pd - One-Time Filter: false -(3 rows) - --- bug 5255: this is not optimizable by join removal -begin; -CREATE TEMP TABLE a (id int PRIMARY KEY); -NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "a_pkey" for table "a" -CREATE TEMP TABLE b (id int PRIMARY KEY, a_id int); -NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "b_pkey" for table "b" -INSERT INTO a VALUES (0), (1); -INSERT INTO b VALUES (0, 0), (1, NULL); -SELECT * FROM b LEFT JOIN a ON (b.a_id = a.id) WHERE (a.id IS NULL OR a.id > 0); - id | a_id | id -----+------+---- - 1 | | -(1 row) - -SELECT b.* FROM b LEFT JOIN a ON (b.a_id = a.id) WHERE (a.id IS NULL OR a.id > 0); - id | a_id -----+------ - 1 | -(1 row) - -rollback; --- another join removal bug: this is not optimizable, either -begin; -create temp table innertab (id int8 primary key, dat1 int8); -NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "innertab_pkey" for table "innertab" -insert into innertab values(123, 42); -SELECT * FROM - (SELECT 1 AS x) ss1 - LEFT JOIN - (SELECT q1, q2, COALESCE(dat1, q1) AS y - FROM int8_tbl LEFT JOIN innertab ON q2 = id) ss2 - ON true order by 1, 2, 3, 4; - x | q1 | q2 | y ----+------------------+-------------------+------------------ - 1 | 123 | 456 | 123 - 1 | 123 | 4567890123456789 | 123 - 1 | 4567890123456789 | -4567890123456789 | 4567890123456789 - 1 | 4567890123456789 | 123 | 42 - 1 | 4567890123456789 | 4567890123456789 | 4567890123456789 -(5 rows) - -rollback; -- 2.39.5