) 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
( 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
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
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
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
-------------------------------------------------------------------------------------------------
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
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
---------------------------------------------------------------------------------------------
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
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
----------------------------------------------------------------------------------------------------------------------
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
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
(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
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
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
(
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
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
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)
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)
--
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,
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)
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);
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;
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
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
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;
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;
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)
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
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
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;
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 (
(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
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)
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)
+++ /dev/null
---
--- 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;
projects / postgres-xl.git / commitdiff