diff --git a/sql/core/src/test/resources/sql-tests/inputs/arithmetic.sql b/sql/core/src/test/resources/sql-tests/inputs/arithmetic.sql index f62b10ca0037b..79815099c59a6 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/arithmetic.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/arithmetic.sql @@ -4,17 +4,17 @@ select -100; select +230; select -5.2; select +6.8e0; -select -key, +key from testdata where key = 2; -select -(key + 1), - key + 1, +(key + 5) from testdata where key = 1; -select -max(key), +max(key) from testdata; +select -key, +key from uniqueRowData where key = 2; +select -(key + 1), - key + 1, +(key + 5) from uniqueRowData where key = 1; +select -max(key), +max(key) from uniqueRowData; select - (-10); -select + (-key) from testdata where key = 32; -select - (+max(key)) from testdata; +select + (-key) from uniqueRowData where key = 32; +select - (+max(key)) from uniqueRowData; select - - 3; select - + 20; select + + 100; -select - - max(key) from testdata; -select + - key from testdata where key = 33; +select - - max(key) from uniqueRowData; +select + - key from uniqueRowData where key = 33; -- div select 5 / 2; diff --git a/sql/core/src/test/resources/sql-tests/inputs/join.sql b/sql/core/src/test/resources/sql-tests/inputs/join.sql new file mode 100644 index 0000000000000..ecae4c00cb6f6 --- /dev/null +++ b/sql/core/src/test/resources/sql-tests/inputs/join.sql @@ -0,0 +1,229 @@ +-- join nested table expressions +SELECT a.k1, a.v1, a.k2, a.v2 +FROM ( +SELECT src1.key as k1, src1.value as v1, + src2.key as k2, src2.value as v2 FROM + (SELECT * FROM duplicateRowData WHERE duplicateRowData.key < 200) src1 + JOIN + (SELECT * FROM duplicateRowData WHERE duplicateRowData.key < 200) src2 + SORT BY k1, v1, k2, v2 +) a; + +-- self-join + join condition +SELECT src1.key, src2.value +FROM duplicateRowData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key); + +-- equi inner join + inner join with a complex join condition +SELECT src1.key, src3.value +FROM duplicateRowData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key) + JOIN duplicateRowData src3 ON (src1.key + src2.key = src3.key); + +-- equi inner join + equi inner join +SELECT src1.key, src3.value +FROM duplicateRowData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key) + JOIN duplicateRowData src3 ON (src1.key = src3.key); + +-- inner join + join condition + filter +SELECT src1.key, src2.value +FROM partitionedData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key) +WHERE src1.ds = '2008-04-08' and src1.hr = '12'; + +-- equi inner join + table.star expansion in nested table expression +FROM +(SELECT duplicateRowData.* from duplicateRowData) x +JOIN +(SELECT duplicateRowData.* from duplicateRowData) Y +ON (x.key = Y.key) +select Y.key, Y.value; + +-- inner join with a complex join condition over nested table expressions +SELECT src1.c1, src2.c4 +FROM + (SELECT duplicateRowData.key as c1, duplicateRowData.value as c2 from duplicateRowData) src1 + JOIN + (SELECT duplicateRowData.key as c3, duplicateRowData.value as c4 from duplicateRowData) src2 + ON src1.c1 = src2.c3 AND src1.c1 < 200; + +-- two inner join with a complex join condition over nested table expressions +SELECT src1.c1, src2.c4 +FROM + (SELECT duplicateRowData.key as c1, duplicateRowData.value as c2 from duplicateRowData) src1 + JOIN + (SELECT duplicateRowData.key as c3, duplicateRowData.value as c4 from duplicateRowData) src2 + ON src1.c1 = src2.c3 AND src1.c1 < 200 + JOIN + (SELECT duplicateRowData.key as c5, duplicateRowData.value as c6 from duplicateRowData) src3 + ON src1.c1 = src3.c5 AND src3.c5 < 100; + +-- two inner join with a complex join condition over nested table expressions +SELECT src1.c1, src2.c4 +FROM + (SELECT duplicateRowData.key as c1, duplicateRowData.value as c2 from duplicateRowData) src1 + JOIN + (SELECT duplicateRowData.key as c3, duplicateRowData.value as c4 from duplicateRowData) src2 + ON src1.c1 = src2.c3 AND src1.c1 < 250 + JOIN + (SELECT duplicateRowData.key as c5, duplicateRowData.value as c6 from duplicateRowData) src3 + ON src1.c1 + src2.c3 = src3.c5 AND src3.c5 < 400; + +-- join two different tables +FROM duplicateRowData JOIN partitionedData +ON duplicateRowData.key = partitionedData.key AND partitionedData.ds = '2008-04-08' + AND duplicateRowData.key > 200 +SELECT duplicateRowData.key, partitionedData.value; + +-- join + sort by +SELECT a.k1, a.v1, a.k2, a.v2 + FROM ( + SELECT src1.key as k1, src1.value as v1, src2.key as k2, src2.value as v2 + FROM duplicateRowData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key) + SORT BY k1, v1, k2, v2 + ) a; + +-- inner join with a filter above join and a filter below join +SELECT subq.key, tab.value +FROM +(select a.key, a.value from duplicateRowData a where a.key > 100 ) subq +JOIN duplicateRowData tab +ON (subq.key = tab.key and subq.key > 150 and subq.value = tab.value) +where tab.key < 200; + +-- star expansion in nested table expression +SELECT src1.*, src2.* +FROM duplicateRowData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key); + +-- join + disjunctive conditions +SELECT src1.key, src2.value +FROM partitionedData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key) +where (src1.ds = '2008-04-08' or src1.ds = '2008-04-09' )and (src1.hr = '12' or src1.hr = '11'); + +-- nested join +SELECT src5.src1_value +FROM + (SELECT src3.*, src4.value as src4_value, src4.key as src4_key + FROM duplicateRowData src4 + JOIN (SELECT src2.*, src1.key as src1_key, src1.value as src1_value + FROM duplicateRowData src1 + JOIN duplicateRowData src2 ON src1.key = src2.key) src3 + ON src3.src1_key = src4.key) src5; + +-- Cartesian join +SELECT * FROM duplicateRowData src1 JOIN duplicateRowData src2 +WHERE src1.key < 200 and src2.key < 200 +SORT BY src1.key, src1.value, src2.key, src2.value; + +-- join +WITH tst1 AS (SELECT a.key, count(1) as cnt FROM duplicateRowData a group by a.key) +SELECT sum(a.cnt) FROM tst1 a JOIN tst1 b ON a.key = b.key; + +-- aggregate over join results +SELECT x.key, count(1) +FROM nullData x JOIN duplicateRowData y +ON (x.key = y.key) group by x.key order by x.key; + +-- join over set operation over aggregate +SELECT count(1) +FROM +( + SELECT duplicateRowData.key, duplicateRowData.value from duplicateRowData + UNION ALL + SELECT DISTINCT duplicateRowData.key, duplicateRowData.value from duplicateRowData +) src_12 +JOIN +( + SELECT duplicateRowData.key as k, duplicateRowData.value as v from duplicateRowData +) src3 +ON src_12.key = src3.k AND src3.k < 300; + +-- inner join with sorted by nested table expression +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +select Y.key,Y.value; + +-- inner + inner with sorted by nested table expression +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Z +ON (x.key = Z.key) +select Y.key,Y.value; + +-- join over set operation +SELECT x.key, x.value, subq1.value +FROM +( SELECT x.key as key, x.value as value from duplicateRowData x where x.key < 200 + UNION ALL + SELECT x1.key as key, x1.value as value from duplicateRowData x1 where x1.key > 100 +) subq1 +JOIN nullData x ON (x.key = subq1.key); + +-- join over set operation over aggregate +SELECT x.key, x.value, subq1.cnt +FROM +( SELECT x.key as key, count(1) as cnt from duplicateRowData x where x.key < 200 group by x.key + UNION ALL + SELECT x1.key as key, count(1) as cnt from duplicateRowData x1 where x1.key > 100 group by x1.key +) subq1 +JOIN nullData x ON (x.key = subq1.key); + +-- self join with aliases +SELECT x.key, COUNT(*) +FROM duplicateRowData x JOIN duplicateRowData y ON x.key = y.key +GROUP BY x.key; + +-- inner join with one-match-per-row filtering predicates (where) +SELECT * FROM uppercasedata u JOIN lowercasedata l WHERE u.n = l.N; + +-- inner join with one-match-per-row join conditions (on) +SELECT * FROM uppercasedata u JOIN lowercasedata l ON u.n = l.N; + +-- inner join with multiple-match-per-row filtering predicates (where) +SELECT * FROM + (SELECT * FROM duplicateColumnValueData WHERE a = 1) x JOIN + (SELECT * FROM duplicateColumnValueData WHERE a = 1) y +WHERE x.a = y.a; + +-- inner join with no-match-per-row filtering predicates (where) +SELECT * FROM + (SELECT * FROM duplicateColumnValueData WHERE a = 1) x JOIN + (SELECT * FROM duplicateColumnValueData WHERE a = 2) y +WHERE x.a = y.a; + +-- inner join ON with table name as qualifier +SELECT * FROM upperCaseData JOIN lowerCaseData ON lowerCaseData.n = upperCaseData.N; + +-- qualified select with inner join ON with table name as qualifier +SELECT upperCaseData.N, upperCaseData.L FROM upperCaseData JOIN lowerCaseData + ON lowerCaseData.n = upperCaseData.N; + +-- SPARK-4120 Join of multiple tables does not work in SparkSQL +SELECT a.key, b.key, c.key +FROM uniqueRowData a,uniqueRowData b,uniqueRowData c +where a.key = b.key and a.key = c.key and a.key < 5; + +-- big inner join, 4 matches per row +SELECT x.key, x.value, y.key, y.value, count(1) FROM + (SELECT * FROM uniqueRowData UNION ALL + SELECT * FROM uniqueRowData UNION ALL + SELECT * FROM uniqueRowData UNION ALL + SELECT * FROM uniqueRowData) x JOIN + (SELECT * FROM uniqueRowData UNION ALL + SELECT * FROM uniqueRowData UNION ALL + SELECT * FROM uniqueRowData UNION ALL + SELECT * FROM uniqueRowData) y +WHERE x.key = y.key group by x.key, x.value, y.key, y.value; + +-- mixed-case keywords +SeleCT * from + (select * from upperCaseData WherE N <= 4) leftTable fuLL OUtER joiN + (sElEcT * FROM upperCaseData whERe N >= 3) rightTable + oN leftTable.N = rightTable.N; + +-- Supporting relational operator '<=>' in Spark SQL +SELECT * FROM nullData as a JOIN nullData as b on a.value <=> b.value; diff --git a/sql/core/src/test/resources/sql-tests/inputs/left-semi-join.sql b/sql/core/src/test/resources/sql-tests/inputs/left-semi-join.sql new file mode 100644 index 0000000000000..a8d3fafc04d68 --- /dev/null +++ b/sql/core/src/test/resources/sql-tests/inputs/left-semi-join.sql @@ -0,0 +1,14 @@ +-- left semi greater than predicate +SELECT * +FROM duplicateColumnValueData x LEFT SEMI JOIN duplicateColumnValueData y +ON x.a >= y.a + 2; + +-- left semi greater than predicate and equal operator #1 +SELECT * +FROM duplicateColumnValueData x LEFT SEMI JOIN duplicateColumnValueData y +ON x.b = y.b and x.a >= y.a + 2; + +-- left semi greater than predicate and equal operator #2 +SELECT * +FROM duplicateColumnValueData x LEFT SEMI JOIN duplicateColumnValueData y +ON x.b = y.a and x.a >= y.b + 1; diff --git a/sql/core/src/test/resources/sql-tests/inputs/limit.sql b/sql/core/src/test/resources/sql-tests/inputs/limit.sql index 2ea35f7f3a5c8..a37c631f015ef 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/limit.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/limit.sql @@ -1,23 +1,23 @@ -- limit on various data types -select * from testdata limit 2; +select * from uniqueRowData limit 2; select * from arraydata limit 2; select * from mapdata limit 2; -- foldable non-literal in limit -select * from testdata limit 2 + 1; +select * from uniqueRowData limit 2 + 1; -select * from testdata limit CAST(1 AS int); +select * from uniqueRowData limit CAST(1 AS int); -- limit must be non-negative -select * from testdata limit -1; +select * from uniqueRowData limit -1; -- limit must be foldable -select * from testdata limit key > 3; +select * from uniqueRowData limit key > 3; -- limit must be integer -select * from testdata limit true; -select * from testdata limit 'a'; +select * from uniqueRowData limit true; +select * from uniqueRowData limit 'a'; -- limit within a subquery select * from (select * from range(10) limit 5) where id > 3; diff --git a/sql/core/src/test/resources/sql-tests/inputs/outer-join.sql b/sql/core/src/test/resources/sql-tests/inputs/outer-join.sql new file mode 100644 index 0000000000000..8669545653ae8 --- /dev/null +++ b/sql/core/src/test/resources/sql-tests/inputs/outer-join.sql @@ -0,0 +1,297 @@ +-- basic full outer join +SELECT * FROM + (SELECT * FROM upperCaseData WHERE N <= 4) leftTable FULL OUTER JOIN + (SELECT * FROM upperCaseData WHERE N >= 3) rightTable + ON leftTable.N = rightTable.N; + +-- basic right outer join +SELECT * FROM lowercasedata l RIGHT OUTER JOIN uppercasedata u ON l.n = u.N; + +-- basic left outer join +SELECT * FROM uppercasedata u LEFT OUTER JOIN lowercasedata l ON l.n = u.N; + + +-- left-outer join over two nested table expressions +SELECT c.c1, c.c2, c.c3, c.c4 +FROM ( + SELECT a.c1 AS c1, a.c2 AS c2, b.c3 AS c3, b.c4 AS c4 + FROM + ( + SELECT src1.key AS c1, src1.value AS c2 + FROM duplicateRowData src1 WHERE src1.key > 100 and src1.key < 300 + ) a + LEFT OUTER JOIN + ( + SELECT src2.key AS c3, src2.value AS c4 + FROM duplicateRowData src2 WHERE src2.key > 200 and src2.key < 400 + ) b + ON (a.c1 = b.c3) +) c; + +-- right-outer join over two nested table expressions +SELECT c.c1, c.c2, c.c3, c.c4 +FROM ( + SELECT a.c1 AS c1, a.c2 AS c2, b.c3 AS c3, b.c4 AS c4 + FROM + ( + SELECT src1.key AS c1, src1.value AS c2 + FROM duplicateRowData src1 WHERE src1.key > 100 and src1.key < 300 + ) a + RIGHT OUTER JOIN + ( + SELECT src2.key AS c3, src2.value AS c4 + FROM duplicateRowData src2 WHERE src2.key > 200 and src2.key < 400 + ) b + ON (a.c1 = b.c3) +) c; + +-- full-outer join over two nested table expressions +SELECT c.c1, c.c2, c.c3, c.c4 +FROM ( + SELECT a.c1 AS c1, a.c2 AS c2, b.c3 AS c3, b.c4 AS c4 + FROM + ( + SELECT src1.key AS c1, src1.value AS c2 + FROM duplicateRowData src1 WHERE src1.key > 100 and src1.key < 300 + ) a + FULL OUTER JOIN + ( + SELECT src2.key AS c3, src2.value AS c4 + FROM duplicateRowData src2 WHERE src2.key > 200 and src2.key < 400 + ) b + ON (a.c1 = b.c3) +) c; + +-- full-outer join + left-outer join over nested table expressions +SELECT c.c1, c.c2, c.c3, c.c4, c.c5, c.c6 +FROM ( + SELECT a.c1 AS c1, a.c2 AS c2, b.c3 AS c3, b.c4 AS c4, c.c5 AS c5, c.c6 AS c6 + FROM + ( + SELECT src1.key AS c1, src1.value AS c2 + FROM duplicateRowData src1 WHERE src1.key > 10 and src1.key < 150 + ) a + FULL OUTER JOIN + ( + SELECT src2.key AS c3, src2.value AS c4 + FROM duplicateRowData src2 WHERE src2.key > 150 and src2.key < 300 + ) b + ON (a.c1 = b.c3) + LEFT OUTER JOIN + ( + SELECT src3.key AS c5, src3.value AS c6 + FROM duplicateRowData src3 WHERE src3.key > 200 and src3.key < 400 + ) c + ON (a.c1 = c.c5) +) c; + +-- left-outer join + join condition + filter +SELECT c.c1, c.c2, c.c3, c.c4 +FROM ( + SELECT a.c1 AS c1, a.c2 AS c2, b.c3 AS c3, b.c4 AS c4 + FROM + ( + SELECT src1.key AS c1, src1.value AS c2 + FROM duplicateRowData src1 WHERE src1.key > 100 and src1.key < 300 + ) a + LEFT OUTER JOIN + ( + SELECT src2.key AS c3, src2.value AS c4 + FROM duplicateRowData src2 WHERE src2.key > 200 and src2.key < 400 + ) b + ON (a.c1 = b.c3) +) c +where c.c3 IS NULL AND c.c1 IS NOT NULL; + +-- full outer join over Aggregate +SELECT a.key, a.value, b.key, b.value +FROM + ( + SELECT src1.key as key, count(src1.value) AS value + FROM duplicateRowData src1 group by src1.key + ) a + FULL OUTER JOIN + ( + SELECT src2.key as key, count(distinct(src2.value)) AS value + FROM nullData src2 group by src2.key + ) b +ON (a.key = b.key); + +-- full outer join + multi distinct +SELECT a.key, a.value, b.key, b.value1, b.value2 +FROM + ( + SELECT src1.key as key, count(src1.value) AS value + FROM duplicateRowData src1 group by src1.key + ) a + FULL OUTER JOIN + ( + SELECT src2.key as key, count(distinct(src2.value)) AS value1, + count(distinct(src2.key)) AS value2 + FROM nullData src2 group by src2.key + ) b +ON (a.key = b.key); + +-- inner join + right-outer join #1 +SELECT a.k1,a.v1,a.k2,a.v2,a.k3,a.v3 +FROM ( + SELECT src1.key as k1, src1.value as v1, src2.key as k2, src2.value as v2 , src3.key as k3, + src3.value as v3 + FROM duplicateRowData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key AND src1.key < 200) + RIGHT OUTER JOIN duplicateRowData src3 ON (src1.key = src3.key AND src3.key < 300) + SORT BY k1,v1,k2,v2,k3,v3 +)a; + +-- inner join + right-outer join #2 +SELECT a.k1,a.v1,a.k2,a.v2,a.k3,a.v3 +FROM ( + SELECT src1.key as k1, src1.value as v1, src2.key as k2, src2.value as v2 , src3.key as k3, + src3.value as v3 + FROM duplicateRowData src1 + JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key < 100) + RIGHT OUTER JOIN duplicateRowData src3 + ON (src1.key = src3.key AND src3.key < 300) + SORT BY k1,v1,k2,v2,k3,v3 +)a; + +-- left outer join + right outer join +SELECT * +FROM + duplicateRowData src1 + LEFT OUTER JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + RIGHT OUTER JOIN duplicateRowData src3 + ON (src2.key = src3.key AND src3.key < 200) +SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value; + +-- left outer + right outer +SELECT * FROM duplicateRowData src1 + LEFT OUTER JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + RIGHT OUTER JOIN duplicateRowData src3 + ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value; + +-- right outer + right outer +SELECT * FROM duplicateRowData src1 + RIGHT OUTER JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + RIGHT OUTER JOIN duplicateRowData src3 + ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value; + +-- left outer + left outer +SELECT * FROM duplicateRowData src1 + LEFT OUTER JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + LEFT OUTER JOIN duplicateRowData src3 + ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value; + +-- right outer + left outer +SELECT * FROM duplicateRowData src1 + RIGHT OUTER JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + LEFT OUTER JOIN duplicateRowData src3 + ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value; + +-- inner + left outer +SELECT * FROM duplicateRowData src1 + JOIN duplicateRowData src2 ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + LEFT OUTER JOIN duplicateRowData src3 ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value; + +-- inner + right outer +SELECT * FROM duplicateRowData src1 + JOIN duplicateRowData src2 ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + RIGHT OUTER JOIN duplicateRowData src3 ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value; + +-- left + inner outer +SELECT * FROM duplicateRowData src1 + LEFT OUTER JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + JOIN duplicateRowData src3 + ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value; + +-- right + inner join +SELECT * FROM duplicateRowData src1 + RIGHT OUTER JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + JOIN duplicateRowData src3 + ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value; + +-- left outer join with sorted by nested table expression +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +LEFT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +select Y.key,Y.value; + +-- right outer join with sorted by nested table expression +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +RIGHT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +select Y.key,Y.value; + +-- inner + left outer with sorted by nested table expression +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +LEFT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Z +ON (x.key = Z.key) +select Y.key,Y.value; + +-- left + left outer with sorted by nested table expression +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +LEFT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +LEFT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Z +ON (x.key = Z.key) +select Y.key,Y.value; + +-- left + right outer with sorted by nested table expression +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +LEFT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +RIGHT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Z +ON (x.key = Z.key) +select Y.key,Y.value; + +-- right + right outer with sorted by nested table expression +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +RIGHT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +RIGHT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Z +ON (x.key = Z.key) +select Y.key,Y.value; + +-- right outer + inner with sorted by nested table expression +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +RIGHT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Z +ON (x.key = Z.key) +select Y.key,Y.value; diff --git a/sql/core/src/test/resources/sql-tests/inputs/using-join.sql b/sql/core/src/test/resources/sql-tests/inputs/using-join.sql new file mode 100644 index 0000000000000..470c74d72ab99 --- /dev/null +++ b/sql/core/src/test/resources/sql-tests/inputs/using-join.sql @@ -0,0 +1,43 @@ +create temporary view ut1 as select * from values + ("r1c1", "r1c2", "t1r1c3"), + ("r2c1", "r2c2", "t1r2c3"), + ("r3c1x", "r3c2", "t1r3c3") + as ut1(c1, c2, c3); + +create temporary view ut2 as select * from values + ("r1c1", "r1c2", "t2r1c3"), + ("r2c1", "r2c2", "t2r2c3"), + ("r3c1y", "r3c2", "t2r3c3") + as ut2(c1, c2, c3); + +create temporary view ut3 as select * from values + (CAST(null as String), "r1c2", "t3r1c3"), + ("r2c1", "r2c2", "t3r2c3"), + ("r3c1y", "r3c2", "t3r3c3") + as ut3(c1, c2, c3); + +-- inner join with one using column +SELECT * FROM ut1 join ut2 using (c1); + +-- inner join with two using columns +SELECT * FROM ut1 join ut2 using (c1, c2); + +-- Left outer join with one using column. +SELECT * FROM ut1 left join ut2 using (c1); + +-- Right outer join with one using column. +SELECT * FROM ut1 right join ut2 using (c1); + +-- Full outer join with one using column. +SELECT * FROM ut1 full outer join ut2 using (c1); + +-- Full outer join with null value in join column. +SELECT * FROM ut1 full outer join ut3 using (c1); + +-- Self join with using columns. +SELECT * FROM ut1 join ut1 using (c1); + +-- clean up the temporary tables +drop view ut1; +drop view ut2; +drop view ut3; diff --git a/sql/core/src/test/resources/sql-tests/results/arithmetic.sql.out b/sql/core/src/test/resources/sql-tests/results/arithmetic.sql.out index 6abe048af477d..c1d3e6a898a5e 100644 --- a/sql/core/src/test/resources/sql-tests/results/arithmetic.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/arithmetic.sql.out @@ -35,7 +35,7 @@ struct<6.8:double> -- !query 4 -select -key, +key from testdata where key = 2 +select -key, +key from uniqueRowData where key = 2 -- !query 4 schema struct<(- key):int,key:int> -- !query 4 output @@ -43,7 +43,7 @@ struct<(- key):int,key:int> -- !query 5 -select -(key + 1), - key + 1, +(key + 5) from testdata where key = 1 +select -(key + 1), - key + 1, +(key + 5) from uniqueRowData where key = 1 -- !query 5 schema struct<(- (key + 1)):int,((- key) + 1):int,(key + 5):int> -- !query 5 output @@ -51,7 +51,7 @@ struct<(- (key + 1)):int,((- key) + 1):int,(key + 5):int> -- !query 6 -select -max(key), +max(key) from testdata +select -max(key), +max(key) from uniqueRowData -- !query 6 schema struct<(- max(key)):int,max(key):int> -- !query 6 output @@ -67,7 +67,7 @@ struct<(- -10):int> -- !query 8 -select + (-key) from testdata where key = 32 +select + (-key) from uniqueRowData where key = 32 -- !query 8 schema struct<(- key):int> -- !query 8 output @@ -75,7 +75,7 @@ struct<(- key):int> -- !query 9 -select - (+max(key)) from testdata +select - (+max(key)) from uniqueRowData -- !query 9 schema struct<(- max(key)):int> -- !query 9 output @@ -107,7 +107,7 @@ struct<100:int> -- !query 13 -select - - max(key) from testdata +select - - max(key) from uniqueRowData -- !query 13 schema struct<(- (- max(key))):int> -- !query 13 output @@ -115,7 +115,7 @@ struct<(- (- max(key))):int> -- !query 14 -select + - key from testdata where key = 33 +select + - key from uniqueRowData where key = 33 -- !query 14 schema struct<(- key):int> -- !query 14 output diff --git a/sql/core/src/test/resources/sql-tests/results/join.sql.out b/sql/core/src/test/resources/sql-tests/results/join.sql.out new file mode 100644 index 0000000000000..bef49c54ec74b --- /dev/null +++ b/sql/core/src/test/resources/sql-tests/results/join.sql.out @@ -0,0 +1,680 @@ +-- Automatically generated by SQLQueryTestSuite +-- Number of queries: 34 + + +-- !query 0 +SELECT a.k1, a.v1, a.k2, a.v2 +FROM ( +SELECT src1.key as k1, src1.value as v1, + src2.key as k2, src2.value as v2 FROM + (SELECT * FROM duplicateRowData WHERE duplicateRowData.key < 200) src1 + JOIN + (SELECT * FROM duplicateRowData WHERE duplicateRowData.key < 200) src2 + SORT BY k1, v1, k2, v2 +) a +-- !query 0 schema +struct +-- !query 0 output +165 val_165 165 val_165 +165 val_165 165 val_165 +165 val_165 165 val_165 +165 val_165 165 val_165 +165 val_165 86 val_86 +165 val_165 86 val_86 +86 val_86 165 val_165 +86 val_86 165 val_165 +86 val_86 86 val_86 + + +-- !query 1 +SELECT src1.key, src2.value +FROM duplicateRowData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key) +-- !query 1 schema +struct +-- !query 1 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 +251 val_251 +330 val_330 +86 val_86 + + +-- !query 2 +SELECT src1.key, src3.value +FROM duplicateRowData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key) + JOIN duplicateRowData src3 ON (src1.key + src2.key = src3.key) +-- !query 2 schema +struct +-- !query 2 output +165 val_330 +165 val_330 +165 val_330 +165 val_330 + + +-- !query 3 +SELECT src1.key, src3.value +FROM duplicateRowData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key) + JOIN duplicateRowData src3 ON (src1.key = src3.key) +-- !query 3 schema +struct +-- !query 3 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +251 val_251 +330 val_330 +86 val_86 + + +-- !query 4 +SELECT src1.key, src2.value +FROM partitionedData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key) +WHERE src1.ds = '2008-04-08' and src1.hr = '12' +-- !query 4 schema +struct +-- !query 4 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 +251 val_251 +330 val_330 +86 val_86 + + +-- !query 5 +FROM +(SELECT duplicateRowData.* from duplicateRowData) x +JOIN +(SELECT duplicateRowData.* from duplicateRowData) Y +ON (x.key = Y.key) +select Y.key, Y.value +-- !query 5 schema +struct +-- !query 5 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 +251 val_251 +330 val_330 +86 val_86 + + +-- !query 6 +SELECT src1.c1, src2.c4 +FROM + (SELECT duplicateRowData.key as c1, duplicateRowData.value as c2 from duplicateRowData) src1 + JOIN + (SELECT duplicateRowData.key as c3, duplicateRowData.value as c4 from duplicateRowData) src2 + ON src1.c1 = src2.c3 AND src1.c1 < 200 +-- !query 6 schema +struct +-- !query 6 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 +86 val_86 + + +-- !query 7 +SELECT src1.c1, src2.c4 +FROM + (SELECT duplicateRowData.key as c1, duplicateRowData.value as c2 from duplicateRowData) src1 + JOIN + (SELECT duplicateRowData.key as c3, duplicateRowData.value as c4 from duplicateRowData) src2 + ON src1.c1 = src2.c3 AND src1.c1 < 200 + JOIN + (SELECT duplicateRowData.key as c5, duplicateRowData.value as c6 from duplicateRowData) src3 + ON src1.c1 = src3.c5 AND src3.c5 < 100 +-- !query 7 schema +struct +-- !query 7 output +86 val_86 + + +-- !query 8 +SELECT src1.c1, src2.c4 +FROM + (SELECT duplicateRowData.key as c1, duplicateRowData.value as c2 from duplicateRowData) src1 + JOIN + (SELECT duplicateRowData.key as c3, duplicateRowData.value as c4 from duplicateRowData) src2 + ON src1.c1 = src2.c3 AND src1.c1 < 250 + JOIN + (SELECT duplicateRowData.key as c5, duplicateRowData.value as c6 from duplicateRowData) src3 + ON src1.c1 + src2.c3 = src3.c5 AND src3.c5 < 400 +-- !query 8 schema +struct +-- !query 8 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 + + +-- !query 9 +FROM duplicateRowData JOIN partitionedData +ON duplicateRowData.key = partitionedData.key AND partitionedData.ds = '2008-04-08' + AND duplicateRowData.key > 200 +SELECT duplicateRowData.key, partitionedData.value +-- !query 9 schema +struct +-- !query 9 output +251 val_251 +251 val_251 +330 val_330 +330 val_330 + + +-- !query 10 +SELECT a.k1, a.v1, a.k2, a.v2 + FROM ( + SELECT src1.key as k1, src1.value as v1, src2.key as k2, src2.value as v2 + FROM duplicateRowData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key) + SORT BY k1, v1, k2, v2 + ) a +-- !query 10 schema +struct +-- !query 10 output +165 val_165 165 val_165 +165 val_165 165 val_165 +165 val_165 165 val_165 +165 val_165 165 val_165 +251 val_251 251 val_251 +330 val_330 330 val_330 +86 val_86 86 val_86 + + +-- !query 11 +SELECT subq.key, tab.value +FROM +(select a.key, a.value from duplicateRowData a where a.key > 100 ) subq +JOIN duplicateRowData tab +ON (subq.key = tab.key and subq.key > 150 and subq.value = tab.value) +where tab.key < 200 +-- !query 11 schema +struct +-- !query 11 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 + + +-- !query 12 +SELECT src1.*, src2.* +FROM duplicateRowData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key) +-- !query 12 schema +struct +-- !query 12 output +165 val_165 165 val_165 +165 val_165 165 val_165 +165 val_165 165 val_165 +165 val_165 165 val_165 +251 val_251 251 val_251 +330 val_330 330 val_330 +86 val_86 86 val_86 + + +-- !query 13 +SELECT src1.key, src2.value +FROM partitionedData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key) +where (src1.ds = '2008-04-08' or src1.ds = '2008-04-09' )and (src1.hr = '12' or src1.hr = '11') +-- !query 13 schema +struct +-- !query 13 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +251 val_251 +251 val_251 +251 val_251 +251 val_251 +330 val_330 +330 val_330 +330 val_330 +330 val_330 +86 val_86 +86 val_86 +86 val_86 +86 val_86 + + +-- !query 14 +SELECT src5.src1_value +FROM + (SELECT src3.*, src4.value as src4_value, src4.key as src4_key + FROM duplicateRowData src4 + JOIN (SELECT src2.*, src1.key as src1_key, src1.value as src1_value + FROM duplicateRowData src1 + JOIN duplicateRowData src2 ON src1.key = src2.key) src3 + ON src3.src1_key = src4.key) src5 +-- !query 14 schema +struct +-- !query 14 output +val_165 +val_165 +val_165 +val_165 +val_165 +val_165 +val_165 +val_165 +val_251 +val_330 +val_86 + + +-- !query 15 +SELECT * FROM duplicateRowData src1 JOIN duplicateRowData src2 +WHERE src1.key < 200 and src2.key < 200 +SORT BY src1.key, src1.value, src2.key, src2.value +-- !query 15 schema +struct +-- !query 15 output +165 val_165 165 val_165 +165 val_165 165 val_165 +165 val_165 165 val_165 +165 val_165 165 val_165 +165 val_165 86 val_86 +165 val_165 86 val_86 +86 val_86 165 val_165 +86 val_86 165 val_165 +86 val_86 86 val_86 + + +-- !query 16 +WITH tst1 AS (SELECT a.key, count(1) as cnt FROM duplicateRowData a group by a.key) +SELECT sum(a.cnt) FROM tst1 a JOIN tst1 b ON a.key = b.key +-- !query 16 schema +struct +-- !query 16 output +5 + + +-- !query 17 +SELECT x.key, count(1) +FROM nullData x JOIN duplicateRowData y +ON (x.key = y.key) group by x.key order by x.key +-- !query 17 schema +struct +-- !query 17 output +86 1 +165 4 +330 1 + + +-- !query 18 +SELECT count(1) +FROM +( + SELECT duplicateRowData.key, duplicateRowData.value from duplicateRowData + UNION ALL + SELECT DISTINCT duplicateRowData.key, duplicateRowData.value from duplicateRowData +) src_12 +JOIN +( + SELECT duplicateRowData.key as k, duplicateRowData.value as v from duplicateRowData +) src3 +ON src_12.key = src3.k AND src3.k < 300 +-- !query 18 schema +struct +-- !query 18 output +10 + + +-- !query 19 +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +select Y.key,Y.value +-- !query 19 schema +struct +-- !query 19 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 +251 val_251 +330 val_330 +86 val_86 + + +-- !query 20 +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Z +ON (x.key = Z.key) +select Y.key,Y.value +-- !query 20 schema +struct +-- !query 20 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +251 val_251 +330 val_330 +86 val_86 + + +-- !query 21 +SELECT x.key, x.value, subq1.value +FROM +( SELECT x.key as key, x.value as value from duplicateRowData x where x.key < 200 + UNION ALL + SELECT x1.key as key, x1.value as value from duplicateRowData x1 where x1.key > 100 +) subq1 +JOIN nullData x ON (x.key = subq1.key) +-- !query 21 schema +struct +-- !query 21 output +165 NULL val_165 +165 NULL val_165 +165 NULL val_165 +165 NULL val_165 +165 val_165 val_165 +165 val_165 val_165 +165 val_165 val_165 +165 val_165 val_165 +330 val_330 val_330 +86 val_86 val_86 + + +-- !query 22 +SELECT x.key, x.value, subq1.cnt +FROM +( SELECT x.key as key, count(1) as cnt from duplicateRowData x where x.key < 200 group by x.key + UNION ALL + SELECT x1.key as key, count(1) as cnt from duplicateRowData x1 where x1.key > 100 group by x1.key +) subq1 +JOIN nullData x ON (x.key = subq1.key) +-- !query 22 schema +struct +-- !query 22 output +165 NULL 2 +165 NULL 2 +165 val_165 2 +165 val_165 2 +330 val_330 1 +86 val_86 1 + + +-- !query 23 +SELECT x.key, COUNT(*) +FROM duplicateRowData x JOIN duplicateRowData y ON x.key = y.key +GROUP BY x.key +-- !query 23 schema +struct +-- !query 23 output +165 4 +251 1 +330 1 +86 1 + + +-- !query 24 +SELECT * FROM uppercasedata u JOIN lowercasedata l WHERE u.n = l.N +-- !query 24 schema +struct +-- !query 24 output +1 A 1 a +2 B 2 b +3 C 3 c +4 D 4 d + + +-- !query 25 +SELECT * FROM uppercasedata u JOIN lowercasedata l ON u.n = l.N +-- !query 25 schema +struct +-- !query 25 output +1 A 1 a +2 B 2 b +3 C 3 c +4 D 4 d + + +-- !query 26 +SELECT * FROM + (SELECT * FROM duplicateColumnValueData WHERE a = 1) x JOIN + (SELECT * FROM duplicateColumnValueData WHERE a = 1) y +WHERE x.a = y.a +-- !query 26 schema +struct +-- !query 26 output +1 1 1 1 +1 1 1 2 +1 2 1 1 +1 2 1 2 + + +-- !query 27 +SELECT * FROM + (SELECT * FROM duplicateColumnValueData WHERE a = 1) x JOIN + (SELECT * FROM duplicateColumnValueData WHERE a = 2) y +WHERE x.a = y.a +-- !query 27 schema +struct +-- !query 27 output + + + +-- !query 28 +SELECT * FROM upperCaseData JOIN lowerCaseData ON lowerCaseData.n = upperCaseData.N +-- !query 28 schema +struct +-- !query 28 output +1 A 1 a +2 B 2 b +3 C 3 c +4 D 4 d + + +-- !query 29 +SELECT upperCaseData.N, upperCaseData.L FROM upperCaseData JOIN lowerCaseData + ON lowerCaseData.n = upperCaseData.N +-- !query 29 schema +struct +-- !query 29 output +1 A +2 B +3 C +4 D + + +-- !query 30 +SELECT a.key, b.key, c.key +FROM uniqueRowData a,uniqueRowData b,uniqueRowData c +where a.key = b.key and a.key = c.key and a.key < 5 +-- !query 30 schema +struct +-- !query 30 output +1 1 1 +2 2 2 +3 3 3 +4 4 4 + + +-- !query 31 +SELECT x.key, x.value, y.key, y.value, count(1) FROM + (SELECT * FROM uniqueRowData UNION ALL + SELECT * FROM uniqueRowData UNION ALL + SELECT * FROM uniqueRowData UNION ALL + SELECT * FROM uniqueRowData) x JOIN + (SELECT * FROM uniqueRowData UNION ALL + SELECT * FROM uniqueRowData UNION ALL + SELECT * FROM uniqueRowData UNION ALL + SELECT * FROM uniqueRowData) y +WHERE x.key = y.key group by x.key, x.value, y.key, y.value +-- !query 31 schema +struct +-- !query 31 output +1 1 1 1 16 +10 10 10 10 16 +100 100 100 100 16 +11 11 11 11 16 +12 12 12 12 16 +13 13 13 13 16 +14 14 14 14 16 +15 15 15 15 16 +16 16 16 16 16 +17 17 17 17 16 +18 18 18 18 16 +19 19 19 19 16 +2 2 2 2 16 +20 20 20 20 16 +21 21 21 21 16 +22 22 22 22 16 +23 23 23 23 16 +24 24 24 24 16 +25 25 25 25 16 +26 26 26 26 16 +27 27 27 27 16 +28 28 28 28 16 +29 29 29 29 16 +3 3 3 3 16 +30 30 30 30 16 +31 31 31 31 16 +32 32 32 32 16 +33 33 33 33 16 +34 34 34 34 16 +35 35 35 35 16 +36 36 36 36 16 +37 37 37 37 16 +38 38 38 38 16 +39 39 39 39 16 +4 4 4 4 16 +40 40 40 40 16 +41 41 41 41 16 +42 42 42 42 16 +43 43 43 43 16 +44 44 44 44 16 +45 45 45 45 16 +46 46 46 46 16 +47 47 47 47 16 +48 48 48 48 16 +49 49 49 49 16 +5 5 5 5 16 +50 50 50 50 16 +51 51 51 51 16 +52 52 52 52 16 +53 53 53 53 16 +54 54 54 54 16 +55 55 55 55 16 +56 56 56 56 16 +57 57 57 57 16 +58 58 58 58 16 +59 59 59 59 16 +6 6 6 6 16 +60 60 60 60 16 +61 61 61 61 16 +62 62 62 62 16 +63 63 63 63 16 +64 64 64 64 16 +65 65 65 65 16 +66 66 66 66 16 +67 67 67 67 16 +68 68 68 68 16 +69 69 69 69 16 +7 7 7 7 16 +70 70 70 70 16 +71 71 71 71 16 +72 72 72 72 16 +73 73 73 73 16 +74 74 74 74 16 +75 75 75 75 16 +76 76 76 76 16 +77 77 77 77 16 +78 78 78 78 16 +79 79 79 79 16 +8 8 8 8 16 +80 80 80 80 16 +81 81 81 81 16 +82 82 82 82 16 +83 83 83 83 16 +84 84 84 84 16 +85 85 85 85 16 +86 86 86 86 16 +87 87 87 87 16 +88 88 88 88 16 +89 89 89 89 16 +9 9 9 9 16 +90 90 90 90 16 +91 91 91 91 16 +92 92 92 92 16 +93 93 93 93 16 +94 94 94 94 16 +95 95 95 95 16 +96 96 96 96 16 +97 97 97 97 16 +98 98 98 98 16 +99 99 99 99 16 + + +-- !query 32 +SeleCT * from + (select * from upperCaseData WherE N <= 4) leftTable fuLL OUtER joiN + (sElEcT * FROM upperCaseData whERe N >= 3) rightTable + oN leftTable.N = rightTable.N +-- !query 32 schema +struct +-- !query 32 output +1 A NULL NULL +2 B NULL NULL +3 C 3 C +4 D 4 D +NULL NULL 5 E +NULL NULL 6 F + + +-- !query 33 +SELECT * FROM nullData as a JOIN nullData as b on a.value <=> b.value +-- !query 33 schema +struct +-- !query 33 output +165 NULL 165 NULL +165 NULL 201 NULL +165 NULL NULL NULL +165 val_165 165 val_165 +201 NULL 165 NULL +201 NULL 201 NULL +201 NULL NULL NULL +330 val_330 330 val_330 +86 val_86 86 val_86 +NULL NULL 165 NULL +NULL NULL 201 NULL +NULL NULL NULL NULL +NULL val_null NULL val_null diff --git a/sql/core/src/test/resources/sql-tests/results/left-semi-join.sql.out b/sql/core/src/test/resources/sql-tests/results/left-semi-join.sql.out new file mode 100644 index 0000000000000..7f668033a794d --- /dev/null +++ b/sql/core/src/test/resources/sql-tests/results/left-semi-join.sql.out @@ -0,0 +1,37 @@ +-- Automatically generated by SQLQueryTestSuite +-- Number of queries: 3 + + +-- !query 0 +SELECT * +FROM duplicateColumnValueData x LEFT SEMI JOIN duplicateColumnValueData y +ON x.a >= y.a + 2 +-- !query 0 schema +struct +-- !query 0 output +3 1 +3 2 + + +-- !query 1 +SELECT * +FROM duplicateColumnValueData x LEFT SEMI JOIN duplicateColumnValueData y +ON x.b = y.b and x.a >= y.a + 2 +-- !query 1 schema +struct +-- !query 1 output +3 1 +3 2 + + +-- !query 2 +SELECT * +FROM duplicateColumnValueData x LEFT SEMI JOIN duplicateColumnValueData y +ON x.b = y.a and x.a >= y.b + 1 +-- !query 2 schema +struct +-- !query 2 output +2 1 +2 2 +3 1 +3 2 diff --git a/sql/core/src/test/resources/sql-tests/results/limit.sql.out b/sql/core/src/test/resources/sql-tests/results/limit.sql.out index cb4e4d04810d0..e3d1a8bc87176 100644 --- a/sql/core/src/test/resources/sql-tests/results/limit.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/limit.sql.out @@ -3,7 +3,7 @@ -- !query 0 -select * from testdata limit 2 +select * from uniqueRowData limit 2 -- !query 0 schema struct -- !query 0 output @@ -30,7 +30,7 @@ struct> -- !query 3 -select * from testdata limit 2 + 1 +select * from uniqueRowData limit 2 + 1 -- !query 3 schema struct -- !query 3 output @@ -40,7 +40,7 @@ struct -- !query 4 -select * from testdata limit CAST(1 AS int) +select * from uniqueRowData limit CAST(1 AS int) -- !query 4 schema struct -- !query 4 output @@ -48,7 +48,7 @@ struct -- !query 5 -select * from testdata limit -1 +select * from uniqueRowData limit -1 -- !query 5 schema struct<> -- !query 5 output @@ -57,16 +57,16 @@ The limit expression must be equal to or greater than 0, but got -1; -- !query 6 -select * from testdata limit key > 3 +select * from uniqueRowData limit key > 3 -- !query 6 schema struct<> -- !query 6 output org.apache.spark.sql.AnalysisException -The limit expression must evaluate to a constant value, but got (testdata.`key` > 3); +The limit expression must evaluate to a constant value, but got (uniquerowdata.`key` > 3); -- !query 7 -select * from testdata limit true +select * from uniqueRowData limit true -- !query 7 schema struct<> -- !query 7 output @@ -75,7 +75,7 @@ The limit expression must be integer type, but got boolean; -- !query 8 -select * from testdata limit 'a' +select * from uniqueRowData limit 'a' -- !query 8 schema struct<> -- !query 8 output diff --git a/sql/core/src/test/resources/sql-tests/results/outer-join.sql.out b/sql/core/src/test/resources/sql-tests/results/outer-join.sql.out new file mode 100644 index 0000000000000..c478745cc2036 --- /dev/null +++ b/sql/core/src/test/resources/sql-tests/results/outer-join.sql.out @@ -0,0 +1,582 @@ +-- Automatically generated by SQLQueryTestSuite +-- Number of queries: 28 + + +-- !query 0 +SELECT * FROM + (SELECT * FROM upperCaseData WHERE N <= 4) leftTable FULL OUTER JOIN + (SELECT * FROM upperCaseData WHERE N >= 3) rightTable + ON leftTable.N = rightTable.N +-- !query 0 schema +struct +-- !query 0 output +1 A NULL NULL +2 B NULL NULL +3 C 3 C +4 D 4 D +NULL NULL 5 E +NULL NULL 6 F + + +-- !query 1 +SELECT * FROM lowercasedata l RIGHT OUTER JOIN uppercasedata u ON l.n = u.N +-- !query 1 schema +struct +-- !query 1 output +1 a 1 A +2 b 2 B +3 c 3 C +4 d 4 D +NULL NULL 5 E +NULL NULL 6 F + + +-- !query 2 +SELECT * FROM uppercasedata u LEFT OUTER JOIN lowercasedata l ON l.n = u.N +-- !query 2 schema +struct +-- !query 2 output +1 A 1 a +2 B 2 b +3 C 3 c +4 D 4 d +5 E NULL NULL +6 F NULL NULL + + +-- !query 3 +SELECT c.c1, c.c2, c.c3, c.c4 +FROM ( + SELECT a.c1 AS c1, a.c2 AS c2, b.c3 AS c3, b.c4 AS c4 + FROM + ( + SELECT src1.key AS c1, src1.value AS c2 + FROM duplicateRowData src1 WHERE src1.key > 100 and src1.key < 300 + ) a + LEFT OUTER JOIN + ( + SELECT src2.key AS c3, src2.value AS c4 + FROM duplicateRowData src2 WHERE src2.key > 200 and src2.key < 400 + ) b + ON (a.c1 = b.c3) +) c +-- !query 3 schema +struct +-- !query 3 output +165 val_165 NULL NULL +165 val_165 NULL NULL +251 val_251 251 val_251 + + +-- !query 4 +SELECT c.c1, c.c2, c.c3, c.c4 +FROM ( + SELECT a.c1 AS c1, a.c2 AS c2, b.c3 AS c3, b.c4 AS c4 + FROM + ( + SELECT src1.key AS c1, src1.value AS c2 + FROM duplicateRowData src1 WHERE src1.key > 100 and src1.key < 300 + ) a + RIGHT OUTER JOIN + ( + SELECT src2.key AS c3, src2.value AS c4 + FROM duplicateRowData src2 WHERE src2.key > 200 and src2.key < 400 + ) b + ON (a.c1 = b.c3) +) c +-- !query 4 schema +struct +-- !query 4 output +251 val_251 251 val_251 +NULL NULL 330 val_330 + + +-- !query 5 +SELECT c.c1, c.c2, c.c3, c.c4 +FROM ( + SELECT a.c1 AS c1, a.c2 AS c2, b.c3 AS c3, b.c4 AS c4 + FROM + ( + SELECT src1.key AS c1, src1.value AS c2 + FROM duplicateRowData src1 WHERE src1.key > 100 and src1.key < 300 + ) a + FULL OUTER JOIN + ( + SELECT src2.key AS c3, src2.value AS c4 + FROM duplicateRowData src2 WHERE src2.key > 200 and src2.key < 400 + ) b + ON (a.c1 = b.c3) +) c +-- !query 5 schema +struct +-- !query 5 output +165 val_165 NULL NULL +165 val_165 NULL NULL +251 val_251 251 val_251 +NULL NULL 330 val_330 + + +-- !query 6 +SELECT c.c1, c.c2, c.c3, c.c4, c.c5, c.c6 +FROM ( + SELECT a.c1 AS c1, a.c2 AS c2, b.c3 AS c3, b.c4 AS c4, c.c5 AS c5, c.c6 AS c6 + FROM + ( + SELECT src1.key AS c1, src1.value AS c2 + FROM duplicateRowData src1 WHERE src1.key > 10 and src1.key < 150 + ) a + FULL OUTER JOIN + ( + SELECT src2.key AS c3, src2.value AS c4 + FROM duplicateRowData src2 WHERE src2.key > 150 and src2.key < 300 + ) b + ON (a.c1 = b.c3) + LEFT OUTER JOIN + ( + SELECT src3.key AS c5, src3.value AS c6 + FROM duplicateRowData src3 WHERE src3.key > 200 and src3.key < 400 + ) c + ON (a.c1 = c.c5) +) c +-- !query 6 schema +struct +-- !query 6 output +86 val_86 NULL NULL NULL NULL +NULL NULL 165 val_165 NULL NULL +NULL NULL 165 val_165 NULL NULL +NULL NULL 251 val_251 NULL NULL + + +-- !query 7 +SELECT c.c1, c.c2, c.c3, c.c4 +FROM ( + SELECT a.c1 AS c1, a.c2 AS c2, b.c3 AS c3, b.c4 AS c4 + FROM + ( + SELECT src1.key AS c1, src1.value AS c2 + FROM duplicateRowData src1 WHERE src1.key > 100 and src1.key < 300 + ) a + LEFT OUTER JOIN + ( + SELECT src2.key AS c3, src2.value AS c4 + FROM duplicateRowData src2 WHERE src2.key > 200 and src2.key < 400 + ) b + ON (a.c1 = b.c3) +) c +where c.c3 IS NULL AND c.c1 IS NOT NULL +-- !query 7 schema +struct +-- !query 7 output +165 val_165 NULL NULL +165 val_165 NULL NULL + + +-- !query 8 +SELECT a.key, a.value, b.key, b.value +FROM + ( + SELECT src1.key as key, count(src1.value) AS value + FROM duplicateRowData src1 group by src1.key + ) a + FULL OUTER JOIN + ( + SELECT src2.key as key, count(distinct(src2.value)) AS value + FROM nullData src2 group by src2.key + ) b +ON (a.key = b.key) +-- !query 8 schema +struct +-- !query 8 output +165 2 165 1 +251 1 NULL NULL +330 1 330 1 +86 1 86 1 +NULL NULL 201 0 +NULL NULL NULL 1 + + +-- !query 9 +SELECT a.key, a.value, b.key, b.value1, b.value2 +FROM + ( + SELECT src1.key as key, count(src1.value) AS value + FROM duplicateRowData src1 group by src1.key + ) a + FULL OUTER JOIN + ( + SELECT src2.key as key, count(distinct(src2.value)) AS value1, + count(distinct(src2.key)) AS value2 + FROM nullData src2 group by src2.key + ) b +ON (a.key = b.key) +-- !query 9 schema +struct +-- !query 9 output +165 2 165 1 1 +251 1 NULL NULL NULL +330 1 330 1 1 +86 1 86 1 1 +NULL NULL 201 0 1 +NULL NULL NULL 1 0 + + +-- !query 10 +SELECT a.k1,a.v1,a.k2,a.v2,a.k3,a.v3 +FROM ( + SELECT src1.key as k1, src1.value as v1, src2.key as k2, src2.value as v2 , src3.key as k3, + src3.value as v3 + FROM duplicateRowData src1 JOIN duplicateRowData src2 ON (src1.key = src2.key AND src1.key < 200) + RIGHT OUTER JOIN duplicateRowData src3 ON (src1.key = src3.key AND src3.key < 300) + SORT BY k1,v1,k2,v2,k3,v3 +)a +-- !query 10 schema +struct +-- !query 10 output +165 val_165 165 val_165 165 val_165 +165 val_165 165 val_165 165 val_165 +165 val_165 165 val_165 165 val_165 +165 val_165 165 val_165 165 val_165 +165 val_165 165 val_165 165 val_165 +165 val_165 165 val_165 165 val_165 +165 val_165 165 val_165 165 val_165 +165 val_165 165 val_165 165 val_165 +86 val_86 86 val_86 86 val_86 +NULL NULL NULL NULL 251 val_251 +NULL NULL NULL NULL 330 val_330 + + +-- !query 11 +SELECT a.k1,a.v1,a.k2,a.v2,a.k3,a.v3 +FROM ( + SELECT src1.key as k1, src1.value as v1, src2.key as k2, src2.value as v2 , src3.key as k3, + src3.value as v3 + FROM duplicateRowData src1 + JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key < 100) + RIGHT OUTER JOIN duplicateRowData src3 + ON (src1.key = src3.key AND src3.key < 300) + SORT BY k1,v1,k2,v2,k3,v3 +)a +-- !query 11 schema +struct +-- !query 11 output +86 val_86 86 val_86 86 val_86 +NULL NULL NULL NULL 165 val_165 +NULL NULL NULL NULL 165 val_165 +NULL NULL NULL NULL 251 val_251 +NULL NULL NULL NULL 330 val_330 + + +-- !query 12 +SELECT * +FROM + duplicateRowData src1 + LEFT OUTER JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + RIGHT OUTER JOIN duplicateRowData src3 + ON (src2.key = src3.key AND src3.key < 200) +SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value +-- !query 12 schema +struct +-- !query 12 output +NULL NULL NULL NULL 165 val_165 +NULL NULL NULL NULL 165 val_165 +NULL NULL NULL NULL 251 val_251 +NULL NULL NULL NULL 330 val_330 +NULL NULL NULL NULL 86 val_86 + + +-- !query 13 +SELECT * FROM duplicateRowData src1 + LEFT OUTER JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + RIGHT OUTER JOIN duplicateRowData src3 + ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value +-- !query 13 schema +struct +-- !query 13 output +NULL NULL NULL NULL 165 val_165 +NULL NULL NULL NULL 165 val_165 +NULL NULL NULL NULL 251 val_251 +NULL NULL NULL NULL 330 val_330 +NULL NULL NULL NULL 86 val_86 + + +-- !query 14 +SELECT * FROM duplicateRowData src1 + RIGHT OUTER JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + RIGHT OUTER JOIN duplicateRowData src3 + ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value +-- !query 14 schema +struct +-- !query 14 output +NULL NULL 165 val_165 165 val_165 +NULL NULL 165 val_165 165 val_165 +NULL NULL 165 val_165 165 val_165 +NULL NULL 165 val_165 165 val_165 +NULL NULL 86 val_86 86 val_86 +NULL NULL NULL NULL 251 val_251 +NULL NULL NULL NULL 330 val_330 + + +-- !query 15 +SELECT * FROM duplicateRowData src1 + LEFT OUTER JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + LEFT OUTER JOIN duplicateRowData src3 + ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value +-- !query 15 schema +struct +-- !query 15 output +165 val_165 NULL NULL NULL NULL +165 val_165 NULL NULL NULL NULL +251 val_251 NULL NULL NULL NULL +330 val_330 NULL NULL NULL NULL +86 val_86 NULL NULL NULL NULL + + +-- !query 16 +SELECT * FROM duplicateRowData src1 + RIGHT OUTER JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + LEFT OUTER JOIN duplicateRowData src3 + ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value +-- !query 16 schema +struct +-- !query 16 output +NULL NULL 165 val_165 165 val_165 +NULL NULL 165 val_165 165 val_165 +NULL NULL 165 val_165 165 val_165 +NULL NULL 165 val_165 165 val_165 +NULL NULL 251 val_251 NULL NULL +NULL NULL 330 val_330 NULL NULL +NULL NULL 86 val_86 86 val_86 + + +-- !query 17 +SELECT * FROM duplicateRowData src1 + JOIN duplicateRowData src2 ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + LEFT OUTER JOIN duplicateRowData src3 ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value +-- !query 17 schema +struct +-- !query 17 output + + + +-- !query 18 +SELECT * FROM duplicateRowData src1 + JOIN duplicateRowData src2 ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + RIGHT OUTER JOIN duplicateRowData src3 ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value +-- !query 18 schema +struct +-- !query 18 output +NULL NULL NULL NULL 165 val_165 +NULL NULL NULL NULL 165 val_165 +NULL NULL NULL NULL 251 val_251 +NULL NULL NULL NULL 330 val_330 +NULL NULL NULL NULL 86 val_86 + + +-- !query 19 +SELECT * FROM duplicateRowData src1 + LEFT OUTER JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + JOIN duplicateRowData src3 + ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value +-- !query 19 schema +struct +-- !query 19 output + + + +-- !query 20 +SELECT * FROM duplicateRowData src1 + RIGHT OUTER JOIN duplicateRowData src2 + ON (src1.key = src2.key AND src1.key < 200 AND src2.key > 200) + JOIN duplicateRowData src3 + ON (src2.key = src3.key AND src3.key < 200) + SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value +-- !query 20 schema +struct +-- !query 20 output +NULL NULL 165 val_165 165 val_165 +NULL NULL 165 val_165 165 val_165 +NULL NULL 165 val_165 165 val_165 +NULL NULL 165 val_165 165 val_165 +NULL NULL 86 val_86 86 val_86 + + +-- !query 21 +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +LEFT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +select Y.key,Y.value +-- !query 21 schema +struct +-- !query 21 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 +251 val_251 +330 val_330 +86 val_86 + + +-- !query 22 +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +RIGHT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +select Y.key,Y.value +-- !query 22 schema +struct +-- !query 22 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 +251 val_251 +330 val_330 +86 val_86 + + +-- !query 23 +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +LEFT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Z +ON (x.key = Z.key) +select Y.key,Y.value +-- !query 23 schema +struct +-- !query 23 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +251 val_251 +330 val_330 +86 val_86 + + +-- !query 24 +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +LEFT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +LEFT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Z +ON (x.key = Z.key) +select Y.key,Y.value +-- !query 24 schema +struct +-- !query 24 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +251 val_251 +330 val_330 +86 val_86 + + +-- !query 25 +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +LEFT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +RIGHT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Z +ON (x.key = Z.key) +select Y.key,Y.value +-- !query 25 schema +struct +-- !query 25 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +251 val_251 +330 val_330 +86 val_86 + + +-- !query 26 +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +RIGHT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +RIGHT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Z +ON (x.key = Z.key) +select Y.key,Y.value +-- !query 26 schema +struct +-- !query 26 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +251 val_251 +330 val_330 +86 val_86 + + +-- !query 27 +FROM +(SELECT duplicateRowData.* FROM duplicateRowData sort by key) x +RIGHT OUTER JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Y +ON (x.key = Y.key) +JOIN +(SELECT duplicateRowData.* FROM duplicateRowData sort by value) Z +ON (x.key = Z.key) +select Y.key,Y.value +-- !query 27 schema +struct +-- !query 27 output +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +165 val_165 +251 val_251 +330 val_330 +86 val_86 diff --git a/sql/core/src/test/resources/sql-tests/results/using-join.sql.out b/sql/core/src/test/resources/sql-tests/results/using-join.sql.out new file mode 100644 index 0000000000000..53930d628d817 --- /dev/null +++ b/sql/core/src/test/resources/sql-tests/results/using-join.sql.out @@ -0,0 +1,133 @@ +-- Automatically generated by SQLQueryTestSuite +-- Number of queries: 13 + + +-- !query 0 +create temporary view ut1 as select * from values + ("r1c1", "r1c2", "t1r1c3"), + ("r2c1", "r2c2", "t1r2c3"), + ("r3c1x", "r3c2", "t1r3c3") + as ut1(c1, c2, c3) +-- !query 0 schema +struct<> +-- !query 0 output + + + +-- !query 1 +create temporary view ut2 as select * from values + ("r1c1", "r1c2", "t2r1c3"), + ("r2c1", "r2c2", "t2r2c3"), + ("r3c1y", "r3c2", "t2r3c3") + as ut2(c1, c2, c3) +-- !query 1 schema +struct<> +-- !query 1 output + + + +-- !query 2 +create temporary view ut3 as select * from values + (CAST(null as String), "r1c2", "t3r1c3"), + ("r2c1", "r2c2", "t3r2c3"), + ("r3c1y", "r3c2", "t3r3c3") + as ut3(c1, c2, c3) +-- !query 2 schema +struct<> +-- !query 2 output + + + +-- !query 3 +SELECT * FROM ut1 join ut2 using (c1) +-- !query 3 schema +struct +-- !query 3 output +r1c1 r1c2 t1r1c3 r1c2 t2r1c3 +r2c1 r2c2 t1r2c3 r2c2 t2r2c3 + + +-- !query 4 +SELECT * FROM ut1 join ut2 using (c1, c2) +-- !query 4 schema +struct +-- !query 4 output +r1c1 r1c2 t1r1c3 t2r1c3 +r2c1 r2c2 t1r2c3 t2r2c3 + + +-- !query 5 +SELECT * FROM ut1 left join ut2 using (c1) +-- !query 5 schema +struct +-- !query 5 output +r1c1 r1c2 t1r1c3 r1c2 t2r1c3 +r2c1 r2c2 t1r2c3 r2c2 t2r2c3 +r3c1x r3c2 t1r3c3 NULL NULL + + +-- !query 6 +SELECT * FROM ut1 right join ut2 using (c1) +-- !query 6 schema +struct +-- !query 6 output +r1c1 r1c2 t1r1c3 r1c2 t2r1c3 +r2c1 r2c2 t1r2c3 r2c2 t2r2c3 +r3c1y NULL NULL r3c2 t2r3c3 + + +-- !query 7 +SELECT * FROM ut1 full outer join ut2 using (c1) +-- !query 7 schema +struct +-- !query 7 output +r1c1 r1c2 t1r1c3 r1c2 t2r1c3 +r2c1 r2c2 t1r2c3 r2c2 t2r2c3 +r3c1x r3c2 t1r3c3 NULL NULL +r3c1y NULL NULL r3c2 t2r3c3 + + +-- !query 8 +SELECT * FROM ut1 full outer join ut3 using (c1) +-- !query 8 schema +struct +-- !query 8 output +NULL NULL NULL r1c2 t3r1c3 +r1c1 r1c2 t1r1c3 NULL NULL +r2c1 r2c2 t1r2c3 r2c2 t3r2c3 +r3c1x r3c2 t1r3c3 NULL NULL +r3c1y NULL NULL r3c2 t3r3c3 + + +-- !query 9 +SELECT * FROM ut1 join ut1 using (c1) +-- !query 9 schema +struct +-- !query 9 output +r1c1 r1c2 t1r1c3 r1c2 t1r1c3 +r2c1 r2c2 t1r2c3 r2c2 t1r2c3 +r3c1x r3c2 t1r3c3 r3c2 t1r3c3 + + +-- !query 10 +drop view ut1 +-- !query 10 schema +struct<> +-- !query 10 output + + + +-- !query 11 +drop view ut2 +-- !query 11 schema +struct<> +-- !query 11 output + + + +-- !query 12 +drop view ut3 +-- !query 12 schema +struct<> +-- !query 12 output + diff --git a/sql/core/src/test/scala/org/apache/spark/sql/DataFrameJoinSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/DataFrameJoinSuite.scala index 4342c039aefc8..69404d55b390c 100644 --- a/sql/core/src/test/scala/org/apache/spark/sql/DataFrameJoinSuite.scala +++ b/sql/core/src/test/scala/org/apache/spark/sql/DataFrameJoinSuite.scala @@ -21,6 +21,7 @@ import org.apache.spark.sql.catalyst.plans.{Inner, LeftOuter, RightOuter} import org.apache.spark.sql.catalyst.plans.logical.Join import org.apache.spark.sql.execution.joins.BroadcastHashJoinExec import org.apache.spark.sql.functions._ +import org.apache.spark.sql.internal.SQLConf import org.apache.spark.sql.test.SharedSQLContext class DataFrameJoinSuite extends QueryTest with SharedSQLContext { @@ -225,4 +226,40 @@ class DataFrameJoinSuite extends QueryTest with SharedSQLContext { Row(1, null) :: Row(null, 2) :: Nil ) } + + test("cartesian product join") { + withSQLConf(SQLConf.CROSS_JOINS_ENABLED.key -> "true") { + checkAnswer( + testData3.join(testData3), + Row(1, null, 1, null) :: + Row(1, null, 2, 2) :: + Row(2, 2, 1, null) :: + Row(2, 2, 2, 2) :: Nil) + } + } + + test("SortMergeJoin returns wrong results when using UnsafeRows") { + // This test is for the fix of https://issues.apache.org/jira/browse/SPARK-10737. + // This bug will be triggered when Tungsten is enabled and there are multiple + // SortMergeJoin operators executed in the same task. + val confs = SQLConf.AUTO_BROADCASTJOIN_THRESHOLD.key -> "1" :: Nil + withSQLConf(confs: _*) { + val df1 = (1 to 50).map(i => (s"str_$i", i)).toDF("i", "j") + val df2 = + df1 + .join(df1.select(df1("i")), "i") + .select(df1("i"), df1("j")) + + val df3 = df2.withColumnRenamed("i", "i1").withColumnRenamed("j", "j1") + val df4 = + df2 + .join(df3, df2("i") === df3("i1")) + .withColumn("diff", $"j" - $"j1") + .select(df2("i"), df2("j"), $"diff") + + checkAnswer( + df4, + df1.withColumn("diff", lit(0))) + } + } } diff --git a/sql/core/src/test/scala/org/apache/spark/sql/SQLQuerySuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/SQLQuerySuite.scala index eac266cba55b8..12424fc22cf1e 100644 --- a/sql/core/src/test/scala/org/apache/spark/sql/SQLQuerySuite.scala +++ b/sql/core/src/test/scala/org/apache/spark/sql/SQLQuerySuite.scala @@ -22,9 +22,6 @@ import java.math.MathContext import java.sql.{Date, Timestamp} import org.apache.spark.{AccumulatorSuite, SparkException} -import org.apache.spark.sql.catalyst.analysis.UnresolvedException -import org.apache.spark.sql.catalyst.expressions.SortOrder -import org.apache.spark.sql.catalyst.plans.logical.Aggregate import org.apache.spark.sql.catalyst.util.StringUtils import org.apache.spark.sql.execution.aggregate import org.apache.spark.sql.execution.joins.{BroadcastHashJoinExec, CartesianProductExec, SortMergeJoinExec} @@ -126,29 +123,6 @@ class SQLQuerySuite extends QueryTest with SharedSQLContext { } } - test("self join with aliases") { - Seq(1, 2, 3).map(i => (i, i.toString)).toDF("int", "str").createOrReplaceTempView("df") - - checkAnswer( - sql( - """ - |SELECT x.str, COUNT(*) - |FROM df x JOIN df y ON x.str = y.str - |GROUP BY x.str - """.stripMargin), - Row("1", 1) :: Row("2", 1) :: Row("3", 1) :: Nil) - } - - test("support table.star") { - checkAnswer( - sql( - """ - |SELECT r.* - |FROM testData l join testData2 r on (l.key = r.a) - """.stripMargin), - Row(1, 1) :: Row(1, 2) :: Row(2, 1) :: Row(2, 2) :: Row(3, 1) :: Row(3, 2) :: Nil) - } - test("self join with alias in agg") { Seq(1, 2, 3) .map(i => (i, i.toString)) @@ -445,25 +419,20 @@ class SQLQuerySuite extends QueryTest with SharedSQLContext { Nil) } - test("left semi greater than predicate") { - withSQLConf(SQLConf.CROSS_JOINS_ENABLED.key -> "true") { - checkAnswer( - sql("SELECT * FROM testData2 x LEFT SEMI JOIN testData2 y ON x.a >= y.a + 2"), - Seq(Row(3, 1), Row(3, 2)) - ) - } - } - - test("left semi greater than predicate and equal operator") { + test("index into array") { checkAnswer( - sql("SELECT * FROM testData2 x LEFT SEMI JOIN testData2 y ON x.b = y.b and x.a >= y.a + 2"), - Seq(Row(3, 1), Row(3, 2)) - ) + sql("SELECT data, data[0], data[0] + data[1], data[0 + 1] FROM arrayData"), + arrayData.map(d => Row(d.data, d.data(0), d.data(0) + d.data(1), d.data(1))).collect()) + } + test("index into array of arrays") { checkAnswer( - sql("SELECT * FROM testData2 x LEFT SEMI JOIN testData2 y ON x.b = y.a and x.a >= y.b + 1"), - Seq(Row(2, 1), Row(2, 2), Row(3, 1), Row(3, 2)) - ) + sql( + "SELECT nestedData, nestedData[0][0], nestedData[0][0] + nestedData[0][1] FROM arrayData"), + arrayData.map(d => + Row(d.nestedData, + d.nestedData(0)(0), + d.nestedData(0)(0) + d.nestedData(0)(1))).collect().toSeq) } test("agg") { @@ -654,129 +623,6 @@ class SQLQuerySuite extends QueryTest with SharedSQLContext { } } - test("inner join where, one match per row") { - withSQLConf(SQLConf.CASE_SENSITIVE.key -> "true") { - checkAnswer( - sql("SELECT * FROM uppercasedata JOIN lowercasedata WHERE n = N"), - Seq( - Row(1, "A", 1, "a"), - Row(2, "B", 2, "b"), - Row(3, "C", 3, "c"), - Row(4, "D", 4, "d"))) - } - } - - test("inner join ON, one match per row") { - withSQLConf(SQLConf.CASE_SENSITIVE.key -> "true") { - checkAnswer( - sql("SELECT * FROM uppercasedata JOIN lowercasedata ON n = N"), - Seq( - Row(1, "A", 1, "a"), - Row(2, "B", 2, "b"), - Row(3, "C", 3, "c"), - Row(4, "D", 4, "d"))) - } - } - - test("inner join, where, multiple matches") { - withSQLConf(SQLConf.CASE_SENSITIVE.key -> "true") { - checkAnswer( - sql( - """ - |SELECT * FROM - | (SELECT * FROM testdata2 WHERE a = 1) x JOIN - | (SELECT * FROM testdata2 WHERE a = 1) y - |WHERE x.a = y.a""".stripMargin), - Row(1, 1, 1, 1) :: - Row(1, 1, 1, 2) :: - Row(1, 2, 1, 1) :: - Row(1, 2, 1, 2) :: Nil) - } - } - - test("inner join, no matches") { - checkAnswer( - sql( - """ - |SELECT * FROM - | (SELECT * FROM testData2 WHERE a = 1) x JOIN - | (SELECT * FROM testData2 WHERE a = 2) y - |WHERE x.a = y.a""".stripMargin), - Nil) - } - - test("big inner join, 4 matches per row") { - checkAnswer( - sql( - """ - |SELECT * FROM - | (SELECT * FROM testData UNION ALL - | SELECT * FROM testData UNION ALL - | SELECT * FROM testData UNION ALL - | SELECT * FROM testData) x JOIN - | (SELECT * FROM testData UNION ALL - | SELECT * FROM testData UNION ALL - | SELECT * FROM testData UNION ALL - | SELECT * FROM testData) y - |WHERE x.key = y.key""".stripMargin), - testData.rdd.flatMap( - row => Seq.fill(16)(Row.merge(row, row))).collect().toSeq) - } - - test("cartesian product join") { - withSQLConf(SQLConf.CROSS_JOINS_ENABLED.key -> "true") { - checkAnswer( - testData3.join(testData3), - Row(1, null, 1, null) :: - Row(1, null, 2, 2) :: - Row(2, 2, 1, null) :: - Row(2, 2, 2, 2) :: Nil) - } - } - - test("left outer join") { - withSQLConf(SQLConf.CASE_SENSITIVE.key -> "true") { - checkAnswer( - sql("SELECT * FROM uppercasedata LEFT OUTER JOIN lowercasedata ON n = N"), - Row(1, "A", 1, "a") :: - Row(2, "B", 2, "b") :: - Row(3, "C", 3, "c") :: - Row(4, "D", 4, "d") :: - Row(5, "E", null, null) :: - Row(6, "F", null, null) :: Nil) - } - } - - test("right outer join") { - withSQLConf(SQLConf.CASE_SENSITIVE.key -> "true") { - checkAnswer( - sql("SELECT * FROM lowercasedata RIGHT OUTER JOIN uppercasedata ON n = N"), - Row(1, "a", 1, "A") :: - Row(2, "b", 2, "B") :: - Row(3, "c", 3, "C") :: - Row(4, "d", 4, "D") :: - Row(null, null, 5, "E") :: - Row(null, null, 6, "F") :: Nil) - } - } - - test("full outer join") { - checkAnswer( - sql( - """ - |SELECT * FROM - | (SELECT * FROM upperCaseData WHERE N <= 4) leftTable FULL OUTER JOIN - | (SELECT * FROM upperCaseData WHERE N >= 3) rightTable - | ON leftTable.N = rightTable.N - """.stripMargin), - Row(1, "A", null, null) :: - Row(2, "B", null, null) :: - Row(3, "C", 3, "C") :: - Row (4, "D", 4, "D") :: - Row(null, null, 5, "E") :: - Row(null, null, 6, "F") :: Nil) - } - test("SPARK-11111 null-safe join should not use cartesian product") { val df = sql("select count(*) from testData a join testData b on (a.key <=> b.key)") val cp = df.queryExecution.sparkPlan.collect { @@ -808,50 +654,12 @@ class SQLQuerySuite extends QueryTest with SharedSQLContext { Row(2, "b", 2) :: Nil) } - test("mixed-case keywords") { - checkAnswer( - sql( - """ - |SeleCT * from - | (select * from upperCaseData WherE N <= 4) leftTable fuLL OUtER joiN - | (sElEcT * FROM upperCaseData whERe N >= 3) rightTable - | oN leftTable.N = rightTable.N - """.stripMargin), - Row(1, "A", null, null) :: - Row(2, "B", null, null) :: - Row(3, "C", 3, "C") :: - Row(4, "D", 4, "D") :: - Row(null, null, 5, "E") :: - Row(null, null, 6, "F") :: Nil) - } - test("select with table name as qualifier") { checkAnswer( sql("SELECT testData.value FROM testData WHERE testData.key = 1"), Row("1")) } - test("inner join ON with table name as qualifier") { - checkAnswer( - sql("SELECT * FROM upperCaseData JOIN lowerCaseData ON lowerCaseData.n = upperCaseData.N"), - Seq( - Row(1, "A", 1, "a"), - Row(2, "B", 2, "b"), - Row(3, "C", 3, "c"), - Row(4, "D", 4, "d"))) - } - - test("qualified select with inner join ON with table name as qualifier") { - checkAnswer( - sql("SELECT upperCaseData.N, upperCaseData.L FROM upperCaseData JOIN lowerCaseData " + - "ON lowerCaseData.n = upperCaseData.N"), - Seq( - Row(1, "A"), - Row(2, "B"), - Row(3, "C"), - Row(4, "D"))) - } - test("system function upper()") { checkAnswer( sql("SELECT n,UPPER(l) FROM lowerCaseData"), @@ -1186,17 +994,6 @@ class SQLQuerySuite extends QueryTest with SharedSQLContext { } } - test("Multiple join") { - checkAnswer( - sql( - """SELECT a.key, b.key, c.key - |FROM testData a - |JOIN testData b ON a.key = b.key - |JOIN testData c ON a.key = c.key - """.stripMargin), - (1 to 100).map(i => Row(i, i, i))) - } - test("SPARK-3483 Special chars in column names") { val data = sparkContext.parallelize( Seq("""{"key?number1": "value1", "key.number2": "value2"}""")) @@ -1220,16 +1017,6 @@ class SQLQuerySuite extends QueryTest with SharedSQLContext { checkAnswer(sql("SELECT ~key FROM testData WHERE key = 1 "), Row(-2)) } - test("SPARK-4120 Join of multiple tables does not work in SparkSQL") { - checkAnswer( - sql( - """SELECT a.key, b.key, c.key - |FROM testData a,testData b,testData c - |where a.key = b.key and a.key = c.key - """.stripMargin), - (1 to 100).map(i => Row(i, i, i))) - } - test("SPARK-4154 Query does not work if it has 'not between' in Spark SQL and HQL") { checkAnswer(sql("SELECT key FROM testData WHERE key not between 0 and 10 order by key"), (11 to 100).map(i => Row(i))) @@ -1266,18 +1053,6 @@ class SQLQuerySuite extends QueryTest with SharedSQLContext { ) } - test("Supporting relational operator '<=>' in Spark SQL") { - val nullCheckData1 = TestData(1, "1") :: TestData(2, null) :: Nil - val rdd1 = sparkContext.parallelize((0 to 1).map(i => nullCheckData1(i))) - rdd1.toDF().createOrReplaceTempView("nulldata1") - val nullCheckData2 = TestData(1, "1") :: TestData(2, null) :: Nil - val rdd2 = sparkContext.parallelize((0 to 1).map(i => nullCheckData2(i))) - rdd2.toDF().createOrReplaceTempView("nulldata2") - checkAnswer(sql("SELECT nulldata1.key FROM nulldata1 join " + - "nulldata2 on nulldata1.value <=> nulldata2.value"), - (1 to 2).map(i => Row(i))) - } - test("Multi-column COUNT(DISTINCT ...)") { val data = TestData(1, "val_1") :: TestData(2, "val_2") :: Nil val rdd = sparkContext.parallelize((0 to 1).map(i => data(i))) @@ -1679,31 +1454,6 @@ class SQLQuerySuite extends QueryTest with SharedSQLContext { "org.apache.spark.sql.execution.datasources.jdbc")) } - test("SortMergeJoin returns wrong results when using UnsafeRows") { - // This test is for the fix of https://issues.apache.org/jira/browse/SPARK-10737. - // This bug will be triggered when Tungsten is enabled and there are multiple - // SortMergeJoin operators executed in the same task. - val confs = SQLConf.AUTO_BROADCASTJOIN_THRESHOLD.key -> "1" :: Nil - withSQLConf(confs: _*) { - val df1 = (1 to 50).map(i => (s"str_$i", i)).toDF("i", "j") - val df2 = - df1 - .join(df1.select(df1("i")), "i") - .select(df1("i"), df1("j")) - - val df3 = df2.withColumnRenamed("i", "i1").withColumnRenamed("j", "j1") - val df4 = - df2 - .join(df3, df2("i") === df3("i1")) - .withColumn("diff", $"j" - $"j1") - .select(df2("i"), df2("j"), $"diff") - - checkAnswer( - df4, - df1.withColumn("diff", lit(0))) - } - } - test("SPARK-11303: filter should not be pushed down into sample") { val df = spark.range(100) List(true, false).foreach { withReplacement => @@ -2203,70 +1953,6 @@ class SQLQuerySuite extends QueryTest with SharedSQLContext { } } - test("join with using clause") { - val df1 = Seq(("r1c1", "r1c2", "t1r1c3"), - ("r2c1", "r2c2", "t1r2c3"), ("r3c1x", "r3c2", "t1r3c3")).toDF("c1", "c2", "c3") - val df2 = Seq(("r1c1", "r1c2", "t2r1c3"), - ("r2c1", "r2c2", "t2r2c3"), ("r3c1y", "r3c2", "t2r3c3")).toDF("c1", "c2", "c3") - val df3 = Seq((null, "r1c2", "t3r1c3"), - ("r2c1", "r2c2", "t3r2c3"), ("r3c1y", "r3c2", "t3r3c3")).toDF("c1", "c2", "c3") - withTempView("t1", "t2", "t3") { - df1.createOrReplaceTempView("t1") - df2.createOrReplaceTempView("t2") - df3.createOrReplaceTempView("t3") - // inner join with one using column - checkAnswer( - sql("SELECT * FROM t1 join t2 using (c1)"), - Row("r1c1", "r1c2", "t1r1c3", "r1c2", "t2r1c3") :: - Row("r2c1", "r2c2", "t1r2c3", "r2c2", "t2r2c3") :: Nil) - - // inner join with two using columns - checkAnswer( - sql("SELECT * FROM t1 join t2 using (c1, c2)"), - Row("r1c1", "r1c2", "t1r1c3", "t2r1c3") :: - Row("r2c1", "r2c2", "t1r2c3", "t2r2c3") :: Nil) - - // Left outer join with one using column. - checkAnswer( - sql("SELECT * FROM t1 left join t2 using (c1)"), - Row("r1c1", "r1c2", "t1r1c3", "r1c2", "t2r1c3") :: - Row("r2c1", "r2c2", "t1r2c3", "r2c2", "t2r2c3") :: - Row("r3c1x", "r3c2", "t1r3c3", null, null) :: Nil) - - // Right outer join with one using column. - checkAnswer( - sql("SELECT * FROM t1 right join t2 using (c1)"), - Row("r1c1", "r1c2", "t1r1c3", "r1c2", "t2r1c3") :: - Row("r2c1", "r2c2", "t1r2c3", "r2c2", "t2r2c3") :: - Row("r3c1y", null, null, "r3c2", "t2r3c3") :: Nil) - - // Full outer join with one using column. - checkAnswer( - sql("SELECT * FROM t1 full outer join t2 using (c1)"), - Row("r1c1", "r1c2", "t1r1c3", "r1c2", "t2r1c3") :: - Row("r2c1", "r2c2", "t1r2c3", "r2c2", "t2r2c3") :: - Row("r3c1x", "r3c2", "t1r3c3", null, null) :: - Row("r3c1y", null, - null, "r3c2", "t2r3c3") :: Nil) - - // Full outer join with null value in join column. - checkAnswer( - sql("SELECT * FROM t1 full outer join t3 using (c1)"), - Row("r1c1", "r1c2", "t1r1c3", null, null) :: - Row("r2c1", "r2c2", "t1r2c3", "r2c2", "t3r2c3") :: - Row("r3c1x", "r3c2", "t1r3c3", null, null) :: - Row("r3c1y", null, null, "r3c2", "t3r3c3") :: - Row(null, null, null, "r1c2", "t3r1c3") :: Nil) - - // Self join with using columns. - checkAnswer( - sql("SELECT * FROM t1 join t1 using (c1)"), - Row("r1c1", "r1c2", "t1r1c3", "r1c2", "t1r1c3") :: - Row("r2c1", "r2c2", "t1r2c3", "r2c2", "t1r2c3") :: - Row("r3c1x", "r3c2", "t1r3c3", "r3c2", "t1r3c3") :: Nil) - } - } - test("SPARK-15327: fail to compile generated code with complex data structure") { withTempDir{ dir => val json = diff --git a/sql/core/src/test/scala/org/apache/spark/sql/SQLQueryTestSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/SQLQueryTestSuite.scala index 55d5a56f1040a..29a45080bdc17 100644 --- a/sql/core/src/test/scala/org/apache/spark/sql/SQLQueryTestSuite.scala +++ b/sql/core/src/test/scala/org/apache/spark/sql/SQLQueryTestSuite.scala @@ -243,12 +243,21 @@ class SQLQueryTestSuite extends QueryTest with SharedSQLContext { private def loadTestData(session: SparkSession): Unit = { import session.implicits._ - (1 to 100).map(i => (i, i.toString)).toDF("key", "value").createOrReplaceTempView("testdata") + // A data set containing non-duplicate column values + (1 to 100).map(i => (i, i.toString)).toDF("key", "value") + .createOrReplaceTempView("uniqueRowData") + // A data set containing duplicate values for each column (but all the rows are unique) + Seq((1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2)) + .toDF("a", "b") + .createOrReplaceTempView("duplicateColumnValueData") + + // A data set containing a complex data type: ARRAY ((Seq(1, 2, 3), Seq(Seq(1, 2, 3))) :: (Seq(2, 3, 4), Seq(Seq(2, 3, 4))) :: Nil) .toDF("arraycol", "nestedarraycol") .createOrReplaceTempView("arraydata") + // A data set containing a complex data type: MAP (Tuple1(Map(1 -> "a1", 2 -> "b1", 3 -> "c1", 4 -> "d1", 5 -> "e1")) :: Tuple1(Map(1 -> "a2", 2 -> "b2", 3 -> "c2", 4 -> "d2")) :: Tuple1(Map(1 -> "a3", 2 -> "b3", 3 -> "c3")) :: @@ -256,6 +265,59 @@ class SQLQueryTestSuite extends QueryTest with SharedSQLContext { Tuple1(Map(1 -> "a5")) :: Nil) .toDF("mapcol") .createOrReplaceTempView("mapdata") + + // A data set containing uppercase column names and column values + Seq((1, "a"), (2, "b"), (3, "c"), (4, "d")) + .toDF("n", "l") + .createOrReplaceTempView("lowerCaseData") + + // A data set containing uppercase column names and column values + Seq((1, "A"), (2, "B"), (3, "C"), (4, "D"), (5, "E"), (6, "F")) + .toDF("N", "L") + .createOrReplaceTempView("upperCaseData") + + // A data set containing duplicate rows + Seq((251, "val_251"), (86, "val_86"), (165, "val_165"), (330, "val_330"), (165, "val_165")) + .toDF("key", "value") + .createOrReplaceTempView("duplicateRowData") + + // A data set containing null + session.sql( + """ + |CREATE OR REPLACE TEMPORARY VIEW nullData AS SELECT * FROM VALUES + |(201, null), + |(86, "val_86"), + |(null, "val_null"), + |(165, "val_165"), + |(null, null), + |(330, "val_330"), + |(165, null) + |as nullData(key, value) + """.stripMargin) + + // A data set with logical partition columns ("ds" and "hr") + Seq((251, "val_251", "2008-04-08", "11"), + (251, "val_251", "2008-04-09", "11"), + (251, "val_251", "2008-04-08", "12"), + (251, "val_251", "2008-04-09", "12"), + (86, "val_86", "2008-04-08", "11"), + (86, "val_86", "2008-04-09", "11"), + (86, "val_86", "2008-04-08", "12"), + (86, "val_86", "2008-04-09", "12"), + (165, "val_165", "2008-04-08", "11"), + (165, "val_165", "2008-04-09", "11"), + (165, "val_165", "2008-04-08", "12"), + (165, "val_165", "2008-04-09", "12"), + (330, "val_330", "2008-04-08", "11"), + (330, "val_330", "2008-04-09", "11"), + (330, "val_330", "2008-04-08", "12"), + (330, "val_330", "2008-04-09", "12"), + (165, "val_165", "2008-04-08", "11"), + (165, "val_165", "2008-04-09", "11"), + (165, "val_165", "2008-04-08", "12"), + (165, "val_165", "2008-04-09", "12")) + .toDF("key", "value", "ds", "hr") + .createOrReplaceTempView("partitionedData") } private val originalTimeZone = TimeZone.getDefault