From 9e6f5a428d06456f4211faacd4d5a2e2a5f4a4c5 Mon Sep 17 00:00:00 2001 From: Yuming Wang Date: Wed, 10 Jul 2019 20:44:56 +0800 Subject: [PATCH 1/5] Add join.sql --- .../resources/sql-tests/inputs/pgSQL/join.sql | 2073 +++++++++++++++++ 1 file changed, 2073 insertions(+) create mode 100644 sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql diff --git a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql new file mode 100644 index 0000000000000..13cfa733a5cd6 --- /dev/null +++ b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql @@ -0,0 +1,2073 @@ +-- +-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group +-- +-- +-- JOIN +-- Test JOIN clauses +-- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/join.sql +-- + +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); + +-- useful in some tests below +create temp table onerow(); +insert into onerow default values; +analyze onerow; + + +-- +-- 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; + +SELECT '' AS "xxx", * + FROM J1_TBL tx; + +SELECT '' AS "xxx", * + FROM J1_TBL AS t1 (a, b, c); + +SELECT '' AS "xxx", * + FROM J1_TBL t1 (a, b, c); + +SELECT '' AS "xxx", * + FROM J1_TBL t1 (a, b, c), J2_TBL t2 (d, e); + +SELECT '' AS "xxx", t1.a, t2.e + FROM J1_TBL t1 (a, b, c), J2_TBL t2 (d, e) + WHERE t1.a = t2.d; + + +-- +-- 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; + +-- ambiguous column +SELECT '' AS "xxx", i, k, t + FROM J1_TBL CROSS JOIN J2_TBL; + +-- resolve previous ambiguity by specifying the table name +SELECT '' AS "xxx", t1.i, k, t + FROM J1_TBL t1 CROSS JOIN J2_TBL t2; + +SELECT '' AS "xxx", ii, tt, kk + FROM (J1_TBL CROSS JOIN J2_TBL) + AS tx (ii, jj, tt, ii2, kk); + +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); + +SELECT '' AS "xxx", * + FROM J1_TBL CROSS JOIN J2_TBL a CROSS JOIN J2_TBL b; + + +-- +-- +-- 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); + +-- Same as above, slightly different syntax +SELECT '' AS "xxx", * + FROM J1_TBL JOIN J2_TBL USING (i); + +SELECT '' AS "xxx", * + FROM J1_TBL t1 (a, b, c) JOIN J2_TBL t2 (a, d) USING (a) + ORDER BY a, d; + +SELECT '' AS "xxx", * + FROM J1_TBL t1 (a, b, c) JOIN J2_TBL t2 (a, b) USING (b) + ORDER BY b, t1.a; + + +-- +-- NATURAL JOIN +-- Inner equi-join on all columns with the same name +-- + +SELECT '' AS "xxx", * + FROM J1_TBL NATURAL JOIN J2_TBL; + +SELECT '' AS "xxx", * + FROM J1_TBL t1 (a, b, c) NATURAL JOIN J2_TBL t2 (a, d); + +SELECT '' AS "xxx", * + FROM J1_TBL t1 (a, b, c) NATURAL JOIN J2_TBL t2 (d, a); + +-- 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); + + +-- +-- Inner joins (equi-joins) +-- + +SELECT '' AS "xxx", * + FROM J1_TBL JOIN J2_TBL ON (J1_TBL.i = J2_TBL.i); + +SELECT '' AS "xxx", * + FROM J1_TBL JOIN J2_TBL ON (J1_TBL.i = J2_TBL.k); + + +-- +-- Non-equi-joins +-- + +SELECT '' AS "xxx", * + FROM J1_TBL JOIN J2_TBL ON (J1_TBL.i <= J2_TBL.k); + + +-- +-- 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; + +SELECT '' AS "xxx", * + FROM J1_TBL LEFT JOIN J2_TBL USING (i) + ORDER BY i, k, t; + +SELECT '' AS "xxx", * + FROM J1_TBL RIGHT OUTER JOIN J2_TBL USING (i); + +SELECT '' AS "xxx", * + FROM J1_TBL RIGHT JOIN J2_TBL USING (i); + +SELECT '' AS "xxx", * + FROM J1_TBL FULL OUTER JOIN J2_TBL USING (i) + ORDER BY i, k, t; + +SELECT '' AS "xxx", * + FROM J1_TBL FULL JOIN J2_TBL USING (i) + ORDER BY i, k, t; + +SELECT '' AS "xxx", * + FROM J1_TBL LEFT JOIN J2_TBL USING (i) WHERE (k = 1); + +SELECT '' AS "xxx", * + FROM J1_TBL LEFT JOIN J2_TBL USING (i) WHERE (i = 1); + +-- +-- semijoin selectivity for <> +-- +explain (costs off) +select * from int4_tbl i4, tenk1 a +where exists(select * from tenk1 b + where a.twothousand = b.twothousand and a.fivethous <> b.fivethous) + and i4.f1 = a.tenthous; + + +-- +-- 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); + +-- +-- 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); + +SELECT * FROM +(SELECT * FROM t2) as s2 +LEFT JOIN +(SELECT * FROM t3) s3 +USING (name); + +SELECT * FROM +(SELECT * FROM t2) as s2 +FULL JOIN +(SELECT * FROM t3) s3 +USING (name); + +-- 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; + +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; + +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; + +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; + +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; + +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; + +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; + +-- Constants as join keys can also be problematic +SELECT * FROM + (SELECT name, n as s1_n FROM t1) as s1 +FULL JOIN + (SELECT name, 2 as s2_n FROM t2) as s2 +ON (s1_n = s2_n); + + +-- 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; +select * from y; + +select * from x left join y on (x1 = y1 and x2 is not null); +select * from x left join y on (x1 = y1 and y2 is not null); + +select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) +on (x1 = xx1); +select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) +on (x1 = xx1 and x2 is not null); +select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) +on (x1 = xx1 and y2 is not null); +select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) +on (x1 = xx1 and xx2 is not null); +-- 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); +select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) +on (x1 = xx1) where (y2 is not null); +select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) +on (x1 = xx1) where (xx2 is not null); + +-- +-- regression test: check for bug with propagation of implied equality +-- to outside an IN +-- +select count(*) from tenk1 a where unique1 in + (select unique1 from tenk1 b join tenk1 c using (unique1) + where b.unique2 = 42); + +-- +-- 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); + +-- 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); +rollback; + +-- +-- regression test: be sure we cope with proven-dummy append rels +-- +explain (costs off) +select aa, bb, unique1, unique1 + from tenk1 right join b on aa = unique1 + where bb < bb and bb is null; + +select aa, bb, unique1, unique1 + from tenk1 right join b on aa = unique1 + where bb < bb and bb is null; + +-- +-- regression test: check handling of empty-FROM subquery underneath outer join +-- +explain (costs off) +select * from int8_tbl i1 left join (int8_tbl i2 join + (select 123 as x) ss on i2.q1 = x) on i1.q2 = i2.q2 +order by 1, 2; + +select * from int8_tbl i1 left join (int8_tbl i2 join + (select 123 as x) ss on i2.q1 = x) on i1.q2 = i2.q2 +order by 1, 2; + +-- +-- regression test: check a case where join_clause_is_movable_into() gives +-- an imprecise result, causing an assertion failure +-- +select count(*) +from + (select t3.tenthous as x1, coalesce(t1.stringu1, t2.stringu1) as x2 + from tenk1 t1 + left join tenk1 t2 on t1.unique1 = t2.unique1 + join tenk1 t3 on t1.unique2 = t3.unique2) ss, + tenk1 t4, + tenk1 t5 +where t4.thousand = t5.unique1 and ss.x1 = t4.tenthous and ss.x2 = t5.stringu1; + +-- +-- regression test: check a case where we formerly missed including an EC +-- enforcement clause because it was expected to be handled at scan level +-- +explain (costs off) +select a.f1, b.f1, t.thousand, t.tenthous from + tenk1 t, + (select sum(f1)+1 as f1 from int4_tbl i4a) a, + (select sum(f1) as f1 from int4_tbl i4b) b +where b.f1 = t.thousand and a.f1 = b.f1 and (a.f1+b.f1+999) = t.tenthous; + +select a.f1, b.f1, t.thousand, t.tenthous from + tenk1 t, + (select sum(f1)+1 as f1 from int4_tbl i4a) a, + (select sum(f1) as f1 from int4_tbl i4b) b +where b.f1 = t.thousand and a.f1 = b.f1 and (a.f1+b.f1+999) = t.tenthous; + +-- +-- check a case where we formerly got confused by conflicting sort orders +-- in redundant merge join path keys +-- +explain (costs off) +select * from + j1_tbl full join + (select * from j2_tbl order by j2_tbl.i desc, j2_tbl.k asc) j2_tbl + on j1_tbl.i = j2_tbl.i and j1_tbl.i = j2_tbl.k; + +select * from + j1_tbl full join + (select * from j2_tbl order by j2_tbl.i desc, j2_tbl.k asc) j2_tbl + on j1_tbl.i = j2_tbl.i and j1_tbl.i = j2_tbl.k; + +-- +-- a different check for handling of redundant sort keys in merge joins +-- +explain (costs off) +select count(*) from + (select * from tenk1 x order by x.thousand, x.twothousand, x.fivethous) x + left join + (select * from tenk1 y order by y.unique2) y + on x.thousand = y.unique2 and x.twothousand = y.hundred and x.fivethous = y.unique2; + +select count(*) from + (select * from tenk1 x order by x.thousand, x.twothousand, x.fivethous) x + left join + (select * from tenk1 y order by y.unique2) y + on x.thousand = y.unique2 and x.twothousand = y.hundred and x.fivethous = y.unique2; + + +-- +-- 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; +DELETE FROM t3 USING t1 JOIN t2 USING (a) WHERE t3.x > t1.a; +SELECT * FROM t3; +DELETE FROM t3 USING t3 t3_other WHERE t3.x = t3_other.x AND t3.y = t3_other.y; +SELECT * FROM t3; + +-- 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); + +-- Test matching of column name with wrong alias + +select t1.x from t1 join t3 on (t1.a = t3.x); + +-- +-- 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; + +select tt1.*, tt2.* from tt2 right join tt1 on tt1.joincol = tt2.joincol; + +reset enable_hashjoin; +reset enable_nestloop; + +-- +-- regression test for bug #13908 (hash join with skew tuples & nbatch increase) +-- + +set work_mem to '64kB'; +set enable_mergejoin to off; + +explain (costs off) +select count(*) from tenk1 a, tenk1 b + where a.hundred = b.thousand and (b.fivethous % 10) < 10; +select count(*) from tenk1 a, tenk1 b + where a.hundred = b.thousand and (b.fivethous % 10) < 10; + +reset work_mem; +reset enable_mergejoin; + +-- +-- 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; + +-- +-- regression test for proper handling of outer joins within antijoins +-- + +create temp table tt4x(c1 int, c2 int, c3 int); + +explain (costs off) +select * from tt4x t1 +where not exists ( + select 1 from tt4x t2 + left join tt4x t3 on t2.c3 = t3.c1 + left join ( select t5.c1 as c1 + from tt4x t4 left join tt4x t5 on t4.c2 = t5.c1 + ) a1 on t3.c2 = a1.c1 + where t1.c1 = t2.c2 +); + +-- +-- 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; + +-- +-- 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; + +-- +-- 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); +create temp table zt2 (f2 int primary key); +create temp table zt3 (f3 int primary key); +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; + +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; + +-- +-- 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); + +-- +-- 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)); +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; + +rollback; + +-- +-- test handling of merge clauses using record_ops +-- +begin; + +create type mycomptype as (id int, v bigint); + +create temp table tidv (idv mycomptype); +create index on tidv (idv); + +explain (costs off) +select a.idv, b.idv from tidv a, tidv b where a.idv = b.idv; + +set enable_mergejoin = 0; + +explain (costs off) +select a.idv, b.idv from tidv a, tidv b where a.idv = b.idv; + +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; + +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; + +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; + +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; + +-- +-- test incorrect failure to NULL pulled-up subexpressions +-- +begin; + +create temp table a ( + code char not null, + constraint a_pk primary key (code) +); +create temp table b ( + a char not null, + num integer not null, + constraint b_pk primary key (a, num) +); +create temp table c ( + name char not null, + a char, + constraint c_pk primary key (name) +); + +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; + +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; + +-- 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; + +-- +-- test case where a PlaceHolderVar is used as a nestloop parameter +-- + +EXPLAIN (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; + +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; + +-- +-- nested nestloops can require nested PlaceHolderVars +-- + +create temp table nt1 ( + id int primary key, + a1 boolean, + a2 boolean +); +create temp table nt2 ( + id int primary key, + nt1_id int, + b1 boolean, + b2 boolean, + foreign key (nt1_id) references nt1(id) +); +create temp table nt3 ( + id int primary key, + nt2_id int, + c1 boolean, + foreign key (nt2_id) references nt2(id) +); + +insert into nt1 values (1,true,true); +insert into nt1 values (2,true,false); +insert into nt1 values (3,false,false); +insert into nt2 values (1,1,true,true); +insert into nt2 values (2,2,true,false); +insert into nt2 values (3,3,false,false); +insert into nt3 values (1,1,true); +insert into nt3 values (2,2,false); +insert into nt3 values (3,3,true); + +explain (costs off) +select nt3.id +from nt3 as nt3 + left join + (select nt2.*, (nt2.b1 and ss1.a3) AS b3 + from nt2 as nt2 + left join + (select nt1.*, (nt1.id is not null) as a3 from nt1) as ss1 + on ss1.id = nt2.nt1_id + ) as ss2 + on ss2.id = nt3.nt2_id +where nt3.id = 1 and ss2.b3; + +select nt3.id +from nt3 as nt3 + left join + (select nt2.*, (nt2.b1 and ss1.a3) AS b3 + from nt2 as nt2 + left join + (select nt1.*, (nt1.id is not null) as a3 from nt1) as ss1 + on ss1.id = nt2.nt1_id + ) as ss2 + on ss2.id = nt3.nt2_id +where nt3.id = 1 and ss2.b3; + +-- +-- test case where a PlaceHolderVar is propagated into a subquery +-- + +explain (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; + +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; + +-- +-- 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; +select * from int4_tbl a full join int4_tbl b on false; + +-- +-- test for ability to use a cartesian join when necessary +-- + +explain (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; + +explain (costs off) +select * from + tenk1 join int4_tbl on f1 = twothousand, + int4(sin(1)) q1, + int4(sin(0)) q2 +where thousand = (q1 + q2); + +-- +-- test ability to generate a suitable plan for a star-schema query +-- + +explain (costs off) +select * from + tenk1, int8_tbl a, int8_tbl b +where thousand = a.q1 and tenthous = b.q1 and a.q2 = 1 and b.q2 = 2; + +-- +-- test a corner case in which we shouldn't apply the star-schema optimization +-- + +explain (costs off) +select t1.unique2, t1.stringu1, t2.unique1, t2.stringu2 from + tenk1 t1 + inner join int4_tbl i1 + left join (select v1.x2, v2.y1, 11 AS d1 + from (select 1,0 from onerow) v1(x1,x2) + left join (select 3,1 from onerow) v2(y1,y2) + on v1.x1 = v2.y2) subq1 + on (i1.f1 = subq1.x2) + on (t1.unique2 = subq1.d1) + left join tenk1 t2 + on (subq1.y1 = t2.unique1) +where t1.unique2 < 42 and t1.stringu1 > t2.stringu2; + +select t1.unique2, t1.stringu1, t2.unique1, t2.stringu2 from + tenk1 t1 + inner join int4_tbl i1 + left join (select v1.x2, v2.y1, 11 AS d1 + from (select 1,0 from onerow) v1(x1,x2) + left join (select 3,1 from onerow) v2(y1,y2) + on v1.x1 = v2.y2) subq1 + on (i1.f1 = subq1.x2) + on (t1.unique2 = subq1.d1) + left join tenk1 t2 + on (subq1.y1 = t2.unique1) +where t1.unique2 < 42 and t1.stringu1 > t2.stringu2; + +-- variant that isn't quite a star-schema case + +select ss1.d1 from + tenk1 as t1 + inner join tenk1 as t2 + on t1.tenthous = t2.ten + inner join + int8_tbl as i8 + left join int4_tbl as i4 + inner join (select 64::information_schema.cardinal_number as d1 + from tenk1 t3, + lateral (select abs(t3.unique1) + random()) ss0(x) + where t3.fivethous < 0) as ss1 + on i4.f1 = ss1.d1 + on i8.q1 = i4.f1 + on t1.tenthous = ss1.d1 +where t1.unique1 < i4.f1; + +-- this variant is foldable by the remove-useless-RESULT-RTEs code + +explain (costs off) +select t1.unique2, t1.stringu1, t2.unique1, t2.stringu2 from + tenk1 t1 + inner join int4_tbl i1 + left join (select v1.x2, v2.y1, 11 AS d1 + from (values(1,0)) v1(x1,x2) + left join (values(3,1)) v2(y1,y2) + on v1.x1 = v2.y2) subq1 + on (i1.f1 = subq1.x2) + on (t1.unique2 = subq1.d1) + left join tenk1 t2 + on (subq1.y1 = t2.unique1) +where t1.unique2 < 42 and t1.stringu1 > t2.stringu2; + +select t1.unique2, t1.stringu1, t2.unique1, t2.stringu2 from + tenk1 t1 + inner join int4_tbl i1 + left join (select v1.x2, v2.y1, 11 AS d1 + from (values(1,0)) v1(x1,x2) + left join (values(3,1)) v2(y1,y2) + on v1.x1 = v2.y2) subq1 + on (i1.f1 = subq1.x2) + on (t1.unique2 = subq1.d1) + left join tenk1 t2 + on (subq1.y1 = t2.unique1) +where t1.unique2 < 42 and t1.stringu1 > t2.stringu2; + +-- +-- test extraction of restriction OR clauses from join OR clause +-- (we used to only do this for indexable clauses) +-- + +explain (costs off) +select * from tenk1 a join tenk1 b on + (a.unique1 = 1 and b.unique1 = 2) or (a.unique2 = 3 and b.hundred = 4); +explain (costs off) +select * from tenk1 a join tenk1 b on + (a.unique1 = 1 and b.unique1 = 2) or (a.unique2 = 3 and b.ten = 4); +explain (costs off) +select * from tenk1 a join tenk1 b on + (a.unique1 = 1 and b.unique1 = 2) or + ((a.unique2 = 3 or a.unique2 = 7) and b.hundred = 4); + +-- +-- test placement of movable quals in a parameterized join tree +-- + +explain (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; + +explain (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; + +explain (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; + +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; + +explain (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; + +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; + +explain (costs off) +select * from +( + select unique1, q1, coalesce(unique1, -1) + q1 as fault + from int8_tbl left join tenk1 on (q2 = unique2) +) ss +where fault = 122 +order by fault; + +select * from +( + select unique1, q1, coalesce(unique1, -1) + q1 as fault + from int8_tbl left join tenk1 on (q2 = unique2) +) ss +where fault = 122 +order by fault; + +explain (costs off) +select * from +(values (1, array[10,20]), (2, array[20,30])) as v1(v1x,v1ys) +left join (values (1, 10), (2, 20)) as v2(v2x,v2y) on v2x = v1x +left join unnest(v1ys) as u1(u1y) on u1y = v2y; + +select * from +(values (1, array[10,20]), (2, array[20,30])) as v1(v1x,v1ys) +left join (values (1, 10), (2, 20)) as v2(v2x,v2y) on v2x = v1x +left join unnest(v1ys) as u1(u1y) on u1y = v2y; + +-- +-- test handling of potential equivalence clauses above outer joins +-- + +explain (costs off) +select q1, unique2, thousand, hundred + from int8_tbl a left join tenk1 b on q1 = unique2 + where coalesce(thousand,123) = q1 and q1 = coalesce(hundred,123); + +select q1, unique2, thousand, hundred + from int8_tbl a left join tenk1 b on q1 = unique2 + where coalesce(thousand,123) = q1 and q1 = coalesce(hundred,123); + +explain (costs off) +select f1, unique2, case when unique2 is null then f1 else 0 end + from int4_tbl a left join tenk1 b on f1 = unique2 + where (case when unique2 is null then f1 else 0 end) = 0; + +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; + +-- +-- another case with equivalence clauses above outer joins (bug #8591) +-- + +explain (costs off) +select a.unique1, b.unique1, c.unique1, coalesce(b.twothousand, a.twothousand) + from tenk1 a left join tenk1 b on b.thousand = a.unique1 left join tenk1 c on c.unique2 = coalesce(b.twothousand, a.twothousand) + where a.unique2 < 10 and coalesce(b.twothousand, a.twothousand) = 44; + +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; + +-- +-- check handling of join aliases when flattening multiple levels of subquery +-- + +explain (verbose, costs off) +select foo1.join_key as foo1_id, foo3.join_key AS foo3_id, bug_field from + (values (0),(1)) foo1(join_key) +left join + (select join_key, bug_field from + (select ss1.join_key, ss1.bug_field from + (select f1 as join_key, 666 as bug_field from int4_tbl i1) ss1 + ) foo2 + left join + (select unique2 as join_key from tenk1 i2) ss2 + using (join_key) + ) foo3 +using (join_key); + +select foo1.join_key as foo1_id, foo3.join_key AS foo3_id, bug_field from + (values (0),(1)) foo1(join_key) +left join + (select join_key, bug_field from + (select ss1.join_key, ss1.bug_field from + (select f1 as join_key, 666 as bug_field from int4_tbl i1) ss1 + ) foo2 + left join + (select unique2 as join_key from tenk1 i2) ss2 + using (join_key) + ) foo3 +using (join_key); + +-- +-- test successful handling of nested outer joins with degenerate join quals +-- + +explain (verbose, costs off) +select t1.* from + text_tbl t1 + left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 + left join int8_tbl i8 + left join (select *, null::int as d2 from int8_tbl i8b2) b2 + on (i8.q1 = b2.q1) + on (b2.d2 = b1.q2) + on (t1.f1 = b1.d1) + left join int4_tbl i4 + on (i8.q2 = i4.f1); + +select t1.* from + text_tbl t1 + left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 + left join int8_tbl i8 + left join (select *, null::int as d2 from int8_tbl i8b2) b2 + on (i8.q1 = b2.q1) + on (b2.d2 = b1.q2) + on (t1.f1 = b1.d1) + left join int4_tbl i4 + on (i8.q2 = i4.f1); + +explain (verbose, costs off) +select t1.* from + text_tbl t1 + left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 + left join int8_tbl i8 + left join (select *, null::int as d2 from int8_tbl i8b2, int4_tbl i4b2) b2 + on (i8.q1 = b2.q1) + on (b2.d2 = b1.q2) + on (t1.f1 = b1.d1) + left join int4_tbl i4 + on (i8.q2 = i4.f1); + +select t1.* from + text_tbl t1 + left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 + left join int8_tbl i8 + left join (select *, null::int as d2 from int8_tbl i8b2, int4_tbl i4b2) b2 + on (i8.q1 = b2.q1) + on (b2.d2 = b1.q2) + on (t1.f1 = b1.d1) + left join int4_tbl i4 + on (i8.q2 = i4.f1); + +explain (verbose, costs off) +select t1.* from + text_tbl t1 + left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 + left join int8_tbl i8 + left join (select *, null::int as d2 from int8_tbl i8b2, int4_tbl i4b2 + where q1 = f1) b2 + on (i8.q1 = b2.q1) + on (b2.d2 = b1.q2) + on (t1.f1 = b1.d1) + left join int4_tbl i4 + on (i8.q2 = i4.f1); + +select t1.* from + text_tbl t1 + left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 + left join int8_tbl i8 + left join (select *, null::int as d2 from int8_tbl i8b2, int4_tbl i4b2 + where q1 = f1) b2 + on (i8.q1 = b2.q1) + on (b2.d2 = b1.q2) + on (t1.f1 = b1.d1) + left join int4_tbl i4 + on (i8.q2 = i4.f1); + +explain (verbose, costs off) +select * from + text_tbl t1 + inner join int8_tbl i8 + on i8.q2 = 456 + right join text_tbl t2 + on t1.f1 = 'doh!' + left join int4_tbl i4 + on i8.q1 = i4.f1; + +select * from + text_tbl t1 + inner join int8_tbl i8 + on i8.q2 = 456 + right join text_tbl t2 + on t1.f1 = 'doh!' + left join int4_tbl i4 + on i8.q1 = i4.f1; + +-- +-- test for appropriate join order in the presence of lateral references +-- + +explain (verbose, costs off) +select * from + text_tbl t1 + left join int8_tbl i8 + on i8.q2 = 123, + lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss +where t1.f1 = ss.f1; + +select * from + text_tbl t1 + left join int8_tbl i8 + on i8.q2 = 123, + lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss +where t1.f1 = ss.f1; + +explain (verbose, costs off) +select * from + text_tbl t1 + left join int8_tbl i8 + on i8.q2 = 123, + lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss1, + lateral (select ss1.* from text_tbl t3 limit 1) as ss2 +where t1.f1 = ss2.f1; + +select * from + text_tbl t1 + left join int8_tbl i8 + on i8.q2 = 123, + lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss1, + lateral (select ss1.* from text_tbl t3 limit 1) as ss2 +where t1.f1 = ss2.f1; + +explain (verbose, costs off) +select 1 from + text_tbl as tt1 + inner join text_tbl as tt2 on (tt1.f1 = 'foo') + left join text_tbl as tt3 on (tt3.f1 = 'foo') + left join text_tbl as tt4 on (tt3.f1 = tt4.f1), + lateral (select tt4.f1 as c0 from text_tbl as tt5 limit 1) as ss1 +where tt1.f1 = ss1.c0; + +select 1 from + text_tbl as tt1 + inner join text_tbl as tt2 on (tt1.f1 = 'foo') + left join text_tbl as tt3 on (tt3.f1 = 'foo') + left join text_tbl as tt4 on (tt3.f1 = tt4.f1), + lateral (select tt4.f1 as c0 from text_tbl as tt5 limit 1) as ss1 +where tt1.f1 = ss1.c0; + +-- +-- check a case in which a PlaceHolderVar forces join order +-- + +explain (verbose, costs off) +select ss2.* from + int4_tbl i41 + left join int8_tbl i8 + join (select i42.f1 as c1, i43.f1 as c2, 42 as c3 + from int4_tbl i42, int4_tbl i43) ss1 + on i8.q1 = ss1.c2 + on i41.f1 = ss1.c1, + lateral (select i41.*, i8.*, ss1.* from text_tbl limit 1) ss2 +where ss1.c2 = 0; + +select ss2.* from + int4_tbl i41 + left join int8_tbl i8 + join (select i42.f1 as c1, i43.f1 as c2, 42 as c3 + from int4_tbl i42, int4_tbl i43) ss1 + on i8.q1 = ss1.c2 + on i41.f1 = ss1.c1, + lateral (select i41.*, i8.*, ss1.* from text_tbl limit 1) ss2 +where ss1.c2 = 0; + +-- +-- test successful handling of full join underneath left join (bug #14105) +-- + +explain (costs off) +select * from + (select 1 as id) as xx + left join + (tenk1 as a1 full join (select 1 as id) as yy on (a1.unique1 = yy.id)) + on (xx.id = coalesce(yy.id)); + +select * from + (select 1 as id) as xx + left join + (tenk1 as a1 full join (select 1 as id) as yy on (a1.unique1 = yy.id)) + on (xx.id = coalesce(yy.id)); + +-- +-- test ability to push constants through outer join clauses +-- + +explain (costs off) + select * from int4_tbl a left join tenk1 b on f1 = unique2 where f1 = 0; + +explain (costs off) + select * from tenk1 a full join tenk1 b using(unique2) where unique2 = 42; + +-- +-- test that quals attached to an outer join have correct semantics, +-- specifically that they don't re-use expressions computed below the join; +-- we force a mergejoin so that coalesce(b.q1, 1) appears as a join input +-- + +set enable_hashjoin to off; +set enable_nestloop to off; + +explain (verbose, costs off) + select a.q2, b.q1 + from int8_tbl a left join int8_tbl b on a.q2 = coalesce(b.q1, 1) + where coalesce(b.q1, 1) > 0; +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; + +reset enable_hashjoin; +reset enable_nestloop; + +-- +-- test join removal +-- + +begin; + +CREATE TEMP TABLE a (id int PRIMARY KEY, b_id int); +CREATE TEMP TABLE b (id int PRIMARY KEY, c_id int); +CREATE TEMP TABLE c (id int PRIMARY KEY); +CREATE TEMP TABLE d (a int, b int); +INSERT INTO a VALUES (0, 0), (1, NULL); +INSERT INTO b VALUES (0, 0), (1, NULL); +INSERT INTO c VALUES (0), (1); +INSERT INTO d VALUES (1,3), (2,2), (3,1); + +-- all three cases should be optimizable into a simple seqscan +explain (costs off) SELECT a.* FROM a LEFT JOIN b ON a.b_id = b.id; +explain (costs off) SELECT b.* FROM b LEFT JOIN c ON b.c_id = c.id; +explain (costs off) + SELECT a.* FROM a LEFT JOIN (b left join c on b.c_id = c.id) + ON (a.b_id = b.id); + +-- check optimization of outer join within another special join +explain (costs off) +select id from a where id in ( + select b.id from b left join c on b.id = c.id +); + +-- check that join removal works for a left join when joining a subquery +-- that is guaranteed to be unique by its GROUP BY clause +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; + +-- 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; + +-- join removal is not possible when the GROUP BY contains a column that is +-- not in the join condition. (Note: as of 9.6, we notice that b.id is a +-- primary key and so drop b.c_id from the GROUP BY of the resulting plan; +-- but this happens too late for join removal in the outer plan level.) +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; + +-- 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; + +-- 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; + +-- 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; + +-- check join removal with lateral references +explain (costs off) +select 1 from (select a.id FROM a left join b on a.b_id = b.id) q, + lateral generate_series(1, q.id) gs(i) where q.id = gs.i; + +rollback; + +create temp table parent (k int primary key, pd int); +create temp table child (k int unique, cd int); +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); +explain (costs off) + select p.* from parent p left join child c on (p.k = c.k); + +-- 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); +explain (costs off) + select p.*, linked from parent p + left join (select c.*, true as linked from child c) as ss + on (p.k = ss.k); + +-- 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; +explain (costs off) +select p.* from + parent p left join child c on (p.k = c.k) + where p.k = 1 and p.k = 2; + +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; +explain (costs off) +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; + +-- bug 5255: this is not optimizable by join removal +begin; + +CREATE TEMP TABLE a (id int PRIMARY KEY); +CREATE TEMP TABLE b (id int PRIMARY KEY, a_id int); +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); +SELECT b.* FROM b LEFT JOIN a ON (b.a_id = a.id) WHERE (a.id IS NULL OR a.id > 0); + +rollback; + +-- another join removal bug: this is not optimizable, either +begin; + +create temp table innertab (id int8 primary key, dat1 int8); +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; + +rollback; + +-- another join removal bug: we must clean up correctly when removing a PHV +begin; + +create temp table uniquetbl (f1 text unique); + +explain (costs off) +select t1.* from + uniquetbl as t1 + left join (select *, '***'::text as d1 from uniquetbl) t2 + on t1.f1 = t2.f1 + left join uniquetbl t3 + on t2.d1 = t3.f1; + +explain (costs off) +select t0.* +from + text_tbl t0 + left join + (select case t1.ten when 0 then 'doh!'::text else null::text end as case1, + t1.stringu2 + from tenk1 t1 + join int4_tbl i4 ON i4.f1 = t1.unique2 + left join uniquetbl u1 ON u1.f1 = t1.string4) ss + on t0.f1 = ss.case1 +where ss.stringu2 !~* ss.case1; + +select t0.* +from + text_tbl t0 + left join + (select case t1.ten when 0 then 'doh!'::text else null::text end as case1, + t1.stringu2 + from tenk1 t1 + join int4_tbl i4 ON i4.f1 = t1.unique2 + left join uniquetbl u1 ON u1.f1 = t1.string4) ss + on t0.f1 = ss.case1 +where ss.stringu2 !~* ss.case1; + +rollback; + +-- bug #8444: we've historically allowed duplicate aliases within aliased JOINs + +select * from + int8_tbl x join (int4_tbl x cross join int4_tbl y) j on q1 = f1; -- error +select * from + int8_tbl x join (int4_tbl x cross join int4_tbl y) j on q1 = y.f1; -- error +select * from + int8_tbl x join (int4_tbl x cross join int4_tbl y(ff)) j on q1 = f1; -- ok + +-- +-- Test hints given on incorrect column references are useful +-- + +select t1.uunique1 from + tenk1 t1 join tenk2 t2 on t1.two = t2.two; -- error, prefer "t1" suggestion +select t2.uunique1 from + tenk1 t1 join tenk2 t2 on t1.two = t2.two; -- error, prefer "t2" suggestion +select uunique1 from + tenk1 t1 join tenk2 t2 on t1.two = t2.two; -- error, suggest both at once + +-- +-- Take care to reference the correct RTE +-- + +select atts.relid::regclass, s.* from pg_stats s join + pg_attribute a on s.attname = a.attname and s.tablename = + a.attrelid::regclass::text join (select unnest(indkey) attnum, + indexrelid from pg_index i) atts on atts.attnum = a.attnum where + schemaname != 'pg_catalog'; + +-- +-- Test LATERAL +-- + +select unique2, x.* +from tenk1 a, lateral (select * from int4_tbl b where f1 = a.unique1) x; +explain (costs off) + select unique2, x.* + from tenk1 a, lateral (select * from int4_tbl b where f1 = a.unique1) x; +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; +explain (costs off) + select unique2, x.* + from int4_tbl x cross join lateral (select unique2 from tenk1 where f1 = unique1) ss; +select unique2, x.* +from int4_tbl x left join lateral (select unique1, unique2 from tenk1 where f1 = unique1) ss on true; +explain (costs off) + select unique2, x.* + from int4_tbl x left join lateral (select unique1, unique2 from tenk1 where f1 = unique1) ss on true; + +-- check scoping of lateral versus parent references +-- the first of these should return int8_tbl.q2, the second int8_tbl.q1 +select *, (select r from (select q1 as q2) x, (select q2 as r) y) from int8_tbl; +select *, (select r from (select q1 as q2) x, lateral (select q2 as r) y) from int8_tbl; + +-- lateral with function in FROM +select count(*) from tenk1 a, lateral generate_series(1,two) g; +explain (costs off) + select count(*) from tenk1 a, lateral generate_series(1,two) g; +explain (costs off) + select count(*) from tenk1 a cross join lateral generate_series(1,two) g; +-- don't need the explicit LATERAL keyword for functions +explain (costs off) + select count(*) from tenk1 a, generate_series(1,two) g; + +-- 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; +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; + +-- lateral with VALUES +explain (costs off) + select count(*) from tenk1 a, + tenk1 b join lateral (values(a.unique1)) ss(x) on b.unique2 = ss.x; +select count(*) from tenk1 a, + tenk1 b join lateral (values(a.unique1)) ss(x) on b.unique2 = ss.x; + +-- lateral with VALUES, no flattening possible +explain (costs off) + select count(*) from tenk1 a, + tenk1 b join lateral (values(a.unique1),(-1)) ss(x) on b.unique2 = ss.x; +select count(*) from tenk1 a, + tenk1 b join lateral (values(a.unique1),(-1)) ss(x) on b.unique2 = ss.x; + +-- lateral injecting a strange outer join condition +explain (costs off) + select * from int8_tbl a, + int8_tbl x left join lateral (select a.q1 from int4_tbl y) ss(z) + on x.q2 = ss.z + order by a.q1, a.q2, x.q1, x.q2, ss.z; +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 + order by a.q1, a.q2, x.q1, x.q2, ss.z; + +-- lateral reference to a join alias variable +select * from (select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1, + lateral (select x) ss2(y); +select * from (select f1 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1, + lateral (values(x)) ss2(y); +select * from ((select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1) j, + lateral (select x) ss2(y); + +-- lateral references requiring pullup +select * from (values(1)) x(lb), + lateral generate_series(lb,4) x4; +select * from (select f1/1000000000 from int4_tbl) x(lb), + lateral generate_series(lb,4) x4; +select * from (values(1)) x(lb), + lateral (values(lb)) y(lbcopy); +select * from (values(1)) x(lb), + lateral (select lb from int4_tbl) y(lbcopy); +select * from + int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1, + lateral (values(x.q1,y.q1,y.q2)) v(xq1,yq1,yq2); +select * from + int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1, + lateral (select x.q1,y.q1,y.q2) v(xq1,yq1,yq2); +select x.* from + int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1, + lateral (select x.q1,y.q1,y.q2) v(xq1,yq1,yq2); +select v.* from + (int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1) + left join int4_tbl z on z.f1 = x.q2, + lateral (select x.q1,y.q1 union all select x.q2,y.q2) v(vx,vy); +select v.* from + (int8_tbl x left join (select q1,(select coalesce(q2,0)) q2 from int8_tbl) y on x.q2 = y.q1) + left join int4_tbl z on z.f1 = x.q2, + lateral (select x.q1,y.q1 union all select x.q2,y.q2) v(vx,vy); +select v.* from + (int8_tbl x left join (select q1,(select coalesce(q2,0)) q2 from int8_tbl) y on x.q2 = y.q1) + left join int4_tbl z on z.f1 = x.q2, + lateral (select x.q1,y.q1 from onerow union all select x.q2,y.q2 from onerow) v(vx,vy); + +explain (verbose, costs off) +select * from + int8_tbl a left join + lateral (select *, a.q2 as x from int8_tbl b) ss on a.q2 = ss.q1; +select * from + int8_tbl a left join + lateral (select *, a.q2 as x from int8_tbl b) ss on a.q2 = ss.q1; +explain (verbose, costs off) +select * from + int8_tbl a left join + lateral (select *, coalesce(a.q2, 42) as x from int8_tbl b) ss on a.q2 = ss.q1; +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; + +-- lateral can result in join conditions appearing below their +-- real semantic level +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; +select * from int4_tbl i left join + lateral (select * from int2_tbl j where i.f1 = j.f1) k on true; +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; +select * from int4_tbl i left join + lateral (select coalesce(i) from int2_tbl j where i.f1 = j.f1) k on true; +explain (verbose, costs off) +select * from int4_tbl a, + lateral ( + select * from int4_tbl b left join int8_tbl c on (b.f1 = q1 and a.f1 = q2) + ) ss; +select * from int4_tbl a, + lateral ( + select * from int4_tbl b left join int8_tbl c on (b.f1 = q1 and a.f1 = q2) + ) ss; + +-- lateral reference in a PlaceHolderVar evaluated at join level +explain (verbose, costs off) +select * from + int8_tbl a left join 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; +select * from + int8_tbl a left join 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; + +-- case requiring nested PlaceHolderVars +explain (verbose, costs off) +select * from + int8_tbl c left join ( + int8_tbl a left join (select q1, coalesce(q2,42) as x from int8_tbl b) ss1 + on a.q2 = ss1.q1 + cross join + 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; + +-- case that breaks the old ph_may_need optimization +explain (verbose, costs off) +select c.*,a.*,ss1.q1,ss2.q1,ss3.* from + int8_tbl c left join ( + int8_tbl a left join + (select q1, coalesce(q2,f1) as x from int8_tbl b, int4_tbl b2 + where q1 < f1) ss1 + on a.q2 = ss1.q1 + cross join + 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; + +-- check processing of postponed quals (bug #9041) +explain (verbose, costs off) +select * from + (select 1 as x offset 0) x cross join (select 2 as y offset 0) y + left join lateral ( + select * from (select 3 as z offset 0) z where z.z = x.x + ) zz on zz.z = y.y; + +-- check dummy rels with lateral references (bug #15694) +explain (verbose, costs off) +select * from int8_tbl i8 left join lateral + (select *, i8.q2 from int4_tbl where false) ss on true; +explain (verbose, costs off) +select * from int8_tbl i8 left join lateral + (select *, i8.q2 from int4_tbl i1, int4_tbl i2 where false) ss on true; + +-- check handling of nested appendrels inside LATERAL +select * from + ((select 2 as v) union all (select 3 as v)) as q1 + cross join lateral + ((select * from + ((select 4 as v) union all (select 5 as v)) as q3) + union all + (select q1.v) + ) as q2; + +-- check we don't try to do a unique-ified semijoin with LATERAL +explain (verbose, costs off) +select * from + (values (0,9998), (1,1000)) v(id,x), + lateral (select f1 from int4_tbl + where f1 = any (select unique1 from tenk1 + where unique2 = v.x offset 0)) ss; +select * from + (values (0,9998), (1,1000)) v(id,x), + lateral (select f1 from int4_tbl + where f1 = any (select unique1 from tenk1 + where unique2 = v.x offset 0)) ss; + +-- check proper extParam/allParam handling (this isn't exactly a LATERAL issue, +-- but we can make the test case much more compact with LATERAL) +explain (verbose, costs off) +select * from (values (0), (1)) v(id), +lateral (select * from int8_tbl t1, + lateral (select * from + (select * from int8_tbl t2 + where q1 = any (select q2 from int8_tbl t3 + where q2 = (select greatest(t1.q1,t2.q2)) + and (select v.id=0)) offset 0) ss2) ss + where t1.q1 = ss.q2) ss0; + +select * from (values (0), (1)) v(id), +lateral (select * from int8_tbl t1, + lateral (select * from + (select * from int8_tbl t2 + where q1 = any (select q2 from int8_tbl t3 + where q2 = (select greatest(t1.q1,t2.q2)) + and (select v.id=0)) offset 0) ss2) ss + where t1.q1 = ss.q2) ss0; + +-- test some error cases where LATERAL should have been used but wasn't +select f1,g from int4_tbl a, (select f1 as g) ss; +select f1,g from int4_tbl a, (select a.f1 as g) ss; +select f1,g from int4_tbl a cross join (select f1 as g) ss; +select f1,g from int4_tbl a cross join (select a.f1 as g) ss; +-- SQL:2008 says the left table is in scope but illegal to access here +select f1,g from int4_tbl a right join lateral generate_series(0, a.f1) g on true; +select f1,g from int4_tbl a full join lateral generate_series(0, a.f1) g on true; +-- check we complain about ambiguous table references +select * from + int8_tbl x cross join (int4_tbl x cross join lateral (select x.f1) ss); +-- LATERAL can be used to put an aggregate into the FROM clause of its query +select 1 from tenk1 a, lateral (select max(a.unique1) from int4_tbl b) ss; + +-- check behavior of LATERAL in UPDATE/DELETE + +create temp table xx1 as select f1 as x1, -f1 as x2 from int4_tbl; + +-- error, can't do this: +update xx1 set x2 = f1 from (select * from int4_tbl where f1 = x1) ss; +update xx1 set x2 = f1 from (select * from int4_tbl where f1 = xx1.x1) ss; +-- can't do it even with LATERAL: +update xx1 set x2 = f1 from lateral (select * from int4_tbl where f1 = x1) ss; +-- we might in future allow something like this, but for now it's an error: +update xx1 set x2 = f1 from xx1, lateral (select * from int4_tbl where f1 = x1) ss; + +-- also errors: +delete from xx1 using (select * from int4_tbl where f1 = x1) ss; +delete from xx1 using (select * from int4_tbl where f1 = xx1.x1) ss; +delete from xx1 using lateral (select * from int4_tbl where f1 = x1) ss; + +-- +-- test LATERAL reference propagation down a multi-level inheritance hierarchy +-- produced for a multi-level partitioned table hierarchy. +-- +create table join_pt1 (a int, b int, c varchar) partition by range(a); +create table join_pt1p1 partition of join_pt1 for values from (0) to (100) partition by range(b); +create table join_pt1p2 partition of join_pt1 for values from (100) to (200); +create table join_pt1p1p1 partition of join_pt1p1 for values from (0) to (100); +insert into join_pt1 values (1, 1, 'x'), (101, 101, 'y'); +create table join_ut1 (a int, b int, c varchar); +insert into join_ut1 values (101, 101, 'y'), (2, 2, 'z'); +explain (verbose, costs off) +select t1.b, ss.phv from join_ut1 t1 left join lateral + (select t2.a as t2a, t3.a t3a, least(t1.a, t2.a, t3.a) phv + from join_pt1 t2 join join_ut1 t3 on t2.a = t3.b) ss + on t1.a = ss.t2a order by t1.a; +select t1.b, ss.phv from join_ut1 t1 left join lateral + (select t2.a as t2a, t3.a t3a, least(t1.a, t2.a, t3.a) phv + from join_pt1 t2 join join_ut1 t3 on t2.a = t3.b) ss + on t1.a = ss.t2a order by t1.a; + +drop table join_pt1; +drop table join_ut1; +-- +-- test that foreign key join estimation performs sanely for outer joins +-- + +begin; + +create table fkest (a int, b int, c int unique, primary key(a,b)); +create table fkest1 (a int, b int, primary key(a,b)); + +insert into fkest select x/10, x%10, x from generate_series(1,1000) x; +insert into fkest1 select x/10, x%10 from generate_series(1,1000) x; + +alter table fkest1 + add constraint fkest1_a_b_fkey foreign key (a,b) references fkest; + +analyze fkest; +analyze fkest1; + +explain (costs off) +select * +from fkest f + left join fkest1 f1 on f.a = f1.a and f.b = f1.b + left join fkest1 f2 on f.a = f2.a and f.b = f2.b + left join fkest1 f3 on f.a = f3.a and f.b = f3.b +where f.c = 1; + +rollback; + +-- +-- test planner's ability to mark joins as unique +-- + +create table j1 (id int primary key); +create table j2 (id int primary key); +create table j3 (id int); + +insert into j1 values(1),(2),(3); +insert into j2 values(1),(2),(3); +insert into j3 values(1),(1); + +analyze j1; +analyze j2; +analyze j3; + +-- ensure join is properly marked as unique +explain (verbose, costs off) +select * from j1 inner join j2 on j1.id = j2.id; + +-- ensure join is not unique when not an equi-join +explain (verbose, costs off) +select * from j1 inner join j2 on j1.id > j2.id; + +-- ensure non-unique rel is not chosen as inner +explain (verbose, costs off) +select * from j1 inner join j3 on j1.id = j3.id; + +-- ensure left join is marked as unique +explain (verbose, costs off) +select * from j1 left join j2 on j1.id = j2.id; + +-- ensure right join is marked as unique +explain (verbose, costs off) +select * from j1 right join j2 on j1.id = j2.id; + +-- ensure full join is marked as unique +explain (verbose, costs off) +select * from j1 full join j2 on j1.id = j2.id; + +-- a clauseless (cross) join can't be unique +explain (verbose, costs off) +select * from j1 cross join j2; + +-- ensure a natural join is marked as unique +explain (verbose, costs off) +select * from j1 natural join j2; + +-- ensure a distinct clause allows the inner to become unique +explain (verbose, costs off) +select * from j1 +inner join (select distinct id from j3) j3 on j1.id = j3.id; + +-- ensure group by clause allows the inner to become unique +explain (verbose, costs off) +select * from j1 +inner join (select id from j3 group by id) j3 on j1.id = j3.id; + +drop table j1; +drop table j2; +drop table j3; + +-- test more complex permutations of unique joins + +create table j1 (id1 int, id2 int, primary key(id1,id2)); +create table j2 (id1 int, id2 int, primary key(id1,id2)); +create table j3 (id1 int, id2 int, primary key(id1,id2)); + +insert into j1 values(1,1),(1,2); +insert into j2 values(1,1); +insert into j3 values(1,1); + +analyze j1; +analyze j2; +analyze j3; + +-- ensure there's no unique join when not all columns which are part of the +-- unique index are seen in the join clause +explain (verbose, costs off) +select * from j1 +inner join j2 on j1.id1 = j2.id1; + +-- ensure proper unique detection with multiple join quals +explain (verbose, costs off) +select * from j1 +inner join j2 on j1.id1 = j2.id1 and j1.id2 = j2.id2; + +-- ensure we don't detect the join to be unique when quals are not part of the +-- join condition +explain (verbose, costs off) +select * from j1 +inner join j2 on j1.id1 = j2.id1 where j1.id2 = 1; + +-- as above, but for left joins. +explain (verbose, costs off) +select * from j1 +left join j2 on j1.id1 = j2.id1 where j1.id2 = 1; + +-- validate logic in merge joins which skips mark and restore. +-- it should only do this if all quals which were used to detect the unique +-- are present as join quals, and not plain quals. +set enable_nestloop to 0; +set enable_hashjoin to 0; +set enable_sort to 0; + +-- create indexes that will be preferred over the PKs to perform the join +create index j1_id1_idx on j1 (id1) where id1 % 1000 = 1; +create index j2_id1_idx on j2 (id1) where id1 % 1000 = 1; + +-- need an additional row in j2, if we want j2_id1_idx to be preferred +insert into j2 values(1,2); +analyze j2; + +explain (costs off) select * from j1 +inner join j2 on j1.id1 = j2.id1 and j1.id2 = j2.id2 +where j1.id1 % 1000 = 1 and j2.id1 % 1000 = 1; + +select * from j1 +inner join j2 on j1.id1 = j2.id1 and j1.id2 = j2.id2 +where j1.id1 % 1000 = 1 and j2.id1 % 1000 = 1; + +reset enable_nestloop; +reset enable_hashjoin; +reset enable_sort; + +drop table j1; +drop table j2; +drop table j3; + +-- check that semijoin inner is not seen as unique for a portion of the outerrel +explain (verbose, costs off) +select t1.unique1, t2.hundred +from onek t1, tenk1 t2 +where exists (select 1 from tenk1 t3 + where t3.thousand = t1.unique1 and t3.tenthous = t2.hundred) + and t1.unique1 < 1; + +-- ... unless it actually is unique +create table j3 as select unique1, tenthous from onek; +vacuum analyze j3; +create unique index on j3(unique1, tenthous); + +explain (verbose, costs off) +select t1.unique1, t2.hundred +from onek t1, tenk1 t2 +where exists (select 1 from j3 + where j3.unique1 = t1.unique1 and j3.tenthous = t2.hundred) + and t1.unique1 < 1; + +drop table j3; From 3942d87a4bc75cd84bfccb48ab289fc280dee135 Mon Sep 17 00:00:00 2001 From: Yuming Wang Date: Sun, 14 Jul 2019 15:08:11 +0800 Subject: [PATCH 2/5] Add result --- .../resources/sql-tests/inputs/pgSQL/join.sql | 2156 +++++----- .../sql-tests/results/pgSQL/join.sql.out | 3488 +++++++++++++++++ 2 files changed, 4569 insertions(+), 1075 deletions(-) create mode 100644 sql/core/src/test/resources/sql-tests/results/pgSQL/join.sql.out diff --git a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql index 13cfa733a5cd6..38f277c864688 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql @@ -6,17 +6,36 @@ -- Test JOIN clauses -- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/join.sql -- +create or replace temporary view INT4_TBL as select * from + (values (0), (123456), (-123456), (2147483647), (-2147483647)) + as v(f1); +create or replace temporary view INT8_TBL as select * from + (values + (123, 456), + (123, 4567890123456789), + (4567890123456789, 123), + (4567890123456789, 4567890123456789), + (4567890123456789, -4567890123456789)) + as v(q1, q2); +create or replace temporary view FLOAT8_TBL as select * from + (values (0.0), (1004.30), (-34.84), + (cast('1.2345678901234e+200' as double)), (cast('1.2345678901234e-200' as double))) + as v(f1); +create or replace temporary view TEXT_TBL as select * from + (values ('doh!'), ('hi de ho neighbor')) + as v(f1); +create or replace temporary view tenk2 as select * from tenk1; CREATE TABLE J1_TBL ( i integer, j integer, - t text -); + t string +) USING parquet; CREATE TABLE J2_TBL ( i integer, k integer -); +) USING parquet; INSERT INTO J1_TBL VALUES (1, 4, 'one'); @@ -41,10 +60,11 @@ INSERT INTO J2_TBL VALUES (0, NULL); INSERT INTO J2_TBL VALUES (NULL, NULL); INSERT INTO J2_TBL VALUES (NULL, 0); +-- [SPARK-20856] Do not need onerow because it only used for test statement using nested joins -- useful in some tests below -create temp table onerow(); -insert into onerow default values; -analyze onerow; +-- create temp table onerow(); +-- insert into onerow default values; +-- analyze onerow; -- @@ -53,24 +73,25 @@ analyze onerow; -- before diving into more complex join syntax. -- -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL AS tx; -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL tx; -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL AS t1 (a, b, c); -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL t1 (a, b, c); -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL t1 (a, b, c), J2_TBL t2 (d, e); -SELECT '' AS "xxx", t1.a, t2.e - FROM J1_TBL t1 (a, b, c), J2_TBL t2 (d, e) - WHERE t1.a = t2.d; +-- [SPARK-28377] Fully support correlation names in the FROM clause +-- SELECT '' AS "xxx", t1.a, t2.e +-- FROM J1_TBL t1 (a, b, c), J2_TBL t2 (d, e) +-- WHERE t1.a = t2.d; -- @@ -79,26 +100,27 @@ SELECT '' AS "xxx", t1.a, t2.e -- which degenerate into a standard unqualified inner join. -- -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL CROSS JOIN J2_TBL; -- ambiguous column -SELECT '' AS "xxx", i, k, t +SELECT '' AS `xxx`, i, k, t FROM J1_TBL CROSS JOIN J2_TBL; -- resolve previous ambiguity by specifying the table name -SELECT '' AS "xxx", t1.i, k, t +SELECT '' AS `xxx`, t1.i, k, t FROM J1_TBL t1 CROSS JOIN J2_TBL t2; -SELECT '' AS "xxx", ii, tt, kk +SELECT '' AS `xxx`, ii, tt, kk FROM (J1_TBL CROSS JOIN J2_TBL) AS tx (ii, jj, tt, ii2, kk); -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); +-- [SPARK-28377] Fully support correlation names in the FROM clause +-- 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); -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL CROSS JOIN J2_TBL a CROSS JOIN J2_TBL b; @@ -115,20 +137,21 @@ SELECT '' AS "xxx", * -- -- Inner equi-join on specified column -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL INNER JOIN J2_TBL USING (i); -- Same as above, slightly different syntax -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL JOIN J2_TBL USING (i); -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL t1 (a, b, c) JOIN J2_TBL t2 (a, d) USING (a) ORDER BY a, d; -SELECT '' AS "xxx", * - FROM J1_TBL t1 (a, b, c) JOIN J2_TBL t2 (a, b) USING (b) - ORDER BY b, t1.a; +-- [SPARK-28377] Fully support correlation names in the FROM clause +-- SELECT '' AS `xxx`, * +-- FROM J1_TBL t1 (a, b, c) JOIN J2_TBL t2 (a, b) USING (b) +-- ORDER BY b, t1.a; -- @@ -136,29 +159,30 @@ SELECT '' AS "xxx", * -- Inner equi-join on all columns with the same name -- -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL NATURAL JOIN J2_TBL; -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL t1 (a, b, c) NATURAL JOIN J2_TBL t2 (a, d); -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL t1 (a, b, c) NATURAL JOIN J2_TBL t2 (d, a); +-- [SPARK-28377] Fully support correlation names in the FROM clause -- 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); +-- SELECT '' AS `xxx`, * +-- FROM J1_TBL t1 (a, b) NATURAL JOIN J2_TBL t2 (a); -- -- Inner joins (equi-joins) -- -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL JOIN J2_TBL ON (J1_TBL.i = J2_TBL.i); -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL JOIN J2_TBL ON (J1_TBL.i = J2_TBL.k); @@ -166,7 +190,7 @@ SELECT '' AS "xxx", * -- Non-equi-joins -- -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL JOIN J2_TBL ON (J1_TBL.i <= J2_TBL.k); @@ -175,42 +199,42 @@ SELECT '' AS "xxx", * -- Note that OUTER is a noise word -- -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL LEFT OUTER JOIN J2_TBL USING (i) ORDER BY i, k, t; -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL LEFT JOIN J2_TBL USING (i) ORDER BY i, k, t; -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL RIGHT OUTER JOIN J2_TBL USING (i); -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL RIGHT JOIN J2_TBL USING (i); -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL FULL OUTER JOIN J2_TBL USING (i) ORDER BY i, k, t; -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL FULL JOIN J2_TBL USING (i) ORDER BY i, k, t; -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL LEFT JOIN J2_TBL USING (i) WHERE (k = 1); -SELECT '' AS "xxx", * +SELECT '' AS `xxx`, * FROM J1_TBL LEFT JOIN J2_TBL USING (i) WHERE (i = 1); -- -- semijoin selectivity for <> -- -explain (costs off) -select * from int4_tbl i4, tenk1 a -where exists(select * from tenk1 b - where a.twothousand = b.twothousand and a.fivethous <> b.fivethous) - and i4.f1 = a.tenthous; +-- explain (costs off) +-- select * from int4_tbl i4, tenk1 a +-- where exists(select * from tenk1 b +-- where a.twothousand = b.twothousand and a.fivethous <> b.fivethous) +-- and i4.f1 = a.tenthous; -- @@ -221,9 +245,9 @@ where exists(select * from tenk1 b -- Multiway full join -- -CREATE TABLE t1 (name TEXT, n INTEGER); -CREATE TABLE t2 (name TEXT, n INTEGER); -CREATE TABLE t3 (name TEXT, n INTEGER); +CREATE TABLE t1 (name STRING, n INTEGER) USING parquet; +CREATE TABLE t2 (name STRING, n INTEGER) USING parquet; +CREATE TABLE t3 (name STRING, n INTEGER) USING parquet; INSERT INTO t1 VALUES ( 'bb', 11 ); INSERT INTO t2 VALUES ( 'bb', 12 ); @@ -317,18 +341,13 @@ ON (s1_n = s2_n); -- 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 or replace temporary view x as select * from + (values (1,11), (2,22), (3,null), (4,44), (5,null)) + as v(x1, x2); -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); +create or replace temporary view y as select * from + (values (1,111), (2,222), (3,333), (4,null)) + as v(y1, y2); select * from x; select * from y; @@ -370,34 +389,35 @@ select count(*) from tenk1 x where x.unique1 in (select aa.f1 from int4_tbl aa,float8_tbl bb where aa.f1=bb.f1); -- try that with GEQO too -begin; -set geqo = on; -set geqo_threshold = 2; +-- 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); -rollback; +-- rollback; +-- Skip this test because we do no know how to create table b -- -- regression test: be sure we cope with proven-dummy append rels -- -explain (costs off) -select aa, bb, unique1, unique1 - from tenk1 right join b on aa = unique1 - where bb < bb and bb is null; +-- explain (costs off) +-- select aa, bb, unique1, unique1 +-- from tenk1 right join b on aa = unique1 +-- where bb < bb and bb is null; -select aa, bb, unique1, unique1 - from tenk1 right join b on aa = unique1 - where bb < bb and bb is null; +-- select aa, bb, unique1, unique1 +-- from tenk1 right join b on aa = unique1 +-- where bb < bb and bb is null; -- -- regression test: check handling of empty-FROM subquery underneath outer join -- -explain (costs off) -select * from int8_tbl i1 left join (int8_tbl i2 join - (select 123 as x) ss on i2.q1 = x) on i1.q2 = i2.q2 -order by 1, 2; +-- explain (costs off) +-- select * from int8_tbl i1 left join (int8_tbl i2 join +-- (select 123 as x) ss on i2.q1 = x) on i1.q2 = i2.q2 +-- order by 1, 2; select * from int8_tbl i1 left join (int8_tbl i2 join (select 123 as x) ss on i2.q1 = x) on i1.q2 = i2.q2 @@ -421,12 +441,12 @@ where t4.thousand = t5.unique1 and ss.x1 = t4.tenthous and ss.x2 = t5.stringu1; -- regression test: check a case where we formerly missed including an EC -- enforcement clause because it was expected to be handled at scan level -- -explain (costs off) -select a.f1, b.f1, t.thousand, t.tenthous from - tenk1 t, - (select sum(f1)+1 as f1 from int4_tbl i4a) a, - (select sum(f1) as f1 from int4_tbl i4b) b -where b.f1 = t.thousand and a.f1 = b.f1 and (a.f1+b.f1+999) = t.tenthous; +-- explain (costs off) +-- select a.f1, b.f1, t.thousand, t.tenthous from +-- tenk1 t, +-- (select sum(f1)+1 as f1 from int4_tbl i4a) a, +-- (select sum(f1) as f1 from int4_tbl i4b) b +-- where b.f1 = t.thousand and a.f1 = b.f1 and (a.f1+b.f1+999) = t.tenthous; select a.f1, b.f1, t.thousand, t.tenthous from tenk1 t, @@ -438,11 +458,11 @@ where b.f1 = t.thousand and a.f1 = b.f1 and (a.f1+b.f1+999) = t.tenthous; -- check a case where we formerly got confused by conflicting sort orders -- in redundant merge join path keys -- -explain (costs off) -select * from - j1_tbl full join - (select * from j2_tbl order by j2_tbl.i desc, j2_tbl.k asc) j2_tbl - on j1_tbl.i = j2_tbl.i and j1_tbl.i = j2_tbl.k; +-- explain (costs off) +-- select * from +-- j1_tbl full join +-- (select * from j2_tbl order by j2_tbl.i desc, j2_tbl.k asc) j2_tbl +-- on j1_tbl.i = j2_tbl.i and j1_tbl.i = j2_tbl.k; select * from j1_tbl full join @@ -452,12 +472,12 @@ select * from -- -- a different check for handling of redundant sort keys in merge joins -- -explain (costs off) -select count(*) from - (select * from tenk1 x order by x.thousand, x.twothousand, x.fivethous) x - left join - (select * from tenk1 y order by y.unique2) y - on x.thousand = y.unique2 and x.twothousand = y.hundred and x.fivethous = y.unique2; +-- explain (costs off) +-- select count(*) from +-- (select * from tenk1 x order by x.thousand, x.twothousand, x.fivethous) x +-- left join +-- (select * from tenk1 y order by y.unique2) y +-- on x.thousand = y.unique2 and x.twothousand = y.hundred and x.fivethous = y.unique2; select count(*) from (select * from tenk1 x order by x.thousand, x.twothousand, x.fivethous) x @@ -480,53 +500,53 @@ 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; -DELETE FROM t3 USING t1 JOIN t2 USING (a) WHERE t3.x > t1.a; -SELECT * FROM t3; -DELETE FROM t3 USING t3 t3_other WHERE t3.x = t3_other.x AND t3.y = t3_other.y; -SELECT * FROM t3; +-- 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; +-- DELETE FROM t3 USING t1 JOIN t2 USING (a) WHERE t3.x > t1.a; +-- SELECT * FROM t3; +-- DELETE FROM t3 USING t3 t3_other WHERE t3.x = t3_other.x AND t3.y = t3_other.y; +-- SELECT * FROM t3; -- Test join against inheritance tree -create temp table t2a () inherits (t2); +-- create temp table t2a () inherits (t2); -insert into t2a values (200, 2001); +-- insert into t2a values (200, 2001); -select * from t1 left join t2 on (t1.a = t2.a); +-- select * from t1 left join t2 on (t1.a = t2.a); -- Test matching of column name with wrong alias -select t1.x from t1 join t3 on (t1.a = t3.x); +-- select t1.x from t1 join t3 on (t1.a = t3.x); -- -- 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 or replace temporary view tt1 as select * from + (values (1, 11), (2, NULL)) + as v(tt1_id, joincol); -CREATE TEMP TABLE tt2 ( tt2_id int4, joincol int4 ); -INSERT INTO tt2 VALUES (21, 11); -INSERT INTO tt2 VALUES (22, 11); +create or replace temporary view tt2 as select * from + (values (21, 11), (22, 11)) + as v(tt2_id, joincol); -set enable_hashjoin to off; -set enable_nestloop to off; +-- set enable_hashjoin to off; +-- set enable_nestloop to off; -- these should give the same results @@ -534,37 +554,39 @@ select tt1.*, tt2.* from tt1 left join tt2 on tt1.joincol = tt2.joincol; select tt1.*, tt2.* from tt2 right join tt1 on tt1.joincol = tt2.joincol; -reset enable_hashjoin; -reset enable_nestloop; +-- reset enable_hashjoin; +-- reset enable_nestloop; -- -- regression test for bug #13908 (hash join with skew tuples & nbatch increase) -- -set work_mem to '64kB'; -set enable_mergejoin to off; +-- set work_mem to '64kB'; +-- set enable_mergejoin to off; -explain (costs off) -select count(*) from tenk1 a, tenk1 b - where a.hundred = b.thousand and (b.fivethous % 10) < 10; +-- explain (costs off) +-- select count(*) from tenk1 a, tenk1 b +-- where a.hundred = b.thousand and (b.fivethous % 10) < 10; select count(*) from tenk1 a, tenk1 b where a.hundred = b.thousand and (b.fivethous % 10) < 10; -reset work_mem; -reset enable_mergejoin; +-- reset work_mem; +-- reset enable_mergejoin; -- -- 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; +drop table if exists tt3; +create table tt3(f1 int, f2 string) using parquet; +insert into tt3 select x.id, repeat('xyzzy', 100) from range(1,10001) x; +-- create index tt3i on tt3(f1); +-- analyze tt3; -create temp table tt4(f1 int); +drop table if exists tt4; +create table tt4(f1 int) using parquet; insert into tt4 values (0),(1),(9999); -analyze tt4; +-- analyze tt4; SELECT a.f1 FROM tt4 a @@ -579,32 +601,29 @@ WHERE d.f1 IS NULL; -- regression test for proper handling of outer joins within antijoins -- -create temp table tt4x(c1 int, c2 int, c3 int); +-- create temp table tt4x(c1 int, c2 int, c3 int); -explain (costs off) -select * from tt4x t1 -where not exists ( - select 1 from tt4x t2 - left join tt4x t3 on t2.c3 = t3.c1 - left join ( select t5.c1 as c1 - from tt4x t4 left join tt4x t5 on t4.c2 = t5.c1 - ) a1 on t3.c2 = a1.c1 - where t1.c1 = t2.c2 -); +-- explain (costs off) +-- select * from tt4x t1 +-- where not exists ( +-- select 1 from tt4x t2 +-- left join tt4x t3 on t2.c3 = t3.c1 +-- left join ( select t5.c1 as c1 +-- from tt4x t4 left join tt4x t5 on t4.c2 = t5.c1 +-- ) a1 on t3.c2 = a1.c1 +-- where t1.c1 = t2.c2 +-- ); -- -- 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); +create or replace temporary view tt5 as select * from + (values (1, 10), (1, 11)) + as v(f1, f2); +create or replace temporary view tt6 as select * from + (values (1, 9), (1, 2), (2, 9)) + as v(f1, f2); select * from tt5,tt6 where tt5.f1 = tt6.f1 and tt5.f1 = tt5.f2 - tt6.f2; @@ -612,16 +631,12 @@ select * from tt5,tt6 where tt5.f1 = tt6.f1 and tt5.f1 = tt5.f2 - tt6.f2; -- 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); +create or replace temporary view xx as select * from + (values (1), (2), (3)) + as v(pkxx); +create or replace temporary view yy as select * from + (values (101, 1), (201, 2), (301, NULL)) + as v(pkyy, pkxx); 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 @@ -635,18 +650,20 @@ from yy -- (as seen in early 8.2.x releases) -- -create temp table zt1 (f1 int primary key); -create temp table zt2 (f2 int primary key); -create temp table zt3 (f3 int primary key); -insert into zt1 values(53); -insert into zt2 values(53); +create or replace temporary view zt1 as select * from + (values (53)) + as v(f1); +create or replace temporary view zt2 as select * from + (values (53)) + as v(f2); +create or replace temporary view zt3(f3 int) using parquet; select * from zt2 left join zt3 on (f2 = f3) left join zt1 on (f3 = f1) where f2 = 53; -create temp view zv1 as select *,'dummy'::text AS junk from zt1; +create temp view zv1 as select *,'dummy' AS junk from zt1; select * from zt2 left join zt3 on (f2 = f3) @@ -666,49 +683,49 @@ where a.unique1 = 42 and -- -- 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)); -execute foo(true); -execute foo(false); +-- 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)); +-- execute foo(true); +-- execute foo(false); -- -- test for sane behavior with noncanonical merge clauses, per bug #4926 -- -begin; +-- begin; -set enable_mergejoin = 1; -set enable_hashjoin = 0; -set enable_nestloop = 0; +-- 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); +create or replace temporary view a (i integer) using parquet; +create or replace temporary view b (x integer, y integer) using parquet; select * from a left join b on i = x and i = y and x = i; -rollback; +-- rollback; -- -- test handling of merge clauses using record_ops -- -begin; +-- begin; -create type mycomptype as (id int, v bigint); +-- create type mycomptype as (id int, v bigint); -create temp table tidv (idv mycomptype); -create index on tidv (idv); +-- create temp table tidv (idv mycomptype); +-- create index on tidv (idv); -explain (costs off) -select a.idv, b.idv from tidv a, tidv b where a.idv = b.idv; +-- explain (costs off) +-- select a.idv, b.idv from tidv a, tidv b where a.idv = b.idv; -set enable_mergejoin = 0; +-- set enable_mergejoin = 0; -explain (costs off) -select a.idv, b.idv from tidv a, tidv b where a.idv = b.idv; +-- explain (costs off) +-- select a.idv, b.idv from tidv a, tidv b where a.idv = b.idv; -rollback; +-- rollback; -- -- test NULL behavior of whole-row Vars, per bug #5025 @@ -721,9 +738,10 @@ 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; -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; +-- [SPARK-28330] Enhance query limit +-- 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; select t1.q2, count(t2.*) from int8_tbl t1 left join @@ -734,30 +752,16 @@ group by t1.q2 order by 1; -- -- test incorrect failure to NULL pulled-up subexpressions -- -begin; - -create temp table a ( - code char not null, - constraint a_pk primary key (code) -); -create temp table b ( - a char not null, - num integer not null, - constraint b_pk primary key (a, num) -); -create temp table c ( - name char not null, - a char, - constraint c_pk primary key (name) -); - -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); +-- begin; +create or replace temporary view a as select * from + (values ('p'), ('q')) + as v(code); +create or replace temporary view b as select * from + (values ('p', 1), ('p', 2)) + as v(a, num); +create or replace temporary view c as select * from + (values ('A', 'p'), ('B', 'q'), ('C', null)) + as v(name, a); select c.name, ss.code, ss.b_cnt, ss.const from c left join @@ -769,7 +773,7 @@ from c left join on (c.a = ss.code) order by c.name; -rollback; +-- rollback; -- -- test incorrect handling of placeholders that only appear in targetlists, @@ -812,14 +816,14 @@ ON sub1.key1 = sub2.key3; -- test case where a PlaceHolderVar is used as a nestloop parameter -- -EXPLAIN (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; +-- EXPLAIN (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; SELECT qq, unique1 FROM @@ -833,47 +837,27 @@ SELECT qq, unique1 -- nested nestloops can require nested PlaceHolderVars -- -create temp table nt1 ( - id int primary key, - a1 boolean, - a2 boolean -); -create temp table nt2 ( - id int primary key, - nt1_id int, - b1 boolean, - b2 boolean, - foreign key (nt1_id) references nt1(id) -); -create temp table nt3 ( - id int primary key, - nt2_id int, - c1 boolean, - foreign key (nt2_id) references nt2(id) -); - -insert into nt1 values (1,true,true); -insert into nt1 values (2,true,false); -insert into nt1 values (3,false,false); -insert into nt2 values (1,1,true,true); -insert into nt2 values (2,2,true,false); -insert into nt2 values (3,3,false,false); -insert into nt3 values (1,1,true); -insert into nt3 values (2,2,false); -insert into nt3 values (3,3,true); - -explain (costs off) -select nt3.id -from nt3 as nt3 - left join - (select nt2.*, (nt2.b1 and ss1.a3) AS b3 - from nt2 as nt2 - left join - (select nt1.*, (nt1.id is not null) as a3 from nt1) as ss1 - on ss1.id = nt2.nt1_id - ) as ss2 - on ss2.id = nt3.nt2_id -where nt3.id = 1 and ss2.b3; +create or replace temporary view nt1 as select * from + (values(1,true,true), (2,true,false), (3,false,false)) + as v(id, a1, a2); +create or replace temporary view nt2 as select * from + (values(1,1,true,true), (2,2,true,false), (3,3,false,false)) + as v(id, nt1_id, b1, b2); +create or replace temporary view nt3 as select * from + (values(1,1,true), (2,2,false), (3,3,true)) + as v(id, nt2_id, c1); +-- explain (costs off) +-- select nt3.id +-- from nt3 as nt3 +-- left join +-- (select nt2.*, (nt2.b1 and ss1.a3) AS b3 +-- from nt2 as nt2 +-- left join +-- (select nt1.*, (nt1.id is not null) as a3 from nt1) as ss1 +-- on ss1.id = nt2.nt1_id +-- ) as ss2 +-- on ss2.id = nt3.nt2_id +-- where nt3.id = 1 and ss2.b3; select nt3.id from nt3 as nt3 @@ -887,26 +871,27 @@ from nt3 as nt3 on ss2.id = nt3.nt2_id where nt3.id = 1 and ss2.b3; +-- [SPARK-28379] Correlated scalar subqueries must be aggregated -- -- test case where a PlaceHolderVar is propagated into a subquery -- -explain (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; +-- explain (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; -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; +-- 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; -- -- test the corner cases FULL JOIN ON TRUE and FULL JOIN ON FALSE @@ -918,157 +903,160 @@ select * from int4_tbl a full join int4_tbl b on false; -- test for ability to use a cartesian join when necessary -- -explain (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; +-- explain (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; -explain (costs off) -select * from - tenk1 join int4_tbl on f1 = twothousand, - int4(sin(1)) q1, - int4(sin(0)) q2 -where thousand = (q1 + q2); +-- explain (costs off) +-- select * from +-- tenk1 join int4_tbl on f1 = twothousand, +-- int4(sin(1)) q1, +-- int4(sin(0)) q2 +-- where thousand = (q1 + q2); -- -- test ability to generate a suitable plan for a star-schema query -- -explain (costs off) -select * from - tenk1, int8_tbl a, int8_tbl b -where thousand = a.q1 and tenthous = b.q1 and a.q2 = 1 and b.q2 = 2; +-- explain (costs off) +-- select * from +-- tenk1, int8_tbl a, int8_tbl b +-- where thousand = a.q1 and tenthous = b.q1 and a.q2 = 1 and b.q2 = 2; -- -- test a corner case in which we shouldn't apply the star-schema optimization -- -explain (costs off) -select t1.unique2, t1.stringu1, t2.unique1, t2.stringu2 from - tenk1 t1 - inner join int4_tbl i1 - left join (select v1.x2, v2.y1, 11 AS d1 - from (select 1,0 from onerow) v1(x1,x2) - left join (select 3,1 from onerow) v2(y1,y2) - on v1.x1 = v2.y2) subq1 - on (i1.f1 = subq1.x2) - on (t1.unique2 = subq1.d1) - left join tenk1 t2 - on (subq1.y1 = t2.unique1) -where t1.unique2 < 42 and t1.stringu1 > t2.stringu2; - -select t1.unique2, t1.stringu1, t2.unique1, t2.stringu2 from - tenk1 t1 - inner join int4_tbl i1 - left join (select v1.x2, v2.y1, 11 AS d1 - from (select 1,0 from onerow) v1(x1,x2) - left join (select 3,1 from onerow) v2(y1,y2) - on v1.x1 = v2.y2) subq1 - on (i1.f1 = subq1.x2) - on (t1.unique2 = subq1.d1) - left join tenk1 t2 - on (subq1.y1 = t2.unique1) -where t1.unique2 < 42 and t1.stringu1 > t2.stringu2; +-- explain (costs off) +-- select t1.unique2, t1.stringu1, t2.unique1, t2.stringu2 from +-- tenk1 t1 +-- inner join int4_tbl i1 +-- left join (select v1.x2, v2.y1, 11 AS d1 +-- from (select 1,0 from onerow) v1(x1,x2) +-- left join (select 3,1 from onerow) v2(y1,y2) +-- on v1.x1 = v2.y2) subq1 +-- on (i1.f1 = subq1.x2) +-- on (t1.unique2 = subq1.d1) +-- left join tenk1 t2 +-- on (subq1.y1 = t2.unique1) +-- where t1.unique2 < 42 and t1.stringu1 > t2.stringu2; + +-- [SPARK-20856] support statement using nested joins +-- select t1.unique2, t1.stringu1, t2.unique1, t2.stringu2 from +-- tenk1 t1 +-- inner join int4_tbl i1 +-- left join (select v1.x2, v2.y1, 11 AS d1 +-- from (select 1,0 from onerow) v1(x1,x2) +-- left join (select 3,1 from onerow) v2(y1,y2) +-- on v1.x1 = v2.y2) subq1 +-- on (i1.f1 = subq1.x2) +-- on (t1.unique2 = subq1.d1) +-- left join tenk1 t2 +-- on (subq1.y1 = t2.unique1) +-- where t1.unique2 < 42 and t1.stringu1 > t2.stringu2; -- variant that isn't quite a star-schema case -select ss1.d1 from - tenk1 as t1 - inner join tenk1 as t2 - on t1.tenthous = t2.ten - inner join - int8_tbl as i8 - left join int4_tbl as i4 - inner join (select 64::information_schema.cardinal_number as d1 - from tenk1 t3, - lateral (select abs(t3.unique1) + random()) ss0(x) - where t3.fivethous < 0) as ss1 - on i4.f1 = ss1.d1 - on i8.q1 = i4.f1 - on t1.tenthous = ss1.d1 -where t1.unique1 < i4.f1; +-- Spark SQL do not support information_schema.cardinal_number type +-- select ss1.d1 from +-- tenk1 as t1 +-- inner join tenk1 as t2 +-- on t1.tenthous = t2.ten +-- inner join +-- int8_tbl as i8 +-- left join int4_tbl as i4 +-- inner join (select 64::information_schema.cardinal_number as d1 +-- from tenk1 t3, +-- lateral (select abs(t3.unique1) + random()) ss0(x) +-- where t3.fivethous < 0) as ss1 +-- on i4.f1 = ss1.d1 +-- on i8.q1 = i4.f1 +-- on t1.tenthous = ss1.d1 +-- where t1.unique1 < i4.f1; -- this variant is foldable by the remove-useless-RESULT-RTEs code -explain (costs off) -select t1.unique2, t1.stringu1, t2.unique1, t2.stringu2 from - tenk1 t1 - inner join int4_tbl i1 - left join (select v1.x2, v2.y1, 11 AS d1 - from (values(1,0)) v1(x1,x2) - left join (values(3,1)) v2(y1,y2) - on v1.x1 = v2.y2) subq1 - on (i1.f1 = subq1.x2) - on (t1.unique2 = subq1.d1) - left join tenk1 t2 - on (subq1.y1 = t2.unique1) -where t1.unique2 < 42 and t1.stringu1 > t2.stringu2; - -select t1.unique2, t1.stringu1, t2.unique1, t2.stringu2 from - tenk1 t1 - inner join int4_tbl i1 - left join (select v1.x2, v2.y1, 11 AS d1 - from (values(1,0)) v1(x1,x2) - left join (values(3,1)) v2(y1,y2) - on v1.x1 = v2.y2) subq1 - on (i1.f1 = subq1.x2) - on (t1.unique2 = subq1.d1) - left join tenk1 t2 - on (subq1.y1 = t2.unique1) -where t1.unique2 < 42 and t1.stringu1 > t2.stringu2; +-- explain (costs off) +-- select t1.unique2, t1.stringu1, t2.unique1, t2.stringu2 from +-- tenk1 t1 +-- inner join int4_tbl i1 +-- left join (select v1.x2, v2.y1, 11 AS d1 +-- from (values(1,0)) v1(x1,x2) +-- left join (values(3,1)) v2(y1,y2) +-- on v1.x1 = v2.y2) subq1 +-- on (i1.f1 = subq1.x2) +-- on (t1.unique2 = subq1.d1) +-- left join tenk1 t2 +-- on (subq1.y1 = t2.unique1) +-- where t1.unique2 < 42 and t1.stringu1 > t2.stringu2; + +-- [SPARK-20856] support statement using nested joins +-- select t1.unique2, t1.stringu1, t2.unique1, t2.stringu2 from +-- tenk1 t1 +-- inner join int4_tbl i1 +-- left join (select v1.x2, v2.y1, 11 AS d1 +-- from (values(1,0)) v1(x1,x2) +-- left join (values(3,1)) v2(y1,y2) +-- on v1.x1 = v2.y2) subq1 +-- on (i1.f1 = subq1.x2) +-- on (t1.unique2 = subq1.d1) +-- left join tenk1 t2 +-- on (subq1.y1 = t2.unique1) +-- where t1.unique2 < 42 and t1.stringu1 > t2.stringu2; -- -- test extraction of restriction OR clauses from join OR clause -- (we used to only do this for indexable clauses) -- -explain (costs off) -select * from tenk1 a join tenk1 b on - (a.unique1 = 1 and b.unique1 = 2) or (a.unique2 = 3 and b.hundred = 4); -explain (costs off) -select * from tenk1 a join tenk1 b on - (a.unique1 = 1 and b.unique1 = 2) or (a.unique2 = 3 and b.ten = 4); -explain (costs off) -select * from tenk1 a join tenk1 b on - (a.unique1 = 1 and b.unique1 = 2) or - ((a.unique2 = 3 or a.unique2 = 7) and b.hundred = 4); +-- explain (costs off) +-- select * from tenk1 a join tenk1 b on +-- (a.unique1 = 1 and b.unique1 = 2) or (a.unique2 = 3 and b.hundred = 4); +-- explain (costs off) +-- select * from tenk1 a join tenk1 b on +-- (a.unique1 = 1 and b.unique1 = 2) or (a.unique2 = 3 and b.ten = 4); +-- explain (costs off) +-- select * from tenk1 a join tenk1 b on +-- (a.unique1 = 1 and b.unique1 = 2) or +-- ((a.unique2 = 3 or a.unique2 = 7) and b.hundred = 4); -- -- test placement of movable quals in a parameterized join tree -- -explain (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; +-- explain (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; -explain (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; +-- explain (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; -explain (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; +-- explain (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; 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; -explain (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; +-- explain (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; select b.unique1 from tenk1 a join tenk1 b on a.unique1 = b.unique2 @@ -1077,14 +1065,14 @@ select b.unique1 from right join int4_tbl i2 on i2.f1 = b.tenthous order by 1; -explain (costs off) -select * from -( - select unique1, q1, coalesce(unique1, -1) + q1 as fault - from int8_tbl left join tenk1 on (q2 = unique2) -) ss -where fault = 122 -order by fault; +-- explain (costs off) +-- select * from +-- ( +-- select unique1, q1, coalesce(unique1, -1) + q1 as fault +-- from int8_tbl left join tenk1 on (q2 = unique2) +-- ) ss +-- where fault = 122 +-- order by fault; select * from ( @@ -1094,34 +1082,35 @@ select * from where fault = 122 order by fault; -explain (costs off) -select * from -(values (1, array[10,20]), (2, array[20,30])) as v1(v1x,v1ys) -left join (values (1, 10), (2, 20)) as v2(v2x,v2y) on v2x = v1x -left join unnest(v1ys) as u1(u1y) on u1y = v2y; +-- explain (costs off) +-- select * from +-- (values (1, array[10,20]), (2, array[20,30])) as v1(v1x,v1ys) +-- left join (values (1, 10), (2, 20)) as v2(v2x,v2y) on v2x = v1x +-- left join unnest(v1ys) as u1(u1y) on u1y = v2y; -select * from -(values (1, array[10,20]), (2, array[20,30])) as v1(v1x,v1ys) -left join (values (1, 10), (2, 20)) as v2(v2x,v2y) on v2x = v1x -left join unnest(v1ys) as u1(u1y) on u1y = v2y; +-- [SPARK-28382] Array Functions: unnest +-- select * from +-- (values (1, array(10,20)), (2, array(20,30))) as v1(v1x,v1ys) +-- left join (values (1, 10), (2, 20)) as v2(v2x,v2y) on v2x = v1x +-- left join unnest(v1ys) as u1(u1y) on u1y = v2y; -- -- test handling of potential equivalence clauses above outer joins -- -explain (costs off) -select q1, unique2, thousand, hundred - from int8_tbl a left join tenk1 b on q1 = unique2 - where coalesce(thousand,123) = q1 and q1 = coalesce(hundred,123); +-- explain (costs off) +-- select q1, unique2, thousand, hundred +-- from int8_tbl a left join tenk1 b on q1 = unique2 +-- where coalesce(thousand,123) = q1 and q1 = coalesce(hundred,123); select q1, unique2, thousand, hundred from int8_tbl a left join tenk1 b on q1 = unique2 where coalesce(thousand,123) = q1 and q1 = coalesce(hundred,123); -explain (costs off) -select f1, unique2, case when unique2 is null then f1 else 0 end - from int4_tbl a left join tenk1 b on f1 = unique2 - where (case when unique2 is null then f1 else 0 end) = 0; +-- explain (costs off) +-- select f1, unique2, case when unique2 is null then f1 else 0 end +-- from int4_tbl a left join tenk1 b on f1 = unique2 +-- where (case when unique2 is null then f1 else 0 end) = 0; select f1, unique2, case when unique2 is null then f1 else 0 end from int4_tbl a left join tenk1 b on f1 = unique2 @@ -1131,10 +1120,10 @@ select f1, unique2, case when unique2 is null then f1 else 0 end -- another case with equivalence clauses above outer joins (bug #8591) -- -explain (costs off) -select a.unique1, b.unique1, c.unique1, coalesce(b.twothousand, a.twothousand) - from tenk1 a left join tenk1 b on b.thousand = a.unique1 left join tenk1 c on c.unique2 = coalesce(b.twothousand, a.twothousand) - where a.unique2 < 10 and coalesce(b.twothousand, a.twothousand) = 44; +-- explain (costs off) +-- select a.unique1, b.unique1, c.unique1, coalesce(b.twothousand, a.twothousand) +-- from tenk1 a left join tenk1 b on b.thousand = a.unique1 left join tenk1 c on c.unique2 = coalesce(b.twothousand, a.twothousand) +-- where a.unique2 < 10 and coalesce(b.twothousand, a.twothousand) = 44; 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) @@ -1144,117 +1133,120 @@ select a.unique1, b.unique1, c.unique1, coalesce(b.twothousand, a.twothousand) -- check handling of join aliases when flattening multiple levels of subquery -- -explain (verbose, costs off) -select foo1.join_key as foo1_id, foo3.join_key AS foo3_id, bug_field from - (values (0),(1)) foo1(join_key) -left join - (select join_key, bug_field from - (select ss1.join_key, ss1.bug_field from - (select f1 as join_key, 666 as bug_field from int4_tbl i1) ss1 - ) foo2 - left join - (select unique2 as join_key from tenk1 i2) ss2 - using (join_key) - ) foo3 -using (join_key); - -select foo1.join_key as foo1_id, foo3.join_key AS foo3_id, bug_field from - (values (0),(1)) foo1(join_key) -left join - (select join_key, bug_field from - (select ss1.join_key, ss1.bug_field from - (select f1 as join_key, 666 as bug_field from int4_tbl i1) ss1 - ) foo2 - left join - (select unique2 as join_key from tenk1 i2) ss2 - using (join_key) - ) foo3 -using (join_key); - +-- explain (verbose, costs off) +-- select foo1.join_key as foo1_id, foo3.join_key AS foo3_id, bug_field from +-- (values (0),(1)) foo1(join_key) +-- left join +-- (select join_key, bug_field from +-- (select ss1.join_key, ss1.bug_field from +-- (select f1 as join_key, 666 as bug_field from int4_tbl i1) ss1 +-- ) foo2 +-- left join +-- (select unique2 as join_key from tenk1 i2) ss2 +-- using (join_key) +-- ) foo3 +-- using (join_key); + + +-- [SPARK-28377] Fully support correlation names in the FROM clause +-- select foo1.join_key as foo1_id, foo3.join_key AS foo3_id, bug_field from +-- (values (0),(1)) foo1(join_key) +-- left join +-- (select join_key, bug_field from +-- (select ss1.join_key, ss1.bug_field from +-- (select f1 as join_key, 666 as bug_field from int4_tbl i1) ss1 +-- ) foo2 +-- left join +-- (select unique2 as join_key from tenk1 i2) ss2 +-- using (join_key) +-- ) foo3 +-- using (join_key); + +-- [SPARK-20856] Support statement using nested joins -- -- test successful handling of nested outer joins with degenerate join quals -- -explain (verbose, costs off) -select t1.* from - text_tbl t1 - left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 - left join int8_tbl i8 - left join (select *, null::int as d2 from int8_tbl i8b2) b2 - on (i8.q1 = b2.q1) - on (b2.d2 = b1.q2) - on (t1.f1 = b1.d1) - left join int4_tbl i4 - on (i8.q2 = i4.f1); - -select t1.* from - text_tbl t1 - left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 - left join int8_tbl i8 - left join (select *, null::int as d2 from int8_tbl i8b2) b2 - on (i8.q1 = b2.q1) - on (b2.d2 = b1.q2) - on (t1.f1 = b1.d1) - left join int4_tbl i4 - on (i8.q2 = i4.f1); - -explain (verbose, costs off) -select t1.* from - text_tbl t1 - left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 - left join int8_tbl i8 - left join (select *, null::int as d2 from int8_tbl i8b2, int4_tbl i4b2) b2 - on (i8.q1 = b2.q1) - on (b2.d2 = b1.q2) - on (t1.f1 = b1.d1) - left join int4_tbl i4 - on (i8.q2 = i4.f1); - -select t1.* from - text_tbl t1 - left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 - left join int8_tbl i8 - left join (select *, null::int as d2 from int8_tbl i8b2, int4_tbl i4b2) b2 - on (i8.q1 = b2.q1) - on (b2.d2 = b1.q2) - on (t1.f1 = b1.d1) - left join int4_tbl i4 - on (i8.q2 = i4.f1); - -explain (verbose, costs off) -select t1.* from - text_tbl t1 - left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 - left join int8_tbl i8 - left join (select *, null::int as d2 from int8_tbl i8b2, int4_tbl i4b2 - where q1 = f1) b2 - on (i8.q1 = b2.q1) - on (b2.d2 = b1.q2) - on (t1.f1 = b1.d1) - left join int4_tbl i4 - on (i8.q2 = i4.f1); - -select t1.* from - text_tbl t1 - left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 - left join int8_tbl i8 - left join (select *, null::int as d2 from int8_tbl i8b2, int4_tbl i4b2 - where q1 = f1) b2 - on (i8.q1 = b2.q1) - on (b2.d2 = b1.q2) - on (t1.f1 = b1.d1) - left join int4_tbl i4 - on (i8.q2 = i4.f1); - -explain (verbose, costs off) -select * from - text_tbl t1 - inner join int8_tbl i8 - on i8.q2 = 456 - right join text_tbl t2 - on t1.f1 = 'doh!' - left join int4_tbl i4 - on i8.q1 = i4.f1; +-- explain (verbose, costs off) +-- select t1.* from +-- text_tbl t1 +-- left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 +-- left join int8_tbl i8 +-- left join (select *, null::int as d2 from int8_tbl i8b2) b2 +-- on (i8.q1 = b2.q1) +-- on (b2.d2 = b1.q2) +-- on (t1.f1 = b1.d1) +-- left join int4_tbl i4 +-- on (i8.q2 = i4.f1); + +-- select t1.* from +-- text_tbl t1 +-- left join (select *, string('***') as d1 from int8_tbl i8b1) b1 +-- left join int8_tbl i8 +-- left join (select *, int(null) as d2 from int8_tbl i8b2) b2 +-- on (i8.q1 = b2.q1) +-- on (b2.d2 = b1.q2) +-- on (t1.f1 = b1.d1) +-- left join int4_tbl i4 +-- on (i8.q2 = i4.f1); + +-- explain (verbose, costs off) +-- select t1.* from +-- text_tbl t1 +-- left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 +-- left join int8_tbl i8 +-- left join (select *, null::int as d2 from int8_tbl i8b2, int4_tbl i4b2) b2 +-- on (i8.q1 = b2.q1) +-- on (b2.d2 = b1.q2) +-- on (t1.f1 = b1.d1) +-- left join int4_tbl i4 +-- on (i8.q2 = i4.f1); + +-- select t1.* from +-- text_tbl t1 +-- left join (select *, string('***') as d1 from int8_tbl i8b1) b1 +-- left join int8_tbl i8 +-- left join (select *, int(null) as d2 from int8_tbl i8b2, int4_tbl i4b2) b2 +-- on (i8.q1 = b2.q1) +-- on (b2.d2 = b1.q2) +-- on (t1.f1 = b1.d1) +-- left join int4_tbl i4 +-- on (i8.q2 = i4.f1); + +-- explain (verbose, costs off) +-- select t1.* from +-- text_tbl t1 +-- left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 +-- left join int8_tbl i8 +-- left join (select *, null::int as d2 from int8_tbl i8b2, int4_tbl i4b2 +-- where q1 = f1) b2 +-- on (i8.q1 = b2.q1) +-- on (b2.d2 = b1.q2) +-- on (t1.f1 = b1.d1) +-- left join int4_tbl i4 +-- on (i8.q2 = i4.f1); + +-- select t1.* from +-- text_tbl t1 +-- left join (select *, string('***') as d1 from int8_tbl i8b1) b1 +-- left join int8_tbl i8 +-- left join (select *, int(null) as d2 from int8_tbl i8b2, int4_tbl i4b2 +-- where q1 = f1) b2 +-- on (i8.q1 = b2.q1) +-- on (b2.d2 = b1.q2) +-- on (t1.f1 = b1.d1) +-- left join int4_tbl i4 +-- on (i8.q2 = i4.f1); + +-- explain (verbose, costs off) +-- select * from +-- text_tbl t1 +-- inner join int8_tbl i8 +-- on i8.q2 = 456 +-- right join text_tbl t2 +-- on t1.f1 = 'doh!' +-- left join int4_tbl i4 +-- on i8.q1 = i4.f1; select * from text_tbl t1 @@ -1265,94 +1257,95 @@ select * from left join int4_tbl i4 on i8.q1 = i4.f1; +-- [SPARK-27877] ANSI SQL: LATERAL derived table(T491) -- -- test for appropriate join order in the presence of lateral references -- -explain (verbose, costs off) -select * from - text_tbl t1 - left join int8_tbl i8 - on i8.q2 = 123, - lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss -where t1.f1 = ss.f1; - -select * from - text_tbl t1 - left join int8_tbl i8 - on i8.q2 = 123, - lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss -where t1.f1 = ss.f1; - -explain (verbose, costs off) -select * from - text_tbl t1 - left join int8_tbl i8 - on i8.q2 = 123, - lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss1, - lateral (select ss1.* from text_tbl t3 limit 1) as ss2 -where t1.f1 = ss2.f1; - -select * from - text_tbl t1 - left join int8_tbl i8 - on i8.q2 = 123, - lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss1, - lateral (select ss1.* from text_tbl t3 limit 1) as ss2 -where t1.f1 = ss2.f1; - -explain (verbose, costs off) -select 1 from - text_tbl as tt1 - inner join text_tbl as tt2 on (tt1.f1 = 'foo') - left join text_tbl as tt3 on (tt3.f1 = 'foo') - left join text_tbl as tt4 on (tt3.f1 = tt4.f1), - lateral (select tt4.f1 as c0 from text_tbl as tt5 limit 1) as ss1 -where tt1.f1 = ss1.c0; - -select 1 from - text_tbl as tt1 - inner join text_tbl as tt2 on (tt1.f1 = 'foo') - left join text_tbl as tt3 on (tt3.f1 = 'foo') - left join text_tbl as tt4 on (tt3.f1 = tt4.f1), - lateral (select tt4.f1 as c0 from text_tbl as tt5 limit 1) as ss1 -where tt1.f1 = ss1.c0; +-- explain (verbose, costs off) +-- select * from +-- text_tbl t1 +-- left join int8_tbl i8 +-- on i8.q2 = 123, +-- lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss +-- where t1.f1 = ss.f1; + +-- select * from +-- text_tbl t1 +-- left join int8_tbl i8 +-- on i8.q2 = 123, +-- lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss +-- where t1.f1 = ss.f1; + +-- explain (verbose, costs off) +-- select * from +-- text_tbl t1 +-- left join int8_tbl i8 +-- on i8.q2 = 123, +-- lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss1, +-- lateral (select ss1.* from text_tbl t3 limit 1) as ss2 +-- where t1.f1 = ss2.f1; + +-- select * from +-- text_tbl t1 +-- left join int8_tbl i8 +-- on i8.q2 = 123, +-- lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss1, +-- lateral (select ss1.* from text_tbl t3 limit 1) as ss2 +-- where t1.f1 = ss2.f1; + +-- explain (verbose, costs off) +-- select 1 from +-- text_tbl as tt1 +-- inner join text_tbl as tt2 on (tt1.f1 = 'foo') +-- left join text_tbl as tt3 on (tt3.f1 = 'foo') +-- left join text_tbl as tt4 on (tt3.f1 = tt4.f1), +-- lateral (select tt4.f1 as c0 from text_tbl as tt5 limit 1) as ss1 +-- where tt1.f1 = ss1.c0; + +-- select 1 from +-- text_tbl as tt1 +-- inner join text_tbl as tt2 on (tt1.f1 = 'foo') +-- left join text_tbl as tt3 on (tt3.f1 = 'foo') +-- left join text_tbl as tt4 on (tt3.f1 = tt4.f1), +-- lateral (select tt4.f1 as c0 from text_tbl as tt5 limit 1) as ss1 +-- where tt1.f1 = ss1.c0; -- -- check a case in which a PlaceHolderVar forces join order -- -explain (verbose, costs off) -select ss2.* from - int4_tbl i41 - left join int8_tbl i8 - join (select i42.f1 as c1, i43.f1 as c2, 42 as c3 - from int4_tbl i42, int4_tbl i43) ss1 - on i8.q1 = ss1.c2 - on i41.f1 = ss1.c1, - lateral (select i41.*, i8.*, ss1.* from text_tbl limit 1) ss2 -where ss1.c2 = 0; - -select ss2.* from - int4_tbl i41 - left join int8_tbl i8 - join (select i42.f1 as c1, i43.f1 as c2, 42 as c3 - from int4_tbl i42, int4_tbl i43) ss1 - on i8.q1 = ss1.c2 - on i41.f1 = ss1.c1, - lateral (select i41.*, i8.*, ss1.* from text_tbl limit 1) ss2 -where ss1.c2 = 0; +-- explain (verbose, costs off) +-- select ss2.* from +-- int4_tbl i41 +-- left join int8_tbl i8 +-- join (select i42.f1 as c1, i43.f1 as c2, 42 as c3 +-- from int4_tbl i42, int4_tbl i43) ss1 +-- on i8.q1 = ss1.c2 +-- on i41.f1 = ss1.c1, +-- lateral (select i41.*, i8.*, ss1.* from text_tbl limit 1) ss2 +-- where ss1.c2 = 0; + +-- select ss2.* from +-- int4_tbl i41 +-- left join int8_tbl i8 +-- join (select i42.f1 as c1, i43.f1 as c2, 42 as c3 +-- from int4_tbl i42, int4_tbl i43) ss1 +-- on i8.q1 = ss1.c2 +-- on i41.f1 = ss1.c1, +-- lateral (select i41.*, i8.*, ss1.* from text_tbl limit 1) ss2 +-- where ss1.c2 = 0; -- -- test successful handling of full join underneath left join (bug #14105) -- -explain (costs off) -select * from - (select 1 as id) as xx - left join - (tenk1 as a1 full join (select 1 as id) as yy on (a1.unique1 = yy.id)) - on (xx.id = coalesce(yy.id)); +-- explain (costs off) +-- select * from +-- (select 1 as id) as xx +-- left join +-- (tenk1 as a1 full join (select 1 as id) as yy on (a1.unique1 = yy.id)) +-- on (xx.id = coalesce(yy.id)); select * from (select 1 as id) as xx @@ -1364,11 +1357,11 @@ select * from -- test ability to push constants through outer join clauses -- -explain (costs off) - select * from int4_tbl a left join tenk1 b on f1 = unique2 where f1 = 0; +-- explain (costs off) +-- select * from int4_tbl a left join tenk1 b on f1 = unique2 where f1 = 0; -explain (costs off) - select * from tenk1 a full join tenk1 b using(unique2) where unique2 = 42; +-- explain (costs off) +-- select * from tenk1 a full join tenk1 b using(unique2) where unique2 = 42; -- -- test that quals attached to an outer join have correct semantics, @@ -1376,144 +1369,150 @@ explain (costs off) -- we force a mergejoin so that coalesce(b.q1, 1) appears as a join input -- -set enable_hashjoin to off; -set enable_nestloop to off; +-- set enable_hashjoin to off; +-- set enable_nestloop to off; -explain (verbose, costs off) - select a.q2, b.q1 - from int8_tbl a left join int8_tbl b on a.q2 = coalesce(b.q1, 1) - where coalesce(b.q1, 1) > 0; +-- explain (verbose, costs off) +-- select a.q2, b.q1 +-- from int8_tbl a left join int8_tbl b on a.q2 = coalesce(b.q1, 1) +-- where coalesce(b.q1, 1) > 0; 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; -reset enable_hashjoin; -reset enable_nestloop; +-- reset enable_hashjoin; +-- reset enable_nestloop; +-- Skip these test because it only test explain -- -- test join removal -- -begin; +-- begin; -CREATE TEMP TABLE a (id int PRIMARY KEY, b_id int); -CREATE TEMP TABLE b (id int PRIMARY KEY, c_id int); -CREATE TEMP TABLE c (id int PRIMARY KEY); -CREATE TEMP TABLE d (a int, b int); -INSERT INTO a VALUES (0, 0), (1, NULL); -INSERT INTO b VALUES (0, 0), (1, NULL); -INSERT INTO c VALUES (0), (1); -INSERT INTO d VALUES (1,3), (2,2), (3,1); +-- CREATE TEMP TABLE a (id int PRIMARY KEY, b_id int); +-- CREATE TEMP TABLE b (id int PRIMARY KEY, c_id int); +-- CREATE TEMP TABLE c (id int PRIMARY KEY); +-- CREATE TEMP TABLE d (a int, b int); +-- INSERT INTO a VALUES (0, 0), (1, NULL); +-- INSERT INTO b VALUES (0, 0), (1, NULL); +-- INSERT INTO c VALUES (0), (1); +-- INSERT INTO d VALUES (1,3), (2,2), (3,1); -- all three cases should be optimizable into a simple seqscan -explain (costs off) SELECT a.* FROM a LEFT JOIN b ON a.b_id = b.id; -explain (costs off) SELECT b.* FROM b LEFT JOIN c ON b.c_id = c.id; -explain (costs off) - SELECT a.* FROM a LEFT JOIN (b left join c on b.c_id = c.id) - ON (a.b_id = b.id); +-- explain (costs off) SELECT a.* FROM a LEFT JOIN b ON a.b_id = b.id; +-- explain (costs off) SELECT b.* FROM b LEFT JOIN c ON b.c_id = c.id; +-- explain (costs off) +-- SELECT a.* FROM a LEFT JOIN (b left join c on b.c_id = c.id) +-- ON (a.b_id = b.id); -- check optimization of outer join within another special join -explain (costs off) -select id from a where id in ( - select b.id from b left join c on b.id = c.id -); +-- explain (costs off) +-- select id from a where id in ( +-- select b.id from b left join c on b.id = c.id +-- ); -- check that join removal works for a left join when joining a subquery -- that is guaranteed to be unique by its GROUP BY clause -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; +-- 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; -- 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; +-- 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; -- join removal is not possible when the GROUP BY contains a column that is -- not in the join condition. (Note: as of 9.6, we notice that b.id is a -- primary key and so drop b.c_id from the GROUP BY of the resulting plan; -- but this happens too late for join removal in the outer plan level.) -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; +-- 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; -- 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; +-- explain (costs off) +-- select d.* from d left join (select distinct * from b) s +-- on d.a = s.id; -- 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; +-- explain (costs off) +-- select d.* from d left join (select id from a union select id from b) s +-- on d.a = s.id; -- 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; +-- 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; -- check join removal with lateral references -explain (costs off) -select 1 from (select a.id FROM a left join b on a.b_id = b.id) q, - lateral generate_series(1, q.id) gs(i) where q.id = gs.i; +-- explain (costs off) +-- select 1 from (select a.id FROM a left join b on a.b_id = b.id) q, +-- lateral generate_series(1, q.id) gs(i) where q.id = gs.i; -rollback; +-- rollback; -create temp table parent (k int primary key, pd int); -create temp table child (k int unique, cd int); -insert into parent values (1, 10), (2, 20), (3, 30); -insert into child values (1, 100), (4, 400); +create or replace temporary view parent as select * from + (values (1, 10), (2, 20), (3, 30)) + as v(k, pd); +create or replace temporary view child as select * from + (values (1, 100), (4, 400)) + as v(k, cd); -- this case is optimizable select p.* from parent p left join child c on (p.k = c.k); -explain (costs off) - select p.* from parent p left join child c on (p.k = c.k); +-- explain (costs off) +-- select p.* from parent p left join child c on (p.k = c.k); -- 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); -explain (costs off) - select p.*, linked from parent p - left join (select c.*, true as linked from child c) as ss - on (p.k = ss.k); +-- explain (costs off) +-- select p.*, linked from parent p +-- left join (select c.*, true as linked from child c) as ss +-- on (p.k = ss.k); -- 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; -explain (costs off) -select p.* from - parent p left join child c on (p.k = c.k) - where p.k = 1 and p.k = 2; +-- explain (costs off) +-- select p.* from +-- parent p left join child c on (p.k = c.k) +-- where p.k = 1 and p.k = 2; 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; -explain (costs off) -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; +-- explain (costs off) +-- 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; -- bug 5255: this is not optimizable by join removal -begin; +-- begin; -CREATE TEMP TABLE a (id int PRIMARY KEY); -CREATE TEMP TABLE b (id int PRIMARY KEY, a_id int); -INSERT INTO a VALUES (0), (1); -INSERT INTO b VALUES (0, 0), (1, NULL); +create or replace temporary view a as select * from + (values (0), (1)) + as v(id); +create or replace temporary view b as select * from + (values (0, 0), (1, NULL)) + as v(id, a_id); SELECT * FROM b LEFT JOIN a ON (b.a_id = a.id) WHERE (a.id IS NULL OR a.id > 0); SELECT b.* FROM b LEFT JOIN a ON (b.a_id = a.id) WHERE (a.id IS NULL OR a.id > 0); -rollback; +-- rollback; -- another join removal bug: this is not optimizable, either -begin; +-- begin; -create temp table innertab (id int8 primary key, dat1 int8); -insert into innertab values(123, 42); +create or replace temporary view innertab as select * from + (values (123L, 42L)) + as v(id, dat1); SELECT * FROM (SELECT 1 AS x) ss1 @@ -1522,47 +1521,48 @@ SELECT * FROM FROM int8_tbl LEFT JOIN innertab ON q2 = id) ss2 ON true; -rollback; +-- rollback; -- another join removal bug: we must clean up correctly when removing a PHV -begin; - -create temp table uniquetbl (f1 text unique); - -explain (costs off) -select t1.* from - uniquetbl as t1 - left join (select *, '***'::text as d1 from uniquetbl) t2 - on t1.f1 = t2.f1 - left join uniquetbl t3 - on t2.d1 = t3.f1; - -explain (costs off) -select t0.* -from - text_tbl t0 - left join - (select case t1.ten when 0 then 'doh!'::text else null::text end as case1, - t1.stringu2 - from tenk1 t1 - join int4_tbl i4 ON i4.f1 = t1.unique2 - left join uniquetbl u1 ON u1.f1 = t1.string4) ss - on t0.f1 = ss.case1 -where ss.stringu2 !~* ss.case1; - -select t0.* -from - text_tbl t0 - left join - (select case t1.ten when 0 then 'doh!'::text else null::text end as case1, - t1.stringu2 - from tenk1 t1 - join int4_tbl i4 ON i4.f1 = t1.unique2 - left join uniquetbl u1 ON u1.f1 = t1.string4) ss - on t0.f1 = ss.case1 -where ss.stringu2 !~* ss.case1; - -rollback; +-- begin; + +-- create temp table uniquetbl (f1 text unique); + +-- explain (costs off) +-- select t1.* from +-- uniquetbl as t1 +-- left join (select *, '***'::text as d1 from uniquetbl) t2 +-- on t1.f1 = t2.f1 +-- left join uniquetbl t3 +-- on t2.d1 = t3.f1; + +-- explain (costs off) +-- select t0.* +-- from +-- text_tbl t0 +-- left join +-- (select case t1.ten when 0 then 'doh!'::text else null::text end as case1, +-- t1.stringu2 +-- from tenk1 t1 +-- join int4_tbl i4 ON i4.f1 = t1.unique2 +-- left join uniquetbl u1 ON u1.f1 = t1.string4) ss +-- on t0.f1 = ss.case1 +-- where ss.stringu2 !~* ss.case1; + +-- [SPARK-27987] Support POSIX Regular Expressions +-- select t0.* +-- from +-- text_tbl t0 +-- left join +-- (select case t1.ten when 0 then 'doh!'::text else null::text end as case1, +-- t1.stringu2 +-- from tenk1 t1 +-- join int4_tbl i4 ON i4.f1 = t1.unique2 +-- left join uniquetbl u1 ON u1.f1 = t1.string4) ss +-- on t0.f1 = ss.case1 +-- where ss.stringu2 !~* ss.case1; + +-- rollback; -- bug #8444: we've historically allowed duplicate aliases within aliased JOINs @@ -1584,260 +1584,263 @@ select t2.uunique1 from select uunique1 from tenk1 t1 join tenk2 t2 on t1.two = t2.two; -- error, suggest both at once +-- Skip this test because it is a PostgreSQL specific case -- -- Take care to reference the correct RTE -- -select atts.relid::regclass, s.* from pg_stats s join - pg_attribute a on s.attname = a.attname and s.tablename = - a.attrelid::regclass::text join (select unnest(indkey) attnum, - indexrelid from pg_index i) atts on atts.attnum = a.attnum where - schemaname != 'pg_catalog'; +-- -- select atts.relid::regclass, s.* from pg_stats s join +-- -- pg_attribute a on s.attname = a.attname and s.tablename = +-- -- a.attrelid::regclass::text join (select unnest(indkey) attnum, +-- -- indexrelid from pg_index i) atts on atts.attnum = a.attnum where +-- schemaname != 'pg_catalog'; +-- [SPARK-27877] ANSI SQL: LATERAL derived table(T491) -- -- Test LATERAL -- -select unique2, x.* -from tenk1 a, lateral (select * from int4_tbl b where f1 = a.unique1) x; -explain (costs off) - select unique2, x.* - from tenk1 a, lateral (select * from int4_tbl b where f1 = a.unique1) x; -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; -explain (costs off) - select unique2, x.* - from int4_tbl x cross join lateral (select unique2 from tenk1 where f1 = unique1) ss; -select unique2, x.* -from int4_tbl x left join lateral (select unique1, unique2 from tenk1 where f1 = unique1) ss on true; -explain (costs off) - select unique2, x.* - from int4_tbl x left join lateral (select unique1, unique2 from tenk1 where f1 = unique1) ss on true; - +-- select unique2, x.* +-- from tenk1 a, lateral (select * from int4_tbl b where f1 = a.unique1) x; +-- explain (costs off) +-- select unique2, x.* +-- from tenk1 a, lateral (select * from int4_tbl b where f1 = a.unique1) x; +-- 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; +-- explain (costs off) +-- select unique2, x.* +-- from int4_tbl x cross join lateral (select unique2 from tenk1 where f1 = unique1) ss; +-- select unique2, x.* +-- from int4_tbl x left join lateral (select unique1, unique2 from tenk1 where f1 = unique1) ss on true; +-- explain (costs off) +-- select unique2, x.* +-- from int4_tbl x left join lateral (select unique1, unique2 from tenk1 where f1 = unique1) ss on true; + +-- [SPARK-27877] ANSI SQL: LATERAL derived table(T491) -- check scoping of lateral versus parent references -- the first of these should return int8_tbl.q2, the second int8_tbl.q1 -select *, (select r from (select q1 as q2) x, (select q2 as r) y) from int8_tbl; -select *, (select r from (select q1 as q2) x, lateral (select q2 as r) y) from int8_tbl; +-- select *, (select r from (select q1 as q2) x, (select q2 as r) y) from int8_tbl; +-- select *, (select r from (select q1 as q2) x, lateral (select q2 as r) y) from int8_tbl; -- lateral with function in FROM -select count(*) from tenk1 a, lateral generate_series(1,two) g; -explain (costs off) - select count(*) from tenk1 a, lateral generate_series(1,two) g; -explain (costs off) - select count(*) from tenk1 a cross join lateral generate_series(1,two) g; +-- select count(*) from tenk1 a, lateral generate_series(1,two) g; +-- explain (costs off) +-- select count(*) from tenk1 a, lateral generate_series(1,two) g; +-- explain (costs off) +-- select count(*) from tenk1 a cross join lateral generate_series(1,two) g; -- don't need the explicit LATERAL keyword for functions -explain (costs off) - select count(*) from tenk1 a, generate_series(1,two) g; +-- explain (costs off) +-- select count(*) from tenk1 a, generate_series(1,two) g; -- 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; -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; +-- 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; +-- 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; -- lateral with VALUES -explain (costs off) - select count(*) from tenk1 a, - tenk1 b join lateral (values(a.unique1)) ss(x) on b.unique2 = ss.x; -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)) ss(x) on b.unique2 = ss.x; +-- select count(*) from tenk1 a, +-- tenk1 b join lateral (values(a.unique1)) ss(x) on b.unique2 = ss.x; -- lateral with VALUES, no flattening possible -explain (costs off) - select count(*) from tenk1 a, - tenk1 b join lateral (values(a.unique1),(-1)) ss(x) on b.unique2 = ss.x; -select count(*) from tenk1 a, - tenk1 b join lateral (values(a.unique1),(-1)) 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; +-- select count(*) from tenk1 a, +-- tenk1 b join lateral (values(a.unique1),(-1)) ss(x) on b.unique2 = ss.x; -- lateral injecting a strange outer join condition -explain (costs off) - select * from int8_tbl a, - int8_tbl x left join lateral (select a.q1 from int4_tbl y) ss(z) - on x.q2 = ss.z - order by a.q1, a.q2, x.q1, x.q2, ss.z; -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 - order by a.q1, a.q2, x.q1, x.q2, ss.z; +-- explain (costs off) +-- select * from int8_tbl a, +-- int8_tbl x left join lateral (select a.q1 from int4_tbl y) ss(z) +-- on x.q2 = ss.z +-- order by a.q1, a.q2, x.q1, x.q2, ss.z; +-- 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 +-- order by a.q1, a.q2, x.q1, x.q2, ss.z; -- lateral reference to a join alias variable -select * from (select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1, - lateral (select x) ss2(y); -select * from (select f1 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1, - lateral (values(x)) ss2(y); -select * from ((select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1) j, - lateral (select x) ss2(y); +-- select * from (select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1, +-- lateral (select x) ss2(y); +-- select * from (select f1 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1, +-- lateral (values(x)) ss2(y); +-- select * from ((select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1) j, +-- lateral (select x) ss2(y); -- lateral references requiring pullup -select * from (values(1)) x(lb), - lateral generate_series(lb,4) x4; -select * from (select f1/1000000000 from int4_tbl) x(lb), - lateral generate_series(lb,4) x4; -select * from (values(1)) x(lb), - lateral (values(lb)) y(lbcopy); -select * from (values(1)) x(lb), - lateral (select lb from int4_tbl) y(lbcopy); -select * from - int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1, - lateral (values(x.q1,y.q1,y.q2)) v(xq1,yq1,yq2); -select * from - int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1, - lateral (select x.q1,y.q1,y.q2) v(xq1,yq1,yq2); -select x.* from - int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1, - lateral (select x.q1,y.q1,y.q2) v(xq1,yq1,yq2); -select v.* from - (int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1) - left join int4_tbl z on z.f1 = x.q2, - lateral (select x.q1,y.q1 union all select x.q2,y.q2) v(vx,vy); -select v.* from - (int8_tbl x left join (select q1,(select coalesce(q2,0)) q2 from int8_tbl) y on x.q2 = y.q1) - left join int4_tbl z on z.f1 = x.q2, - lateral (select x.q1,y.q1 union all select x.q2,y.q2) v(vx,vy); -select v.* from - (int8_tbl x left join (select q1,(select coalesce(q2,0)) q2 from int8_tbl) y on x.q2 = y.q1) - left join int4_tbl z on z.f1 = x.q2, - lateral (select x.q1,y.q1 from onerow union all select x.q2,y.q2 from onerow) v(vx,vy); - -explain (verbose, costs off) -select * from - int8_tbl a left join - lateral (select *, a.q2 as x from int8_tbl b) ss on a.q2 = ss.q1; -select * from - int8_tbl a left join - lateral (select *, a.q2 as x from int8_tbl b) ss on a.q2 = ss.q1; -explain (verbose, costs off) -select * from - int8_tbl a left join - lateral (select *, coalesce(a.q2, 42) as x from int8_tbl b) ss on a.q2 = ss.q1; -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; +-- select * from (values(1)) x(lb), +-- lateral generate_series(lb,4) x4; +-- select * from (select f1/1000000000 from int4_tbl) x(lb), +-- lateral generate_series(lb,4) x4; +-- select * from (values(1)) x(lb), +-- lateral (values(lb)) y(lbcopy); +-- select * from (values(1)) x(lb), +-- lateral (select lb from int4_tbl) y(lbcopy); +-- select * from +-- int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1, +-- lateral (values(x.q1,y.q1,y.q2)) v(xq1,yq1,yq2); +-- select * from +-- int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1, +-- lateral (select x.q1,y.q1,y.q2) v(xq1,yq1,yq2); +-- select x.* from +-- int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1, +-- lateral (select x.q1,y.q1,y.q2) v(xq1,yq1,yq2); +-- select v.* from +-- (int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1) +-- left join int4_tbl z on z.f1 = x.q2, +-- lateral (select x.q1,y.q1 union all select x.q2,y.q2) v(vx,vy); +-- select v.* from +-- (int8_tbl x left join (select q1,(select coalesce(q2,0)) q2 from int8_tbl) y on x.q2 = y.q1) +-- left join int4_tbl z on z.f1 = x.q2, +-- lateral (select x.q1,y.q1 union all select x.q2,y.q2) v(vx,vy); +-- select v.* from +-- (int8_tbl x left join (select q1,(select coalesce(q2,0)) q2 from int8_tbl) y on x.q2 = y.q1) +-- left join int4_tbl z on z.f1 = x.q2, +-- lateral (select x.q1,y.q1 from onerow union all select x.q2,y.q2 from onerow) v(vx,vy); + +-- explain (verbose, costs off) +-- select * from +-- int8_tbl a left join +-- lateral (select *, a.q2 as x from int8_tbl b) ss on a.q2 = ss.q1; +-- select * from +-- int8_tbl a left join +-- lateral (select *, a.q2 as x from int8_tbl b) ss on a.q2 = ss.q1; +-- explain (verbose, costs off) +-- select * from +-- int8_tbl a left join +-- lateral (select *, coalesce(a.q2, 42) as x from int8_tbl b) ss on a.q2 = ss.q1; +-- 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; -- lateral can result in join conditions appearing below their -- real semantic level -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; -select * from int4_tbl i left join - lateral (select * from int2_tbl j where i.f1 = j.f1) k on true; -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; -select * from int4_tbl i left join - lateral (select coalesce(i) from int2_tbl j where i.f1 = j.f1) k on true; -explain (verbose, costs off) -select * from int4_tbl a, - lateral ( - select * from int4_tbl b left join int8_tbl c on (b.f1 = q1 and a.f1 = q2) - ) ss; -select * from int4_tbl a, - lateral ( - select * from int4_tbl b left join int8_tbl c on (b.f1 = q1 and a.f1 = q2) - ) ss; +-- 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; +-- select * from int4_tbl i left join +-- lateral (select * from int2_tbl j where i.f1 = j.f1) k on true; +-- 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; +-- select * from int4_tbl i left join +-- lateral (select coalesce(i) from int2_tbl j where i.f1 = j.f1) k on true; +-- explain (verbose, costs off) +-- select * from int4_tbl a, +-- lateral ( +-- select * from int4_tbl b left join int8_tbl c on (b.f1 = q1 and a.f1 = q2) +-- ) ss; +-- select * from int4_tbl a, +-- lateral ( +-- select * from int4_tbl b left join int8_tbl c on (b.f1 = q1 and a.f1 = q2) +-- ) ss; -- lateral reference in a PlaceHolderVar evaluated at join level -explain (verbose, costs off) -select * from - int8_tbl a left join 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; -select * from - int8_tbl a left join 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; +-- explain (verbose, costs off) +-- select * from +-- int8_tbl a left join 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; +-- select * from +-- int8_tbl a left join 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; -- case requiring nested PlaceHolderVars -explain (verbose, costs off) -select * from - int8_tbl c left join ( - int8_tbl a left join (select q1, coalesce(q2,42) as x from int8_tbl b) ss1 - on a.q2 = ss1.q1 - cross join - 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; +-- explain (verbose, costs off) +-- select * from +-- int8_tbl c left join ( +-- int8_tbl a left join (select q1, coalesce(q2,42) as x from int8_tbl b) ss1 +-- on a.q2 = ss1.q1 +-- cross join +-- 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; -- case that breaks the old ph_may_need optimization -explain (verbose, costs off) -select c.*,a.*,ss1.q1,ss2.q1,ss3.* from - int8_tbl c left join ( - int8_tbl a left join - (select q1, coalesce(q2,f1) as x from int8_tbl b, int4_tbl b2 - where q1 < f1) ss1 - on a.q2 = ss1.q1 - cross join - 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; +-- explain (verbose, costs off) +-- select c.*,a.*,ss1.q1,ss2.q1,ss3.* from +-- int8_tbl c left join ( +-- int8_tbl a left join +-- (select q1, coalesce(q2,f1) as x from int8_tbl b, int4_tbl b2 +-- where q1 < f1) ss1 +-- on a.q2 = ss1.q1 +-- cross join +-- 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; -- check processing of postponed quals (bug #9041) -explain (verbose, costs off) -select * from - (select 1 as x offset 0) x cross join (select 2 as y offset 0) y - left join lateral ( - select * from (select 3 as z offset 0) z where z.z = x.x - ) zz on zz.z = y.y; +-- explain (verbose, costs off) +-- select * from +-- (select 1 as x offset 0) x cross join (select 2 as y offset 0) y +-- left join lateral ( +-- select * from (select 3 as z offset 0) z where z.z = x.x +-- ) zz on zz.z = y.y; -- check dummy rels with lateral references (bug #15694) -explain (verbose, costs off) -select * from int8_tbl i8 left join lateral - (select *, i8.q2 from int4_tbl where false) ss on true; -explain (verbose, costs off) -select * from int8_tbl i8 left join lateral - (select *, i8.q2 from int4_tbl i1, int4_tbl i2 where false) ss on true; +-- explain (verbose, costs off) +-- select * from int8_tbl i8 left join lateral +-- (select *, i8.q2 from int4_tbl where false) ss on true; +-- explain (verbose, costs off) +-- select * from int8_tbl i8 left join lateral +-- (select *, i8.q2 from int4_tbl i1, int4_tbl i2 where false) ss on true; -- check handling of nested appendrels inside LATERAL -select * from - ((select 2 as v) union all (select 3 as v)) as q1 - cross join lateral - ((select * from - ((select 4 as v) union all (select 5 as v)) as q3) - union all - (select q1.v) - ) as q2; +-- select * from +-- ((select 2 as v) union all (select 3 as v)) as q1 +-- cross join lateral +-- ((select * from +-- ((select 4 as v) union all (select 5 as v)) as q3) +-- union all +-- (select q1.v) +-- ) as q2; -- check we don't try to do a unique-ified semijoin with LATERAL -explain (verbose, costs off) -select * from - (values (0,9998), (1,1000)) v(id,x), - lateral (select f1 from int4_tbl - where f1 = any (select unique1 from tenk1 - where unique2 = v.x offset 0)) ss; -select * from - (values (0,9998), (1,1000)) v(id,x), - lateral (select f1 from int4_tbl - where f1 = any (select unique1 from tenk1 - where unique2 = v.x offset 0)) ss; +-- explain (verbose, costs off) +-- select * from +-- (values (0,9998), (1,1000)) v(id,x), +-- lateral (select f1 from int4_tbl +-- where f1 = any (select unique1 from tenk1 +-- where unique2 = v.x offset 0)) ss; +-- select * from +-- (values (0,9998), (1,1000)) v(id,x), +-- lateral (select f1 from int4_tbl +-- where f1 = any (select unique1 from tenk1 +-- where unique2 = v.x offset 0)) ss; -- check proper extParam/allParam handling (this isn't exactly a LATERAL issue, -- but we can make the test case much more compact with LATERAL) -explain (verbose, costs off) -select * from (values (0), (1)) v(id), -lateral (select * from int8_tbl t1, - lateral (select * from - (select * from int8_tbl t2 - where q1 = any (select q2 from int8_tbl t3 - where q2 = (select greatest(t1.q1,t2.q2)) - and (select v.id=0)) offset 0) ss2) ss - where t1.q1 = ss.q2) ss0; - -select * from (values (0), (1)) v(id), -lateral (select * from int8_tbl t1, - lateral (select * from - (select * from int8_tbl t2 - where q1 = any (select q2 from int8_tbl t3 - where q2 = (select greatest(t1.q1,t2.q2)) - and (select v.id=0)) offset 0) ss2) ss - where t1.q1 = ss.q2) ss0; +-- explain (verbose, costs off) +-- select * from (values (0), (1)) v(id), +-- lateral (select * from int8_tbl t1, +-- lateral (select * from +-- (select * from int8_tbl t2 +-- where q1 = any (select q2 from int8_tbl t3 +-- where q2 = (select greatest(t1.q1,t2.q2)) +-- and (select v.id=0)) offset 0) ss2) ss +-- where t1.q1 = ss.q2) ss0; + +-- select * from (values (0), (1)) v(id), +-- lateral (select * from int8_tbl t1, +-- lateral (select * from +-- (select * from int8_tbl t2 +-- where q1 = any (select q2 from int8_tbl t3 +-- where q2 = (select greatest(t1.q1,t2.q2)) +-- and (select v.id=0)) offset 0) ss2) ss +-- where t1.q1 = ss.q2) ss0; -- test some error cases where LATERAL should have been used but wasn't select f1,g from int4_tbl a, (select f1 as g) ss; @@ -1845,229 +1848,232 @@ select f1,g from int4_tbl a, (select a.f1 as g) ss; select f1,g from int4_tbl a cross join (select f1 as g) ss; select f1,g from int4_tbl a cross join (select a.f1 as g) ss; -- SQL:2008 says the left table is in scope but illegal to access here -select f1,g from int4_tbl a right join lateral generate_series(0, a.f1) g on true; -select f1,g from int4_tbl a full join lateral generate_series(0, a.f1) g on true; +-- select f1,g from int4_tbl a right join lateral generate_series(0, a.f1) g on true; +-- select f1,g from int4_tbl a full join lateral generate_series(0, a.f1) g on true; -- check we complain about ambiguous table references -select * from - int8_tbl x cross join (int4_tbl x cross join lateral (select x.f1) ss); +-- select * from +-- int8_tbl x cross join (int4_tbl x cross join lateral (select x.f1) ss); -- LATERAL can be used to put an aggregate into the FROM clause of its query -select 1 from tenk1 a, lateral (select max(a.unique1) from int4_tbl b) ss; +-- select 1 from tenk1 a, lateral (select max(a.unique1) from int4_tbl b) ss; -- check behavior of LATERAL in UPDATE/DELETE -create temp table xx1 as select f1 as x1, -f1 as x2 from int4_tbl; +-- create temp table xx1 as select f1 as x1, -f1 as x2 from int4_tbl; -- error, can't do this: -update xx1 set x2 = f1 from (select * from int4_tbl where f1 = x1) ss; -update xx1 set x2 = f1 from (select * from int4_tbl where f1 = xx1.x1) ss; +-- update xx1 set x2 = f1 from (select * from int4_tbl where f1 = x1) ss; +-- update xx1 set x2 = f1 from (select * from int4_tbl where f1 = xx1.x1) ss; -- can't do it even with LATERAL: -update xx1 set x2 = f1 from lateral (select * from int4_tbl where f1 = x1) ss; +-- update xx1 set x2 = f1 from lateral (select * from int4_tbl where f1 = x1) ss; -- we might in future allow something like this, but for now it's an error: -update xx1 set x2 = f1 from xx1, lateral (select * from int4_tbl where f1 = x1) ss; +-- update xx1 set x2 = f1 from xx1, lateral (select * from int4_tbl where f1 = x1) ss; -- also errors: -delete from xx1 using (select * from int4_tbl where f1 = x1) ss; -delete from xx1 using (select * from int4_tbl where f1 = xx1.x1) ss; -delete from xx1 using lateral (select * from int4_tbl where f1 = x1) ss; +-- delete from xx1 using (select * from int4_tbl where f1 = x1) ss; +-- delete from xx1 using (select * from int4_tbl where f1 = xx1.x1) ss; +-- delete from xx1 using lateral (select * from int4_tbl where f1 = x1) ss; +-- [SPARK-25411] Implement range partition in Spark -- -- test LATERAL reference propagation down a multi-level inheritance hierarchy -- produced for a multi-level partitioned table hierarchy. -- -create table join_pt1 (a int, b int, c varchar) partition by range(a); -create table join_pt1p1 partition of join_pt1 for values from (0) to (100) partition by range(b); -create table join_pt1p2 partition of join_pt1 for values from (100) to (200); -create table join_pt1p1p1 partition of join_pt1p1 for values from (0) to (100); -insert into join_pt1 values (1, 1, 'x'), (101, 101, 'y'); -create table join_ut1 (a int, b int, c varchar); -insert into join_ut1 values (101, 101, 'y'), (2, 2, 'z'); -explain (verbose, costs off) -select t1.b, ss.phv from join_ut1 t1 left join lateral - (select t2.a as t2a, t3.a t3a, least(t1.a, t2.a, t3.a) phv - from join_pt1 t2 join join_ut1 t3 on t2.a = t3.b) ss - on t1.a = ss.t2a order by t1.a; -select t1.b, ss.phv from join_ut1 t1 left join lateral - (select t2.a as t2a, t3.a t3a, least(t1.a, t2.a, t3.a) phv - from join_pt1 t2 join join_ut1 t3 on t2.a = t3.b) ss - on t1.a = ss.t2a order by t1.a; - -drop table join_pt1; -drop table join_ut1; +-- create table join_pt1 (a int, b int, c varchar) partition by range(a); +-- create table join_pt1p1 partition of join_pt1 for values from (0) to (100) partition by range(b); +-- create table join_pt1p2 partition of join_pt1 for values from (100) to (200); +-- create table join_pt1p1p1 partition of join_pt1p1 for values from (0) to (100); +-- insert into join_pt1 values (1, 1, 'x'), (101, 101, 'y'); +-- create table join_ut1 (a int, b int, c varchar); +-- insert into join_ut1 values (101, 101, 'y'), (2, 2, 'z'); +-- explain (verbose, costs off) +-- select t1.b, ss.phv from join_ut1 t1 left join lateral +-- (select t2.a as t2a, t3.a t3a, least(t1.a, t2.a, t3.a) phv +-- from join_pt1 t2 join join_ut1 t3 on t2.a = t3.b) ss +-- on t1.a = ss.t2a order by t1.a; +-- select t1.b, ss.phv from join_ut1 t1 left join lateral +-- (select t2.a as t2a, t3.a t3a, least(t1.a, t2.a, t3.a) phv +-- from join_pt1 t2 join join_ut1 t3 on t2.a = t3.b) ss +-- on t1.a = ss.t2a order by t1.a; +-- +-- drop table join_pt1; +-- drop table join_ut1; -- -- test that foreign key join estimation performs sanely for outer joins -- -begin; +-- begin; -create table fkest (a int, b int, c int unique, primary key(a,b)); -create table fkest1 (a int, b int, primary key(a,b)); +-- create table fkest (a int, b int, c int unique, primary key(a,b)); +-- create table fkest1 (a int, b int, primary key(a,b)); -insert into fkest select x/10, x%10, x from generate_series(1,1000) x; -insert into fkest1 select x/10, x%10 from generate_series(1,1000) x; +-- insert into fkest select x/10, x%10, x from generate_series(1,1000) x; +-- insert into fkest1 select x/10, x%10 from generate_series(1,1000) x; -alter table fkest1 - add constraint fkest1_a_b_fkey foreign key (a,b) references fkest; +-- alter table fkest1 +-- add constraint fkest1_a_b_fkey foreign key (a,b) references fkest; -analyze fkest; -analyze fkest1; +-- analyze fkest; +-- analyze fkest1; -explain (costs off) -select * -from fkest f - left join fkest1 f1 on f.a = f1.a and f.b = f1.b - left join fkest1 f2 on f.a = f2.a and f.b = f2.b - left join fkest1 f3 on f.a = f3.a and f.b = f3.b -where f.c = 1; +-- explain (costs off) +-- select * +-- from fkest f +-- left join fkest1 f1 on f.a = f1.a and f.b = f1.b +-- left join fkest1 f2 on f.a = f2.a and f.b = f2.b +-- left join fkest1 f3 on f.a = f3.a and f.b = f3.b +-- where f.c = 1; -rollback; +-- rollback; +-- Skip these test because it only test explain -- -- test planner's ability to mark joins as unique -- -create table j1 (id int primary key); -create table j2 (id int primary key); -create table j3 (id int); +-- create table j1 (id int primary key); +-- create table j2 (id int primary key); +-- create table j3 (id int); -insert into j1 values(1),(2),(3); -insert into j2 values(1),(2),(3); -insert into j3 values(1),(1); +-- insert into j1 values(1),(2),(3); +-- insert into j2 values(1),(2),(3); +-- insert into j3 values(1),(1); -analyze j1; -analyze j2; -analyze j3; +-- analyze j1; +-- analyze j2; +-- analyze j3; -- ensure join is properly marked as unique -explain (verbose, costs off) -select * from j1 inner join j2 on j1.id = j2.id; +-- explain (verbose, costs off) +-- select * from j1 inner join j2 on j1.id = j2.id; -- ensure join is not unique when not an equi-join -explain (verbose, costs off) -select * from j1 inner join j2 on j1.id > j2.id; +-- explain (verbose, costs off) +-- select * from j1 inner join j2 on j1.id > j2.id; -- ensure non-unique rel is not chosen as inner -explain (verbose, costs off) -select * from j1 inner join j3 on j1.id = j3.id; +-- explain (verbose, costs off) +-- select * from j1 inner join j3 on j1.id = j3.id; -- ensure left join is marked as unique -explain (verbose, costs off) -select * from j1 left join j2 on j1.id = j2.id; +-- explain (verbose, costs off) +-- select * from j1 left join j2 on j1.id = j2.id; -- ensure right join is marked as unique -explain (verbose, costs off) -select * from j1 right join j2 on j1.id = j2.id; +-- explain (verbose, costs off) +-- select * from j1 right join j2 on j1.id = j2.id; -- ensure full join is marked as unique -explain (verbose, costs off) -select * from j1 full join j2 on j1.id = j2.id; +-- explain (verbose, costs off) +-- select * from j1 full join j2 on j1.id = j2.id; -- a clauseless (cross) join can't be unique -explain (verbose, costs off) -select * from j1 cross join j2; +-- explain (verbose, costs off) +-- select * from j1 cross join j2; -- ensure a natural join is marked as unique -explain (verbose, costs off) -select * from j1 natural join j2; +-- explain (verbose, costs off) +-- select * from j1 natural join j2; -- ensure a distinct clause allows the inner to become unique -explain (verbose, costs off) -select * from j1 -inner join (select distinct id from j3) j3 on j1.id = j3.id; +-- explain (verbose, costs off) +-- select * from j1 +-- inner join (select distinct id from j3) j3 on j1.id = j3.id; -- ensure group by clause allows the inner to become unique -explain (verbose, costs off) -select * from j1 -inner join (select id from j3 group by id) j3 on j1.id = j3.id; +-- explain (verbose, costs off) +-- select * from j1 +-- inner join (select id from j3 group by id) j3 on j1.id = j3.id; -drop table j1; -drop table j2; -drop table j3; +drop table if exists j1; +drop table if exists j2; +drop table if exists j3; -- test more complex permutations of unique joins -create table j1 (id1 int, id2 int, primary key(id1,id2)); -create table j2 (id1 int, id2 int, primary key(id1,id2)); -create table j3 (id1 int, id2 int, primary key(id1,id2)); +create table j1 (id1 int, id2 int) using parquet; +create table j2 (id1 int, id2 int) using parquet; +create table j3 (id1 int, id2 int) using parquet; insert into j1 values(1,1),(1,2); insert into j2 values(1,1); insert into j3 values(1,1); -analyze j1; -analyze j2; -analyze j3; +-- analyze j1; +-- analyze j2; +-- analyze j3; -- ensure there's no unique join when not all columns which are part of the -- unique index are seen in the join clause -explain (verbose, costs off) -select * from j1 -inner join j2 on j1.id1 = j2.id1; +-- explain (verbose, costs off) +-- select * from j1 +-- inner join j2 on j1.id1 = j2.id1; -- ensure proper unique detection with multiple join quals -explain (verbose, costs off) -select * from j1 -inner join j2 on j1.id1 = j2.id1 and j1.id2 = j2.id2; +-- explain (verbose, costs off) +-- select * from j1 +-- inner join j2 on j1.id1 = j2.id1 and j1.id2 = j2.id2; -- ensure we don't detect the join to be unique when quals are not part of the -- join condition -explain (verbose, costs off) -select * from j1 -inner join j2 on j1.id1 = j2.id1 where j1.id2 = 1; +-- explain (verbose, costs off) +-- select * from j1 +-- inner join j2 on j1.id1 = j2.id1 where j1.id2 = 1; -- as above, but for left joins. -explain (verbose, costs off) -select * from j1 -left join j2 on j1.id1 = j2.id1 where j1.id2 = 1; +-- explain (verbose, costs off) +-- select * from j1 +-- left join j2 on j1.id1 = j2.id1 where j1.id2 = 1; -- validate logic in merge joins which skips mark and restore. -- it should only do this if all quals which were used to detect the unique -- are present as join quals, and not plain quals. -set enable_nestloop to 0; -set enable_hashjoin to 0; -set enable_sort to 0; +-- set enable_nestloop to 0; +-- set enable_hashjoin to 0; +-- set enable_sort to 0; -- create indexes that will be preferred over the PKs to perform the join -create index j1_id1_idx on j1 (id1) where id1 % 1000 = 1; -create index j2_id1_idx on j2 (id1) where id1 % 1000 = 1; +-- create index j1_id1_idx on j1 (id1) where id1 % 1000 = 1; +-- create index j2_id1_idx on j2 (id1) where id1 % 1000 = 1; -- need an additional row in j2, if we want j2_id1_idx to be preferred insert into j2 values(1,2); -analyze j2; +-- analyze j2; -explain (costs off) select * from j1 -inner join j2 on j1.id1 = j2.id1 and j1.id2 = j2.id2 -where j1.id1 % 1000 = 1 and j2.id1 % 1000 = 1; +-- explain (costs off) select * from j1 +-- inner join j2 on j1.id1 = j2.id1 and j1.id2 = j2.id2 +-- where j1.id1 % 1000 = 1 and j2.id1 % 1000 = 1; select * from j1 inner join j2 on j1.id1 = j2.id1 and j1.id2 = j2.id2 where j1.id1 % 1000 = 1 and j2.id1 % 1000 = 1; -reset enable_nestloop; -reset enable_hashjoin; -reset enable_sort; +-- reset enable_nestloop; +-- reset enable_hashjoin; +-- reset enable_sort; drop table j1; drop table j2; drop table j3; +-- Skip these tests because it only test explain -- check that semijoin inner is not seen as unique for a portion of the outerrel -explain (verbose, costs off) -select t1.unique1, t2.hundred -from onek t1, tenk1 t2 -where exists (select 1 from tenk1 t3 - where t3.thousand = t1.unique1 and t3.tenthous = t2.hundred) - and t1.unique1 < 1; +-- explain (verbose, costs off) +-- select t1.unique1, t2.hundred +-- from onek t1, tenk1 t2 +-- where exists (select 1 from tenk1 t3 +-- where t3.thousand = t1.unique1 and t3.tenthous = t2.hundred) +-- and t1.unique1 < 1; -- ... unless it actually is unique -create table j3 as select unique1, tenthous from onek; -vacuum analyze j3; -create unique index on j3(unique1, tenthous); - -explain (verbose, costs off) -select t1.unique1, t2.hundred -from onek t1, tenk1 t2 -where exists (select 1 from j3 - where j3.unique1 = t1.unique1 and j3.tenthous = t2.hundred) - and t1.unique1 < 1; - -drop table j3; +-- create table j3 as select unique1, tenthous from onek; +-- vacuum analyze j3; +-- create unique index on j3(unique1, tenthous); + +-- explain (verbose, costs off) +-- select t1.unique1, t2.hundred +-- from onek t1, tenk1 t2 +-- where exists (select 1 from j3 +-- where j3.unique1 = t1.unique1 and j3.tenthous = t2.hundred) +-- and t1.unique1 < 1; + +-- drop table j3; diff --git a/sql/core/src/test/resources/sql-tests/results/pgSQL/join.sql.out b/sql/core/src/test/resources/sql-tests/results/pgSQL/join.sql.out new file mode 100644 index 0000000000000..94ef8e047e6f7 --- /dev/null +++ b/sql/core/src/test/resources/sql-tests/results/pgSQL/join.sql.out @@ -0,0 +1,3488 @@ +-- Automatically generated by SQLQueryTestSuite +-- Number of queries: 191 + + +-- !query 0 +create or replace temporary view INT4_TBL as select * from + (values (0), (123456), (-123456), (2147483647), (-2147483647)) + as v(f1) +-- !query 0 schema +struct<> +-- !query 0 output + + + +-- !query 1 +create or replace temporary view INT8_TBL as select * from + (values + (123, 456), + (123, 4567890123456789), + (4567890123456789, 123), + (4567890123456789, 4567890123456789), + (4567890123456789, -4567890123456789)) + as v(q1, q2) +-- !query 1 schema +struct<> +-- !query 1 output + + + +-- !query 2 +create or replace temporary view FLOAT8_TBL as select * from + (values (0.0), (1004.30), (-34.84), + (cast('1.2345678901234e+200' as double)), (cast('1.2345678901234e-200' as double))) + as v(f1) +-- !query 2 schema +struct<> +-- !query 2 output + + + +-- !query 3 +create or replace temporary view TEXT_TBL as select * from + (values ('doh!'), ('hi de ho neighbor')) + as v(f1) +-- !query 3 schema +struct<> +-- !query 3 output + + + +-- !query 4 +create or replace temporary view tenk2 as select * from tenk1 +-- !query 4 schema +struct<> +-- !query 4 output + + + +-- !query 5 +CREATE TABLE J1_TBL ( + i integer, + j integer, + t string +) USING parquet +-- !query 5 schema +struct<> +-- !query 5 output + + + +-- !query 6 +CREATE TABLE J2_TBL ( + i integer, + k integer +) USING parquet +-- !query 6 schema +struct<> +-- !query 6 output + + + +-- !query 7 +INSERT INTO J1_TBL VALUES (1, 4, 'one') +-- !query 7 schema +struct<> +-- !query 7 output + + + +-- !query 8 +INSERT INTO J1_TBL VALUES (2, 3, 'two') +-- !query 8 schema +struct<> +-- !query 8 output + + + +-- !query 9 +INSERT INTO J1_TBL VALUES (3, 2, 'three') +-- !query 9 schema +struct<> +-- !query 9 output + + + +-- !query 10 +INSERT INTO J1_TBL VALUES (4, 1, 'four') +-- !query 10 schema +struct<> +-- !query 10 output + + + +-- !query 11 +INSERT INTO J1_TBL VALUES (5, 0, 'five') +-- !query 11 schema +struct<> +-- !query 11 output + + + +-- !query 12 +INSERT INTO J1_TBL VALUES (6, 6, 'six') +-- !query 12 schema +struct<> +-- !query 12 output + + + +-- !query 13 +INSERT INTO J1_TBL VALUES (7, 7, 'seven') +-- !query 13 schema +struct<> +-- !query 13 output + + + +-- !query 14 +INSERT INTO J1_TBL VALUES (8, 8, 'eight') +-- !query 14 schema +struct<> +-- !query 14 output + + + +-- !query 15 +INSERT INTO J1_TBL VALUES (0, NULL, 'zero') +-- !query 15 schema +struct<> +-- !query 15 output + + + +-- !query 16 +INSERT INTO J1_TBL VALUES (NULL, NULL, 'null') +-- !query 16 schema +struct<> +-- !query 16 output + + + +-- !query 17 +INSERT INTO J1_TBL VALUES (NULL, 0, 'zero') +-- !query 17 schema +struct<> +-- !query 17 output + + + +-- !query 18 +INSERT INTO J2_TBL VALUES (1, -1) +-- !query 18 schema +struct<> +-- !query 18 output + + + +-- !query 19 +INSERT INTO J2_TBL VALUES (2, 2) +-- !query 19 schema +struct<> +-- !query 19 output + + + +-- !query 20 +INSERT INTO J2_TBL VALUES (3, -3) +-- !query 20 schema +struct<> +-- !query 20 output + + + +-- !query 21 +INSERT INTO J2_TBL VALUES (2, 4) +-- !query 21 schema +struct<> +-- !query 21 output + + + +-- !query 22 +INSERT INTO J2_TBL VALUES (5, -5) +-- !query 22 schema +struct<> +-- !query 22 output + + + +-- !query 23 +INSERT INTO J2_TBL VALUES (5, -5) +-- !query 23 schema +struct<> +-- !query 23 output + + + +-- !query 24 +INSERT INTO J2_TBL VALUES (0, NULL) +-- !query 24 schema +struct<> +-- !query 24 output + + + +-- !query 25 +INSERT INTO J2_TBL VALUES (NULL, NULL) +-- !query 25 schema +struct<> +-- !query 25 output + + + +-- !query 26 +INSERT INTO J2_TBL VALUES (NULL, 0) +-- !query 26 schema +struct<> +-- !query 26 output + + + +-- !query 27 +SELECT '' AS `xxx`, * + FROM J1_TBL AS tx +-- !query 27 schema +struct +-- !query 27 output +0 NULL 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 + NULL 0 zero + NULL NULL null + + +-- !query 28 +SELECT '' AS `xxx`, * + FROM J1_TBL tx +-- !query 28 schema +struct +-- !query 28 output +0 NULL 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 + NULL 0 zero + NULL NULL null + + +-- !query 29 +SELECT '' AS `xxx`, * + FROM J1_TBL AS t1 (a, b, c) +-- !query 29 schema +struct +-- !query 29 output +0 NULL 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 + NULL 0 zero + NULL NULL null + + +-- !query 30 +SELECT '' AS `xxx`, * + FROM J1_TBL t1 (a, b, c) +-- !query 30 schema +struct +-- !query 30 output +0 NULL 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 + NULL 0 zero + NULL NULL null + + +-- !query 31 +SELECT '' AS `xxx`, * + FROM J1_TBL t1 (a, b, c), J2_TBL t2 (d, e) +-- !query 31 schema +struct +-- !query 31 output +0 NULL zero 0 NULL + 0 NULL zero 1 -1 + 0 NULL zero 2 2 + 0 NULL zero 2 4 + 0 NULL zero 3 -3 + 0 NULL zero 5 -5 + 0 NULL zero 5 -5 + 0 NULL zero NULL 0 + 0 NULL zero NULL NULL + 1 4 one 0 NULL + 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 NULL 0 + 1 4 one NULL NULL + 2 3 two 0 NULL + 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 NULL 0 + 2 3 two NULL NULL + 3 2 three 0 NULL + 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 NULL 0 + 3 2 three NULL NULL + 4 1 four 0 NULL + 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 NULL 0 + 4 1 four NULL NULL + 5 0 five 0 NULL + 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 NULL 0 + 5 0 five NULL NULL + 6 6 six 0 NULL + 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 NULL 0 + 6 6 six NULL NULL + 7 7 seven 0 NULL + 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 NULL 0 + 7 7 seven NULL NULL + 8 8 eight 0 NULL + 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 NULL 0 + 8 8 eight NULL NULL + NULL 0 zero 0 NULL + NULL 0 zero 1 -1 + NULL 0 zero 2 2 + NULL 0 zero 2 4 + NULL 0 zero 3 -3 + NULL 0 zero 5 -5 + NULL 0 zero 5 -5 + NULL 0 zero NULL 0 + NULL 0 zero NULL NULL + NULL NULL null 0 NULL + NULL NULL null 1 -1 + NULL NULL null 2 2 + NULL NULL null 2 4 + NULL NULL null 3 -3 + NULL NULL null 5 -5 + NULL NULL null 5 -5 + NULL NULL null NULL 0 + NULL NULL null NULL NULL + + +-- !query 32 +SELECT '' AS `xxx`, * + FROM J1_TBL CROSS JOIN J2_TBL +-- !query 32 schema +struct +-- !query 32 output +0 NULL zero 0 NULL + 0 NULL zero 1 -1 + 0 NULL zero 2 2 + 0 NULL zero 2 4 + 0 NULL zero 3 -3 + 0 NULL zero 5 -5 + 0 NULL zero 5 -5 + 0 NULL zero NULL 0 + 0 NULL zero NULL NULL + 1 4 one 0 NULL + 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 NULL 0 + 1 4 one NULL NULL + 2 3 two 0 NULL + 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 NULL 0 + 2 3 two NULL NULL + 3 2 three 0 NULL + 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 NULL 0 + 3 2 three NULL NULL + 4 1 four 0 NULL + 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 NULL 0 + 4 1 four NULL NULL + 5 0 five 0 NULL + 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 NULL 0 + 5 0 five NULL NULL + 6 6 six 0 NULL + 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 NULL 0 + 6 6 six NULL NULL + 7 7 seven 0 NULL + 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 NULL 0 + 7 7 seven NULL NULL + 8 8 eight 0 NULL + 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 NULL 0 + 8 8 eight NULL NULL + NULL 0 zero 0 NULL + NULL 0 zero 1 -1 + NULL 0 zero 2 2 + NULL 0 zero 2 4 + NULL 0 zero 3 -3 + NULL 0 zero 5 -5 + NULL 0 zero 5 -5 + NULL 0 zero NULL 0 + NULL 0 zero NULL NULL + NULL NULL null 0 NULL + NULL NULL null 1 -1 + NULL NULL null 2 2 + NULL NULL null 2 4 + NULL NULL null 3 -3 + NULL NULL null 5 -5 + NULL NULL null 5 -5 + NULL NULL null NULL 0 + NULL NULL null NULL NULL + + +-- !query 33 +SELECT '' AS `xxx`, i, k, t + FROM J1_TBL CROSS JOIN J2_TBL +-- !query 33 schema +struct<> +-- !query 33 output +org.apache.spark.sql.AnalysisException +Reference 'i' is ambiguous, could be: default.j1_tbl.i, default.j2_tbl.i.; line 1 pos 20 + + +-- !query 34 +SELECT '' AS `xxx`, t1.i, k, t + FROM J1_TBL t1 CROSS JOIN J2_TBL t2 +-- !query 34 schema +struct +-- !query 34 output +0 -1 zero + 0 -3 zero + 0 -5 zero + 0 -5 zero + 0 0 zero + 0 2 zero + 0 4 zero + 0 NULL zero + 0 NULL zero + 1 -1 one + 1 -3 one + 1 -5 one + 1 -5 one + 1 0 one + 1 2 one + 1 4 one + 1 NULL one + 1 NULL one + 2 -1 two + 2 -3 two + 2 -5 two + 2 -5 two + 2 0 two + 2 2 two + 2 4 two + 2 NULL two + 2 NULL two + 3 -1 three + 3 -3 three + 3 -5 three + 3 -5 three + 3 0 three + 3 2 three + 3 4 three + 3 NULL three + 3 NULL three + 4 -1 four + 4 -3 four + 4 -5 four + 4 -5 four + 4 0 four + 4 2 four + 4 4 four + 4 NULL four + 4 NULL four + 5 -1 five + 5 -3 five + 5 -5 five + 5 -5 five + 5 0 five + 5 2 five + 5 4 five + 5 NULL five + 5 NULL five + 6 -1 six + 6 -3 six + 6 -5 six + 6 -5 six + 6 0 six + 6 2 six + 6 4 six + 6 NULL six + 6 NULL six + 7 -1 seven + 7 -3 seven + 7 -5 seven + 7 -5 seven + 7 0 seven + 7 2 seven + 7 4 seven + 7 NULL seven + 7 NULL seven + 8 -1 eight + 8 -3 eight + 8 -5 eight + 8 -5 eight + 8 0 eight + 8 2 eight + 8 4 eight + 8 NULL eight + 8 NULL eight + NULL -1 null + NULL -1 zero + NULL -3 null + NULL -3 zero + NULL -5 null + NULL -5 null + NULL -5 zero + NULL -5 zero + NULL 0 null + NULL 0 zero + NULL 2 null + NULL 2 zero + NULL 4 null + NULL 4 zero + NULL NULL null + NULL NULL null + NULL NULL zero + NULL NULL zero + + +-- !query 35 +SELECT '' AS `xxx`, ii, tt, kk + FROM (J1_TBL CROSS JOIN J2_TBL) + AS tx (ii, jj, tt, ii2, kk) +-- !query 35 schema +struct +-- !query 35 output +0 zero -1 + 0 zero -3 + 0 zero -5 + 0 zero -5 + 0 zero 0 + 0 zero 2 + 0 zero 4 + 0 zero NULL + 0 zero NULL + 1 one -1 + 1 one -3 + 1 one -5 + 1 one -5 + 1 one 0 + 1 one 2 + 1 one 4 + 1 one NULL + 1 one NULL + 2 two -1 + 2 two -3 + 2 two -5 + 2 two -5 + 2 two 0 + 2 two 2 + 2 two 4 + 2 two NULL + 2 two NULL + 3 three -1 + 3 three -3 + 3 three -5 + 3 three -5 + 3 three 0 + 3 three 2 + 3 three 4 + 3 three NULL + 3 three NULL + 4 four -1 + 4 four -3 + 4 four -5 + 4 four -5 + 4 four 0 + 4 four 2 + 4 four 4 + 4 four NULL + 4 four NULL + 5 five -1 + 5 five -3 + 5 five -5 + 5 five -5 + 5 five 0 + 5 five 2 + 5 five 4 + 5 five NULL + 5 five NULL + 6 six -1 + 6 six -3 + 6 six -5 + 6 six -5 + 6 six 0 + 6 six 2 + 6 six 4 + 6 six NULL + 6 six NULL + 7 seven -1 + 7 seven -3 + 7 seven -5 + 7 seven -5 + 7 seven 0 + 7 seven 2 + 7 seven 4 + 7 seven NULL + 7 seven NULL + 8 eight -1 + 8 eight -3 + 8 eight -5 + 8 eight -5 + 8 eight 0 + 8 eight 2 + 8 eight 4 + 8 eight NULL + 8 eight NULL + NULL null -1 + NULL null -3 + NULL null -5 + NULL null -5 + NULL null 0 + NULL null 2 + NULL null 4 + NULL null NULL + NULL null NULL + NULL zero -1 + NULL zero -3 + NULL zero -5 + NULL zero -5 + NULL zero 0 + NULL zero 2 + NULL zero 4 + NULL zero NULL + NULL zero NULL + + +-- !query 36 +SELECT '' AS `xxx`, * + FROM J1_TBL CROSS JOIN J2_TBL a CROSS JOIN J2_TBL b +-- !query 36 schema +struct +-- !query 36 output +0 NULL zero 0 NULL 0 NULL + 0 NULL zero 0 NULL 1 -1 + 0 NULL zero 0 NULL 2 2 + 0 NULL zero 0 NULL 2 4 + 0 NULL zero 0 NULL 3 -3 + 0 NULL zero 0 NULL 5 -5 + 0 NULL zero 0 NULL 5 -5 + 0 NULL zero 0 NULL NULL 0 + 0 NULL zero 0 NULL NULL NULL + 0 NULL zero 1 -1 0 NULL + 0 NULL zero 1 -1 1 -1 + 0 NULL zero 1 -1 2 2 + 0 NULL zero 1 -1 2 4 + 0 NULL zero 1 -1 3 -3 + 0 NULL zero 1 -1 5 -5 + 0 NULL zero 1 -1 5 -5 + 0 NULL zero 1 -1 NULL 0 + 0 NULL zero 1 -1 NULL NULL + 0 NULL zero 2 2 0 NULL + 0 NULL zero 2 2 1 -1 + 0 NULL zero 2 2 2 2 + 0 NULL zero 2 2 2 4 + 0 NULL zero 2 2 3 -3 + 0 NULL zero 2 2 5 -5 + 0 NULL zero 2 2 5 -5 + 0 NULL zero 2 2 NULL 0 + 0 NULL zero 2 2 NULL NULL + 0 NULL zero 2 4 0 NULL + 0 NULL zero 2 4 1 -1 + 0 NULL zero 2 4 2 2 + 0 NULL zero 2 4 2 4 + 0 NULL zero 2 4 3 -3 + 0 NULL zero 2 4 5 -5 + 0 NULL zero 2 4 5 -5 + 0 NULL zero 2 4 NULL 0 + 0 NULL zero 2 4 NULL NULL + 0 NULL zero 3 -3 0 NULL + 0 NULL zero 3 -3 1 -1 + 0 NULL zero 3 -3 2 2 + 0 NULL zero 3 -3 2 4 + 0 NULL zero 3 -3 3 -3 + 0 NULL zero 3 -3 5 -5 + 0 NULL zero 3 -3 5 -5 + 0 NULL zero 3 -3 NULL 0 + 0 NULL zero 3 -3 NULL NULL + 0 NULL zero 5 -5 0 NULL + 0 NULL zero 5 -5 0 NULL + 0 NULL zero 5 -5 1 -1 + 0 NULL zero 5 -5 1 -1 + 0 NULL zero 5 -5 2 2 + 0 NULL zero 5 -5 2 2 + 0 NULL zero 5 -5 2 4 + 0 NULL zero 5 -5 2 4 + 0 NULL zero 5 -5 3 -3 + 0 NULL zero 5 -5 3 -3 + 0 NULL zero 5 -5 5 -5 + 0 NULL zero 5 -5 5 -5 + 0 NULL zero 5 -5 5 -5 + 0 NULL zero 5 -5 5 -5 + 0 NULL zero 5 -5 NULL 0 + 0 NULL zero 5 -5 NULL 0 + 0 NULL zero 5 -5 NULL NULL + 0 NULL zero 5 -5 NULL NULL + 0 NULL zero NULL 0 0 NULL + 0 NULL zero NULL 0 1 -1 + 0 NULL zero NULL 0 2 2 + 0 NULL zero NULL 0 2 4 + 0 NULL zero NULL 0 3 -3 + 0 NULL zero NULL 0 5 -5 + 0 NULL zero NULL 0 5 -5 + 0 NULL zero NULL 0 NULL 0 + 0 NULL zero NULL 0 NULL NULL + 0 NULL zero NULL NULL 0 NULL + 0 NULL zero NULL NULL 1 -1 + 0 NULL zero NULL NULL 2 2 + 0 NULL zero NULL NULL 2 4 + 0 NULL zero NULL NULL 3 -3 + 0 NULL zero NULL NULL 5 -5 + 0 NULL zero NULL NULL 5 -5 + 0 NULL zero NULL NULL NULL 0 + 0 NULL zero NULL NULL NULL NULL + 1 4 one 0 NULL 0 NULL + 1 4 one 0 NULL 1 -1 + 1 4 one 0 NULL 2 2 + 1 4 one 0 NULL 2 4 + 1 4 one 0 NULL 3 -3 + 1 4 one 0 NULL 5 -5 + 1 4 one 0 NULL 5 -5 + 1 4 one 0 NULL NULL 0 + 1 4 one 0 NULL NULL NULL + 1 4 one 1 -1 0 NULL + 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 NULL 0 + 1 4 one 1 -1 NULL NULL + 1 4 one 2 2 0 NULL + 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 NULL 0 + 1 4 one 2 2 NULL NULL + 1 4 one 2 4 0 NULL + 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 NULL 0 + 1 4 one 2 4 NULL NULL + 1 4 one 3 -3 0 NULL + 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 NULL 0 + 1 4 one 3 -3 NULL NULL + 1 4 one 5 -5 0 NULL + 1 4 one 5 -5 0 NULL + 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 NULL 0 + 1 4 one 5 -5 NULL 0 + 1 4 one 5 -5 NULL NULL + 1 4 one 5 -5 NULL NULL + 1 4 one NULL 0 0 NULL + 1 4 one NULL 0 1 -1 + 1 4 one NULL 0 2 2 + 1 4 one NULL 0 2 4 + 1 4 one NULL 0 3 -3 + 1 4 one NULL 0 5 -5 + 1 4 one NULL 0 5 -5 + 1 4 one NULL 0 NULL 0 + 1 4 one NULL 0 NULL NULL + 1 4 one NULL NULL 0 NULL + 1 4 one NULL NULL 1 -1 + 1 4 one NULL NULL 2 2 + 1 4 one NULL NULL 2 4 + 1 4 one NULL NULL 3 -3 + 1 4 one NULL NULL 5 -5 + 1 4 one NULL NULL 5 -5 + 1 4 one NULL NULL NULL 0 + 1 4 one NULL NULL NULL NULL + 2 3 two 0 NULL 0 NULL + 2 3 two 0 NULL 1 -1 + 2 3 two 0 NULL 2 2 + 2 3 two 0 NULL 2 4 + 2 3 two 0 NULL 3 -3 + 2 3 two 0 NULL 5 -5 + 2 3 two 0 NULL 5 -5 + 2 3 two 0 NULL NULL 0 + 2 3 two 0 NULL NULL NULL + 2 3 two 1 -1 0 NULL + 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 NULL 0 + 2 3 two 1 -1 NULL NULL + 2 3 two 2 2 0 NULL + 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 NULL 0 + 2 3 two 2 2 NULL NULL + 2 3 two 2 4 0 NULL + 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 NULL 0 + 2 3 two 2 4 NULL NULL + 2 3 two 3 -3 0 NULL + 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 NULL 0 + 2 3 two 3 -3 NULL NULL + 2 3 two 5 -5 0 NULL + 2 3 two 5 -5 0 NULL + 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 NULL 0 + 2 3 two 5 -5 NULL 0 + 2 3 two 5 -5 NULL NULL + 2 3 two 5 -5 NULL NULL + 2 3 two NULL 0 0 NULL + 2 3 two NULL 0 1 -1 + 2 3 two NULL 0 2 2 + 2 3 two NULL 0 2 4 + 2 3 two NULL 0 3 -3 + 2 3 two NULL 0 5 -5 + 2 3 two NULL 0 5 -5 + 2 3 two NULL 0 NULL 0 + 2 3 two NULL 0 NULL NULL + 2 3 two NULL NULL 0 NULL + 2 3 two NULL NULL 1 -1 + 2 3 two NULL NULL 2 2 + 2 3 two NULL NULL 2 4 + 2 3 two NULL NULL 3 -3 + 2 3 two NULL NULL 5 -5 + 2 3 two NULL NULL 5 -5 + 2 3 two NULL NULL NULL 0 + 2 3 two NULL NULL NULL NULL + 3 2 three 0 NULL 0 NULL + 3 2 three 0 NULL 1 -1 + 3 2 three 0 NULL 2 2 + 3 2 three 0 NULL 2 4 + 3 2 three 0 NULL 3 -3 + 3 2 three 0 NULL 5 -5 + 3 2 three 0 NULL 5 -5 + 3 2 three 0 NULL NULL 0 + 3 2 three 0 NULL NULL NULL + 3 2 three 1 -1 0 NULL + 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 NULL 0 + 3 2 three 1 -1 NULL NULL + 3 2 three 2 2 0 NULL + 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 NULL 0 + 3 2 three 2 2 NULL NULL + 3 2 three 2 4 0 NULL + 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 NULL 0 + 3 2 three 2 4 NULL NULL + 3 2 three 3 -3 0 NULL + 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 NULL 0 + 3 2 three 3 -3 NULL NULL + 3 2 three 5 -5 0 NULL + 3 2 three 5 -5 0 NULL + 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 NULL 0 + 3 2 three 5 -5 NULL 0 + 3 2 three 5 -5 NULL NULL + 3 2 three 5 -5 NULL NULL + 3 2 three NULL 0 0 NULL + 3 2 three NULL 0 1 -1 + 3 2 three NULL 0 2 2 + 3 2 three NULL 0 2 4 + 3 2 three NULL 0 3 -3 + 3 2 three NULL 0 5 -5 + 3 2 three NULL 0 5 -5 + 3 2 three NULL 0 NULL 0 + 3 2 three NULL 0 NULL NULL + 3 2 three NULL NULL 0 NULL + 3 2 three NULL NULL 1 -1 + 3 2 three NULL NULL 2 2 + 3 2 three NULL NULL 2 4 + 3 2 three NULL NULL 3 -3 + 3 2 three NULL NULL 5 -5 + 3 2 three NULL NULL 5 -5 + 3 2 three NULL NULL NULL 0 + 3 2 three NULL NULL NULL NULL + 4 1 four 0 NULL 0 NULL + 4 1 four 0 NULL 1 -1 + 4 1 four 0 NULL 2 2 + 4 1 four 0 NULL 2 4 + 4 1 four 0 NULL 3 -3 + 4 1 four 0 NULL 5 -5 + 4 1 four 0 NULL 5 -5 + 4 1 four 0 NULL NULL 0 + 4 1 four 0 NULL NULL NULL + 4 1 four 1 -1 0 NULL + 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 NULL 0 + 4 1 four 1 -1 NULL NULL + 4 1 four 2 2 0 NULL + 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 NULL 0 + 4 1 four 2 2 NULL NULL + 4 1 four 2 4 0 NULL + 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 NULL 0 + 4 1 four 2 4 NULL NULL + 4 1 four 3 -3 0 NULL + 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 NULL 0 + 4 1 four 3 -3 NULL NULL + 4 1 four 5 -5 0 NULL + 4 1 four 5 -5 0 NULL + 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 NULL 0 + 4 1 four 5 -5 NULL 0 + 4 1 four 5 -5 NULL NULL + 4 1 four 5 -5 NULL NULL + 4 1 four NULL 0 0 NULL + 4 1 four NULL 0 1 -1 + 4 1 four NULL 0 2 2 + 4 1 four NULL 0 2 4 + 4 1 four NULL 0 3 -3 + 4 1 four NULL 0 5 -5 + 4 1 four NULL 0 5 -5 + 4 1 four NULL 0 NULL 0 + 4 1 four NULL 0 NULL NULL + 4 1 four NULL NULL 0 NULL + 4 1 four NULL NULL 1 -1 + 4 1 four NULL NULL 2 2 + 4 1 four NULL NULL 2 4 + 4 1 four NULL NULL 3 -3 + 4 1 four NULL NULL 5 -5 + 4 1 four NULL NULL 5 -5 + 4 1 four NULL NULL NULL 0 + 4 1 four NULL NULL NULL NULL + 5 0 five 0 NULL 0 NULL + 5 0 five 0 NULL 1 -1 + 5 0 five 0 NULL 2 2 + 5 0 five 0 NULL 2 4 + 5 0 five 0 NULL 3 -3 + 5 0 five 0 NULL 5 -5 + 5 0 five 0 NULL 5 -5 + 5 0 five 0 NULL NULL 0 + 5 0 five 0 NULL NULL NULL + 5 0 five 1 -1 0 NULL + 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 NULL 0 + 5 0 five 1 -1 NULL NULL + 5 0 five 2 2 0 NULL + 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 NULL 0 + 5 0 five 2 2 NULL NULL + 5 0 five 2 4 0 NULL + 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 NULL 0 + 5 0 five 2 4 NULL NULL + 5 0 five 3 -3 0 NULL + 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 NULL 0 + 5 0 five 3 -3 NULL NULL + 5 0 five 5 -5 0 NULL + 5 0 five 5 -5 0 NULL + 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 NULL 0 + 5 0 five 5 -5 NULL 0 + 5 0 five 5 -5 NULL NULL + 5 0 five 5 -5 NULL NULL + 5 0 five NULL 0 0 NULL + 5 0 five NULL 0 1 -1 + 5 0 five NULL 0 2 2 + 5 0 five NULL 0 2 4 + 5 0 five NULL 0 3 -3 + 5 0 five NULL 0 5 -5 + 5 0 five NULL 0 5 -5 + 5 0 five NULL 0 NULL 0 + 5 0 five NULL 0 NULL NULL + 5 0 five NULL NULL 0 NULL + 5 0 five NULL NULL 1 -1 + 5 0 five NULL NULL 2 2 + 5 0 five NULL NULL 2 4 + 5 0 five NULL NULL 3 -3 + 5 0 five NULL NULL 5 -5 + 5 0 five NULL NULL 5 -5 + 5 0 five NULL NULL NULL 0 + 5 0 five NULL NULL NULL NULL + 6 6 six 0 NULL 0 NULL + 6 6 six 0 NULL 1 -1 + 6 6 six 0 NULL 2 2 + 6 6 six 0 NULL 2 4 + 6 6 six 0 NULL 3 -3 + 6 6 six 0 NULL 5 -5 + 6 6 six 0 NULL 5 -5 + 6 6 six 0 NULL NULL 0 + 6 6 six 0 NULL NULL NULL + 6 6 six 1 -1 0 NULL + 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 NULL 0 + 6 6 six 1 -1 NULL NULL + 6 6 six 2 2 0 NULL + 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 NULL 0 + 6 6 six 2 2 NULL NULL + 6 6 six 2 4 0 NULL + 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 NULL 0 + 6 6 six 2 4 NULL NULL + 6 6 six 3 -3 0 NULL + 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 NULL 0 + 6 6 six 3 -3 NULL NULL + 6 6 six 5 -5 0 NULL + 6 6 six 5 -5 0 NULL + 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 NULL 0 + 6 6 six 5 -5 NULL 0 + 6 6 six 5 -5 NULL NULL + 6 6 six 5 -5 NULL NULL + 6 6 six NULL 0 0 NULL + 6 6 six NULL 0 1 -1 + 6 6 six NULL 0 2 2 + 6 6 six NULL 0 2 4 + 6 6 six NULL 0 3 -3 + 6 6 six NULL 0 5 -5 + 6 6 six NULL 0 5 -5 + 6 6 six NULL 0 NULL 0 + 6 6 six NULL 0 NULL NULL + 6 6 six NULL NULL 0 NULL + 6 6 six NULL NULL 1 -1 + 6 6 six NULL NULL 2 2 + 6 6 six NULL NULL 2 4 + 6 6 six NULL NULL 3 -3 + 6 6 six NULL NULL 5 -5 + 6 6 six NULL NULL 5 -5 + 6 6 six NULL NULL NULL 0 + 6 6 six NULL NULL NULL NULL + 7 7 seven 0 NULL 0 NULL + 7 7 seven 0 NULL 1 -1 + 7 7 seven 0 NULL 2 2 + 7 7 seven 0 NULL 2 4 + 7 7 seven 0 NULL 3 -3 + 7 7 seven 0 NULL 5 -5 + 7 7 seven 0 NULL 5 -5 + 7 7 seven 0 NULL NULL 0 + 7 7 seven 0 NULL NULL NULL + 7 7 seven 1 -1 0 NULL + 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 NULL 0 + 7 7 seven 1 -1 NULL NULL + 7 7 seven 2 2 0 NULL + 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 NULL 0 + 7 7 seven 2 2 NULL NULL + 7 7 seven 2 4 0 NULL + 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 NULL 0 + 7 7 seven 2 4 NULL NULL + 7 7 seven 3 -3 0 NULL + 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 NULL 0 + 7 7 seven 3 -3 NULL NULL + 7 7 seven 5 -5 0 NULL + 7 7 seven 5 -5 0 NULL + 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 NULL 0 + 7 7 seven 5 -5 NULL 0 + 7 7 seven 5 -5 NULL NULL + 7 7 seven 5 -5 NULL NULL + 7 7 seven NULL 0 0 NULL + 7 7 seven NULL 0 1 -1 + 7 7 seven NULL 0 2 2 + 7 7 seven NULL 0 2 4 + 7 7 seven NULL 0 3 -3 + 7 7 seven NULL 0 5 -5 + 7 7 seven NULL 0 5 -5 + 7 7 seven NULL 0 NULL 0 + 7 7 seven NULL 0 NULL NULL + 7 7 seven NULL NULL 0 NULL + 7 7 seven NULL NULL 1 -1 + 7 7 seven NULL NULL 2 2 + 7 7 seven NULL NULL 2 4 + 7 7 seven NULL NULL 3 -3 + 7 7 seven NULL NULL 5 -5 + 7 7 seven NULL NULL 5 -5 + 7 7 seven NULL NULL NULL 0 + 7 7 seven NULL NULL NULL NULL + 8 8 eight 0 NULL 0 NULL + 8 8 eight 0 NULL 1 -1 + 8 8 eight 0 NULL 2 2 + 8 8 eight 0 NULL 2 4 + 8 8 eight 0 NULL 3 -3 + 8 8 eight 0 NULL 5 -5 + 8 8 eight 0 NULL 5 -5 + 8 8 eight 0 NULL NULL 0 + 8 8 eight 0 NULL NULL NULL + 8 8 eight 1 -1 0 NULL + 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 NULL 0 + 8 8 eight 1 -1 NULL NULL + 8 8 eight 2 2 0 NULL + 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 NULL 0 + 8 8 eight 2 2 NULL NULL + 8 8 eight 2 4 0 NULL + 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 NULL 0 + 8 8 eight 2 4 NULL NULL + 8 8 eight 3 -3 0 NULL + 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 NULL 0 + 8 8 eight 3 -3 NULL NULL + 8 8 eight 5 -5 0 NULL + 8 8 eight 5 -5 0 NULL + 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 NULL 0 + 8 8 eight 5 -5 NULL 0 + 8 8 eight 5 -5 NULL NULL + 8 8 eight 5 -5 NULL NULL + 8 8 eight NULL 0 0 NULL + 8 8 eight NULL 0 1 -1 + 8 8 eight NULL 0 2 2 + 8 8 eight NULL 0 2 4 + 8 8 eight NULL 0 3 -3 + 8 8 eight NULL 0 5 -5 + 8 8 eight NULL 0 5 -5 + 8 8 eight NULL 0 NULL 0 + 8 8 eight NULL 0 NULL NULL + 8 8 eight NULL NULL 0 NULL + 8 8 eight NULL NULL 1 -1 + 8 8 eight NULL NULL 2 2 + 8 8 eight NULL NULL 2 4 + 8 8 eight NULL NULL 3 -3 + 8 8 eight NULL NULL 5 -5 + 8 8 eight NULL NULL 5 -5 + 8 8 eight NULL NULL NULL 0 + 8 8 eight NULL NULL NULL NULL + NULL 0 zero 0 NULL 0 NULL + NULL 0 zero 0 NULL 1 -1 + NULL 0 zero 0 NULL 2 2 + NULL 0 zero 0 NULL 2 4 + NULL 0 zero 0 NULL 3 -3 + NULL 0 zero 0 NULL 5 -5 + NULL 0 zero 0 NULL 5 -5 + NULL 0 zero 0 NULL NULL 0 + NULL 0 zero 0 NULL NULL NULL + NULL 0 zero 1 -1 0 NULL + NULL 0 zero 1 -1 1 -1 + NULL 0 zero 1 -1 2 2 + NULL 0 zero 1 -1 2 4 + NULL 0 zero 1 -1 3 -3 + NULL 0 zero 1 -1 5 -5 + NULL 0 zero 1 -1 5 -5 + NULL 0 zero 1 -1 NULL 0 + NULL 0 zero 1 -1 NULL NULL + NULL 0 zero 2 2 0 NULL + NULL 0 zero 2 2 1 -1 + NULL 0 zero 2 2 2 2 + NULL 0 zero 2 2 2 4 + NULL 0 zero 2 2 3 -3 + NULL 0 zero 2 2 5 -5 + NULL 0 zero 2 2 5 -5 + NULL 0 zero 2 2 NULL 0 + NULL 0 zero 2 2 NULL NULL + NULL 0 zero 2 4 0 NULL + NULL 0 zero 2 4 1 -1 + NULL 0 zero 2 4 2 2 + NULL 0 zero 2 4 2 4 + NULL 0 zero 2 4 3 -3 + NULL 0 zero 2 4 5 -5 + NULL 0 zero 2 4 5 -5 + NULL 0 zero 2 4 NULL 0 + NULL 0 zero 2 4 NULL NULL + NULL 0 zero 3 -3 0 NULL + NULL 0 zero 3 -3 1 -1 + NULL 0 zero 3 -3 2 2 + NULL 0 zero 3 -3 2 4 + NULL 0 zero 3 -3 3 -3 + NULL 0 zero 3 -3 5 -5 + NULL 0 zero 3 -3 5 -5 + NULL 0 zero 3 -3 NULL 0 + NULL 0 zero 3 -3 NULL NULL + NULL 0 zero 5 -5 0 NULL + NULL 0 zero 5 -5 0 NULL + NULL 0 zero 5 -5 1 -1 + NULL 0 zero 5 -5 1 -1 + NULL 0 zero 5 -5 2 2 + NULL 0 zero 5 -5 2 2 + NULL 0 zero 5 -5 2 4 + NULL 0 zero 5 -5 2 4 + NULL 0 zero 5 -5 3 -3 + NULL 0 zero 5 -5 3 -3 + NULL 0 zero 5 -5 5 -5 + NULL 0 zero 5 -5 5 -5 + NULL 0 zero 5 -5 5 -5 + NULL 0 zero 5 -5 5 -5 + NULL 0 zero 5 -5 NULL 0 + NULL 0 zero 5 -5 NULL 0 + NULL 0 zero 5 -5 NULL NULL + NULL 0 zero 5 -5 NULL NULL + NULL 0 zero NULL 0 0 NULL + NULL 0 zero NULL 0 1 -1 + NULL 0 zero NULL 0 2 2 + NULL 0 zero NULL 0 2 4 + NULL 0 zero NULL 0 3 -3 + NULL 0 zero NULL 0 5 -5 + NULL 0 zero NULL 0 5 -5 + NULL 0 zero NULL 0 NULL 0 + NULL 0 zero NULL 0 NULL NULL + NULL 0 zero NULL NULL 0 NULL + NULL 0 zero NULL NULL 1 -1 + NULL 0 zero NULL NULL 2 2 + NULL 0 zero NULL NULL 2 4 + NULL 0 zero NULL NULL 3 -3 + NULL 0 zero NULL NULL 5 -5 + NULL 0 zero NULL NULL 5 -5 + NULL 0 zero NULL NULL NULL 0 + NULL 0 zero NULL NULL NULL NULL + NULL NULL null 0 NULL 0 NULL + NULL NULL null 0 NULL 1 -1 + NULL NULL null 0 NULL 2 2 + NULL NULL null 0 NULL 2 4 + NULL NULL null 0 NULL 3 -3 + NULL NULL null 0 NULL 5 -5 + NULL NULL null 0 NULL 5 -5 + NULL NULL null 0 NULL NULL 0 + NULL NULL null 0 NULL NULL NULL + NULL NULL null 1 -1 0 NULL + NULL NULL null 1 -1 1 -1 + NULL NULL null 1 -1 2 2 + NULL NULL null 1 -1 2 4 + NULL NULL null 1 -1 3 -3 + NULL NULL null 1 -1 5 -5 + NULL NULL null 1 -1 5 -5 + NULL NULL null 1 -1 NULL 0 + NULL NULL null 1 -1 NULL NULL + NULL NULL null 2 2 0 NULL + NULL NULL null 2 2 1 -1 + NULL NULL null 2 2 2 2 + NULL NULL null 2 2 2 4 + NULL NULL null 2 2 3 -3 + NULL NULL null 2 2 5 -5 + NULL NULL null 2 2 5 -5 + NULL NULL null 2 2 NULL 0 + NULL NULL null 2 2 NULL NULL + NULL NULL null 2 4 0 NULL + NULL NULL null 2 4 1 -1 + NULL NULL null 2 4 2 2 + NULL NULL null 2 4 2 4 + NULL NULL null 2 4 3 -3 + NULL NULL null 2 4 5 -5 + NULL NULL null 2 4 5 -5 + NULL NULL null 2 4 NULL 0 + NULL NULL null 2 4 NULL NULL + NULL NULL null 3 -3 0 NULL + NULL NULL null 3 -3 1 -1 + NULL NULL null 3 -3 2 2 + NULL NULL null 3 -3 2 4 + NULL NULL null 3 -3 3 -3 + NULL NULL null 3 -3 5 -5 + NULL NULL null 3 -3 5 -5 + NULL NULL null 3 -3 NULL 0 + NULL NULL null 3 -3 NULL NULL + NULL NULL null 5 -5 0 NULL + NULL NULL null 5 -5 0 NULL + NULL NULL null 5 -5 1 -1 + NULL NULL null 5 -5 1 -1 + NULL NULL null 5 -5 2 2 + NULL NULL null 5 -5 2 2 + NULL NULL null 5 -5 2 4 + NULL NULL null 5 -5 2 4 + NULL NULL null 5 -5 3 -3 + NULL NULL null 5 -5 3 -3 + NULL NULL null 5 -5 5 -5 + NULL NULL null 5 -5 5 -5 + NULL NULL null 5 -5 5 -5 + NULL NULL null 5 -5 5 -5 + NULL NULL null 5 -5 NULL 0 + NULL NULL null 5 -5 NULL 0 + NULL NULL null 5 -5 NULL NULL + NULL NULL null 5 -5 NULL NULL + NULL NULL null NULL 0 0 NULL + NULL NULL null NULL 0 1 -1 + NULL NULL null NULL 0 2 2 + NULL NULL null NULL 0 2 4 + NULL NULL null NULL 0 3 -3 + NULL NULL null NULL 0 5 -5 + NULL NULL null NULL 0 5 -5 + NULL NULL null NULL 0 NULL 0 + NULL NULL null NULL 0 NULL NULL + NULL NULL null NULL NULL 0 NULL + NULL NULL null NULL NULL 1 -1 + NULL NULL null NULL NULL 2 2 + NULL NULL null NULL NULL 2 4 + NULL NULL null NULL NULL 3 -3 + NULL NULL null NULL NULL 5 -5 + NULL NULL null NULL NULL 5 -5 + NULL NULL null NULL NULL NULL 0 + NULL NULL null NULL NULL NULL NULL + + +-- !query 37 +SELECT '' AS `xxx`, * + FROM J1_TBL INNER JOIN J2_TBL USING (i) +-- !query 37 schema +struct +-- !query 37 output +0 NULL zero NULL + 1 4 one -1 + 2 3 two 2 + 2 3 two 4 + 3 2 three -3 + 5 0 five -5 + 5 0 five -5 + + +-- !query 38 +SELECT '' AS `xxx`, * + FROM J1_TBL JOIN J2_TBL USING (i) +-- !query 38 schema +struct +-- !query 38 output +0 NULL zero NULL + 1 4 one -1 + 2 3 two 2 + 2 3 two 4 + 3 2 three -3 + 5 0 five -5 + 5 0 five -5 + + +-- !query 39 +SELECT '' AS `xxx`, * + FROM J1_TBL t1 (a, b, c) JOIN J2_TBL t2 (a, d) USING (a) + ORDER BY a, d +-- !query 39 schema +struct +-- !query 39 output +0 NULL zero NULL + 1 4 one -1 + 2 3 two 2 + 2 3 two 4 + 3 2 three -3 + 5 0 five -5 + 5 0 five -5 + + +-- !query 40 +SELECT '' AS `xxx`, * + FROM J1_TBL NATURAL JOIN J2_TBL +-- !query 40 schema +struct +-- !query 40 output +0 NULL zero NULL + 1 4 one -1 + 2 3 two 2 + 2 3 two 4 + 3 2 three -3 + 5 0 five -5 + 5 0 five -5 + + +-- !query 41 +SELECT '' AS `xxx`, * + FROM J1_TBL t1 (a, b, c) NATURAL JOIN J2_TBL t2 (a, d) +-- !query 41 schema +struct +-- !query 41 output +0 NULL zero NULL + 1 4 one -1 + 2 3 two 2 + 2 3 two 4 + 3 2 three -3 + 5 0 five -5 + 5 0 five -5 + + +-- !query 42 +SELECT '' AS `xxx`, * + FROM J1_TBL t1 (a, b, c) NATURAL JOIN J2_TBL t2 (d, a) +-- !query 42 schema +struct +-- !query 42 output +0 NULL zero NULL + 2 3 two 2 + 4 1 four 2 + + +-- !query 43 +SELECT '' AS `xxx`, * + FROM J1_TBL JOIN J2_TBL ON (J1_TBL.i = J2_TBL.i) +-- !query 43 schema +struct +-- !query 43 output +0 NULL zero 0 NULL + 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 + + +-- !query 44 +SELECT '' AS `xxx`, * + FROM J1_TBL JOIN J2_TBL ON (J1_TBL.i = J2_TBL.k) +-- !query 44 schema +struct +-- !query 44 output +0 NULL zero NULL 0 + 2 3 two 2 2 + 4 1 four 2 4 + + +-- !query 45 +SELECT '' AS `xxx`, * + FROM J1_TBL JOIN J2_TBL ON (J1_TBL.i <= J2_TBL.k) +-- !query 45 schema +struct +-- !query 45 output +0 NULL zero 2 2 + 0 NULL zero 2 4 + 0 NULL zero NULL 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 + + +-- !query 46 +SELECT '' AS `xxx`, * + FROM J1_TBL LEFT OUTER JOIN J2_TBL USING (i) + ORDER BY i, k, t +-- !query 46 schema +struct +-- !query 46 output +NULL NULL null NULL + NULL 0 zero NULL + 0 NULL zero NULL + 1 4 one -1 + 2 3 two 2 + 2 3 two 4 + 3 2 three -3 + 4 1 four NULL + 5 0 five -5 + 5 0 five -5 + 6 6 six NULL + 7 7 seven NULL + 8 8 eight NULL + + +-- !query 47 +SELECT '' AS `xxx`, * + FROM J1_TBL LEFT JOIN J2_TBL USING (i) + ORDER BY i, k, t +-- !query 47 schema +struct +-- !query 47 output +NULL NULL null NULL + NULL 0 zero NULL + 0 NULL zero NULL + 1 4 one -1 + 2 3 two 2 + 2 3 two 4 + 3 2 three -3 + 4 1 four NULL + 5 0 five -5 + 5 0 five -5 + 6 6 six NULL + 7 7 seven NULL + 8 8 eight NULL + + +-- !query 48 +SELECT '' AS `xxx`, * + FROM J1_TBL RIGHT OUTER JOIN J2_TBL USING (i) +-- !query 48 schema +struct +-- !query 48 output +0 NULL zero NULL + 1 4 one -1 + 2 3 two 2 + 2 3 two 4 + 3 2 three -3 + 5 0 five -5 + 5 0 five -5 + NULL NULL NULL 0 + NULL NULL NULL NULL + + +-- !query 49 +SELECT '' AS `xxx`, * + FROM J1_TBL RIGHT JOIN J2_TBL USING (i) +-- !query 49 schema +struct +-- !query 49 output +0 NULL zero NULL + 1 4 one -1 + 2 3 two 2 + 2 3 two 4 + 3 2 three -3 + 5 0 five -5 + 5 0 five -5 + NULL NULL NULL 0 + NULL NULL NULL NULL + + +-- !query 50 +SELECT '' AS `xxx`, * + FROM J1_TBL FULL OUTER JOIN J2_TBL USING (i) + ORDER BY i, k, t +-- !query 50 schema +struct +-- !query 50 output +NULL NULL NULL NULL + NULL NULL null NULL + NULL 0 zero NULL + NULL NULL NULL 0 + 0 NULL zero NULL + 1 4 one -1 + 2 3 two 2 + 2 3 two 4 + 3 2 three -3 + 4 1 four NULL + 5 0 five -5 + 5 0 five -5 + 6 6 six NULL + 7 7 seven NULL + 8 8 eight NULL + + +-- !query 51 +SELECT '' AS `xxx`, * + FROM J1_TBL FULL JOIN J2_TBL USING (i) + ORDER BY i, k, t +-- !query 51 schema +struct +-- !query 51 output +NULL NULL NULL NULL + NULL NULL null NULL + NULL 0 zero NULL + NULL NULL NULL 0 + 0 NULL zero NULL + 1 4 one -1 + 2 3 two 2 + 2 3 two 4 + 3 2 three -3 + 4 1 four NULL + 5 0 five -5 + 5 0 five -5 + 6 6 six NULL + 7 7 seven NULL + 8 8 eight NULL + + +-- !query 52 +SELECT '' AS `xxx`, * + FROM J1_TBL LEFT JOIN J2_TBL USING (i) WHERE (k = 1) +-- !query 52 schema +struct +-- !query 52 output + + + +-- !query 53 +SELECT '' AS `xxx`, * + FROM J1_TBL LEFT JOIN J2_TBL USING (i) WHERE (i = 1) +-- !query 53 schema +struct +-- !query 53 output +1 4 one -1 + + +-- !query 54 +CREATE TABLE t1 (name STRING, n INTEGER) USING parquet +-- !query 54 schema +struct<> +-- !query 54 output + + + +-- !query 55 +CREATE TABLE t2 (name STRING, n INTEGER) USING parquet +-- !query 55 schema +struct<> +-- !query 55 output + + + +-- !query 56 +CREATE TABLE t3 (name STRING, n INTEGER) USING parquet +-- !query 56 schema +struct<> +-- !query 56 output + + + +-- !query 57 +INSERT INTO t1 VALUES ( 'bb', 11 ) +-- !query 57 schema +struct<> +-- !query 57 output + + + +-- !query 58 +INSERT INTO t2 VALUES ( 'bb', 12 ) +-- !query 58 schema +struct<> +-- !query 58 output + + + +-- !query 59 +INSERT INTO t2 VALUES ( 'cc', 22 ) +-- !query 59 schema +struct<> +-- !query 59 output + + + +-- !query 60 +INSERT INTO t2 VALUES ( 'ee', 42 ) +-- !query 60 schema +struct<> +-- !query 60 output + + + +-- !query 61 +INSERT INTO t3 VALUES ( 'bb', 13 ) +-- !query 61 schema +struct<> +-- !query 61 output + + + +-- !query 62 +INSERT INTO t3 VALUES ( 'cc', 23 ) +-- !query 62 schema +struct<> +-- !query 62 output + + + +-- !query 63 +INSERT INTO t3 VALUES ( 'dd', 33 ) +-- !query 63 schema +struct<> +-- !query 63 output + + + +-- !query 64 +SELECT * FROM t1 FULL JOIN t2 USING (name) FULL JOIN t3 USING (name) +-- !query 64 schema +struct +-- !query 64 output +bb 11 12 13 +cc NULL 22 23 +dd NULL NULL 33 +ee NULL 42 NULL + + +-- !query 65 +SELECT * FROM +(SELECT * FROM t2) as s2 +INNER JOIN +(SELECT * FROM t3) s3 +USING (name) +-- !query 65 schema +struct +-- !query 65 output +bb 12 13 +cc 22 23 + + +-- !query 66 +SELECT * FROM +(SELECT * FROM t2) as s2 +LEFT JOIN +(SELECT * FROM t3) s3 +USING (name) +-- !query 66 schema +struct +-- !query 66 output +bb 12 13 +cc 22 23 +ee 42 NULL + + +-- !query 67 +SELECT * FROM +(SELECT * FROM t2) as s2 +FULL JOIN +(SELECT * FROM t3) s3 +USING (name) +-- !query 67 schema +struct +-- !query 67 output +bb 12 13 +cc 22 23 +dd NULL 33 +ee 42 NULL + + +-- !query 68 +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 +-- !query 68 schema +struct +-- !query 68 output +bb 12 2 13 3 +cc 22 2 23 3 + + +-- !query 69 +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 +-- !query 69 schema +struct +-- !query 69 output +bb 12 2 13 3 +cc 22 2 23 3 +ee 42 2 NULL NULL + + +-- !query 70 +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 +-- !query 70 schema +struct +-- !query 70 output +bb 12 2 13 3 +cc 22 2 23 3 +dd NULL NULL 33 3 +ee 42 2 NULL NULL + + +-- !query 71 +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 +-- !query 71 schema +struct +-- !query 71 output +bb 11 1 12 2 13 3 + + +-- !query 72 +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 +-- !query 72 schema +struct +-- !query 72 output +bb 11 1 12 2 13 3 +cc NULL NULL 22 2 23 3 +dd NULL NULL NULL NULL 33 3 +ee NULL NULL 42 2 NULL NULL + + +-- !query 73 +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 +-- !query 73 schema +struct +-- !query 73 output +bb 11 12 13 +cc NULL 22 23 +dd NULL NULL 33 +ee NULL 42 NULL + + +-- !query 74 +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 +-- !query 74 schema +struct +-- !query 74 output +bb 11 12 2 13 +cc NULL 22 2 23 +dd NULL NULL NULL 33 +ee NULL 42 2 NULL + + +-- !query 75 +SELECT * FROM + (SELECT name, n as s1_n FROM t1) as s1 +FULL JOIN + (SELECT name, 2 as s2_n FROM t2) as s2 +ON (s1_n = s2_n) +-- !query 75 schema +struct +-- !query 75 output +NULL NULL bb 2 +NULL NULL cc 2 +NULL NULL ee 2 +bb 11 NULL NULL + + +-- !query 76 +create or replace temporary view x as select * from + (values (1,11), (2,22), (3,null), (4,44), (5,null)) + as v(x1, x2) +-- !query 76 schema +struct<> +-- !query 76 output + + + +-- !query 77 +create or replace temporary view y as select * from + (values (1,111), (2,222), (3,333), (4,null)) + as v(y1, y2) +-- !query 77 schema +struct<> +-- !query 77 output + + + +-- !query 78 +select * from x +-- !query 78 schema +struct +-- !query 78 output +1 11 +2 22 +3 NULL +4 44 +5 NULL + + +-- !query 79 +select * from y +-- !query 79 schema +struct +-- !query 79 output +1 111 +2 222 +3 333 +4 NULL + + +-- !query 80 +select * from x left join y on (x1 = y1 and x2 is not null) +-- !query 80 schema +struct +-- !query 80 output +1 11 1 111 +2 22 2 222 +3 NULL NULL NULL +4 44 4 NULL +5 NULL NULL NULL + + +-- !query 81 +select * from x left join y on (x1 = y1 and y2 is not null) +-- !query 81 schema +struct +-- !query 81 output +1 11 1 111 +2 22 2 222 +3 NULL 3 333 +4 44 NULL NULL +5 NULL NULL NULL + + +-- !query 82 +select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) +on (x1 = xx1) +-- !query 82 schema +struct +-- !query 82 output +1 11 1 111 1 11 +2 22 2 222 2 22 +3 NULL 3 333 3 NULL +4 44 4 NULL 4 44 +5 NULL NULL NULL 5 NULL + + +-- !query 83 +select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) +on (x1 = xx1 and x2 is not null) +-- !query 83 schema +struct +-- !query 83 output +1 11 1 111 1 11 +2 22 2 222 2 22 +3 NULL 3 333 NULL NULL +4 44 4 NULL 4 44 +5 NULL NULL NULL NULL NULL + + +-- !query 84 +select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) +on (x1 = xx1 and y2 is not null) +-- !query 84 schema +struct +-- !query 84 output +1 11 1 111 1 11 +2 22 2 222 2 22 +3 NULL 3 333 3 NULL +4 44 4 NULL NULL NULL +5 NULL NULL NULL NULL NULL + + +-- !query 85 +select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) +on (x1 = xx1 and xx2 is not null) +-- !query 85 schema +struct +-- !query 85 output +1 11 1 111 1 11 +2 22 2 222 2 22 +3 NULL 3 333 NULL NULL +4 44 4 NULL 4 44 +5 NULL NULL NULL NULL NULL + + +-- !query 86 +select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) +on (x1 = xx1) where (x2 is not null) +-- !query 86 schema +struct +-- !query 86 output +1 11 1 111 1 11 +2 22 2 222 2 22 +4 44 4 NULL 4 44 + + +-- !query 87 +select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) +on (x1 = xx1) where (y2 is not null) +-- !query 87 schema +struct +-- !query 87 output +1 11 1 111 1 11 +2 22 2 222 2 22 +3 NULL 3 333 3 NULL + + +-- !query 88 +select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) +on (x1 = xx1) where (xx2 is not null) +-- !query 88 schema +struct +-- !query 88 output +1 11 1 111 1 11 +2 22 2 222 2 22 +4 44 4 NULL 4 44 + + +-- !query 89 +select count(*) from tenk1 a where unique1 in + (select unique1 from tenk1 b join tenk1 c using (unique1) + where b.unique2 = 42) +-- !query 89 schema +struct +-- !query 89 output +1 + + +-- !query 90 +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) +-- !query 90 schema +struct +-- !query 90 output +1 + + +-- !query 91 +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) +-- !query 91 schema +struct +-- !query 91 output +1 + + +-- !query 92 +select * from int8_tbl i1 left join (int8_tbl i2 join + (select 123 as x) ss on i2.q1 = x) on i1.q2 = i2.q2 +order by 1, 2 +-- !query 92 schema +struct +-- !query 92 output +123 456 123 456 123 +123 4567890123456789 123 4567890123456789 123 +4567890123456789 -4567890123456789 NULL NULL NULL +4567890123456789 123 NULL NULL NULL +4567890123456789 4567890123456789 123 4567890123456789 123 + + +-- !query 93 +select count(*) +from + (select t3.tenthous as x1, coalesce(t1.stringu1, t2.stringu1) as x2 + from tenk1 t1 + left join tenk1 t2 on t1.unique1 = t2.unique1 + join tenk1 t3 on t1.unique2 = t3.unique2) ss, + tenk1 t4, + tenk1 t5 +where t4.thousand = t5.unique1 and ss.x1 = t4.tenthous and ss.x2 = t5.stringu1 +-- !query 93 schema +struct +-- !query 93 output +1000 + + +-- !query 94 +select a.f1, b.f1, t.thousand, t.tenthous from + tenk1 t, + (select sum(f1)+1 as f1 from int4_tbl i4a) a, + (select sum(f1) as f1 from int4_tbl i4b) b +where b.f1 = t.thousand and a.f1 = b.f1 and (a.f1+b.f1+999) = t.tenthous +-- !query 94 schema +struct +-- !query 94 output + + + +-- !query 95 +select * from + j1_tbl full join + (select * from j2_tbl order by j2_tbl.i desc, j2_tbl.k asc) j2_tbl + on j1_tbl.i = j2_tbl.i and j1_tbl.i = j2_tbl.k +-- !query 95 schema +struct +-- !query 95 output +0 NULL zero NULL NULL +1 4 one NULL NULL +2 3 two 2 2 +3 2 three NULL NULL +4 1 four NULL NULL +5 0 five NULL NULL +6 6 six NULL NULL +7 7 seven NULL NULL +8 8 eight NULL NULL +NULL 0 zero NULL NULL +NULL NULL NULL 0 NULL +NULL NULL NULL 1 -1 +NULL NULL NULL 2 4 +NULL NULL NULL 3 -3 +NULL NULL NULL 5 -5 +NULL NULL NULL 5 -5 +NULL NULL NULL NULL 0 +NULL NULL NULL NULL NULL +NULL NULL null NULL NULL + + +-- !query 96 +select count(*) from + (select * from tenk1 x order by x.thousand, x.twothousand, x.fivethous) x + left join + (select * from tenk1 y order by y.unique2) y + on x.thousand = y.unique2 and x.twothousand = y.hundred and x.fivethous = y.unique2 +-- !query 96 schema +struct +-- !query 96 output +10000 + + +-- !query 97 +DROP TABLE t1 +-- !query 97 schema +struct<> +-- !query 97 output + + + +-- !query 98 +DROP TABLE t2 +-- !query 98 schema +struct<> +-- !query 98 output + + + +-- !query 99 +DROP TABLE t3 +-- !query 99 schema +struct<> +-- !query 99 output + + + +-- !query 100 +DROP TABLE J1_TBL +-- !query 100 schema +struct<> +-- !query 100 output + + + +-- !query 101 +DROP TABLE J2_TBL +-- !query 101 schema +struct<> +-- !query 101 output + + + +-- !query 102 +create or replace temporary view tt1 as select * from + (values (1, 11), (2, NULL)) + as v(tt1_id, joincol) +-- !query 102 schema +struct<> +-- !query 102 output + + + +-- !query 103 +create or replace temporary view tt2 as select * from + (values (21, 11), (22, 11)) + as v(tt2_id, joincol) +-- !query 103 schema +struct<> +-- !query 103 output + + + +-- !query 104 +select tt1.*, tt2.* from tt1 left join tt2 on tt1.joincol = tt2.joincol +-- !query 104 schema +struct +-- !query 104 output +1 11 21 11 +1 11 22 11 +2 NULL NULL NULL + + +-- !query 105 +select tt1.*, tt2.* from tt2 right join tt1 on tt1.joincol = tt2.joincol +-- !query 105 schema +struct +-- !query 105 output +1 11 21 11 +1 11 22 11 +2 NULL NULL NULL + + +-- !query 106 +select count(*) from tenk1 a, tenk1 b + where a.hundred = b.thousand and (b.fivethous % 10) < 10 +-- !query 106 schema +struct +-- !query 106 output +100000 + + +-- !query 107 +drop table if exists tt3 +-- !query 107 schema +struct<> +-- !query 107 output + + + +-- !query 108 +create table tt3(f1 int, f2 string) using parquet +-- !query 108 schema +struct<> +-- !query 108 output + + + +-- !query 109 +insert into tt3 select x.id, repeat('xyzzy', 100) from range(1,10001) x +-- !query 109 schema +struct<> +-- !query 109 output + + + +-- !query 110 +drop table if exists tt4 +-- !query 110 schema +struct<> +-- !query 110 output + + + +-- !query 111 +create table tt4(f1 int) using parquet +-- !query 111 schema +struct<> +-- !query 111 output + + + +-- !query 112 +insert into tt4 values (0),(1),(9999) +-- !query 112 schema +struct<> +-- !query 112 output + + + +-- !query 113 +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 +-- !query 113 schema +struct +-- !query 113 output +0 +1 +9999 + + +-- !query 114 +create or replace temporary view tt5 as select * from + (values (1, 10), (1, 11)) + as v(f1, f2) +-- !query 114 schema +struct<> +-- !query 114 output + + + +-- !query 115 +create or replace temporary view tt6 as select * from + (values (1, 9), (1, 2), (2, 9)) + as v(f1, f2) +-- !query 115 schema +struct<> +-- !query 115 output + + + +-- !query 116 +select * from tt5,tt6 where tt5.f1 = tt6.f1 and tt5.f1 = tt5.f2 - tt6.f2 +-- !query 116 schema +struct +-- !query 116 output +1 10 1 9 + + +-- !query 117 +create or replace temporary view xx as select * from + (values (1), (2), (3)) + as v(pkxx) +-- !query 117 schema +struct<> +-- !query 117 output + + + +-- !query 118 +create or replace temporary view yy as select * from + (values (101, 1), (201, 2), (301, NULL)) + as v(pkyy, pkxx) +-- !query 118 schema +struct<> +-- !query 118 output + + + +-- !query 119 +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 +-- !query 119 schema +struct +-- !query 119 output +101 1 101 1 1 +201 2 NULL NULL 1 +301 NULL NULL NULL 1 + + +-- !query 120 +create or replace temporary view zt1 as select * from + (values (53)) + as v(f1) +-- !query 120 schema +struct<> +-- !query 120 output + + + +-- !query 121 +create or replace temporary view zt2 as select * from + (values (53)) + as v(f2) +-- !query 121 schema +struct<> +-- !query 121 output + + + +-- !query 122 +create or replace temporary view zt3(f3 int) using parquet +-- !query 122 schema +struct<> +-- !query 122 output + + + +-- !query 123 +select * from + zt2 left join zt3 on (f2 = f3) + left join zt1 on (f3 = f1) +where f2 = 53 +-- !query 123 schema +struct +-- !query 123 output +53 NULL NULL + + +-- !query 124 +create temp view zv1 as select *,'dummy' AS junk from zt1 +-- !query 124 schema +struct<> +-- !query 124 output + + + +-- !query 125 +select * from + zt2 left join zt3 on (f2 = f3) + left join zv1 on (f3 = f1) +where f2 = 53 +-- !query 125 schema +struct +-- !query 125 output +53 NULL NULL NULL + + +-- !query 126 +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) +-- !query 126 schema +struct +-- !query 126 output + + + +-- !query 127 +create or replace temporary view a (i integer) using parquet +-- !query 127 schema +struct<> +-- !query 127 output + + + +-- !query 128 +create or replace temporary view b (x integer, y integer) using parquet +-- !query 128 schema +struct<> +-- !query 128 output + + + +-- !query 129 +select * from a left join b on i = x and i = y and x = i +-- !query 129 schema +struct +-- !query 129 output + + + +-- !query 130 +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 +-- !query 130 schema +struct +-- !query 130 output +-4567890123456789 0 +123 2 +456 0 +4567890123456789 6 + + +-- !query 131 +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 +-- !query 131 schema +struct +-- !query 131 output +-4567890123456789 0 +123 2 +456 0 +4567890123456789 6 + + +-- !query 132 +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 +-- !query 132 schema +struct +-- !query 132 output +-4567890123456789 0 +123 2 +456 0 +4567890123456789 6 + + +-- !query 133 +create or replace temporary view a as select * from + (values ('p'), ('q')) + as v(code) +-- !query 133 schema +struct<> +-- !query 133 output + + + +-- !query 134 +create or replace temporary view b as select * from + (values ('p', 1), ('p', 2)) + as v(a, num) +-- !query 134 schema +struct<> +-- !query 134 output + + + +-- !query 135 +create or replace temporary view c as select * from + (values ('A', 'p'), ('B', 'q'), ('C', null)) + as v(name, a) +-- !query 135 schema +struct<> +-- !query 135 output + + + +-- !query 136 +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 +-- !query 136 schema +struct +-- !query 136 output +A p 2 -1 +B q 0 -1 +C NULL NULL NULL + + +-- !query 137 +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 +-- !query 137 schema +struct +-- !query 137 output +1 1 1 1 + + +-- !query 138 +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 +-- !query 138 schema +struct +-- !query 138 output +1 1 1 1 + + +-- !query 139 +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 139 schema +struct +-- !query 139 output +123 4596 +123 4596 +456 7318 + + +-- !query 140 +create or replace temporary view nt1 as select * from + (values(1,true,true), (2,true,false), (3,false,false)) + as v(id, a1, a2) +-- !query 140 schema +struct<> +-- !query 140 output + + + +-- !query 141 +create or replace temporary view nt2 as select * from + (values(1,1,true,true), (2,2,true,false), (3,3,false,false)) + as v(id, nt1_id, b1, b2) +-- !query 141 schema +struct<> +-- !query 141 output + + + +-- !query 142 +create or replace temporary view nt3 as select * from + (values(1,1,true), (2,2,false), (3,3,true)) + as v(id, nt2_id, c1) +-- !query 142 schema +struct<> +-- !query 142 output + + + +-- !query 143 +select nt3.id +from nt3 as nt3 + left join + (select nt2.*, (nt2.b1 and ss1.a3) AS b3 + from nt2 as nt2 + left join + (select nt1.*, (nt1.id is not null) as a3 from nt1) as ss1 + on ss1.id = nt2.nt1_id + ) as ss2 + on ss2.id = nt3.nt2_id +where nt3.id = 1 and ss2.b3 +-- !query 143 schema +struct +-- !query 143 output +1 + + +-- !query 144 +select * from int4_tbl a full join int4_tbl b on true +-- !query 144 schema +struct +-- !query 144 output +-123456 -123456 +-123456 -2147483647 +-123456 0 +-123456 123456 +-123456 2147483647 +-2147483647 -123456 +-2147483647 -2147483647 +-2147483647 0 +-2147483647 123456 +-2147483647 2147483647 +0 -123456 +0 -2147483647 +0 0 +0 123456 +0 2147483647 +123456 -123456 +123456 -2147483647 +123456 0 +123456 123456 +123456 2147483647 +2147483647 -123456 +2147483647 -2147483647 +2147483647 0 +2147483647 123456 +2147483647 2147483647 + + +-- !query 145 +select * from int4_tbl a full join int4_tbl b on false +-- !query 145 schema +struct +-- !query 145 output +-123456 NULL +-2147483647 NULL +0 NULL +123456 NULL +2147483647 NULL +NULL -123456 +NULL -2147483647 +NULL 0 +NULL 123456 +NULL 2147483647 + + +-- !query 146 +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 146 schema +struct +-- !query 146 output +10 + + +-- !query 147 +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 147 schema +struct +-- !query 147 output +NULL +NULL +NULL +NULL +0 + + +-- !query 148 +select * from +( + select unique1, q1, coalesce(unique1, -1) + q1 as fault + from int8_tbl left join tenk1 on (q2 = unique2) +) ss +where fault = 122 +order by fault +-- !query 148 schema +struct +-- !query 148 output +NULL 123 122 + + +-- !query 149 +select q1, unique2, thousand, hundred + from int8_tbl a left join tenk1 b on q1 = unique2 + where coalesce(thousand,123) = q1 and q1 = coalesce(hundred,123) +-- !query 149 schema +struct +-- !query 149 output + + + +-- !query 150 +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 150 schema +struct +-- !query 150 output +0 0 0 + + +-- !query 151 +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 151 schema +struct +-- !query 151 output + + + +-- !query 152 +select * from + text_tbl t1 + inner join int8_tbl i8 + on i8.q2 = 456 + right join text_tbl t2 + on t1.f1 = 'doh!' + left join int4_tbl i4 + on i8.q1 = i4.f1 +-- !query 152 schema +struct +-- !query 152 output +doh! 123 456 doh! NULL +doh! 123 456 hi de ho neighbor NULL + + +-- !query 153 +select * from + (select 1 as id) as xx + left join + (tenk1 as a1 full join (select 1 as id) as yy on (a1.unique1 = yy.id)) + on (xx.id = coalesce(yy.id)) +-- !query 153 schema +struct +-- !query 153 output +1 1 2838 1 1 1 1 1 1 1 1 1 2 3 BAAAAA EFEAAA OOOOxx 1 + + +-- !query 154 +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 154 schema +struct +-- !query 154 output +-4567890123456789 NULL +123 123 +123 123 +456 NULL +4567890123456789 4567890123456789 +4567890123456789 4567890123456789 +4567890123456789 4567890123456789 +4567890123456789 4567890123456789 +4567890123456789 4567890123456789 +4567890123456789 4567890123456789 + + +-- !query 155 +create or replace temporary view parent as select * from + (values (1, 10), (2, 20), (3, 30)) + as v(k, pd) +-- !query 155 schema +struct<> +-- !query 155 output + + + +-- !query 156 +create or replace temporary view child as select * from + (values (1, 100), (4, 400)) + as v(k, cd) +-- !query 156 schema +struct<> +-- !query 156 output + + + +-- !query 157 +select p.* from parent p left join child c on (p.k = c.k) +-- !query 157 schema +struct +-- !query 157 output +1 10 +2 20 +3 30 + + +-- !query 158 +select p.*, linked from parent p + left join (select c.*, true as linked from child c) as ss + on (p.k = ss.k) +-- !query 158 schema +struct +-- !query 158 output +1 10 true +2 20 NULL +3 30 NULL + + +-- !query 159 +select p.* from + parent p left join child c on (p.k = c.k) + where p.k = 1 and p.k = 2 +-- !query 159 schema +struct +-- !query 159 output + + + +-- !query 160 +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 160 schema +struct +-- !query 160 output + + + +-- !query 161 +create or replace temporary view a as select * from + (values (0), (1)) + as v(id) +-- !query 161 schema +struct<> +-- !query 161 output + + + +-- !query 162 +create or replace temporary view b as select * from + (values (0, 0), (1, NULL)) + as v(id, a_id) +-- !query 162 schema +struct<> +-- !query 162 output + + + +-- !query 163 +SELECT * FROM b LEFT JOIN a ON (b.a_id = a.id) WHERE (a.id IS NULL OR a.id > 0) +-- !query 163 schema +struct +-- !query 163 output +1 NULL NULL + + +-- !query 164 +SELECT b.* FROM b LEFT JOIN a ON (b.a_id = a.id) WHERE (a.id IS NULL OR a.id > 0) +-- !query 164 schema +struct +-- !query 164 output +1 NULL + + +-- !query 165 +create or replace temporary view innertab as select * from + (values (123L, 42L)) + as v(id, dat1) +-- !query 165 schema +struct<> +-- !query 165 output + + + +-- !query 166 +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 +-- !query 166 schema +struct +-- !query 166 output +1 123 456 123 +1 123 4567890123456789 123 +1 4567890123456789 -4567890123456789 4567890123456789 +1 4567890123456789 123 42 +1 4567890123456789 4567890123456789 4567890123456789 + + +-- !query 167 +select * from + int8_tbl x join (int4_tbl x cross join int4_tbl y) j on q1 = f1 +-- !query 167 schema +struct<> +-- !query 167 output +org.apache.spark.sql.AnalysisException +Reference 'f1' is ambiguous, could be: j.f1, j.f1.; line 2 pos 63 + + +-- !query 168 +-- error +select * from + int8_tbl x join (int4_tbl x cross join int4_tbl y) j on q1 = y.f1 +-- !query 168 schema +struct<> +-- !query 168 output +org.apache.spark.sql.AnalysisException +cannot resolve '`y.f1`' given input columns: [j.f1, j.f1, x.q1, x.q2]; line 3 pos 63 + + +-- !query 169 +-- error +select * from + int8_tbl x join (int4_tbl x cross join int4_tbl y(ff)) j on q1 = f1 +-- !query 169 schema +struct +-- !query 169 output + + + +-- !query 170 +-- ok + + +select t1.uunique1 from + tenk1 t1 join tenk2 t2 on t1.two = t2.two +-- !query 170 schema +struct<> +-- !query 170 output +org.apache.spark.sql.AnalysisException +cannot resolve '`t1.uunique1`' given input columns: [t1.even, t2.even, t1.fivethous, t2.fivethous, t1.four, t2.four, t1.hundred, t2.hundred, t1.odd, t2.odd, t1.string4, t2.string4, t1.stringu1, t2.stringu1, t1.stringu2, t2.stringu2, t1.ten, t2.ten, t1.tenthous, t2.tenthous, t1.thousand, t2.thousand, t1.twenty, t2.twenty, t1.two, t2.two, t1.twothousand, t2.twothousand, t1.unique1, t2.unique1, t1.unique2, t2.unique2]; line 4 pos 7 + + +-- !query 171 +-- error, prefer "t1" suggestion +select t2.uunique1 from + tenk1 t1 join tenk2 t2 on t1.two = t2.two +-- !query 171 schema +struct<> +-- !query 171 output +org.apache.spark.sql.AnalysisException +cannot resolve '`t2.uunique1`' given input columns: [t1.even, t2.even, t1.fivethous, t2.fivethous, t1.four, t2.four, t1.hundred, t2.hundred, t1.odd, t2.odd, t1.string4, t2.string4, t1.stringu1, t2.stringu1, t1.stringu2, t2.stringu2, t1.ten, t2.ten, t1.tenthous, t2.tenthous, t1.thousand, t2.thousand, t1.twenty, t2.twenty, t1.two, t2.two, t1.twothousand, t2.twothousand, t1.unique1, t2.unique1, t1.unique2, t2.unique2]; line 2 pos 7 + + +-- !query 172 +-- error, prefer "t2" suggestion +select uunique1 from + tenk1 t1 join tenk2 t2 on t1.two = t2.two +-- !query 172 schema +struct<> +-- !query 172 output +org.apache.spark.sql.AnalysisException +cannot resolve '`uunique1`' given input columns: [t1.even, t2.even, t1.fivethous, t2.fivethous, t1.four, t2.four, t1.hundred, t2.hundred, t1.odd, t2.odd, t1.string4, t2.string4, t1.stringu1, t2.stringu1, t1.stringu2, t2.stringu2, t1.ten, t2.ten, t1.tenthous, t2.tenthous, t1.thousand, t2.thousand, t1.twenty, t2.twenty, t1.two, t2.two, t1.twothousand, t2.twothousand, t1.unique1, t2.unique1, t1.unique2, t2.unique2]; line 2 pos 7 + + +-- !query 173 +-- error, suggest both at once + + + + + + + + + + + + + + + + + + + + + + + + +select f1,g from int4_tbl a, (select f1 as g) ss +-- !query 173 schema +struct<> +-- !query 173 output +org.apache.spark.sql.AnalysisException +cannot resolve '`f1`' given input columns: []; line 26 pos 37 + + +-- !query 174 +select f1,g from int4_tbl a, (select a.f1 as g) ss +-- !query 174 schema +struct<> +-- !query 174 output +org.apache.spark.sql.AnalysisException +cannot resolve '`a.f1`' given input columns: []; line 1 pos 37 + + +-- !query 175 +select f1,g from int4_tbl a cross join (select f1 as g) ss +-- !query 175 schema +struct<> +-- !query 175 output +org.apache.spark.sql.AnalysisException +cannot resolve '`f1`' given input columns: []; line 1 pos 47 + + +-- !query 176 +select f1,g from int4_tbl a cross join (select a.f1 as g) ss +-- !query 176 schema +struct<> +-- !query 176 output +org.apache.spark.sql.AnalysisException +cannot resolve '`a.f1`' given input columns: []; line 1 pos 47 + + +-- !query 177 +drop table if exists j1 +-- !query 177 schema +struct<> +-- !query 177 output + + + +-- !query 178 +drop table if exists j2 +-- !query 178 schema +struct<> +-- !query 178 output + + + +-- !query 179 +drop table if exists j3 +-- !query 179 schema +struct<> +-- !query 179 output + + + +-- !query 180 +create table j1 (id1 int, id2 int) using parquet +-- !query 180 schema +struct<> +-- !query 180 output + + + +-- !query 181 +create table j2 (id1 int, id2 int) using parquet +-- !query 181 schema +struct<> +-- !query 181 output + + + +-- !query 182 +create table j3 (id1 int, id2 int) using parquet +-- !query 182 schema +struct<> +-- !query 182 output + + + +-- !query 183 +insert into j1 values(1,1),(1,2) +-- !query 183 schema +struct<> +-- !query 183 output + + + +-- !query 184 +insert into j2 values(1,1) +-- !query 184 schema +struct<> +-- !query 184 output + + + +-- !query 185 +insert into j3 values(1,1) +-- !query 185 schema +struct<> +-- !query 185 output + + + +-- !query 186 +insert into j2 values(1,2) +-- !query 186 schema +struct<> +-- !query 186 output + + + +-- !query 187 +select * from j1 +inner join j2 on j1.id1 = j2.id1 and j1.id2 = j2.id2 +where j1.id1 % 1000 = 1 and j2.id1 % 1000 = 1 +-- !query 187 schema +struct +-- !query 187 output +1 1 1 1 +1 2 1 2 + + +-- !query 188 +drop table j1 +-- !query 188 schema +struct<> +-- !query 188 output + + + +-- !query 189 +drop table j2 +-- !query 189 schema +struct<> +-- !query 189 output + + + +-- !query 190 +drop table j3 +-- !query 190 schema +struct<> +-- !query 190 output + From f329e6df444242ee7522b10a63b9caec6660a0df Mon Sep 17 00:00:00 2001 From: Yuming Wang Date: Sun, 14 Jul 2019 21:25:29 +0800 Subject: [PATCH 3/5] Fix comment --- sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql index 38f277c864688..e7e755920590c 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql @@ -398,7 +398,7 @@ select count(*) from tenk1 x where x.unique1 in (select aa.f1 from int4_tbl aa,float8_tbl bb where aa.f1=bb.f1); -- rollback; --- Skip this test because we do no know how to create table b +-- Skip this test because table b inherits from table a and we do not support this feature, see inherits.sql -- -- regression test: be sure we cope with proven-dummy append rels -- From 12ff0b2fe5378e29a5bce8a35f9870bddc3dcadc Mon Sep 17 00:00:00 2001 From: Yuming Wang Date: Mon, 29 Jul 2019 22:40:53 +0800 Subject: [PATCH 4/5] fix --- .../resources/sql-tests/inputs/pgSQL/join.sql | 60 ++++----- .../sql-tests/results/pgSQL/join.sql.out | 114 +++++------------- 2 files changed, 63 insertions(+), 111 deletions(-) diff --git a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql index e7e755920590c..24c2027fbeac2 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql @@ -6,25 +6,25 @@ -- Test JOIN clauses -- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/join.sql -- -create or replace temporary view INT4_TBL as select * from - (values (0), (123456), (-123456), (2147483647), (-2147483647)) - as v(f1); -create or replace temporary view INT8_TBL as select * from - (values +CREATE OR REPLACE TEMPORARY VIEW INT4_TBL AS SELECT * FROM + (VALUES (0), (123456), (-123456), (2147483647), (-2147483647)) + AS v(f1); +CREATE OR REPLACE TEMPORARY VIEW INT8_TBL AS SELECT * FROM + (VALUES (123, 456), (123, 4567890123456789), (4567890123456789, 123), (4567890123456789, 4567890123456789), (4567890123456789, -4567890123456789)) - as v(q1, q2); -create or replace temporary view FLOAT8_TBL as select * from - (values (0.0), (1004.30), (-34.84), + AS v(q1, q2); +CREATE OR REPLACE TEMPORARY VIEW FLOAT8_TBL AS SELECT * FROM + (VALUES (0.0), (1004.30), (-34.84), (cast('1.2345678901234e+200' as double)), (cast('1.2345678901234e-200' as double))) - as v(f1); -create or replace temporary view TEXT_TBL as select * from - (values ('doh!'), ('hi de ho neighbor')) - as v(f1); -create or replace temporary view tenk2 as select * from tenk1; + AS v(f1); +CREATE OR REPLACE TEMPORARY VIEW TEXT_TBL AS SELECT * FROM + (VALUES ('doh!'), ('hi de ho neighbor')) + AS v(f1); +CREATE OR REPLACE TEMPORARY VIEW tenk2 AS SELECT * FROM tenk1; CREATE TABLE J1_TBL ( i integer, @@ -577,15 +577,15 @@ select count(*) from tenk1 a, tenk1 b -- regression test for 8.2 bug with improper re-ordering of left joins -- -drop table if exists tt3; -create table tt3(f1 int, f2 string) using parquet; -insert into tt3 select x.id, repeat('xyzzy', 100) from range(1,10001) x; +DROP TABLE IF EXISTS tt3; +CREATE TABLE tt3(f1 int, f2 string) USING parquet; +INSERT INTO tt3 SELECT x.id, repeat('xyzzy', 100) FROM range(1,10001) x; -- create index tt3i on tt3(f1); -- analyze tt3; -drop table if exists tt4; -create table tt4(f1 int) using parquet; -insert into tt4 values (0),(1),(9999); +DROP TABLE IF EXISTS tt4; +CREATE TABLE tt4(f1 int) USING parquet; +INSERT INTO tt4 VALUES (0),(1),(9999); -- analyze tt4; SELECT a.f1 @@ -1984,19 +1984,19 @@ select f1,g from int4_tbl a cross join (select a.f1 as g) ss; -- select * from j1 -- inner join (select id from j3 group by id) j3 on j1.id = j3.id; -drop table if exists j1; -drop table if exists j2; -drop table if exists j3; +-- drop table if exists j1; +-- drop table if exists j2; +-- drop table if exists j3; -- test more complex permutations of unique joins -create table j1 (id1 int, id2 int) using parquet; -create table j2 (id1 int, id2 int) using parquet; -create table j3 (id1 int, id2 int) using parquet; +CREATE TABLE j1 (id1 int, id2 int) USING parquet; +CREATE TABLE j2 (id1 int, id2 int) USING parquet; +-- create table j3 (id1 int, id2 int) using parquet; -insert into j1 values(1,1),(1,2); -insert into j2 values(1,1); -insert into j3 values(1,1); +INSERT INTO j1 values(1,1),(1,2); +INSERT INTO j2 values(1,1); +-- insert into j3 values(1,1); -- analyze j1; -- analyze j2; @@ -2036,7 +2036,7 @@ insert into j3 values(1,1); -- create index j2_id1_idx on j2 (id1) where id1 % 1000 = 1; -- need an additional row in j2, if we want j2_id1_idx to be preferred -insert into j2 values(1,2); +INSERT INTO j2 values(1,2); -- analyze j2; -- explain (costs off) select * from j1 @@ -2053,7 +2053,7 @@ where j1.id1 % 1000 = 1 and j2.id1 % 1000 = 1; drop table j1; drop table j2; -drop table j3; +-- drop table j3; -- Skip these tests because it only test explain -- check that semijoin inner is not seen as unique for a portion of the outerrel diff --git a/sql/core/src/test/resources/sql-tests/results/pgSQL/join.sql.out b/sql/core/src/test/resources/sql-tests/results/pgSQL/join.sql.out index 94ef8e047e6f7..83b8138b8526c 100644 --- a/sql/core/src/test/resources/sql-tests/results/pgSQL/join.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/pgSQL/join.sql.out @@ -1,11 +1,11 @@ -- Automatically generated by SQLQueryTestSuite --- Number of queries: 191 +-- Number of queries: 185 -- !query 0 -create or replace temporary view INT4_TBL as select * from - (values (0), (123456), (-123456), (2147483647), (-2147483647)) - as v(f1) +CREATE OR REPLACE TEMPORARY VIEW INT4_TBL AS SELECT * FROM + (VALUES (0), (123456), (-123456), (2147483647), (-2147483647)) + AS v(f1) -- !query 0 schema struct<> -- !query 0 output @@ -13,14 +13,14 @@ struct<> -- !query 1 -create or replace temporary view INT8_TBL as select * from - (values +CREATE OR REPLACE TEMPORARY VIEW INT8_TBL AS SELECT * FROM + (VALUES (123, 456), (123, 4567890123456789), (4567890123456789, 123), (4567890123456789, 4567890123456789), (4567890123456789, -4567890123456789)) - as v(q1, q2) + AS v(q1, q2) -- !query 1 schema struct<> -- !query 1 output @@ -28,10 +28,10 @@ struct<> -- !query 2 -create or replace temporary view FLOAT8_TBL as select * from - (values (0.0), (1004.30), (-34.84), +CREATE OR REPLACE TEMPORARY VIEW FLOAT8_TBL AS SELECT * FROM + (VALUES (0.0), (1004.30), (-34.84), (cast('1.2345678901234e+200' as double)), (cast('1.2345678901234e-200' as double))) - as v(f1) + AS v(f1) -- !query 2 schema struct<> -- !query 2 output @@ -39,9 +39,9 @@ struct<> -- !query 3 -create or replace temporary view TEXT_TBL as select * from - (values ('doh!'), ('hi de ho neighbor')) - as v(f1) +CREATE OR REPLACE TEMPORARY VIEW TEXT_TBL AS SELECT * FROM + (VALUES ('doh!'), ('hi de ho neighbor')) + AS v(f1) -- !query 3 schema struct<> -- !query 3 output @@ -49,7 +49,7 @@ struct<> -- !query 4 -create or replace temporary view tenk2 as select * from tenk1 +CREATE OR REPLACE TEMPORARY VIEW tenk2 AS SELECT * FROM tenk1 -- !query 4 schema struct<> -- !query 4 output @@ -2536,7 +2536,7 @@ struct -- !query 107 -drop table if exists tt3 +DROP TABLE IF EXISTS tt3 -- !query 107 schema struct<> -- !query 107 output @@ -2544,7 +2544,7 @@ struct<> -- !query 108 -create table tt3(f1 int, f2 string) using parquet +CREATE TABLE tt3(f1 int, f2 string) USING parquet -- !query 108 schema struct<> -- !query 108 output @@ -2552,7 +2552,7 @@ struct<> -- !query 109 -insert into tt3 select x.id, repeat('xyzzy', 100) from range(1,10001) x +INSERT INTO tt3 SELECT x.id, repeat('xyzzy', 100) FROM range(1,10001) x -- !query 109 schema struct<> -- !query 109 output @@ -2560,7 +2560,7 @@ struct<> -- !query 110 -drop table if exists tt4 +DROP TABLE IF EXISTS tt4 -- !query 110 schema struct<> -- !query 110 output @@ -2568,7 +2568,7 @@ struct<> -- !query 111 -create table tt4(f1 int) using parquet +CREATE TABLE tt4(f1 int) USING parquet -- !query 111 schema struct<> -- !query 111 output @@ -2576,7 +2576,7 @@ struct<> -- !query 112 -insert into tt4 values (0),(1),(9999) +INSERT INTO tt4 VALUES (0),(1),(9999) -- !query 112 schema struct<> -- !query 112 output @@ -3374,7 +3374,7 @@ cannot resolve '`a.f1`' given input columns: []; line 1 pos 47 -- !query 177 -drop table if exists j1 +CREATE TABLE j1 (id1 int, id2 int) USING parquet -- !query 177 schema struct<> -- !query 177 output @@ -3382,7 +3382,7 @@ struct<> -- !query 178 -drop table if exists j2 +CREATE TABLE j2 (id1 int, id2 int) USING parquet -- !query 178 schema struct<> -- !query 178 output @@ -3390,7 +3390,7 @@ struct<> -- !query 179 -drop table if exists j3 +INSERT INTO j1 values(1,1),(1,2) -- !query 179 schema struct<> -- !query 179 output @@ -3398,7 +3398,7 @@ struct<> -- !query 180 -create table j1 (id1 int, id2 int) using parquet +INSERT INTO j2 values(1,1) -- !query 180 schema struct<> -- !query 180 output @@ -3406,7 +3406,7 @@ struct<> -- !query 181 -create table j2 (id1 int, id2 int) using parquet +INSERT INTO j2 values(1,2) -- !query 181 schema struct<> -- !query 181 output @@ -3414,75 +3414,27 @@ struct<> -- !query 182 -create table j3 (id1 int, id2 int) using parquet --- !query 182 schema -struct<> --- !query 182 output - - - --- !query 183 -insert into j1 values(1,1),(1,2) --- !query 183 schema -struct<> --- !query 183 output - - - --- !query 184 -insert into j2 values(1,1) --- !query 184 schema -struct<> --- !query 184 output - - - --- !query 185 -insert into j3 values(1,1) --- !query 185 schema -struct<> --- !query 185 output - - - --- !query 186 -insert into j2 values(1,2) --- !query 186 schema -struct<> --- !query 186 output - - - --- !query 187 select * from j1 inner join j2 on j1.id1 = j2.id1 and j1.id2 = j2.id2 where j1.id1 % 1000 = 1 and j2.id1 % 1000 = 1 --- !query 187 schema +-- !query 182 schema struct --- !query 187 output +-- !query 182 output 1 1 1 1 1 2 1 2 --- !query 188 +-- !query 183 drop table j1 --- !query 188 schema +-- !query 183 schema struct<> --- !query 188 output +-- !query 183 output --- !query 189 +-- !query 184 drop table j2 --- !query 189 schema -struct<> --- !query 189 output - - - --- !query 190 -drop table j3 --- !query 190 schema +-- !query 184 schema struct<> --- !query 190 output +-- !query 184 output From 6261c875fbfa8af50bf7c3982e6f1489b7852745 Mon Sep 17 00:00:00 2001 From: Yuming Wang Date: Tue, 30 Jul 2019 10:13:11 +0800 Subject: [PATCH 5/5] Add [SPARK-16452] basic INFORMATION_SCHEMA support --- sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql index 24c2027fbeac2..08f54fe0a40e5 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/pgSQL/join.sql @@ -960,7 +960,7 @@ select * from int4_tbl a full join int4_tbl b on false; -- variant that isn't quite a star-schema case --- Spark SQL do not support information_schema.cardinal_number type +-- [SPARK-16452] basic INFORMATION_SCHEMA support -- select ss1.d1 from -- tenk1 as t1 -- inner join tenk1 as t2