marsultor/email-tracker
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

should be it

Browse Source
This commit is contained in:
Mars Ultor
2025-10-24 19:21:19 -05:00
parent a4b23fc57c
commit f09560c7b1
14047 changed files with 3161551 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
external/duckdb/test/sql/subquery/any_all/issue_2999.test vendored Normal file
View File

@@ -0,0 +1,23 @@
# name: test/sql/subquery/any_all/issue_2999.test
# description: Issue #2999: Correlated group on ANY subquery
# group: [any_all]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE t0 (c0 INT);
statement ok
CREATE TABLE t1 (c0 INT);
statement ok
INSERT INTO t0 VALUES (1);
statement ok
INSERT INTO t1 VALUES (1);
query I
SELECT 1 = ANY(SELECT 1 FROM t1 JOIN (SELECT count(*) GROUP BY t0.c0) AS x(x) ON TRUE) FROM t0;
----
true

27
external/duckdb/test/sql/subquery/any_all/subquery_in.test vendored Normal file
View File

@@ -0,0 +1,27 @@
# name: test/sql/subquery/any_all/subquery_in.test
# description: Test subquery in IN clause
# group: [any_all]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE t0 (c0 TIME,c1 DOUBLE PRECISION);
statement ok
CREATE TABLE t1 (c0 INT);
statement ok
INSERT INTO t1 VALUES (1),(10),(7),(9),(NULL),(1),(7),(7),(0),(8),(0),(9),(NULL),(5),(3),(8),(0);
statement error
SELECT (FALSE) IN (TRUE, (SELECT TIME '13:35:07' FROM t1) BETWEEN t0.c0 AND t0.c0) FROM t0;
----
More than one row returned
statement ok
SET scalar_subquery_error_on_multiple_rows=false
query I
SELECT (FALSE) IN (TRUE, (SELECT TIME '13:35:07' FROM t1) BETWEEN t0.c0 AND t0.c0) FROM t0;
----

92
external/duckdb/test/sql/subquery/any_all/test_any_all.test vendored Normal file
View File

@@ -0,0 +1,92 @@
# name: test/sql/subquery/any_all/test_any_all.test
# description: Test ANY/ALL queries
# group: [any_all]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3)
# ANY is like EXISTS without NULL values
query T
SELECT 2 > ANY(SELECT * FROM integers)
----
1
query T
SELECT 1 > ANY(SELECT * FROM integers)
----
0
query T
SELECT 4 > ALL(SELECT * FROM integers)
----
1
query T
SELECT 1 > ALL(SELECT * FROM integers)
----
0
# NULL input always results in NULL output
query T
SELECT NULL > ANY(SELECT * FROM integers)
----
NULL
query T
SELECT NULL > ALL(SELECT * FROM integers)
----
NULL
# now with a NULL value in the input
statement ok
INSERT INTO integers VALUES (NULL)
# ANY returns either true or NULL
query T
SELECT 2 > ANY(SELECT * FROM integers)
----
1
query T
SELECT 1 > ANY(SELECT * FROM integers)
----
NULL
# ALL returns either NULL or false
query T
SELECT 4 > ALL(SELECT * FROM integers)
----
NULL
query T
SELECT 1 > ALL(SELECT * FROM integers)
----
0
# NULL input always results in NULL
query T
SELECT NULL > ANY(SELECT * FROM integers)
----
NULL
query T
SELECT NULL > ALL(SELECT * FROM integers)
----
NULL
# unsupported comparisons
statement error
SELECT 2 ^ ANY(SELECT * FROM integers)
----
Parser Error: ANY and ALL operators require one of =,<>,>,<,>=,<= comparisons!
statement error
SELECT 2 ^ ANY([1, 2, 3])
----
Parser Error: Unsupported comparison "^" for ANY/ALL subquery

184
external/duckdb/test/sql/subquery/any_all/test_correlated_any_all.test vendored Normal file
View File

@@ -0,0 +1,184 @@
# name: test/sql/subquery/any_all/test_correlated_any_all.test
# description: Test correlated ANY/ALL subqueries
# group: [any_all]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL)
# correlated ANY/ALL
query T
SELECT i=ANY(SELECT i FROM integers WHERE i=i1.i) FROM integers i1 ORDER BY i;
----
0
1
1
1
query T
SELECT i>ALL(SELECT (i+i1.i-1)/2 FROM integers WHERE i IS NOT NULL) FROM integers i1 ORDER BY i;
----
NULL
0
0
1
query T
SELECT i=ALL(SELECT i FROM integers WHERE i<>i1.i) FROM integers i1 ORDER BY i;
----
1
0
0
0
# correlated ANY/ALL
query I
SELECT i FROM integers i1 WHERE i=ANY(SELECT i FROM integers WHERE i=i1.i) ORDER BY i;
----
1
2
3
query I
SELECT i FROM integers i1 WHERE i<>ANY(SELECT i FROM integers WHERE i=i1.i) ORDER BY i;
----
query I
SELECT i FROM integers i1 WHERE i=ANY(SELECT i FROM integers WHERE i<>i1.i) ORDER BY i;
----
query I
SELECT i FROM integers i1 WHERE i>ANY(SELECT i FROM integers WHERE i<>i1.i) ORDER BY i;
----
2
3
query I
SELECT i FROM integers i1 WHERE i>ALL(SELECT (i+i1.i-1)/2 FROM integers WHERE i IS NOT NULL) ORDER BY i;
----
3
# if there is i=ANY() where the subquery returns an EMPTY result set and i=NULL, the result becomes FALSE instead
# of NULL
query T
SELECT i=ALL(SELECT i FROM integers WHERE i=i1.i) FROM integers i1 ORDER BY i;
----
1
1
1
1
query T
SELECT i=ANY(SELECT i FROM integers WHERE i=i1.i) FROM integers i1 ORDER BY i;
----
0
1
1
1
query T
SELECT i<>ALL(SELECT i FROM integers WHERE i=i1.i) FROM integers i1 ORDER BY i;
----
1
0
0
0
query T
SELECT i<>ANY(SELECT i FROM integers WHERE i=i1.i) FROM integers i1 ORDER BY i;
----
0
0
0
0
query T
SELECT i=ALL(SELECT i FROM integers WHERE i<>i1.i) FROM integers i1 ORDER BY i;
----
1
0
0
0
query T
SELECT i=ANY(SELECT i FROM integers WHERE i<>i1.i) FROM integers i1 ORDER BY i;
----
0
0
0
0
query T
SELECT i>ANY(SELECT i FROM integers WHERE i<>i1.i) FROM integers i1 ORDER BY i;
----
0
0
1
1
query T
SELECT i>ALL(SELECT (i+i1.i-1)/2 FROM integers) FROM integers i1 ORDER BY i;
----
NULL
0
0
NULL
query T
SELECT i>ALL(SELECT (i+i1.i-1)/2 FROM integers WHERE i IS NOT NULL) FROM integers i1 ORDER BY i;
----
NULL
0
0
1
query T
SELECT i=ANY(SELECT i FROM integers WHERE i=i1.i OR i IS NULL) FROM integers i1 ORDER BY i;
----
NULL
1
1
1
query T
SELECT i=ALL(SELECT i FROM integers WHERE i=i1.i OR i IS NULL) FROM integers i1 ORDER BY i;
----
NULL
NULL
NULL
NULL
# correlated ANY/ALL with aggregations
query T
SELECT MIN(i)>ANY(SELECT i FROM integers WHERE i>MIN(i1.i)) FROM integers i1;
----
0
query T
SELECT SUM(i)>ANY(SELECT i FROM integers WHERE i>MIN(i1.i)) FROM integers i1;
----
1
# correlated subquery with correlated any
query T
SELECT (SELECT SUM(i)+SUM(i1.i) FROM integers)>ANY(SELECT i FROM integers WHERE i>MIN(i1.i)) FROM integers i1;
----
1
# zero results for all
query T
SELECT i=ANY(SELECT i FROM integers WHERE i=i1.i AND i>10) FROM integers i1 ORDER BY i;
----
0
0
0
0

49
external/duckdb/test/sql/subquery/any_all/test_scalar_any_all.test vendored Normal file
View File

@@ -0,0 +1,49 @@
# name: test/sql/subquery/any_all/test_scalar_any_all.test
# description: Test scalar ANY/ALL queries
# group: [any_all]
statement ok
PRAGMA enable_verification
# scalar ANY
query T
SELECT 1 = ANY(SELECT 1)
----
1
query T
SELECT 1 = ANY(SELECT NULL)
----
NULL
query T
SELECT 1 = ANY(SELECT 2)
----
0
query T
SELECT NULL = ANY(SELECT 2)
----
NULL
# scalar ALL
query T
SELECT 1 = ALL(SELECT 1)
----
1
query T
SELECT 1 = ALL(SELECT NULL)
----
NULL
query T
SELECT 1 = ALL(SELECT 2)
----
0
query T
SELECT NULL = ALL(SELECT 2)
----
NULL

79
external/duckdb/test/sql/subquery/any_all/test_scalar_in.test vendored Normal file
View File

@@ -0,0 +1,79 @@
# name: test/sql/subquery/any_all/test_scalar_in.test
# description: Test scalar IN query
# group: [any_all]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
query T
SELECT 1 IN (SELECT 1)
----
1
query T
SELECT NULL IN (SELECT 1)
----
NULL
query T
SELECT 1 IN (SELECT NULL)
----
NULL
query T
SELECT 1 IN (SELECT 2)
----
0
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3)
query T
SELECT 4 IN (SELECT * FROM integers)
----
0
query T
SELECT 1 IN (SELECT * FROM integers)
----
1
query T
SELECT 1 IN (SELECT * FROM integers) FROM integers
----
1
1
1
statement ok
INSERT INTO integers VALUES (NULL)
query T
SELECT 4 IN (SELECT * FROM integers)
----
NULL
query T
SELECT 1 IN (SELECT * FROM integers)
----
1
query I
SELECT * FROM integers WHERE (4 IN (SELECT * FROM integers)) IS NULL ORDER BY 1
----
NULL
1
2
3
query I
SELECT * FROM integers WHERE (i IN (SELECT * FROM integers)) IS NULL ORDER BY 1
----
NULL

36
external/duckdb/test/sql/subquery/any_all/test_simple_not_in.test vendored Normal file
View File

@@ -0,0 +1,36 @@
# name: test/sql/subquery/any_all/test_simple_not_in.test
# description: Test subqueries with (NOT) IN clause
# group: [any_all]
statement ok
PRAGMA enable_verification
# scalar subquery
query I
SELECT 1 AS one WHERE 1 IN (SELECT 1);
----
1
statement ok
CREATE TABLE test (id INTEGER, b INTEGER);
statement ok
INSERT INTO test VALUES (1, 22)
statement ok
INSERT INTO test VALUES (2, 21)
statement ok
INSERT INTO test VALUES (3, 23)
query II
SELECT * FROM test WHERE b IN (SELECT b FROM test WHERE b * id < 30) ORDER BY id, b
----
1 22
query II
SELECT * FROM test WHERE b NOT IN (SELECT b FROM test WHERE b * id < 30) ORDER BY id, b
----
2 21
3 23

219
external/duckdb/test/sql/subquery/any_all/test_uncorrelated_all_subquery.test vendored Normal file
View File

@@ -0,0 +1,219 @@
# name: test/sql/subquery/any_all/test_uncorrelated_all_subquery.test
# description: Test uncorrelated ALL subqueries
# group: [any_all]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL)
# uncorrelated ALL
query I
SELECT i FROM integers WHERE i >= ALL(SELECT i FROM integers)
----
query IT
SELECT i, i >= ALL(SELECT i FROM integers) FROM integers ORDER BY i
----
NULL NULL
1 0
2 0
3 NULL
query I
SELECT i FROM integers WHERE i >= ALL(SELECT i FROM integers WHERE i IS NOT NULL)
----
3
query IT
SELECT i, i >= ALL(SELECT i FROM integers WHERE i IS NOT NULL) FROM integers ORDER BY i
----
NULL NULL
1 0
2 0
3 1
query I
SELECT i FROM integers WHERE i >= ALL(SELECT i FROM integers WHERE i IS NOT NULL)
----
3
query I
SELECT i FROM integers WHERE i > ALL(SELECT MIN(i) FROM integers)
----
2
3
query I
SELECT i FROM integers WHERE i < ALL(SELECT MAX(i) FROM integers) ORDER BY 1
----
1
2
query I
SELECT i FROM integers WHERE i <= ALL(SELECT i FROM integers)
----
query I
SELECT i FROM integers WHERE i <= ALL(SELECT i FROM integers WHERE i IS NOT NULL)
----
1
query I
SELECT i FROM integers WHERE i = ALL(SELECT i FROM integers WHERE i=1)
----
1
query I
SELECT i FROM integers WHERE i <> ALL(SELECT i FROM integers WHERE i=1)
----
2
3
query I
SELECT i FROM integers WHERE i = ALL(SELECT i FROM integers WHERE i IS NOT NULL)
----
query I
SELECT i FROM integers WHERE i <> ALL(SELECT i FROM integers WHERE i IS NOT NULL)
----
# zero results always results in TRUE for ALL, even if "i" is NULL
query I
SELECT i FROM integers WHERE i <> ALL(SELECT i FROM integers WHERE i>10) ORDER BY i;
----
NULL
1
2
3
query IT
SELECT i, i <> ALL(SELECT i FROM integers WHERE i>10) FROM integers ORDER BY i;
----
NULL 1
1 1
2 1
3 1
# zero results always results in FALSE for ANY
query IT
SELECT i, i > ANY(SELECT i FROM integers WHERE i>10) FROM integers ORDER BY i;
----
NULL 0
1 0
2 0
3 0
query IT
SELECT i, i = ANY(SELECT i FROM integers WHERE i>10) FROM integers ORDER BY i;
----
NULL 0
1 0
2 0
3 0
query IT
SELECT i, i >= ANY(SELECT i FROM integers WHERE i>10) FROM integers ORDER BY i;
----
NULL 0
1 0
2 0
3 0
query IT
SELECT i, i <= ANY(SELECT i FROM integers WHERE i>10) FROM integers ORDER BY i;
----
NULL 0
1 0
2 0
3 0
query IT
SELECT i, i < ANY(SELECT i FROM integers WHERE i>10) FROM integers ORDER BY i;
----
NULL 0
1 0
2 0
3 0
query IT
SELECT i, i <> ANY(SELECT i FROM integers WHERE i>10) FROM integers ORDER BY i;
----
NULL 0
1 0
2 0
3 0
# nested uncorrelated subqueries
query I
SELECT (SELECT (SELECT (SELECT 42)))
----
42
query T
SELECT (SELECT EXISTS(SELECT * FROM integers WHERE i>2)) FROM integers;
----
1
1
1
1
query IR
SELECT (SELECT MAX(i) FROM integers) AS k, SUM(i) FROM integers GROUP BY k;
----
3 6.000000
# subqueries in GROUP BY clause
query TR
SELECT i >= ALL(SELECT i FROM integers WHERE i IS NOT NULL) AS k, SUM(i) FROM integers GROUP BY k ORDER BY k;
----
NULL NULL
0 3.000000
1 3.000000
query R
SELECT SUM(i) FROM integers GROUP BY (i >= ALL(SELECT i FROM integers WHERE i IS NOT NULL)) ORDER BY 1;
----
NULL
3.000000
3.000000
query TR
SELECT i >= ALL(SELECT MIN(i) FROM integers WHERE i IS NOT NULL) AS k, SUM(i) FROM integers GROUP BY k ORDER BY k;
----
NULL NULL
1 6.000000
# subquery in CASE statement
query IR
SELECT i, SUM(CASE WHEN (i >= ALL(SELECT i FROM integers WHERE i=2)) THEN 1 ELSE 0 END) FROM integers GROUP BY i ORDER BY i;
----
NULL 0.000000
1 0.000000
2 1.000000
3 1.000000
# subquery in HAVING
query IR
SELECT i % 2 AS k, SUM(i) FROM integers GROUP BY k HAVING SUM(i) > (SELECT MAX(i) FROM integers)
----
1 4.000000
query I
SELECT i FROM integers WHERE NOT(i IN (SELECT i FROM integers WHERE i>1));
----
1
# multiple subqueries in select without FROM
query RI
SELECT (SELECT SUM(i) FROM integers), (SELECT 42)
----
6.000000 42

134
external/duckdb/test/sql/subquery/any_all/test_uncorrelated_any_subquery.test vendored Normal file
View File

@@ -0,0 +1,134 @@
# name: test/sql/subquery/any_all/test_uncorrelated_any_subquery.test
# description: Test uncorrelated ANY subqueries
# group: [any_all]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL)
# uncorrelated ANY
query I
SELECT i FROM integers WHERE i <= ANY(SELECT i FROM integers)
----
1
2
3
query I
SELECT i FROM integers WHERE i > ANY(SELECT i FROM integers) ORDER BY 1
----
2
3
query IT
SELECT i, i > ANY(SELECT i FROM integers) FROM integers ORDER BY i
----
NULL NULL
1 NULL
2 1
3 1
query IT
SELECT i, i > ANY(SELECT i FROM integers WHERE i IS NOT NULL) FROM integers ORDER BY i
----
NULL NULL
1 0
2 1
3 1
query IT
SELECT i, NULL > ANY(SELECT i FROM integers) FROM integers ORDER BY i
----
NULL NULL
1 NULL
2 NULL
3 NULL
query IT
SELECT i, NULL > ANY(SELECT i FROM integers WHERE i IS NOT NULL) FROM integers ORDER BY i
----
NULL NULL
1 NULL
2 NULL
3 NULL
query I
SELECT i FROM integers WHERE i = ANY(SELECT i FROM integers) order by i
----
1
2
3
query IT
SELECT i, i = ANY(SELECT i FROM integers WHERE i>2) FROM integers ORDER BY i
----
NULL NULL
1 0
2 0
3 1
query IT
SELECT i, i = ANY(SELECT i FROM integers WHERE i>2 OR i IS NULL) FROM integers ORDER BY i
----
NULL NULL
1 NULL
2 NULL
3 1
query IT
SELECT i, i <> ANY(SELECT i FROM integers WHERE i>2) FROM integers ORDER BY i
----
NULL NULL
1 1
2 1
3 0
query IT
SELECT i, i <> ANY(SELECT i FROM integers WHERE i>2 OR i IS NULL) FROM integers ORDER BY i
----
NULL NULL
1 1
2 1
3 NULL
# use a bunch of cross products to make bigger data sets (> STANDARD_VECTOR_SIZE)
query IT
SELECT i, i = ANY(SELECT i1.i FROM integers i1, integers i2, integers i3, integers i4, integers i5, integers i6 WHERE i1.i IS NOT NULL) FROM integers ORDER BY i
----
NULL NULL
1 1
2 1
3 1
query IT
SELECT i, i = ANY(SELECT i1.i FROM integers i1, integers i2, integers i3, integers i4, integers i5, integers i6 WHERE i1.i IS NOT NULL AND i1.i <> 2) FROM integers ORDER BY i
----
NULL NULL
1 1
2 0
3 1
query IT
SELECT i, i >= ANY(SELECT i1.i FROM integers i1, integers i2, integers i3, integers i4, integers i5, integers i6 WHERE i1.i IS NOT NULL) FROM integers ORDER BY i
----
NULL NULL
1 1
2 1
3 1
query IT
SELECT i, i >= ANY(SELECT i1.i FROM integers i1, integers i2, integers i3, integers i4, integers i5, integers i6 WHERE i1.i IS NOT NULL AND i1.i <> 1 LIMIT 1) FROM integers ORDER BY i
----
NULL NULL
1 0
2 1
3 1

47
external/duckdb/test/sql/subquery/complex/complex_correlated_subquery_issue.test vendored Normal file
View File

@@ -0,0 +1,47 @@
# name: test/sql/subquery/complex/complex_correlated_subquery_issue.test
# description: Test complex correlated subquery
# group: [complex]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE t0(c0 INT);
statement ok
CREATE TABLE t1(c0 INT);
statement ok
CREATE TABLE t2(c0 INT);
statement ok
SELECT * FROM t2, t1, ( SELECT t2.c0 AS col_1, t1.c0 AS col_2) as subQuery0 INNER JOIN t0 ON ((subQuery0.col_2)) CROSS JOIN (SELECT t0.c0 AS col_1);
statement ok
INSERT INTO t2(c0) VALUES (2);
statement ok
INSERT INTO t1(c0) VALUES (1);
statement ok
INSERT INTO t0(c0) VALUES (1);
query IIII
SELECT * FROM t2, t0 LEFT JOIN Lateral(SELECT t0.c0 AS col_0, t2.c0 AS col_1) as subQuery1 ON ((subQuery1.col_1)<(t0.c0));
----
2 1 NULL NULL
statement ok
drop table t0;
statement ok
drop table t1;
statement ok
CREATE TABLE t0(c0 DATE);
statement ok
CREATE TABLE t1(c0 DATETIME, c1 DOUBLE);
statement ok
SELECT * FROM t0, t1 CROSS JOIN (SELECT t0.c0 AS col_0 WHERE t1.c1) as subQuery0;

179
external/duckdb/test/sql/subquery/complex/correlated_internal_issue_5975.test vendored Normal file
View File

@@ -0,0 +1,179 @@
# name: test/sql/subquery/complex/correlated_internal_issue_5975.test
# description: Test internal issue 5975 - INTERNAL Error: Failed to bind column reference ""
# group: [complex]
statement ok
CREATE TABLE my_logs (
featherEventId UUID,
"duckInfo.gooseEmail" VARCHAR,
"duckInfo.gooseSubject" VARCHAR
);
statement ok
CREATE TYPE MY_ENUM AS ENUM (
'EnumField1',
'EnumField2',
'EnumField3',
'EnumField4',
'EnumField5',
'EnumField6',
'EnumField7',
'EnumField8'
);
statement ok
CREATE OR REPLACE MACRO swan_MY_ENUM (sa) AS (
WITH sa_parts AS (
SELECT STRING_SPLIT(sa, '@') AS emailParts
)
SELECT 'EnumField2'::MY_ENUM
FROM sa_parts
);
statement ok
CREATE OR REPLACE MACRO swan_email_info (duckEmail) AS (
SELECT
CASE
WHEN ENDS_WITH(duckEmail, 'duckdblabs.com') THEN STRUCT_PACK(
subject := 'serviceAccount:' || duckEmail,
type := swan_MY_ENUM (duckEmail)
)
WHEN duckEmail = 'my@duckdblabs.com'
OR duckEmail = 'EnumField8' THEN STRUCT_PACK(
subject := 'EnumField8',
type := 'EnumField8'::MY_ENUM
)
WHEN REGEXP_MATCHES(duckEmail, '[\w-.+]+@(([\w-]+).)+[\w-]{2,4}') THEN STRUCT_PACK(
subject := 'user:' || duckEmail,
type := 'EnumField1'::MY_ENUM
)
END AS duckInfo
);
statement ok
CREATE OR REPLACE MACRO swan_subject_info (duckSubject) AS (
WITH
subjectComponents AS (
SELECT
duckSubject AS subject,
STRING_SPLIT(duckSubject, ':') AS parts
)
SELECT
CASE
WHEN parts[1] = 'EnumField2' THEN STRUCT_PACK(
subject := subject,
type := swan_MY_ENUM (parts[2])
)
WHEN parts[1] = 'EnumField1' THEN STRUCT_PACK(subject := subject, type := 'EnumField1'::MY_ENUM)
WHEN REGEXP_MATCHES(
subject,
'duckdb.org'
) THEN STRUCT_PACK(
subject := subject,
type := 'EnumField6'::MY_ENUM
)
WHEN NOT REGEXP_FULL_MATCH(subject, '.+@.+\..+') THEN STRUCT_PACK(
subject := subject,
type := 'EnumField7'::MY_ENUM
)
END AS duckInfo
FROM
subjectComponents
);
statement ok
WITH
duck_info AS (
SELECT
featherEventId,
"duckInfo.gooseEmail" AS email,
"duckInfo.gooseSubject" AS subject,
HASH('email' || "duckInfo.gooseEmail") AS emailHash,
HASH(
'subject' || "duckInfo.gooseSubject"
) AS subjectHash,
FROM
my_logs
),
unique_emails AS (
SELECT
email,
emailHash
FROM
duck_info
WHERE
email IS NOT NULL
GROUP BY
1,
2
),
email_info AS (
SELECT
emailHash AS swanHash,
swan_email_info (email) AS swanInfo
FROM
unique_emails
),
unique_subjects AS (
SELECT
subject,
subjectHash
FROM
duck_info
WHERE
subject IS NOT NULL
GROUP BY
1,
2
),
subject_info AS (
SELECT
subjectHash AS swanHash,
swan_subject_info (subject) AS swanInfo
FROM
unique_subjects
),
swan_info AS (
SELECT
*
FROM
email_info
UNION ALL
SELECT
*
FROM
subject_info
),
goose_id AS (
SELECT
featherEventId,
CASE
WHEN subject IS NOT NULL THEN subjectHash
WHEN email IS NOT NULL THEN emailHash
END AS swanHash,
FROM
duck_info
),
normalized_ids AS (
SELECT
featherEventId,
swanInfo.subject AS featherIdentityId,
swanInfo.type AS featherIdentityType,
FROM
goose_id
LEFT JOIN swan_info USING (swanHash)
),
chicken_info AS (
SELECT
featherEventId,
featherIdentityId,
featherIdentityType,
FROM
normalized_ids
)
SELECT
featherEventId,
featherIdentityId,
featherIdentityType,
FROM
chicken_info;

279
external/duckdb/test/sql/subquery/complex/correlated_list_aggregate.test_slow vendored Normal file
View File

@@ -0,0 +1,279 @@
# name: test/sql/subquery/complex/correlated_list_aggregate.test_slow
# description: Test correlated aggregate subqueries
# group: [complex]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE lists(l INTEGER[]);
statement ok
INSERT INTO lists VALUES (ARRAY[1]), (ARRAY[2]), (ARRAY[3]), (NULL), (ARRAY[NULL]::INT[]);
# aggregate with correlation in final projection
query II
SELECT l, (SELECT MIN(l[1])+i1.l[1] FROM lists) FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 2
[2] 3
[3] 4
[NULL] NULL
# aggregate with correlation inside aggregation
query II
SELECT l, (SELECT MIN(l[1]+2*i1.l[1]) FROM lists) FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 3
[2] 5
[3] 7
[NULL] NULL
query IRR
SELECT l, SUM(l[1]), (SELECT SUM(l[1])+SUM(i1.l[1]) FROM lists) FROM lists i1 GROUP BY l ORDER BY l;
----
NULL NULL NULL
[1] 1.000000 7.000000
[2] 2.000000 8.000000
[3] 3.000000 9.000000
[NULL] NULL NULL
query IRR
SELECT l, SUM(l[1]), (SELECT SUM(l[1])+COUNT(i1.l[1]) FROM lists) FROM lists i1 GROUP BY l ORDER BY l;
----
NULL NULL 6.000000
[1] 1.000000 7.000000
[2] 2.000000 7.000000
[3] 3.000000 7.000000
[NULL] NULL 6.000000
# correlated COUNT(*)
query II
SELECT l, (SELECT COUNT(*) FROM lists i2 WHERE i2.l[1]>i1.l[1]) FROM lists i1 ORDER BY l;
----
NULL 0
[1] 2
[2] 1
[3] 0
[NULL] 0
# aggregate with correlation inside aggregation
query II
SELECT l, (SELECT MIN(l[1]+2*i1.l[1]) FROM lists) FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 3
[2] 5
[3] 7
[NULL] NULL
# aggregate ONLY inside subquery
query R
SELECT (SELECT SUM(i1.l[1])) FROM lists i1;
----
6.000000
# aggregate ONLY inside subquery, with column reference outside of subquery
query IR
SELECT MIN(l[1]), (SELECT SUM(i1.l[1])) FROM lists i1;
----
1 6.000000
# this will fail, because "l[1]" is not an aggregate but the SUM(i1.l[1]) turns this query into an aggregate
statement error
SELECT l, (SELECT SUM(i1.l[1])) FROM lists i1;
----
statement error
SELECT l[1]+1, (SELECT SUM(i1.l[1])) FROM lists i1;
----
query IR
SELECT MIN(l[1]), (SELECT SUM(i1.l[1])) FROM lists i1;
----
1 6.000000
query RR
SELECT (SELECT SUM(i1.l[1])), (SELECT SUM(i1.l[1])) FROM lists i1;
----
6.000000 6.000000
# subquery inside aggregation
query RR
SELECT SUM(l[1]), SUM((SELECT l[1] FROM lists WHERE l[1]=i1.l[1])) FROM lists i1;
----
6.000000 6.000000
query RR
SELECT SUM(l[1]), (SELECT SUM(l[1]) FROM lists WHERE l[1]>SUM(i1.l[1])) FROM lists i1;
----
6.000000 NULL
# subquery with aggregation inside aggregation should fail
statement error
SELECT SUM((SELECT SUM(l[1]))) FROM lists
----
# aggregate with correlation in filter
query II
SELECT l, (SELECT MIN(l[1]) FROM lists WHERE l[1]>i1.l[1]) FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 2
[2] 3
[3] NULL
[NULL] NULL
# aggregate with correlation in both filter and projection
query II
SELECT l, (SELECT MIN(l[1])+i1.l[1] FROM lists WHERE l[1]>i1.l[1]) FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 3
[2] 5
[3] NULL
[NULL] NULL
# aggregate with correlation in GROUP BY
query II
SELECT l, (SELECT MIN(l[1]) FROM lists GROUP BY i1.l[1]) AS j FROM lists i1 ORDER BY l;
----
NULL 1
[1] 1
[2] 1
[3] 1
[NULL] 1
# aggregate with correlation in HAVING clause
query II
SELECT l, (SELECT l[1] FROM lists GROUP BY l[1] HAVING l[1]=i1.l[1]) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 1
[2] 2
[3] 3
[NULL] NULL
# correlated subquery in HAVING
query IR
SELECT i1.l, SUM(l[1]) FROM lists i1 GROUP BY i1.l HAVING SUM(l[1])=(SELECT MIN(l[1]) FROM lists WHERE l[1]<>i1.l[1]+1) ORDER BY 1;
----
[1] 1.000000
query IR
SELECT l[1] % 2 AS j, SUM(l[1]) FROM lists i1 GROUP BY j HAVING SUM(l[1])=(SELECT SUM(l[1]) FROM lists WHERE l[1]<>j+1) ORDER BY 1;
----
1 4.000000
# aggregate query with non-aggregate subquery without group by
query R
SELECT (SELECT l[1]+SUM(i1.l[1]) FROM lists WHERE l[1]=1 LIMIT 1) FROM lists i1;
----
7.000000
query R
SELECT (SELECT SUM(l[1])+SUM(i1.l[1]) FROM lists) FROM lists i1 ORDER BY 1;
----
12.000000
# aggregate query with non-aggregate subquery with group by
query IR
SELECT l, (SELECT l[1]+SUM(i1.l[1]) FROM lists WHERE l[1]=1) FROM lists i1 GROUP BY l ORDER BY l;
----
NULL NULL
[1] 2.000000
[2] 3.000000
[3] 4.000000
[NULL] NULL
# subquery inside aggregate
query R
SELECT SUM((SELECT l[1]+i1.l[1] FROM lists WHERE l[1]=1)) FROM lists i1;
----
9.000000
query IRR
SELECT l, SUM(i1.l[1]), (SELECT SUM(i1.l[1])) AS k FROM lists i1 GROUP BY l ORDER BY l;
----
NULL NULL NULL
[1] 1.000000 1.000000
[2] 2.000000 2.000000
[3] 3.000000 3.000000
[NULL] NULL NULL
# aggregation of both entries inside subquery
# aggregate on group inside subquery
query IR
SELECT i1.l AS j, (SELECT SUM(j[1]+l[1]) FROM lists) AS k FROM lists i1 GROUP BY j ORDER BY j;
----
NULL NULL
[1] 9.000000
[2] 12.000000
[3] 15.000000
[NULL] NULL
query R
SELECT (SELECT SUM(i1.l[1]*l[1]) FROM lists) FROM lists i1 ORDER BY l;
----
NULL
6.000000
12.000000
18.000000
NULL
# ORDER BY correlated subquery
query IR
SELECT l, SUM(i1.l[1]) FROM lists i1 GROUP BY l ORDER BY (SELECT SUM(i1.l[1])), l;
----
NULL NULL
[NULL] NULL
[1] 1.000000
[2] 2.000000
[3] 3.000000
# LIMIT 0 on correlated subquery
query IR
SELECT l, SUM((SELECT SUM(l[1])*i1.l[1] FROM lists LIMIT 0)) AS k FROM lists i1 GROUP BY l ORDER BY l;
----
NULL NULL
[1] NULL
[2] NULL
[3] NULL
[NULL] NULL
# GROUP BY correlated subquery
query IR
SELECT (SELECT l[1]+i1.l[1] FROM lists WHERE l[1]=1) AS k, SUM(l[1]) AS j FROM lists i1 GROUP BY k ORDER BY 1;
----
NULL NULL
2 1.000000
3 2.000000
4 3.000000
# correlated subquery in WHERE
query R
SELECT SUM(l[1]) FROM lists i1 WHERE l[1]>(SELECT (l[1]+i1.l[1])/2 FROM lists WHERE l[1]=1);
----
5.000000
# correlated aggregate in WHERE
query R
SELECT SUM(l[1]) FROM lists i1 WHERE l[1]>(SELECT (SUM(l[1])+i1.l[1])/2 FROM lists WHERE l[1]=1);
----
5.000000
# use scalar subquery as argument to ALL/ANY
query IT
SELECT l, (SELECT MIN(l[1]) FROM lists WHERE l[1]=i1.l[1]) >= ALL(SELECT l[1] FROM lists WHERE l[1] IS NOT NULL) FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 0
[2] 0
[3] 1
[NULL] NULL

79
external/duckdb/test/sql/subquery/complex/correlated_list_any_join.test vendored Normal file
View File

@@ -0,0 +1,79 @@
# name: test/sql/subquery/complex/correlated_list_any_join.test
# description: Test subqueries on ANY join with correlated lists
# group: [complex]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE lists(l INTEGER[]);
statement ok
INSERT INTO lists VALUES (ARRAY[1]), (ARRAY[2]), (ARRAY[3]), (NULL);
# correlated expressions in inner/left/right joins
query II
SELECT l, l IN (SELECT i1.l FROM (SELECT * FROM lists i1 WHERE i1.l=lists.l) i1 JOIN generate_series(1, 2, 1) tbl(s) ON i1.l=ARRAY[tbl.s]) FROM lists ORDER BY l NULLS LAST;
----
[1] True
[2] True
[3] False
NULL False
query I
SELECT l IN (SELECT i1.l FROM (SELECT * FROM lists i1 WHERE i1.l=lists.l) i1 LEFT JOIN generate_series(1, 2, 1) tbl(s) ON i1.l=ARRAY[tbl.s]) FROM lists ORDER BY l NULLS LAST;
----
true
true
true
false
query I
SELECT l IN (SELECT i1.l FROM (SELECT * FROM lists i1 WHERE i1.l=lists.l) i1 RIGHT JOIN generate_series(1, 2, 1) tbl(s) ON i1.l=ARRAY[tbl.s]) FROM lists ORDER BY l NULLS LAST;
----
true
true
NULL
NULL
# other way around
query I
SELECT l IN (SELECT i1.l FROM generate_series(1, 2, 1) tbl(s) LEFT JOIN (SELECT * FROM lists i1 WHERE i1.l=lists.l) i1 ON i1.l=ARRAY[tbl.s]) FROM lists ORDER BY l NULLS LAST;
----
true
true
NULL
NULL
query I
SELECT l IN (SELECT i1.l FROM generate_series(1, 2, 1) tbl(s) RIGHT JOIN (SELECT * FROM lists i1 WHERE i1.l=lists.l) i1 ON i1.l=ARRAY[tbl.s]) FROM lists ORDER BY l NULLS LAST;
----
true
true
true
false
# complex join condition
query I
SELECT l IN (SELECT i1.l FROM (SELECT * FROM lists i1 WHERE i1.l IS NOT DISTINCT FROM lists.l) i1 JOIN generate_series(1, 2, 1) tbl(s) ON i1.l=ARRAY[tbl.s] OR (i1.l IS NULL AND tbl.s IS NULL)) FROM lists ORDER BY l NULLS LAST;
----
true
true
false
false
query I
SELECT l IN (SELECT i1.l FROM (SELECT * FROM lists i1 WHERE i1.l IS NOT DISTINCT FROM lists.l) i1 LEFT JOIN generate_series(1, 2, 1) tbl(s) ON i1.l=ARRAY[tbl.s] OR (i1.l IS NULL AND tbl.s IS NULL)) FROM lists ORDER BY l NULLS LAST;
----
true
true
true
NULL
query I
SELECT l IN (SELECT i1.l FROM (SELECT * FROM lists i1 WHERE i1.l IS NOT DISTINCT FROM lists.l) i1 RIGHT JOIN generate_series(1, 2, 1) tbl(s) ON i1.l=ARRAY[tbl.s] OR (i1.l IS NULL AND tbl.s IS NULL)) FROM lists ORDER BY l NULLS LAST;
----
true
true
NULL
NULL

75
external/duckdb/test/sql/subquery/complex/expensive_deduplication_3593.test_slow vendored Normal file
View File

@@ -0,0 +1,75 @@
# name: test/sql/subquery/complex/expensive_deduplication_3593.test_slow
# description: Issue #3593: Macros causes crash: memory consumption or recursion or something
# group: [complex]
statement ok
PRAGMA enable_verification
query I
SELECT
(
select count(*) as value
FROM (
SELECT UNNEST(array_agg(distinct id))
) a
)
as total_seats
FROM (
SELECT gen_random_uuid() id, 1 as val FROM generate_series(0, 160)
) as m;
----
161
query II
SELECT
z%2 AS k,
(
select count(*) as value
FROM (
SELECT UNNEST(array_agg(distinct id))
) a
)
as total_seats
FROM (
SELECT row_number() over () AS z, gen_random_uuid() id, 1 as val FROM generate_series(0, 160)
) as m
GROUP BY k
ORDER BY k;
----
0 80
1 81
# disable verification for these queries, they are too slow to run without the deduplication
statement ok
PRAGMA disable_verification
query I
SELECT
(
select count(*) as value
FROM (
SELECT UNNEST(array_agg(distinct id))
) a
)
as total_seats
FROM (
SELECT gen_random_uuid() id, 1 as val FROM generate_series(0, 100000)
) as m;
----
100001
query I
SELECT
(
select sum(a.val) as value
FROM (
SELECT UNNEST(list(distinct {key:m.id, val: m.val})) a
) x
)
as total_seats
FROM (
SELECT gen_random_uuid() id, 1 as val FROM range(0, 100000)
) as m
cross join (select * FROM range(0,3)) as r
----
100000

333
external/duckdb/test/sql/subquery/complex/nested_correlated_list.test_slow vendored Normal file
View File

@@ -0,0 +1,333 @@
# name: test/sql/subquery/complex/nested_correlated_list.test_slow
# description: Test nested correlated list subqueries
# group: [complex]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE lists(l INTEGER[]);
statement ok
INSERT INTO lists VALUES (ARRAY[1]), (ARRAY[2]), (ARRAY[3]), (NULL);
# nested correlated queries
query II
SELECT l, (SELECT (SELECT 42+i1.l[1])+42+i1.l[1]) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 86
[2] 88
[3] 90
query II
SELECT l, (SELECT (SELECT (SELECT (SELECT 42+i1.l[1])++i1.l[1])+42+i1.l[1])+42+i1.l[1]) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 130
[2] 134
[3] 138
query IR
SELECT l, (SELECT (SELECT i1.l[1]+SUM(i2.l[1])) FROM lists i2) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 7.000000
[2] 8.000000
[3] 9.000000
# correlated query inside uncorrelated query
query II
SELECT l, (SELECT (SELECT (SELECT (SELECT i1.l[1]+i1.l[1]+i1.l[1]+i1.l[1]+i1.l[1])))) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 5
[2] 10
[3] 15
query IR
SELECT l, (SELECT SUM(l[1])+(SELECT 42+i1.l[1]) FROM lists) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 49.000000
[2] 50.000000
[3] 51.000000
query IR
SELECT l, (SELECT ((SELECT ((SELECT ((SELECT SUM(l[1])+SUM(i4.l[1])+SUM(i3.l[1])+SUM(i2.l[1])+SUM(i1.l[1]) FROM lists i5)) FROM lists i4)) FROM lists i3)) FROM lists i2) AS j FROM lists i1 GROUP BY l ORDER BY l;
----
NULL NULL
[1] 25.000000
[2] 26.000000
[3] 27.000000
query II
SELECT l, (SELECT (SELECT (SELECT (SELECT i1.l[1]+i1.l[1]+i1.l[1]+i1.l[1]+i1.l[1]+i2.l[1]) FROM lists i2 WHERE i2.l=i1.l))) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 6
[2] 12
[3] 18
query R
SELECT (SELECT (SELECT SUM(i1.l[1])+SUM(i2.l[1])+SUM(i3.l[1]) FROM lists i3) FROM lists i2) FROM lists i1 ORDER BY 1
----
18.000000
# explicit join on subquery
query IR
SELECT l, (SELECT SUM(s1.l[1]) FROM lists s1 INNER JOIN lists s2 ON (SELECT i1.l[1]+s1.l[1])=(SELECT i1.l[1]+s2.l[1])) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 6.000000
[2] 6.000000
[3] 6.000000
# nested aggregate queries
query IRR
SELECT l, SUM(l[1]), (SELECT (SELECT SUM(l[1])+SUM(i1.l[1])+SUM(i2.l[1]) FROM lists) FROM lists i2) FROM lists i1 GROUP BY l ORDER BY l;
----
NULL NULL NULL
[1] 1.000000 13.000000
[2] 2.000000 14.000000
[3] 3.000000 15.000000
# correlated ANY inside subquery
query IR
SELECT l, (SELECT SUM(ss1.l[1]) FROM (SELECT l FROM lists s1 WHERE l[1]>ANY(SELECT l[1] FROM lists WHERE l<>s1.l)) ss1) AS j FROM lists i1 ORDER BY l;
----
NULL 5.000000
[1] 5.000000
[2] 5.000000
[3] 5.000000
query IR
SELECT l, (SELECT SUM(ss2.l[1]) FROM (SELECT l FROM lists s1 WHERE l=i1.l AND l=ANY(SELECT l FROM lists WHERE l=s1.l)) ss2) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 1.000000
[2] 2.000000
[3] 3.000000
# left outer join on correlated subquery within subquery
# not supported yet: left outer join on JoinSide::BOTH
statement error
SELECT l, (SELECT SUM(s1.l[1]) FROM lists s1 LEFT OUTER JOIN lists s2 ON (SELECT i1.l[1]+s1.l[1])=(SELECT i1.l[1]+s2.l[1])) AS j FROM lists i1 ORDER BY l;
----
# REQUIRE(CHECK_COLUMN(result, 0, {Value(), 1, 2, 3}));
# REQUIRE(CHECK_COLUMN(result, 1, {6, 6, 6, 6}));
query IR
SELECT l, (SELECT SUM(ss1.l[1])+SUM(ss2.l[1]) FROM (SELECT l FROM lists s1 WHERE l>ANY(SELECT l FROM lists WHERE l<>s1.l)) ss1 LEFT OUTER JOIN (SELECT l FROM lists s1 WHERE l=ANY(SELECT l FROM lists WHERE l=s1.l)) ss2 ON ss1.l=ss2.l) AS j FROM lists i1 ORDER BY l;
----
NULL 10.000000
[1] 10.000000
[2] 10.000000
[3] 10.000000
# left outer join with correlation on LHS
query IR
SELECT l, (SELECT SUM(s1.l[1]) FROM (SELECT l FROM lists WHERE l=i1.l) s1 LEFT OUTER JOIN lists s2 ON s1.l=s2.l) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 1.000000
[2] 2.000000
[3] 3.000000
query IR
SELECT l, (SELECT SUM(s1.l[1]) FROM (SELECT l FROM lists WHERE l<>i1.l) s1 LEFT OUTER JOIN lists s2 ON s1.l=s2.l) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 5.000000
[2] 4.000000
[3] 3.000000
# left outer join with correlation on RHS
query IR
SELECT l, (SELECT SUM(s2.l[1]) FROM lists s1 LEFT OUTER JOIN (SELECT l FROM lists WHERE l=i1.l) s2 ON s1.l=s2.l) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 1.000000
[2] 2.000000
[3] 3.000000
query IR
SELECT l, (SELECT SUM(s2.l[1]) FROM lists s1 LEFT OUTER JOIN (SELECT l FROM lists WHERE l<>i1.l) s2 ON s1.l=s2.l) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 5.000000
[2] 4.000000
[3] 3.000000
query IR
SELECT l, (SELECT SUM(ss2.l[1]) FROM (SELECT l FROM lists s1 WHERE CASE WHEN (l=i1.l AND l=ANY(SELECT l FROM lists WHERE l=s1.l)) THEN true ELSE false END) ss2) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 1.000000
[2] 2.000000
[3] 3.000000
query IR
SELECT l, (SELECT SUM(ss2.l[1]) FROM (SELECT l FROM lists s1 WHERE l=i1.l AND l=ANY(SELECT l FROM lists WHERE l=s1.l)) ss2) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 1.000000
[2] 2.000000
[3] 3.000000
query IR
SELECT l, (SELECT SUM(ss2.l[1]) FROM (SELECT l FROM lists s1 WHERE l=i1.l) ss2) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 1.000000
[2] 2.000000
[3] 3.000000
query IR
SELECT l, (SELECT SUM(ss2.l[1]) FROM (SELECT l FROM lists s1 WHERE l=ANY(SELECT l FROM lists WHERE l=s1.l)) ss2) AS j FROM lists i1 ORDER BY l;
----
NULL 6.000000
[1] 6.000000
[2] 6.000000
[3] 6.000000
query IT
SELECT l, (SELECT l=ANY(SELECT l FROM lists WHERE l=s1.l) FROM lists s1 WHERE l=i1.l) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 1
[2] 1
[3] 1
query IR
SELECT l, (SELECT SUM(ss2.l[1]) FROM (SELECT l FROM lists s1 WHERE l=i1.l OR l=ANY(SELECT l FROM lists WHERE l=s1.l)) ss2) AS j FROM lists i1 ORDER BY l;
----
NULL 6.000000
[1] 6.000000
[2] 6.000000
[3] 6.000000
query IR
SELECT l, (SELECT SUM(ss2.l[1]) FROM (SELECT l FROM lists s1 WHERE CASE WHEN (l=i1.l AND l=ANY(SELECT l FROM lists WHERE l=s1.l)) THEN true ELSE false END) ss2) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 1.000000
[2] 2.000000
[3] 3.000000
query IR
SELECT l, (SELECT SUM(ss2.l[1]) FROM (SELECT l FROM lists s1 WHERE l=i1.l AND EXISTS(SELECT l FROM lists WHERE l=s1.l)) ss2) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 1.000000
[2] 2.000000
[3] 3.000000
# complex left outer join with correlation on RHS
query IR
SELECT l, (SELECT SUM(ss1.l[1]) FROM (SELECT l FROM lists s1 WHERE l>ANY(SELECT l FROM lists WHERE l<>s1.l)) ss1) AS j FROM lists i1 ORDER BY l;
----
NULL 5.000000
[1] 5.000000
[2] 5.000000
[3] 5.000000
query IR
SELECT l, (SELECT SUM(ss1.l[1]) FROM (SELECT l FROM lists s1 WHERE l>ANY(SELECT l FROM lists WHERE l<>s1.l)) ss1 LEFT OUTER JOIN (SELECT l FROM lists s1 WHERE l=i1.l AND l=ANY(SELECT l FROM lists WHERE l=s1.l)) ss2 ON ss1.l=ss2.l) AS j FROM lists i1 ORDER BY l;
----
NULL 5.000000
[1] 5.000000
[2] 5.000000
[3] 5.000000
query IR
SELECT l, (SELECT SUM(ss2.l[1]) FROM (SELECT l FROM lists s1 WHERE l>ANY(SELECT l FROM lists WHERE l<>s1.l)) ss1 LEFT OUTER JOIN (SELECT l FROM lists s1 WHERE l=i1.l AND l=ANY(SELECT l FROM lists WHERE l=s1.l)) ss2 ON ss1.l=ss2.l) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] NULL
[2] 2.000000
[3] 3.000000
query IR
SELECT l, (SELECT SUM(ss1.l[1])+SUM(ss2.l[1]) FROM (SELECT l FROM lists s1 WHERE l>ANY(SELECT l FROM lists WHERE l<>s1.l)) ss1 LEFT OUTER JOIN (SELECT l FROM lists s1 WHERE l=i1.l AND l=ANY(SELECT l FROM lists WHERE l=s1.l)) ss2 ON ss1.l=ss2.l) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] NULL
[2] 7.000000
[3] 8.000000
# complex left outer join with correlation on LHS
query IR
SELECT l, (SELECT SUM(ss1.l[1])+SUM(ss2.l[1]) FROM (SELECT l FROM lists s1 WHERE l=i1.l AND l>ANY(SELECT l FROM lists WHERE l<>s1.l)) ss1 LEFT OUTER JOIN (SELECT l FROM lists s1 WHERE l=ANY(SELECT l FROM lists WHERE l=s1.l)) ss2 ON ss1.l=ss2.l) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] NULL
[2] 4.000000
[3] 6.000000
# complex left outer join with correlation on both sides
query IR
SELECT l, (SELECT SUM(ss1.l[1])+SUM(ss2.l[1]) FROM (SELECT l FROM lists s1 WHERE l=i1.l AND l>ANY(SELECT l FROM lists WHERE l<>s1.l)) ss1 LEFT OUTER JOIN (SELECT l FROM lists s1 WHERE l<>i1.l OR l=ANY(SELECT l FROM lists WHERE l=s1.l)) ss2 ON ss1.l=ss2.l) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] NULL
[2] 4.000000
[3] 6.000000
# test correlated queries with correlated expressions inside FROM clause
# subquery
query II
SELECT l, (SELECT * FROM (SELECT (SELECT 42+i1.l[1])) s1) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 43
[2] 44
[3] 45
# cross product
query II
SELECT l, (SELECT s1.k+s2.k FROM (SELECT (SELECT 42+i1.l[1]) AS k) s1, (SELECT (SELECT 42+i1.l[1]) AS k) s2) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 86
[2] 88
[3] 90
# join
query II
SELECT l, (SELECT s1.k+s2.k FROM (SELECT (SELECT 42+i1.l[1]) AS k) s1 LEFT OUTER JOIN (SELECT (SELECT 42+i1.l[1]) AS k) s2 ON s1.k=s2.k) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 86
[2] 88
[3] 90
# IN list inside correlated subquery
query IT
SELECT l, (SELECT i1.l[1] IN (1, 2, 3, 4, 5, 6, 7, 8)) AS j FROM lists i1 ORDER BY l;
----
NULL NULL
[1] 1
[2] 1
[3] 1
# nested correlated subqueries with multiple aggregate parameters
query R
SELECT (SELECT (SELECT COVAR_POP(i1.l[1], i3.l[1]) FROM lists i3) FROM lists i2 LIMIT 1) FROM lists i1 ORDER BY 1
----
NULL
0.000000
0.000000
0.000000
query R
SELECT (SELECT (SELECT COVAR_POP(i2.l[1], i3.l[1]) FROM lists i3) FROM lists i2 LIMIT 1) FROM lists i1 ORDER BY 1
----
0.000000
0.000000
0.000000
0.000000

37
external/duckdb/test/sql/subquery/complex/nested_unnest_subquery.test vendored Normal file
View File

@@ -0,0 +1,37 @@
# name: test/sql/subquery/complex/nested_unnest_subquery.test
# description: Test nested correlated unnest subqueries
# group: [complex]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE nested_lists(l INTEGER[][]);
statement ok
INSERT INTO nested_lists VALUES (ARRAY[ARRAY[0], ARRAY[1]]), (ARRAY[ARRAY[2], ARRAY[NULL, 3]]), (ARRAY[ARRAY[4, 5], ARRAY[6, 7], ARRAY[], ARRAY[8]]), (NULL), (ARRAY[NULL]::INT[][]);
query I
SELECT UNNEST(l) FROM nested_lists
----
[0]
[1]
[2]
[NULL, 3]
[4, 5]
[6, 7]
[]
[8]
NULL
query II
SELECT l, (SELECT SUM(a) FROM (SELECT UNNEST(b) AS a FROM (SELECT UNNEST(l) AS b))) FROM nested_lists ORDER BY l
----
NULL NULL
[[0], [1]] 1
[[2], [NULL, 3]] 5
[[4, 5], [6, 7], [], [8]] 30
[NULL] NULL

129
external/duckdb/test/sql/subquery/exists/test_correlated_exists.test vendored Normal file
View File

@@ -0,0 +1,129 @@
# name: test/sql/subquery/exists/test_correlated_exists.test
# description: Test correlated exists
# group: [exists]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL)
# correlated EXISTS
query IT
SELECT i, EXISTS(SELECT i FROM integers WHERE i1.i>2) FROM integers i1 ORDER BY i;
----
NULL 0
1 0
2 0
3 1
query IT
SELECT i, EXISTS(SELECT i FROM integers WHERE i=i1.i) FROM integers i1 ORDER BY i;
----
NULL 0
1 1
2 1
3 1
query IT
SELECT i, EXISTS(SELECT i FROM integers WHERE i IS NULL OR i>i1.i*10) FROM integers i1 ORDER BY i;
----
NULL 1
1 1
2 1
3 1
query IT
SELECT i, EXISTS(SELECT i FROM integers WHERE i1.i>i OR i1.i IS NULL) FROM integers i1 ORDER BY i;
----
NULL 1
1 0
2 1
3 1
query I
SELECT i FROM integers i1 WHERE EXISTS(SELECT i FROM integers WHERE i=i1.i) ORDER BY i;
----
1
2
3
# correlated EXISTS with aggregations
query T
SELECT EXISTS(SELECT i FROM integers WHERE i>MIN(i1.i)) FROM integers i1;
----
1
query IR
SELECT i, SUM(i) FROM integers i1 GROUP BY i HAVING EXISTS(SELECT i FROM integers WHERE i>MIN(i1.i)) ORDER BY i;
----
1 1.000000
2 2.000000
query T
SELECT EXISTS(SELECT i+MIN(i1.i) FROM integers WHERE i=3) FROM integers i1;
----
1
query T
SELECT EXISTS(SELECT i+MIN(i1.i) FROM integers WHERE i=5) FROM integers i1;
----
0
# GROUP BY correlated exists
query TI
SELECT EXISTS(SELECT i FROM integers WHERE i=i1.i) AS g, COUNT(*) FROM integers i1 GROUP BY g ORDER BY g;
----
0 1
1 3
# SUM on exists
query R
SELECT SUM(CASE WHEN EXISTS(SELECT i FROM integers WHERE i=i1.i) THEN 1 ELSE 0 END) FROM integers i1;
----
3.000000
# aggregates with multiple parameters
query R
SELECT (SELECT COVAR_POP(i1.i, i2.i) FROM integers i2) FROM integers i1 ORDER BY 1
----
NULL
0.000000
0.000000
0.000000
query R
SELECT (SELECT COVAR_POP(i2.i, i1.i) FROM integers i2) FROM integers i1 ORDER BY 1
----
NULL
0.000000
0.000000
0.000000
query R
SELECT (SELECT COVAR_POP(i1.i+i2.i, i1.i+i2.i) FROM integers i2) FROM integers i1 ORDER BY 1
----
NULL
0.666667
0.666667
0.666667
query R
SELECT (SELECT COVAR_POP(i2.i, i2.i) FROM integers i2) FROM integers i1 ORDER BY 1;
----
0.666667
0.666667
0.666667
0.666667
query R
SELECT (SELECT COVAR_POP(i1.i, i1.i) FROM integers i2 LIMIT 1) FROM integers i1 ORDER BY 1;
----
0.666667

24
external/duckdb/test/sql/subquery/exists/test_exists_union_by_name.test vendored Normal file
View File

@@ -0,0 +1,24 @@
# name: test/sql/subquery/exists/test_exists_union_by_name.test
# description: Test exists subquery with union by name
# group: [exists]
statement ok
create table all_types as select * exclude(small_enum, medium_enum, large_enum) from test_all_types() limit 0;
statement ok
SELECT (
EXISTS(
(
SELECT
DISTINCT outer_alltypes."BIGINT", outer_alltypes."INT"
FROM all_types inner_alltypes_1
WHERE inner_alltypes_1."BIGINT" GROUP BY NULL
)
UNION BY NAME
(
SELECT inner2."FLOAT" from all_types inner2
)
) IS DISTINCT FROM outer_alltypes."struct"
)
FROM all_types outer_alltypes GROUP BY ALL;

30
external/duckdb/test/sql/subquery/exists/test_issue_9308.test vendored Normal file
View File

@@ -0,0 +1,30 @@
# name: test/sql/subquery/exists/test_issue_9308.test
# description: Issue #9308: wrong result: NOT EXISTS predicate with correlated non-equality comparison
# group: [exists]
statement ok
PRAGMA enable_verification
statement ok
create or replace table t1(c1 int64);
statement ok
insert into t1 values (1);
statement ok
create or replace table t2(c1 int64);
query II
select c1, not exists (select 1 from t2 where t1.c1 <= t2.c1) from t1;
----
1 true
query I
select c1 from t1 where not exists (select 1 from t2 where t1.c1 <= t2.c1);
----
1
query I
select c1 from t1 anti join t2 on (t1.c1 <= t2.c1)
----
1

36
external/duckdb/test/sql/subquery/exists/test_scalar_exists.test vendored Normal file
View File

@@ -0,0 +1,36 @@
# name: test/sql/subquery/exists/test_scalar_exists.test
# description: Test scalar EXISTS query
# group: [exists]
statement ok
PRAGMA enable_verification
query T
SELECT EXISTS(SELECT 1)
----
1
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL)
query T
SELECT EXISTS(SELECT 1) FROM integers
----
1
1
1
1
query T
SELECT EXISTS(SELECT * FROM integers)
----
1
query T
SELECT EXISTS(SELECT * FROM integers WHERE i IS NULL)
----
1

118
external/duckdb/test/sql/subquery/exists/test_uncorrelated_exists_subquery.test vendored Normal file
View File

@@ -0,0 +1,118 @@
# name: test/sql/subquery/exists/test_uncorrelated_exists_subquery.test
# description: Test uncorrelated exists subqueries
# group: [exists]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL)
# uncorrelated EXISTS
query I
SELECT * FROM integers WHERE EXISTS(SELECT 1) ORDER BY i
----
NULL
1
2
3
query I
SELECT * FROM integers WHERE EXISTS(SELECT * FROM integers) ORDER BY i
----
NULL
1
2
3
query I
SELECT * FROM integers WHERE NOT EXISTS(SELECT * FROM integers) ORDER BY i
----
query I
SELECT * FROM integers WHERE EXISTS(SELECT NULL) ORDER BY i
----
NULL
1
2
3
# exists in SELECT clause
query T
SELECT EXISTS(SELECT * FROM integers)
----
1
query T
SELECT EXISTS(SELECT * FROM integers WHERE i>10)
----
0
# multiple exists
query TT
SELECT EXISTS(SELECT * FROM integers), EXISTS(SELECT * FROM integers)
----
1 1
# exists used in operations
query T
SELECT EXISTS(SELECT * FROM integers) AND EXISTS(SELECT * FROM integers)
----
1
# nested EXISTS
query T
SELECT EXISTS(SELECT EXISTS(SELECT * FROM integers))
----
1
# uncorrelated IN
query I
SELECT * FROM integers WHERE 1 IN (SELECT 1) ORDER BY i
----
NULL
1
2
3
query I
SELECT * FROM integers WHERE 1 IN (SELECT * FROM integers) ORDER BY i
----
NULL
1
2
3
query I
SELECT * FROM integers WHERE 1 IN (SELECT NULL::INTEGER) ORDER BY i
----
# scalar NULL results
query T
SELECT 1 IN (SELECT NULL::INTEGER) FROM integers
----
NULL
NULL
NULL
NULL
query T
SELECT NULL IN (SELECT * FROM integers) FROM integers
----
NULL
NULL
NULL
NULL
# add aggregations after the subquery
query R
SELECT SUM(i) FROM integers WHERE 1 IN (SELECT * FROM integers)
----
6.000000

59
external/duckdb/test/sql/subquery/lateral/lateral_arrays.test vendored Normal file
View File

@@ -0,0 +1,59 @@
# name: test/sql/subquery/lateral/lateral_arrays.test
# description: Test LATERAL joins with arrays
# group: [lateral]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE tbl(i INTEGER, arr INT[]);
statement ok
INSERT INTO tbl VALUES (1, ARRAY[1, 3, 7]), (2, ARRAY[8, NULL]), (3, ARRAY[3, NULL, 4]), (NULL, ARRAY[]::INT[]);
query III
SELECT * FROM tbl JOIN LATERAL (SELECT UNNEST(tbl.arr)) t(b) ON (i=b) ORDER BY i;
----
1 [1, 3, 7] 1
3 [3, NULL, 4] 3
query III
SELECT * FROM tbl JOIN LATERAL (SELECT UNNEST(tbl.arr)) t(b) ON (i<>b) ORDER BY i, b;
----
1 [1, 3, 7] 3
1 [1, 3, 7] 7
2 [8, NULL] 8
3 [3, NULL, 4] 4
query III
SELECT * FROM tbl JOIN LATERAL (SELECT UNNEST(tbl.arr)) t(b) ON (i<b) ORDER BY i, b;
----
1 [1, 3, 7] 3
1 [1, 3, 7] 7
2 [8, NULL] 8
3 [3, NULL, 4] 4
query III
SELECT * FROM tbl JOIN LATERAL (SELECT UNNEST(tbl.arr)) t(b) ON (i>=b) ORDER BY i, b;
----
1 [1, 3, 7] 1
3 [3, NULL, 4] 3
query III
SELECT * FROM tbl JOIN LATERAL (SELECT UNNEST(ARRAY[tbl.i * tbl.i])) t(b) ON (i>=b) ORDER BY i, b;
----
1 [1, 3, 7] 1
query III
SELECT * FROM tbl JOIN LATERAL (SELECT x FROM generate_series(0,5,1) t(x) WHERE x>i) t(b) ON (i>=b) ORDER BY i, b;
----
query III
SELECT * FROM tbl JOIN LATERAL (SELECT x FROM generate_series(0,5,1) t(x) WHERE x<i) t(b) ON (i>=b) ORDER BY i, b;
----
1 [1, 3, 7] 0
2 [8, NULL] 0
2 [8, NULL] 1
3 [3, NULL, 4] 0
3 [3, NULL, 4] 1
3 [3, NULL, 4] 2

19
external/duckdb/test/sql/subquery/lateral/lateral_binding_views.test vendored Normal file
View File

@@ -0,0 +1,19 @@
# name: test/sql/subquery/lateral/lateral_binding_views.test
# description: Verify that views cannot reference lateral join columns
# group: [lateral]
statement ok
copy (select date '2000-01-01' as dt) to '__TEST_DIR__/datetest.csv';
statement ok
create view v1 as select * from read_csv('__TEST_DIR__/datetest.csv', columns={'dt': date});
query I
from v1
----
2000-01-01
query II
select * from (select date '1992-01-01' as date), v1;
----
1992-01-01 2000-01-01

28
external/duckdb/test/sql/subquery/lateral/lateral_fuzzer_1463.test vendored Normal file
View File

@@ -0,0 +1,28 @@
# name: test/sql/subquery/lateral/lateral_fuzzer_1463.test
# description: Test case for fuzzer issue 1463: Expression with depth > 1 detected in non-lateral join
# group: [lateral]
query II
SELECT *
FROM
(SELECT 42 AS c1) AS ref,
(SELECT a + b + 1
FROM
(SELECT 1) t1(a),
(SELECT (SELECT (SELECT ref.c1 + 1)) + 1) t2(b)
)
;
----
42 46
# postgres compatible variant
query I
SELECT NULL
FROM
(SELECT 42 AS c1) AS ref,
LATERAL (SELECT NULL
FROM
(SELECT NULL) AS r2,
(SELECT (SELECT (SELECT ref.c1))) AS r3) AS r4;
----
NULL

13
external/duckdb/test/sql/subquery/lateral/lateral_fuzzer_5984_23.test vendored Normal file
View File

@@ -0,0 +1,13 @@
# name: test/sql/subquery/lateral/lateral_fuzzer_5984_23.test
# description: Test case for fuzzer issue 5984, number 23
# group: [lateral]
query I
SELECT 1 FROM (SELECT 1) t1(c1), (SELECT TRUE IN (TRUE, t1.c1::VARCHAR LIKE 'a' ESCAPE NULL));
----
1
query I
SELECT (SELECT t1.c1::VARCHAR LIKE 'a' ESCAPE NULL) FROM (SELECT 1) t1(c1)
----
NULL

48
external/duckdb/test/sql/subquery/lateral/lateral_grouping_sets.test vendored Normal file
View File

@@ -0,0 +1,48 @@
# name: test/sql/subquery/lateral/lateral_grouping_sets.test
# description: Test LATERAL join with empty grouping sets
# group: [lateral]
statement ok
PRAGMA enable_verification
query III
select x, a, b
from
(values (1), (2)) t2(x),
lateral (select count(*), count(a) from (select 1, 2 where 1 = x) t(a, b) group by grouping sets ((), (b), (a, b))) t3(a, b)
order by all;
----
1 1 1
1 1 1
1 1 1
2 0 0
query II
select x, a
from
(values (1), (2)) t2(x),
lateral (select sum(a) from (select 1, 2 where 1 = x) t(a, b) group by grouping sets ((), (b), (a, b))) t3(a)
order by all;
----
1 1
1 1
1 1
2 NULL
query II
select *
from
(values (1), (2)) t2(x), lateral (select sum(a) from (select 42 a) where x=1)
order by all
----
1 42
2 NULL
query II
select *
from
(values (1), (2)) t2(x) left join (select sum(a) from (select 42 a) where x=1) on (1=1)
order by all
----
1 42
2 NULL

36
external/duckdb/test/sql/subquery/lateral/lateral_join_aggregate.test vendored Normal file
View File

@@ -0,0 +1,36 @@
# name: test/sql/subquery/lateral/lateral_join_aggregate.test
# description: Lateral join with aggregates
# group: [lateral]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
# we cannot bind aggregates over lateral joins
# Postgres error message is "aggregate functions are not allowed in FROM clause of their own query level"
statement error
SELECT * FROM integers, (SELECT SUM(i)) t(sum);
----
Binder Error: LATERAL join cannot contain aggregates
statement error
SELECT * FROM integers, LATERAL (SELECT SUM(i)) t(sum);
----
Binder Error: LATERAL join cannot contain aggregates
# we can use lateral columns inside aggregate expressions, however
query II
SELECT * FROM integers i1, LATERAL (SELECT SUM(i + i1.i) FROM integers) t(sum) ORDER BY i;
----
NULL NULL
1 9
2 12
3 15

62
external/duckdb/test/sql/subquery/lateral/lateral_join_chain.test vendored Normal file
View File

@@ -0,0 +1,62 @@
# name: test/sql/subquery/lateral/lateral_join_chain.test
# description: Test lateral join
# group: [lateral]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
# Multiple LATERAL joins in a row
query III
SELECT * FROM integers, (SELECT [i + 1]) t(k), (SELECT UNNEST(k)) t2(l) ORDER BY i;
----
NULL [NULL] NULL
1 [2] 2
2 [3] 3
3 [4] 4
# explicit LATERAL
query III
SELECT * FROM integers, LATERAL (SELECT [i + 1]) t(k), LATERAL (SELECT UNNEST(k)) t2(l) ORDER BY i;
----
NULL [NULL] NULL
1 [2] 2
2 [3] 3
3 [4] 4
# lateral cross join
query III
SELECT * FROM integers CROSS JOIN LATERAL (SELECT [i + 1]) t(k) CROSS JOIN LATERAL (SELECT UNNEST(k)) t2(l) ORDER BY i;
----
NULL [NULL] NULL
1 [2] 2
2 [3] 3
3 [4] 4
# refer to other table in lateral join
query II
SELECT * FROM integers, (SELECT integers) ORDER BY i
----
NULL {'i': NULL}
1 {'i': 1}
2 {'i': 2}
3 {'i': 3}
# FIXME: this works as expected in Postgres
statement error
SELECT * FROM integers, LATERAL (SELECT integers.*) t2(k) ORDER BY i;
----
* expression
statement error
SELECT * FROM integers, LATERAL (SELECT *) t2(k) ORDER BY i;
----
* expression

23
external/duckdb/test/sql/subquery/lateral/lateral_join_generated_columns.test vendored Normal file
View File

@@ -0,0 +1,23 @@
# name: test/sql/subquery/lateral/lateral_join_generated_columns.test
# description: Test lateral joins with generated columns
# group: [lateral]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE tbl (
x INTEGER,
gen_x AS (x + 5)
);
statement ok
INSERT INTO tbl VALUES (1), (2), (3), (NULL);
query III
SELECT * FROM tbl, (SELECT gen_x + 10) ORDER BY x NULLS LAST
----
1 6 16
2 7 17
3 8 18
NULL NULL NULL

25
external/duckdb/test/sql/subquery/lateral/lateral_join_macro.test vendored Normal file
View File

@@ -0,0 +1,25 @@
# name: test/sql/subquery/lateral/lateral_join_macro.test
# description: Test lateral joins with macros
# group: [lateral]
statement ok
PRAGMA enable_verification
statement ok
CREATE FUNCTION my_func(x) AS (x + x)
statement ok
CREATE TABLE tbl (
x INTEGER
);
statement ok
INSERT INTO tbl VALUES (1), (2), (3), (NULL);
query II
SELECT * FROM tbl, (SELECT my_func(x)) ORDER BY x NULLS LAST
----
1 2
2 4
3 6
NULL NULL

260
external/duckdb/test/sql/subquery/lateral/lateral_join_nested.test_slow vendored Normal file
View File

@@ -0,0 +1,260 @@
# name: test/sql/subquery/lateral/lateral_join_nested.test_slow
# description: Lateral join inside a lateral join
# group: [lateral]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
# nested correlated lateral joins
query III
SELECT i1.i, SUM(r2.k), COUNT(*) FROM integers i1, LATERAL (SELECT i1.i+i2.i FROM integers i2, LATERAL (SELECT i2.i+i3.i FROM integers i3) r3) r2(k) GROUP BY i1.i ORDER BY i1.i;
----
NULL NULL 16
1 36 16
2 48 16
3 60 16
query III
SELECT i1.i, SUM(r2.k), COUNT(*) FROM integers i1, LATERAL (SELECT i1.i+i2.i FROM integers i2, LATERAL (SELECT i1.i+i2.i+i3.i FROM integers i3) r3) r2(k) GROUP BY i1.i ORDER BY i1.i;
----
NULL NULL 16
1 36 16
2 48 16
3 60 16
# lateral join inside correlated subquery
query I
SELECT (SELECT k+l FROM (SELECT i1.i + 1) t1(k), LATERAL (SELECT k + 1) t2(l)) FROM integers i1 ORDER BY i;
----
NULL
5
7
9
# random stress tests for laterals and subqueries
query I
SELECT * FROM (SELECT 42) t(i) WHERE i IN (SELECT l FROM (SELECT 42) t(l) , (SELECT i * 2) t2(j), (SELECT i + j) t3(k) WHERE k IN (SELECT l*3 FROM (SELECT 42 l) t4(l) WHERE k-i = j));
----
42
query III
SELECT * FROM (SELECT 42) t(i), (SELECT * FROM (SELECT 142 k) t3(k), (SELECT 1 WHERE k-i=100) t4(l));
----
42 142 1
query III
SELECT * FROM (SELECT 42) t1(i), (SELECT 22) t2(j), (SELECT 1 WHERE i+j=64) t3(l);
----
42 22 1
query III
SELECT * FROM (SELECT 64) t1(i), (SELECT 22) t2(j), (SELECT 1 WHERE i+j=64) t3(l);
----
query III
SELECT * FROM (SELECT 42) t1(i), (SELECT 22) t2(j), (SELECT i+j WHERE i+j=64) t3(l);
----
42 22 64
query III
SELECT * FROM (SELECT i,j,k FROM (SELECT 42) t(i), (SELECT i * 2) t2(j), (SELECT i + j) t3(k));
----
42 84 126
query III
SELECT * FROM (SELECT i,j,k FROM (SELECT 42) t(i), (SELECT i * 2) t2(j), (SELECT i + j) t3(k));
----
42 84 126
query III
SELECT * FROM (SELECT 42) t(i), (SELECT * FROM (SELECT 142 k) t3(k), (SELECT 1 WHERE i+k=0) t4(l));
----
query III
SELECT * FROM (SELECT * FROM (SELECT 42) t1(i), (SELECT 22) t2(j), (SELECT 1 WHERE i+j=64) t3(l));
----
42 22 1
query III
SELECT * FROM (SELECT * FROM (SELECT 42) t(i), (SELECT * FROM (SELECT 142 k) t3(k), (SELECT 1 WHERE k-i=100) t4(l)));
----
42 142 1
query III
SELECT * FROM (SELECT * FROM (SELECT 42) t(i), (SELECT * FROM (SELECT 142 k) t3(k), (SELECT 1 WHERE i-k=-100) t4(l)));
----
42 142 1
query IIII
SELECT * FROM (SELECT 42) t(i), (SELECT * FROM (SELECT 142 k) t3(k), (SELECT * FROM (SELECT 242 l) t4(l), (SELECT 1 WHERE i+l+k=426) t5(m)));
----
42 142 242 1
query I
SELECT i FROM (SELECT 42) t(i) WHERE i*2 IN (SELECT j FROM (SELECT i) t(l) , (SELECT l+i) t2(j), (SELECT i+j) t3(k));
----
42
query I
SELECT * FROM (SELECT 42) t(i) WHERE i IN (SELECT k FROM (SELECT 42) t(k) WHERE k IN (SELECT l FROM (SELECT 42 l) t4(l) WHERE i-k IN (SELECT * FROM (SELECT i+5))));
----
query III
SELECT * FROM (SELECT 42) t(i), (SELECT * FROM (SELECT 142 k) t3(k), (SELECT 1 WHERE i+k=0) t4(l));
----
query II
SELECT * FROM (SELECT 42) t4(m), (SELECT 64) t5(n) WHERE m IN ( SELECT j FROM (SELECT 21*m*n) t(i), (SELECT m) t2(j));
----
42 64
query I
SELECT * FROM (SELECT 42) t4(m) WHERE m IN ( SELECT i FROM (SELECT m) t(i), (SELECT i*m/2 * 2/m) t2(j));
----
42
query I
SELECT * FROM (SELECT 10) t(i) WHERE i IN (SELECT k FROM (SELECT 20) t(k) WHERE k IN (SELECT l FROM (SELECT 30) t4(l) WHERE i-k IN (SELECT * FROM (SELECT i+100))));
----
query I
SELECT * FROM (SELECT 42) t(i) WHERE i IN (SELECT k FROM (SELECT 42) t(k) WHERE k IN (SELECT l FROM (SELECT 42 l) t4(l) WHERE i-k IN (SELECT * FROM (SELECT 0))));
----
42
query I
SELECT * FROM (SELECT 42) t(i) WHERE i IN (SELECT k FROM (SELECT 42) t(k) WHERE k IN (SELECT i FROM (SELECT i) t4 WHERE i*2-k IN (SELECT * FROM (SELECT i))));
----
42
query III
SELECT * FROM (SELECT 42) t1(i), (SELECT 22) t2(j), (SELECT i+j WHERE i+j=(SELECT 64)) t3(l);
----
42 22 64
query I
SELECT * FROM (SELECT 42) t(i) WHERE i IN (SELECT k FROM (SELECT i) t(k) WHERE k = 0);
----
query I
SELECT * FROM (SELECT 42) t(i) WHERE i IN (SELECT l FROM (SELECT 42) t(l) WHERE l IN (SELECT l FROM (SELECT 42 l) t4(l), (SELECT l+5) t5(n) WHERE i+2*l IN (SELECT k FROM (SELECT i+5), (SELECT i * 2) t2(j), (SELECT i + j) t3(k) WHERE k-l IN (SELECT i*2))));
----
42
query I
SELECT (SELECT (SELECT k FROM (SELECT i) t2(j), (SELECT j) t3(k))) FROM (SELECT 42) t(i);
----
42
query I
SELECT i FROM (SELECT 42) t(i) WHERE i IN (SELECT l FROM (SELECT 42) t(l) , (SELECT 42) t2(j), (SELECT i+j+l) t3(k));
----
42
query IIII
SELECT * FROM (SELECT 42) t(i),
(SELECT *
FROM (SELECT 142) t3(y),
(SELECT *
FROM (SELECT 242) t4(z),
(SELECT 58 WHERE i+y+z=426) t5(m)))
WHERE z-y-m IN (SELECT l FROM (SELECT 42) t(l)
WHERE l IN (SELECT l FROM (SELECT 42 l) t4(l),
(SELECT l+5) t5(n)
WHERE i+2*l IN (SELECT k FROM (SELECT i+5),
(SELECT i * 2) t2(j),
(SELECT i + j) t3(k)
WHERE k-l IN (SELECT i*2))
));
----
42 142 242 58
query I
SELECT (SELECT (SELECT k
FROM (SELECT i) t2(j),
(SELECT j) t3(k)))
FROM (SELECT 42) t(i)
WHERE i IN (SELECT l FROM (SELECT 42) t(l)
WHERE l IN (SELECT l FROM (SELECT 42 l) t4(l),
(SELECT l+5) t5(n)
WHERE i+2*l IN (SELECT k FROM (SELECT i+5),
(SELECT i * 2) t2(j),
(SELECT i + j) t3(k)
WHERE k-l IN (SELECT i*2))
));
----
42
query I
SELECT * FROM (SELECT 42) t(i)
WHERE i IN (SELECT l FROM (SELECT 42) t4(l)
WHERE l IN (SELECT l FROM (SELECT (SELECT z-y As l
FROM (SELECT x) t20(y),
(SELECT y+x) t21(z))
FROM (SELECT 42) t22(x)),
(SELECT l+5) t5(n)
WHERE i+2*l IN (SELECT k FROM (SELECT i+5),
(SELECT i * 2) t2(j),
(SELECT i + j) t3(k)
WHERE k-l IN (SELECT i*2))
));
----
42
query I
SELECT (SELECT res.*
FROM (SELECT 1) AS t2(z),
(SELECT (SELECT i
FROM (SELECT MAX(k) FROM generate_series(1,10) t(k)) AS t(i)
GROUP BY i
HAVING (COUNT(*)) = x)
) as res
)
FROM generate_series(1, 5) t(x);
----
10
NULL
NULL
NULL
NULL
statement ok
create view strings as (with recursive t(a) as (select 1 union select a+1 from t where a < 5) select * from t order by a);
query I
select sum(a)
from strings
where a in (select k
from (select 1) t(l) ,
(select 1+l) t2(j),
(select a-j
from strings) t3(k));
----
6
statement ok
create view strings2 as (with recursive t2(b) as (select 0 union select 10*a from strings where a < 5) select * from t2 order by b);
query I
select *
from strings2
where b in (select k
from (select 10) t(l) ,
(select 10+l) t2(j),
(select l+10*a
from strings) t3(k))
group by b
having b%20 == 0
order by b desc;
----
40
20

19
external/duckdb/test/sql/subquery/lateral/lateral_large_lists.test vendored Normal file
View File

@@ -0,0 +1,19 @@
# name: test/sql/subquery/lateral/lateral_large_lists.test
# description: Test LATERAL joins with large arrays (inspired by #3593 but with a lateral join)
# group: [lateral]
statement ok
PRAGMA enable_verification
query I
SELECT total_seats
FROM (
SELECT list(distinct {'key': gen_random_uuid(), 'val': 1 }) as l FROM range(0, 1600)
) as m, (
select sum(a.val) as value
FROM (
SELECT UNNEST(l) a
) x
) as l(total_seats)
----
1600

71
external/duckdb/test/sql/subquery/lateral/lateral_left_join.test vendored Normal file
View File

@@ -0,0 +1,71 @@
# name: test/sql/subquery/lateral/lateral_left_join.test
# description: Test LATERAL left joins
# group: [lateral]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
query II
SELECT * FROM integers LEFT JOIN LATERAL (SELECT integers.i + 1) t(b) ON (i=b) ORDER BY i;
----
NULL NULL
1 NULL
2 NULL
3 NULL
query II
SELECT * FROM integers LEFT JOIN LATERAL (SELECT integers.i) t(b) ON (i=b) ORDER BY i;
----
NULL NULL
1 1
2 2
3 3
query II
SELECT * FROM integers LEFT JOIN LATERAL (SELECT * FROM integers WHERE i<>integers.i) t(b) ON (i=b) ORDER BY i;
----
NULL NULL
1 NULL
2 NULL
3 NULL
query II
SELECT * FROM integers INNER JOIN LATERAL (SELECT integers.i WHERE integers.i IN (1, 3)) t(b) ON (i=b) ORDER BY i;
----
1 1
3 3
query II
SELECT * FROM integers LEFT JOIN LATERAL (SELECT integers.i WHERE integers.i IN (1, 3)) t(b) ON (i=b) ORDER BY i;
----
NULL NULL
1 1
2 NULL
3 3
# left-join on arbitrary expressions not supported
statement error
SELECT * FROM integers LEFT JOIN LATERAL (SELECT integers.i WHERE integers.i IN (1, 3)) t(b) ON (i+b<b) ORDER BY i;
----
must be a comparison
# full-outer join not supported
statement error
SELECT * FROM (SELECT * FROM integers WHERE i=2) t(i) FULL JOIN LATERAL (SELECT t.i WHERE t.i IN (1, 3)) t2(b) ON (i=b) ORDER BY i, b;
----
LATERAL
# right-join not supported
statement error
SELECT * FROM (SELECT * FROM integers WHERE i=2) t(i) RIGHT JOIN LATERAL (SELECT t.i WHERE t.i IN (1, 3)) t2(b) ON (i=b) ORDER BY i, b;
----
LATERAL

15
external/duckdb/test/sql/subquery/lateral/lateral_qualify.test vendored Normal file
View File

@@ -0,0 +1,15 @@
# name: test/sql/subquery/lateral/lateral_qualify.test
# description: Test LATERAL joins and QUALIFY clause interaction
# group: [lateral]
statement ok
PRAGMA enable_verification
query III
FROM (SELECT 42) t(x), (SELECT x, row_number() OVER () QUALIFY NULL);
----
query II
FROM (SELECT 42) t(x), (SELECT x * 2 QUALIFY row_number() OVER () < 10);
----
42 84

70
external/duckdb/test/sql/subquery/lateral/lateral_unnest.test_slow vendored Normal file
View File

@@ -0,0 +1,70 @@
# name: test/sql/subquery/lateral/lateral_unnest.test_slow
# description: Test LATERAL UNNEST
# group: [lateral]
statement ok
PRAGMA enable_verification
mode skip
# FIXME: this causes an internal exception to be thrown
statement ok
PREPARE v1 AS SELECT l, (SELECT SUM(k) FROM UNNEST(l) t(k)) AS sum FROM (SELECT ARRAY [?, ?, ?] UNION ALL SELECT ARRAY[?, ?, ?] UNION ALL SELECT ARRAY[]::INT[]) t(l) ORDER BY sum NULLS LAST
mode unskip
# lateral join with unnest
query II
SELECT * FROM (SELECT ARRAY[1, 2, 3]) t(l), UNNEST(l) t2(k) ORDER BY k
----
[1, 2, 3] 1
[1, 2, 3] 2
[1, 2, 3] 3
# explicit LATERAL
query II
SELECT * FROM (SELECT ARRAY[1, 2, 3]) t(l), LATERAL UNNEST(l) t2(k) ORDER BY k
----
[1, 2, 3] 1
[1, 2, 3] 2
[1, 2, 3] 3
query II
SELECT * FROM (SELECT ARRAY[1, 2, 3] UNION ALL SELECT ARRAY[]::INT[] UNION ALL SELECT ARRAY[4, NULL, 5] UNION ALL SELECT ARRAY[]::INT[]) t(l), UNNEST(l) t2(k) ORDER BY k NULLS LAST
----
[1, 2, 3] 1
[1, 2, 3] 2
[1, 2, 3] 3
[4, NULL, 5] 4
[4, NULL, 5] 5
[4, NULL, 5] NULL
# empty table
query II
SELECT * FROM (SELECT ARRAY[]::INT[]) t(l), UNNEST(l) t2(k) ORDER BY k NULLS LAST
----
# large table
statement ok
CREATE TABLE lists AS SELECT ARRAY[i, i + 1, i + 2] l FROM generate_series(0, 999, 1) t(i);
query I
SELECT SUM(k) FROM lists, UNNEST(l) t(k)
----
1501500
# table in-out function in correlated scalar subquery
query I
SELECT (SELECT SUM(k) FROM UNNEST(l) t(k)) FROM (SELECT ARRAY [1, 2, 3]) t(l)
----
6
statement ok
PRAGMA disable_verification
query II
SELECT l, (SELECT SUM(k) FROM UNNEST(l) t(k)) AS sum FROM (SELECT ARRAY [1, 2, 3] UNION ALL SELECT ARRAY[4, 5, NULL] UNION ALL SELECT ARRAY[]::INT[]) t(l) ORDER BY sum NULLS LAST
----
[1, 2, 3] 6
[4, 5, NULL] 9
[] NULL

21
external/duckdb/test/sql/subquery/lateral/lateral_unnest_large.test_slow vendored Normal file
View File

@@ -0,0 +1,21 @@
# name: test/sql/subquery/lateral/lateral_unnest_large.test_slow
# description: Test large LATERAL UNNEST
# group: [lateral]
# large table
statement ok
CREATE TABLE lists AS SELECT ARRAY[i, NULL, i + 1, i + 2, NULL] l FROM generate_series(0, 999999, 1) t(i);
query I
SELECT SUM(k) FROM lists, UNNEST(l) t(k)
----
1500001500000
# strings
statement ok
CREATE TABLE lists_strings AS SELECT ARRAY['longstringprefix_' || i, NULL, 'longstringprefix_' || (i + 1), 'longstringprefix_' || (i + 2), NULL] l FROM generate_series(0, 999999, 1) t(i);
query I
SELECT SUM(replace(k, 'longstringprefix_', '')::BIGINT) FROM lists_strings, UNNEST(l) t(k)
----
1500001500000

43
external/duckdb/test/sql/subquery/lateral/lateral_values.test vendored Normal file
View File

@@ -0,0 +1,43 @@
# name: test/sql/subquery/lateral/lateral_values.test
# description: Test LATERAL with values clause
# group: [lateral]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
query II
SELECT * FROM integers, LATERAL (VALUES (integers.i + 1)) t(k) ORDER BY i;
----
NULL NULL
1 2
2 3
3 4
query III
SELECT * FROM integers a, integers b JOIN LATERAL (VALUES (a.i)) ss(x) ON (true) ORDER BY a.i, b.i;
----
NULL NULL NULL
NULL 1 NULL
NULL 2 NULL
NULL 3 NULL
1 NULL 1
1 1 1
1 2 1
1 3 1
2 NULL 2
2 1 2
2 2 2
2 3 2
3 NULL 3
3 1 3
3 2 3
3 3 3

554
external/duckdb/test/sql/subquery/lateral/pg_lateral.test vendored Normal file
View File

@@ -0,0 +1,554 @@
# name: test/sql/subquery/lateral/pg_lateral.test
# description: Several LATERAL JOIN tests taken from Postgres
# group: [lateral]
statement ok
PRAGMA enable_verification
query III
select s1, s2, sm
from generate_series(1, 3) s1(s1),
lateral (select s2, sum(s1 + s2) sm
from generate_series(1, 3) s2(s2) group by s2) ss
order by 1, 2;
----
1 1 2
1 2 3
1 3 4
2 1 3
2 2 4
2 3 5
3 1 4
3 2 5
3 3 6
statement ok
create table agg_data_1k as select g*10 AS g from generate_series(0, 999) g(g);
query IIII
select * from
(values (100), (300), (500)) as r(a),
lateral (
select (g/2)::int as c1,
array_agg(g::int) as c2,
count(*) as c3
from agg_data_1k
where g < r.a
group by g/2) as s
order by 1, 2, 4, 3;
----
100 0 [0] 1
100 5 [10] 1
100 10 [20] 1
100 15 [30] 1
100 20 [40] 1
100 25 [50] 1
100 30 [60] 1
100 35 [70] 1
100 40 [80] 1
100 45 [90] 1
300 0 [0] 1
300 5 [10] 1
300 10 [20] 1
300 15 [30] 1
300 20 [40] 1
300 25 [50] 1
300 30 [60] 1
300 35 [70] 1
300 40 [80] 1
300 45 [90] 1
300 50 [100] 1
300 55 [110] 1
300 60 [120] 1
300 65 [130] 1
300 70 [140] 1
300 75 [150] 1
300 80 [160] 1
300 85 [170] 1
300 90 [180] 1
300 95 [190] 1
300 100 [200] 1
300 105 [210] 1
300 110 [220] 1
300 115 [230] 1
300 120 [240] 1
300 125 [250] 1
300 130 [260] 1
300 135 [270] 1
300 140 [280] 1
300 145 [290] 1
500 0 [0] 1
500 5 [10] 1
500 10 [20] 1
500 15 [30] 1
500 20 [40] 1
500 25 [50] 1
500 30 [60] 1
500 35 [70] 1
500 40 [80] 1
500 45 [90] 1
500 50 [100] 1
500 55 [110] 1
500 60 [120] 1
500 65 [130] 1
500 70 [140] 1
500 75 [150] 1
500 80 [160] 1
500 85 [170] 1
500 90 [180] 1
500 95 [190] 1
500 100 [200] 1
500 105 [210] 1
500 110 [220] 1
500 115 [230] 1
500 120 [240] 1
500 125 [250] 1
500 130 [260] 1
500 135 [270] 1
500 140 [280] 1
500 145 [290] 1
500 150 [300] 1
500 155 [310] 1
500 160 [320] 1
500 165 [330] 1
500 170 [340] 1
500 175 [350] 1
500 180 [360] 1
500 185 [370] 1
500 190 [380] 1
500 195 [390] 1
500 200 [400] 1
500 205 [410] 1
500 210 [420] 1
500 215 [430] 1
500 220 [440] 1
500 225 [450] 1
500 230 [460] 1
500 235 [470] 1
500 240 [480] 1
500 245 [490] 1
statement ok
CREATE TABLE INT2_TBL(f1 int2);
statement ok
INSERT INTO INT2_TBL(f1) VALUES
('0 '),
(' 1234 '),
(' -1234'),
('32767'), -- largest and smallest values
('-32767');
statement ok
CREATE TABLE INT4_TBL(f1 int4);
statement ok
INSERT INTO INT4_TBL(f1) VALUES
(' 0 '),
('123456 '),
(' -123456'),
('2147483647'), -- largest and smallest values
('-2147483647');
statement ok
CREATE TABLE INT8_TBL(q1 int8, q2 int8);
statement ok
INSERT INTO INT8_TBL VALUES
(' 123 ',' 456'),
('123 ','4567890123456789'),
('4567890123456789','123'),
(+4567890123456789,'4567890123456789'),
('+4567890123456789','-4567890123456789');
statement ok
CREATE TABLE TEXT_TBL (f1 text);
statement ok
INSERT INTO TEXT_TBL VALUES
('doh!'),
('hi de ho neighbor');
statement ok
CREATE TABLE tenk1 (
unique1 int4,
unique2 int4,
two int4,
four int4,
ten int4,
twenty int4,
hundred int4,
thousand int4,
twothousand int4,
fivethous int4,
tenthous int4,
odd int4,
even int4,
stringu1 varchar,
stringu2 varchar,
string4 varchar
);
statement ok
COPY tenk1 FROM 'data/csv/tenk.tsv.gz' (DELIMITER '\t')
query II rowsort
select * from
int4_tbl as i41,
lateral
(select 1 as x from
(select i41.f1 as lat,
i42.f1 as loc from
int8_tbl as i81, int4_tbl as i42) as ss1
right join int4_tbl as i43 on (i43.f1 > 1)
where ss1.loc = ss1.lat) as ss2
where i41.f1 > 0;
----
123456 1
123456 1
123456 1
123456 1
123456 1
123456 1
123456 1
123456 1
123456 1
123456 1
2147483647 1
2147483647 1
2147483647 1
2147483647 1
2147483647 1
2147483647 1
2147483647 1
2147483647 1
2147483647 1
2147483647 1
query I
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 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;
----
query III
select * from
(select 1 as x) ss1 left join (select 2 as y) ss2 on (true),
lateral (select ss2.y as z limit 1) ss3;
----
1 2 2
query III
select * from
(select 0 as z) as t1
left join
(select true as a) as t2
on true,
lateral (select true as b
union all
select a as b) as t3
where b;
----
0 true true
0 true true
query IIIII
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;
----
doh! 4567890123456789 123 4567890123456789 doh!
# FIXME: lateral chain with star
mode skip
query IIIIIII
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;
----
doh! 4567890123456789 123 4567890123456789 doh! 4567890123456789 doh!
query I
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;
----
query I
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;
----
mode unskip
query IIII
select i8.*, ss.v, t.unique2
from int8_tbl i8
left join int4_tbl i4 on i4.f1 = 1
left join lateral (select i4.f1 + 1 as v) as ss on true
left join tenk1 t on t.unique2 = ss.v
where q2 = 456;
----
123 456 NULL NULL
query II
select unique2, x.*
from tenk1 a, lateral (select * from int4_tbl b where f1 = a.unique1) x;
----
9998 0
query II
select unique2, x.*
from int4_tbl x, lateral (select unique2 from tenk1 where f1 = unique1) ss;
----
9998 0
query II
select unique2, x.*
from int4_tbl x left join lateral (select unique1, unique2 from tenk1 where f1 = unique1) ss on true
order by all;
----
9998 0
NULL -2147483647
NULL -123456
NULL 123456
NULL 2147483647
# FIXME: INTERNAL Error: Logical operator type "DELIM_JOIN" for dependent join
mode skip
query IIII rowsort qlateral
select *, (select r from (select q1 as q2) x, (select q2 as r) y) from int8_tbl;
----
query IIII rowsort qlateral
select *, (select r from (select q1 as q2) x, lateral (select q2 as r) y) from int8_tbl;
----
mode unskip
# FIXME: Not implemented Error: LATERAL not implemented
mode skip
query I
select count(*) from tenk1 a, lateral generate_series(1,two) g;
----
5000
mode unskip
query III rowsort
select * from generate_series(100,200) g(g),
lateral (select * from int8_tbl a where g = q1 union all
select * from int8_tbl b where g = q2) ss;
----
123 123 456
123 123 4567890123456789
123 4567890123456789 123
query I
select count(*) from tenk1 a,
tenk1 b join lateral (values(a.unique1)) ss(x) on b.unique2 = ss.x;
----
10000
query I
select count(*) from tenk1 a,
tenk1 b join lateral (values(a.unique1),(-1)) ss(x) on b.unique2 = ss.x;
----
10000
query III
select * from (select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1,
lateral (select x) ss2(y);
----
0 0 0
query III rowsort
select * from (select f1 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1,
lateral (values(x)) ss2(y);
----
-123456 -123456 -123456
-2147483647 -2147483647 -2147483647
0 0 0
123456 123456 123456
2147483647 2147483647 2147483647
query III
select * from ((select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1) j,
lateral (select x) ss2(y);
----
0 0 0
# FIXME: Not implemented Error: LATERAL not implemented
mode skip
query II
select * from (values(1)) x(lb),
lateral generate_series(lb,4) x4
ORDER BY ALL;
----
1 1
1 2
1 3
1 4
query II
select * from (select f1/1000000000 from int4_tbl) x(lb),
lateral generate_series(lb,4) x4
ORDER BY ALL;
----
-2 -2
-2 -1
-2 0
-2 1
-2 2
-2 3
-2 4
0 0
0 1
0 2
0 3
0 4
0 0
0 1
0 2
0 3
0 4
0 0
0 1
0 2
0 3
0 4
2 2
2 3
2 4
mode unskip
query II
select * from (values(1)) x(lb),
lateral (values(lb)) y(lbcopy);
----
1 1
query II
select * from (values(1)) x(lb),
lateral (select lb from int4_tbl) y(lbcopy);
----
1 1
1 1
1 1
1 1
1 1
query II rowsort
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) order by 1, 2;
----
123 456
123 4567890123456789
123 4567890123456789
123 4567890123456789
4567890123456789 -4567890123456789
4567890123456789 123
4567890123456789 123
4567890123456789 4567890123456789
4567890123456789 4567890123456789
4567890123456789 4567890123456789
# FIXME: postgres has a better error message here
statement error
select 1 from tenk1 a, lateral (select max(a.unique1) from int4_tbl b) ss;
----
Binder Error: LATERAL join cannot contain aggregates
statement ok
create table xx1 as select f1 as x1, -f1 as x2 from int4_tbl;
query II
select * from xx1;
----
0 0
123456 -123456
-123456 123456
2147483647 -2147483647
-2147483647 2147483647
statement error
update xx1 set x2 = f1 from (select * from int4_tbl where f1 = x1) ss;
----
not found
statement error
update xx1 set x2 = f1 from (select * from int4_tbl where f1 = xx1.x1) ss;
----
not found
statement error
update xx1 set x2 = f1 from lateral (select * from int4_tbl where f1 = x1) ss;
----
not found
statement ok
update xx1 set x2 = f1 from xx1 AS xx2, lateral (select * from int4_tbl where f1 = xx2.x1 AND f1=-2147483647) ss;
query II
select * from xx1;
----
0 -2147483647
123456 -2147483647
-123456 -2147483647
2147483647 -2147483647
-2147483647 -2147483647
statement error
delete from xx1 using (select * from int4_tbl where f1 = x1) ss;
----
not found
statement error
delete from xx1 using (select * from int4_tbl where f1 = xx1.x1) ss;
----
not found
statement error
delete from xx1 using lateral (select * from int4_tbl where f1 = x1) ss;
----
not found

177
external/duckdb/test/sql/subquery/lateral/test_lateral_join.test vendored Normal file
View File

@@ -0,0 +1,177 @@
# name: test/sql/subquery/lateral/test_lateral_join.test
# description: Test lateral join
# group: [lateral]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
query I
select (select MIN(val) from unnest((select a)) t(val)) from (select ARRAY[1, 2, 3, NULL]) t(a);
----
1
query I
select (select MIN(val) from unnest((select (select a))) t(val)) from (select ARRAY[1, 2, 3, NULL]) t(a);
----
1
query II rowsort
select * from (select array[1, 2, 3] a), unnest((select (select (select a))))
----
[1, 2, 3] 1
[1, 2, 3] 2
[1, 2, 3] 3
query I
select (select MIN(val) from unnest(a) t(val)) from (select ARRAY[1, 2, 3, NULL]) t(a);
----
1
# simplest lateral joins
query II
select * from (select 42) t(a), (select t.a + 1);
----
42 43
query II
select * from (select 42) t(a) cross join lateral (select t.a + 1);
----
42 43
# more rows
query II
select * from (select 42 union all select 84) t(a), (select t.a + 1) ORDER BY ALL;
----
42 43
84 85
query I
select (select MIN(val) from unnest(a) t(val)) from (select ARRAY[1, 2, 3, NULL]) t(a);
----
1
# unnest
query II
select * from (select [42, 43, 44]) t(a), (select unnest(t.a)) order by all;
----
[42, 43, 44] 42
[42, 43, 44] 43
[42, 43, 44] 44
query II
select * from (select [42, 43, 44]) t(a), (select unnest(t.a)) t2(b) where b=43;
----
[42, 43, 44] 43
query II
select * from (select [42, 43, 44] union all select [45, NULL, 46]) t(a), (select unnest(t.a)) t2(b) order by all;
----
[42, 43, 44] 42
[42, 43, 44] 43
[42, 43, 44] 44
[45, NULL, 46] NULL
[45, NULL, 46] 45
[45, NULL, 46] 46
query I
select sum(b) from (select [42, 43, 44] union all select [45, NULL, 46]) t(a), (select unnest(t.a)) t2(b);
----
220
query II
select a, sum(b) from (select [42, 43, 44] union all select [45, NULL, 46]) t(a), (select unnest(t.a)) t2(b) group by a order by a;
----
[42, 43, 44] 129
[45, NULL, 46] 91
# join syntax
query II
select * from (select array[42, 43, 44]) t(a) join (select unnest(t.a)) t2(b) on (true) order by all;
----
[42, 43, 44] 42
[42, 43, 44] 43
[42, 43, 44] 44
# explicit LATERAL (Postgres syntax)
query II
select * from (select array[42, 43, 44]) t(a) join lateral (select unnest(t.a)) t2(b) on (true) order by all;
----
[42, 43, 44] 42
[42, 43, 44] 43
[42, 43, 44] 44
query II
select * from (select array[42, 43, 44]) t(a) join lateral (select unnest(t.a)) t2(b) on (a[1]=b);
----
[42, 43, 44] 42
query II
select * from (select array[42, 43, 44]) t(a) join lateral (select unnest(t.a)) t2(b) on (a[1]<b) order by all;
----
[42, 43, 44] 43
[42, 43, 44] 44
query II
select * from (select array[42, 43, 44]) t(a) join lateral (select unnest(t.a)) t2(b) on (false) order by all;
----
# postgres syntax
query II
select * from (select 42) t(a) join lateral (select t.a + 1) t2(b) on (true);
----
42 43
# we can use random expressions in join conditions of inner joins
query II
select * from (select 42) t(a) join lateral (select t.a + 1) t2(b) on (a+b>=80);
----
42 43
query II
select * from (select ARRAY[42, 43, 44]) t(a) join lateral (select * from unnest(t.a)) t2(b) on (true) ORDER BY b;
----
[42, 43, 44] 42
[42, 43, 44] 43
[42, 43, 44] 44
statement ok
CREATE TABLE students(id INTEGER, name VARCHAR, major VARCHAR, year INTEGER)
statement ok
CREATE TABLE exams(sid INTEGER, course VARCHAR, curriculum VARCHAR, grade INTEGER, year INTEGER)
statement ok
INSERT INTO students VALUES (1, 'Mark', 'CS', 2017)
statement ok
INSERT INTO students VALUES (2, 'Dirk', 'CS', 2017)
statement ok
INSERT INTO exams VALUES (1, 'Database Systems', 'CS', 10, 2015)
statement ok
INSERT INTO exams VALUES (1, 'Graphics', 'CS', 9, 2016)
statement ok
INSERT INTO exams VALUES (2, 'Database Systems', 'CS', 7, 2015)
statement ok
INSERT INTO exams VALUES (2, 'Graphics', 'CS', 7, 2016)
# lateral join with explicit LATERAL added
query II
SELECT name, total FROM students JOIN LATERAL (SELECT SUM(grade) AS total FROM exams WHERE exams.sid=students.id) grades ON true ORDER BY total DESC;
----
Mark 19
Dirk 14
# lateral join without explicit LATERAL
query II
SELECT name, total FROM students, (SELECT SUM(grade) AS total FROM exams WHERE exams.sid=students.id) grades ORDER BY total DESC;
----
Mark 19
Dirk 14

121
external/duckdb/test/sql/subquery/scalar/array_order_subquery.test vendored Normal file
View File

@@ -0,0 +1,121 @@
# name: test/sql/subquery/scalar/array_order_subquery.test
# description: Issue #11293: Unstable ordering of array(subquery) function when using DISTINCT and ORDER BY in subquery
# group: [scalar]
statement ok
create table t (i int);
statement ok
insert into t values (1),(2),(3),(4),(4);
query III
select
array(select distinct i from t order by i desc) as a,
array(select distinct i from t order by i desc) as b,
array(select distinct i from t order by i desc) as c;
----
[4, 3, 2, 1] [4, 3, 2, 1] [4, 3, 2, 1]
# correlated
query I
select array(select unnest(l) AS i order by i desc nulls last) as a from (values ([NULL, 1, 2, 3, 4]), ([5, 6, NULL, 7, 8]), ([]), ([10, 11, 12])) t(l);
----
[4, 3, 2, 1, NULL]
[8, 7, 6, 5, NULL]
[]
[12, 11, 10]
query I
select array(select unnest(l) AS i order by i desc nulls first) as a from (values ([NULL, 1, 2, 3, 4]), ([5, 6, NULL, 7, 8]), ([]), ([10, 11, 12])) t(l);
----
[NULL, 4, 3, 2, 1]
[NULL, 8, 7, 6, 5]
[]
[12, 11, 10]
# row id
query I
SELECT ARRAY(SELECT i FROM t ORDER BY rowid DESC)
----
[4, 4, 3, 2, 1]
# qualified name
query I
SELECT ARRAY(SELECT i FROM t ORDER BY t.rowid)
----
[1, 2, 3, 4, 4]
# use integer literals
query I
SELECT ARRAY
(SELECT 1 UNION ALL
SELECT 2 UNION ALL
SELECT 3
ORDER by 1) AS new_array;
----
[1, 2, 3]
# qualified names
query I
select
array(select distinct i from t order by t.i desc) as a
----
[4, 3, 2, 1]
query I
select
array(select distinct i from t union all select distinct i from t order by t.i desc) as a
----
[4, 4, 3, 3, 2, 2, 1, 1]
statement error
select
array(select distinct i from t order by x.i desc) as a
----
Referenced table "x" not found
query I
SELECT ARRAY
(SELECT 1 UNION ALL
SELECT 2 UNION ALL
SELECT 3
ORDER by 1 DESC) AS new_array;
----
[3, 2, 1]
query I
select array(select * from unnest(['a', 'b']) as _t(u) order by if(u='a',100, 1)) as out;
----
[b, a]
query I
select array(select * from unnest(['a', 'b']) as _t(u) order by if(u='a',100, 1) desc) as out;
----
[a, b]
statement error
SELECT ARRAY
(SELECT 1 UNION ALL
SELECT 2 UNION ALL
SELECT 3
ORDER by -1) AS new_array;
----
ORDER term out of range
statement error
SELECT ARRAY
(SELECT 1 UNION ALL
SELECT 2 UNION ALL
SELECT 3
ORDER by 2) AS new_array;
----
ORDER term out of range
statement error
SELECT ARRAY
(SELECT 1 UNION ALL
SELECT 2 UNION ALL
SELECT 3
ORDER by 'hello world') AS new_array;
----
ORDER BY non-integer literal has no effect

96
external/duckdb/test/sql/subquery/scalar/array_subquery.test vendored Normal file
View File

@@ -0,0 +1,96 @@
# name: test/sql/subquery/scalar/array_subquery.test
# description: Test ARRAY subquery
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
# uncorrelated
query II
SELECT i, ARRAY(
SELECT 42
) top
FROM integers i1
ORDER BY i
----
NULL [42]
1 [42]
2 [42]
3 [42]
# single element
query II
SELECT i, ARRAY(
SELECT i FROM integers WHERE i1.i=i
) top
FROM integers i1
ORDER BY i
----
NULL []
1 [1]
2 [2]
3 [3]
# multiple elements
query II
SELECT i, ARRAY(
SELECT i FROM integers WHERE i>i1.i ORDER BY i ASC NULLS FIRST
) top
FROM integers i1
ORDER BY i
----
NULL []
1 [2, 3]
2 [3]
3 []
# array with limit
query II
SELECT i, ARRAY(
SELECT i1.i FROM integers i1, integers i2, integers i3, integers i4 WHERE i1.i=integers.i LIMIT 3
) top
FROM integers
ORDER BY i
----
NULL []
1 [1, 1, 1]
2 [2, 2, 2]
3 [3, 3, 3]
# array with limit and offset
query II
SELECT i, ARRAY(
SELECT i1.i FROM integers i1, integers i2, integers i3, integers i4 WHERE i1.i=integers.i LIMIT 3 OFFSET 3
) top
FROM integers
ORDER BY i
----
NULL []
1 [1, 1, 1]
2 [2, 2, 2]
3 [3, 3, 3]
# offset on the edge
query II
SELECT i, ARRAY(
SELECT i1.i FROM integers i1, integers i2, integers i3, integers i4 WHERE i1.i=integers.i LIMIT 3 OFFSET 62
) top
FROM integers
ORDER BY i
----
NULL []
1 [1, 1]
2 [2, 2]
3 [3, 3]
# should only allow one column in array subquery
statement error
select array(select 1,2)
----
<REGEX>:.*inder Error.*Subquery returns 2 columns.*

8
external/duckdb/test/sql/subquery/scalar/coalesce_subquery.test vendored Normal file
View File

@@ -0,0 +1,8 @@
# name: test/sql/subquery/scalar/coalesce_subquery.test
# description: Issue #2452: Coalesce operator with subquery throws error
# group: [scalar]
query I
SELECT 1 FROM (select 4) v1(vc0) WHERE (3) NOT IN (COALESCE((SELECT 1 WHERE FALSE), v1.vc0));
----
1

54
external/duckdb/test/sql/subquery/scalar/correlated_missing_columns.test vendored Normal file
View File

@@ -0,0 +1,54 @@
# name: test/sql/subquery/scalar/correlated_missing_columns.test
# description: Test correlated missing columns
# group: [scalar]
require tpch
statement ok
CALL dbgen(sf=0);
# verify that we can grab missing columns from either the correlated subquery or the outer (uncorrelated) subquery
statement error
SELECT (SELECT l_linestat FROM orders) FROM lineitem
----
l_linestatus
statement error
SELECT (SELECT l_returnfla FROM orders) FROM lineitem
----
l_returnflag
statement error
SELECT (SELECT o_totalp FROM orders) FROM lineitem
----
o_totalprice
# column exists in outer query but is used in an aggregate
statement error
SELECT * FROM lineitem WHERE (SELECT SUM(l_orderkey) > 0)
----
cannot contain aggregates
# prefer missing column over unsupported
# where clause
statement error
SELECT * FROM lineitem WHERE (SELECT SUM(o_orderke) FROM orders)
----
o_orderkey
statement error
SELECT * FROM lineitem WHERE (SELECT SUM(o_orderke) OVER () FROM orders)
----
o_orderkey
# group by
statement error
SELECT * FROM lineitem GROUP BY (SELECT SUM(o_orderke) OVER () FROM orders)
----
o_orderkey
# limit
statement error
SELECT * FROM lineitem LIMIT (SELECT SUM(o_orderke) FROM orders LIMIT 1)
----
o_orderkey

68
external/duckdb/test/sql/subquery/scalar/correlated_pivot.test vendored Normal file
View File

@@ -0,0 +1,68 @@
# name: test/sql/subquery/scalar/correlated_pivot.test
# description: Test using PIVOT in correlated subqueries
# group: [scalar]
statement ok
CREATE TABLE Product(DaysToManufacture int, StandardCost int);
statement ok
INSERT INTO Product VALUES (0, 5.0885), (1, 223.88), (2, 359.1082), (4, 949.4105);
statement ok
SET pivot_filter_threshold=0
# pivot
statement error
SELECT DaysToManufacture, StandardCost, (SELECT ["0", "1", "2", "3", "4"] FROM
(SELECT DaysToManufacture, StandardCost) AS SourceTable
PIVOT
(
AVG(StandardCost)
FOR DaysToManufacture IN (0, 1, 2, 3, 4)
) AS PivotTable
)
FROM Product
----
PIVOT is not supported in correlated subqueries yet
# unpivot with exclude nulls (default)
statement error
SELECT DaysToManufacture, StandardCost, (SELECT cost FROM
(SELECT DaysToManufacture, StandardCost) AS SourceTable
PIVOT
(
AVG(StandardCost)
FOR DaysToManufacture IN (0, 1, 2, 3, 4)
) AS PivotTable
UNPIVOT
(
cost FOR days IN (0, 1, 2, 3, 4)
)
)
FROM Product
----
PIVOT is not supported in correlated subqueries yet
# unpivot with include nulls
statement error
SELECT DaysToManufacture, StandardCost, (SELECT LIST(cost) FROM
(SELECT DaysToManufacture, StandardCost) AS SourceTable
PIVOT
(
AVG(StandardCost)
FOR DaysToManufacture IN (0, 1, 2, 3, 4)
) AS PivotTable
UNPIVOT INCLUDE NULLS
(
cost FOR days IN (0, 1, 2, 3, 4)
)
)
FROM Product
----
PIVOT is not supported in correlated subqueries yet
statement ok
SET pivot_filter_threshold TO DEFAULT
statement ok
RESET SESSION pivot_filter_threshold

104
external/duckdb/test/sql/subquery/scalar/expression_get.test_slow vendored Normal file
View File

@@ -0,0 +1,104 @@
# name: test/sql/subquery/scalar/expression_get.test_slow
# description: Issue #2701: Nested selecting max from column values gives dependent join internal error
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
# basic correlated VALUES clause in subquery
statement ok
CREATE TABLE test AS SELECT CAST((i % 10) AS INTEGER) AS i, CAST(((i * 2) % 10) AS INTEGER) AS j FROM generate_series(0, 9, 1) tbl(i);
query III
SELECT i, j, (SELECT max(x) FROM (VALUES (i), (j)) AS X(x)) as maxn FROM test ORDER BY ALL;
----
0 0 0
1 2 2
2 4 4
3 6 6
4 8 8
5 0 5
6 2 6
7 4 7
8 6 8
9 8 9
# mix of correlated and non-correlated values
query III
SELECT i, j, (SELECT max(x) FROM (VALUES (i), (j), (3), (NULL), (5)) AS X(x)) as maxn FROM test ORDER BY ALL;
----
0 0 5
1 2 5
2 4 5
3 6 6
4 8 8
5 0 5
6 2 6
7 4 7
8 6 8
9 8 9
# more complex correlated queries involving VALUES lists
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
# subquery within correlated values list
query I
SELECT (SELECT max(x) FROM (VALUES ((SELECT i))) tbl(x)) FROM integers ORDER BY i;
----
NULL
1
2
3
# correlated values list within correlated values list
query I
SELECT (SELECT max(x) FROM (VALUES ((SELECT * FROM (VALUES (i)) tbl3(x)))) tbl(x)) FROM integers ORDER BY i;
----
NULL
1
2
3
# join between correlated values lists
query I
SELECT (SELECT max(x) FROM (VALUES (i)) tbl(x) JOIN (VALUES (i)) tbl2(x) USING (x)) FROM integers ORDER BY i;
----
NULL
1
2
3
# many rows
statement ok
CREATE TABLE test2 AS SELECT (i % 10)::INTEGER AS i, ((i * 2) % 10)::INTEGER AS j FROM generate_series(0, 99999, 1) tbl(i);
query IIII
SELECT SUM(i), SUM(j), SUM(GREATEST(i, j)), SUM((SELECT max(x) FROM (VALUES (i), (j)) AS X(x))) as maxn FROM test2;
----
450000 400000 550000 550000
query IIII
SELECT SUM(i), SUM(j), SUM(GREATEST(i, j)), SUM((SELECT max(x) FROM (VALUES (i), (j), (i), (j), (i), (j)) AS X(x))) as maxn FROM test2;
----
450000 400000 550000 550000
# NULLs
statement ok
CREATE TABLE test3 AS SELECT CASE WHEN i%7=2 THEN NULL ELSE (i % 10)::INTEGER END AS i, CASE WHEN i%9=2 THEN NULL ELSE ((i * 2) % 10)::INTEGER END AS j FROM generate_series(0, 99999, 1) tbl(i);
query III
SELECT SUM(i), SUM(j), SUM((SELECT max(x) FROM (VALUES (i), (j)) AS X(x))) as maxn FROM test3;
----
385713 355556 512700
query III
SELECT SUM(i), SUM(j), SUM((SELECT max(x) FROM (VALUES (i), (j), (NULL), (NULL), (6)) AS X(x))) as maxn FROM test3;
----
385713 355556 671748

21
external/duckdb/test/sql/subquery/scalar/in_multiple_columns.test vendored Normal file
View File

@@ -0,0 +1,21 @@
# name: test/sql/subquery/scalar/in_multiple_columns.test
# description: Test IN operator with multiple columns
# group: [scalar]
statement ok
CREATE TABLE table1(x INTEGER, y INTEGER);
statement ok
INSERT INTO table1 VALUES (NULL, 2), (1, NULL);
statement ok
CREATE TABLE table2(i INTEGER);
statement ok
INSERT INTO table2 VALUES (1), (2), (3);
query I
SELECT (x, y) IN (SELECT i, i + 1 FROM table2) from table1;
----
NULL
NULL

18
external/duckdb/test/sql/subquery/scalar/nested_subquery_window.test vendored Normal file
View File

@@ -0,0 +1,18 @@
# name: test/sql/subquery/scalar/nested_subquery_window.test
# description: Fuzzer issue - nested subquery inside a window function
# group: [scalar]
query I
SELECT (SELECT max((SELECT subq_0.c0 AS c1))) FROM (SELECT NULL AS c0) AS subq_0;
----
NULL
query I
SELECT (SELECT max(42) OVER (PARTITION BY (SELECT subq_0.c0 AS c1)) AS c6) FROM (SELECT NULL AS c0) AS subq_0;
----
42
query I
SELECT (SELECT max((SELECT subq_0.c0 AS c1)) OVER () AS c6) FROM (SELECT NULL AS c0) AS subq_0;
----
NULL

50
external/duckdb/test/sql/subquery/scalar/order_by_correlated.test vendored Normal file
View File

@@ -0,0 +1,50 @@
# name: test/sql/subquery/scalar/order_by_correlated.test
# description: Test ORDER BY in correlated subqueries
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
# order by with limit
query II
SELECT i, (
SELECT * FROM integers WHERE i>i1.i ORDER BY i ASC NULLS FIRST LIMIT 1
) top
FROM integers i1
ORDER BY i
----
NULL NULL
1 2
2 3
3 NULL
query II
SELECT i, (
SELECT * FROM integers WHERE i>i1.i ORDER BY i DESC NULLS FIRST LIMIT 1
) top
FROM integers i1
ORDER BY i
----
NULL NULL
1 3
2 3
3 NULL
# stand-alone order, with array expression
query II
SELECT i, ARRAY(
SELECT * FROM integers WHERE i>i1.i ORDER BY i
) top
FROM integers i1
ORDER BY i
----
NULL []
1 [2, 3]
2 [3]
3 []

81
external/duckdb/test/sql/subquery/scalar/subquery_row_in_any.test vendored Normal file
View File

@@ -0,0 +1,81 @@
# name: test/sql/subquery/scalar/subquery_row_in_any.test
# description: Test (a, b) IN (SELECT a, b ...)
# group: [scalar]
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
query I
SELECT (1, 2) IN (SELECT i, i + 1 FROM integers)
----
true
# mixed types
query I
SELECT (date '1992-01-02', 2) IN (SELECT date '1992-01-01' + interval (i) days, i + 1 FROM integers)
----
true
# it still works with the row inside the subquery
query I
SELECT (1, 2) IN (SELECT (i, i + 1) FROM integers)
----
true
query I
SELECT row(1) IN (SELECT i FROM integers)
----
true
# also works with explicit row function
query I
SELECT ROW(1, 2) IN (SELECT i, i + 1 FROM integers)
----
true
# NULL semantics
query I
SELECT ROW(1, 2) IN (SELECT i, i + 2 FROM integers)
----
NULL
query I
SELECT ROW(1, 2) IN (SELECT i, i + 2 FROM integers WHERE i IS NOT NULL)
----
false
query I
select 1 where (1,2) in (select 1,2);
----
1
query I
select 1 where (1,2) not in (select 1,2);
----
statement error
SELECT (1, 2) IN (SELECT (i, i + 1, i + 2) FROM integers)
----
Cannot compare values of type
# FIXME: correlated not yet supported
statement error
SELECT ROW(1, 2) IN (SELECT i1.i, i1.i + 1)
FROM integers i1
----
not yet supported
mode skip
# correlated
query I
SELECT ROW(1, 2) IN (SELECT i1.i, i1.i + 1)
FROM integers i1
----
true
false
false
NULL

162
external/duckdb/test/sql/subquery/scalar/test_complex_correlated_subquery.test vendored Normal file
View File

@@ -0,0 +1,162 @@
# name: test/sql/subquery/scalar/test_complex_correlated_subquery.test
# description: Test complex correlated subqueries
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL)
# correlated expression in subquery
query II
SELECT i, (SELECT s1.i FROM (SELECT * FROM integers WHERE i=i1.i) s1) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1
2 2
3 3
# join on two subqueries that both have a correlated expression in them
query II
SELECT i, (SELECT s1.i FROM (SELECT i FROM integers WHERE i=i1.i) s1 INNER JOIN (SELECT i FROM integers WHERE i=4-i1.i) s2 ON s1.i>s2.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 NULL
2 NULL
3 3
# implicit join with correlated expression in filter
query II
SELECT i, (SELECT s1.i FROM integers s1, integers s2 WHERE s1.i=s2.i AND s1.i=4-i1.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 3
2 2
3 1
# join with a correlated expression in the join condition
query II
SELECT i, (SELECT s1.i FROM integers s1 INNER JOIN integers s2 ON s1.i=s2.i AND s1.i=4-i1.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 3
2 2
3 1
# inner join on correlated subquery
query II
SELECT * FROM integers s1 INNER JOIN integers s2 ON (SELECT 2*SUM(i)*s1.i FROM integers)=(SELECT SUM(i)*s2.i FROM integers) ORDER BY s1.i;
----
1 2
# inner join on non-equality subquery
query II
SELECT * FROM integers s1 INNER JOIN integers s2 ON (SELECT s1.i=s2.i) ORDER BY s1.i;
----
1 1
2 2
3 3
query II
SELECT * FROM integers s1 INNER JOIN integers s2 ON (SELECT s1.i=i FROM integers WHERE s2.i=i) ORDER BY s1.i;
----
1 1
2 2
3 3
# left outer join on comparison between correlated subqueries
query TT
SELECT * FROM integers s1 LEFT OUTER JOIN integers s2 ON (SELECT 2*SUM(i)*s1.i FROM integers)=(SELECT SUM(i)*s2.i FROM integers) ORDER BY s1.i;
----
NULL NULL
1 2
2 NULL
3 NULL
# left outer join on arbitrary correlated subquery: not supported
statement error
SELECT * FROM integers s1 LEFT OUTER JOIN integers s2 ON (SELECT CASE WHEN s1.i+s2.i>10 THEN TRUE ELSE FALSE END) ORDER BY s1.i;
----
# left outer join on subquery only involving RHS works
query TT
SELECT * FROM integers s1 LEFT OUTER JOIN integers s2 ON s1.i=s2.i AND (SELECT CASE WHEN s2.i>2 THEN TRUE ELSE FALSE END) ORDER BY s1.i;
----
NULL NULL
1 NULL
2 NULL
3 3
# left outer join on subquery only involving LHS is not supported
statement error
SELECT * FROM integers s1 LEFT OUTER JOIN integers s2 ON s1.i=s2.i AND (SELECT CASE WHEN s1.i>2 THEN TRUE ELSE FALSE END) ORDER BY s1.i;
----
# left outer join in correlated expression
statement error
SELECT i, (SELECT SUM(s1.i) FROM integers s1 LEFT OUTER JOIN integers s2 ON s1.i=s2.i OR s1.i=i1.i-1) AS j FROM integers i1 ORDER BY i;
----
# REQUIRE(CHECK_COLUMN(result, 0, {Value(), 1, 2, 3}));
# REQUIRE(CHECK_COLUMN(result, 1, {Value(), 6, 9, 12}));
# full outer join: both sqlite and postgres actually cannot run this one
statement error
SELECT i, (SELECT SUM(s1.i) FROM integers s1 FULL OUTER JOIN integers s2 ON s1.i=s2.i OR s1.i=i1.i-1) AS j FROM integers i1 ORDER BY i;
----
# REQUIRE(CHECK_COLUMN(result, 0, {Value(), 1, 2, 3}));
# REQUIRE(CHECK_COLUMN(result, 1, {6, 6, 9, 12}));
# correlated expression inside window function not supported
statement error
SELECT i, (SELECT row_number() OVER (ORDER BY i)) FROM integers i1 ORDER BY i;
----
# union with correlated expression
query II
SELECT i, (SELECT i FROM integers WHERE i=i1.i UNION SELECT i FROM integers WHERE i=i1.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1
2 2
3 3
# except with correlated expression
query II
SELECT i, (SELECT i FROM integers WHERE i IS NOT NULL EXCEPT SELECT i FROM integers WHERE i<>i1.i) AS j FROM integers i1 WHERE i IS NOT NULL ORDER BY i;
----
1 1
2 2
3 3
# intersect with correlated expression
query II
SELECT i, (SELECT i FROM integers WHERE i=i1.i INTERSECT SELECT i FROM integers WHERE i=i1.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1
2 2
3 3
# multiple setops
query II
SELECT i, (SELECT i FROM integers WHERE i=i1.i UNION SELECT i FROM integers WHERE i<>i1.i EXCEPT SELECT i FROM integers WHERE i<>i1.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1
2 2
3 3
# uncorrelated query inside correlated query
query IR
SELECT i, (SELECT (SELECT SUM(i) FROM integers)+42+i1.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 49.000000
2 50.000000
3 51.000000

45
external/duckdb/test/sql/subquery/scalar/test_complex_nested_correlated_subquery.test vendored Normal file
View File

@@ -0,0 +1,45 @@
# name: test/sql/subquery/scalar/test_complex_nested_correlated_subquery.test
# description: Test nested correlated subqueries with multiple columns
# group: [scalar]
statement ok
CREATE TABLE tbl(a TINYINT, b SMALLINT, c INTEGER, d BIGINT, e VARCHAR, f DATE, g TIMESTAMP)
statement ok
INSERT INTO tbl VALUES (1, 2, 3, 4, '5', DATE '1992-01-01', TIMESTAMP '1992-01-01 00:00:00')
query T
SELECT EXISTS(SELECT t1.b+t1.c) FROM tbl t1
----
1
query I
SELECT t1.c+(SELECT t1.b FROM tbl t2 WHERE EXISTS(SELECT t1.b+t2.a)) FROM tbl t1
----
5
query I
SELECT 1 FROM tbl t1 JOIN tbl t2 ON (t1.d=t2.d) WHERE EXISTS(SELECT t1.c FROM tbl t3 WHERE t1.d+t3.c<100 AND EXISTS(SELECT t2.f < DATE '2000-01-01'))
----
1
query T
SELECT EXISTS(SELECT 1 WHERE (t1.c>100 OR 1) AND t1.d<100) FROM tbl t1
----
1
query T
SELECT EXISTS(SELECT t1.c,t1.d WHERE t1.d<100) FROM tbl t1
----
1
query TTTTTTTTTTTTTT
SELECT * FROM tbl t1 LEFT JOIN tbl t2 ON (SELECT t2.a)<100
----
1 2 3 4 5 1992-01-01 1992-01-01 00:00:00 1 2 3 4 5 1992-01-01 1992-01-01 00:00:00
query TTTTTTTTTTTTTT
SELECT * FROM tbl t1 LEFT JOIN tbl t2 ON (SELECT t2.a)>100
----
1 2 3 4 5 1992-01-01 1992-01-01 00:00:00 NULL NULL NULL NULL NULL NULL NULL

390
external/duckdb/test/sql/subquery/scalar/test_correlated_aggregate_subquery.test_slow vendored Normal file
View File

@@ -0,0 +1,390 @@
# name: test/sql/subquery/scalar/test_correlated_aggregate_subquery.test_slow
# description: Test correlated aggregate subqueries
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL)
# aggregate with correlation in final projection
query II
SELECT i, (SELECT MIN(i)+i1.i FROM integers) FROM integers i1 ORDER BY i;
----
NULL NULL
1 2
2 3
3 4
# aggregate with correlation inside aggregation
query II
SELECT i, (SELECT MIN(i+2*i1.i) FROM integers) FROM integers i1 ORDER BY i;
----
NULL NULL
1 3
2 5
3 7
query IRR
SELECT i, SUM(i), (SELECT SUM(i)+SUM(i1.i) FROM integers) FROM integers i1 GROUP BY i ORDER BY i;
----
NULL NULL NULL
1 1.000000 7.000000
2 2.000000 8.000000
3 3.000000 9.000000
query IRR
SELECT i, SUM(i), (SELECT SUM(i)+COUNT(i1.i) FROM integers) FROM integers i1 GROUP BY i ORDER BY i;
----
NULL NULL 6.000000
1 1.000000 7.000000
2 2.000000 7.000000
3 3.000000 7.000000
# correlated COUNT(*)
query II
SELECT i, (SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i) FROM integers i1 ORDER BY i;
----
NULL 0
1 2
2 1
3 0
# aggregate with correlation inside aggregation
query II
SELECT i, (SELECT MIN(i+2*i1.i) FROM integers) FROM integers i1 ORDER BY i;
----
NULL NULL
1 3
2 5
3 7
# aggregate ONLY inside subquery
query R
SELECT (SELECT SUM(i1.i)) FROM integers i1;
----
6.000000
# aggregate ONLY inside subquery, with column reference outside of subquery
query IR
SELECT MIN(i), (SELECT SUM(i1.i)) FROM integers i1;
----
1 6.000000
# this will fail, because "i" is not an aggregate but the SUM(i1.i) turns this query into an aggregate
statement error
SELECT i, (SELECT SUM(i1.i)) FROM integers i1;
----
statement error
SELECT i+1, (SELECT SUM(i1.i)) FROM integers i1;
----
query IR
SELECT MIN(i), (SELECT SUM(i1.i)) FROM integers i1;
----
1 6.000000
query RR
SELECT (SELECT SUM(i1.i)), (SELECT SUM(i1.i)) FROM integers i1;
----
6.000000 6.000000
# subquery inside aggregation
query RR
SELECT SUM(i), SUM((SELECT i FROM integers WHERE i=i1.i)) FROM integers i1;
----
6.000000 6.000000
query RR
SELECT SUM(i), (SELECT SUM(i) FROM integers WHERE i>SUM(i1.i)) FROM integers i1;
----
6.000000 NULL
# subquery with aggregation inside aggregation should fail
statement error
SELECT SUM((SELECT SUM(i))) FROM integers
----
# aggregate with correlation in filter
query II
SELECT i, (SELECT MIN(i) FROM integers WHERE i>i1.i) FROM integers i1 ORDER BY i;
----
NULL NULL
1 2
2 3
3 NULL
# aggregate with correlation in both filter and projection
query II
SELECT i, (SELECT MIN(i)+i1.i FROM integers WHERE i>i1.i) FROM integers i1 ORDER BY i;
----
NULL NULL
1 3
2 5
3 NULL
# aggregate with correlation in GROUP BY
query II
SELECT i, (SELECT MIN(i) FROM integers GROUP BY i1.i) AS j FROM integers i1 ORDER BY i;
----
NULL 1
1 1
2 1
3 1
# aggregate with correlation in HAVING clause
query II
SELECT i, (SELECT i FROM integers GROUP BY i HAVING i=i1.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1
2 2
3 3
# correlated subquery in HAVING
query IR
SELECT i1.i, SUM(i) FROM integers i1 GROUP BY i1.i HAVING SUM(i)=(SELECT MIN(i) FROM integers WHERE i<>i1.i+1) ORDER BY 1;
----
1 1.000000
query IR
SELECT i % 2 AS j, SUM(i) FROM integers i1 GROUP BY j HAVING SUM(i)=(SELECT SUM(i) FROM integers WHERE i<>j+1) ORDER BY 1;
----
1 4.000000
# aggregate query with non-aggregate subquery without group by
query R
SELECT (SELECT i+SUM(i1.i) FROM integers WHERE i=1 LIMIT 1) FROM integers i1;
----
7.000000
query R
SELECT (SELECT SUM(i)+SUM(i1.i) FROM integers) FROM integers i1 ORDER BY 1;
----
12.000000
query R
SELECT (SELECT SUM(i)+SUM((CASE WHEN i IS NOT NULL THEN i*0 ELSE 0 END)+i1.i) FROM integers) FROM integers i1 ORDER BY 1;
----
NULL
10.000000
14.000000
18.000000
# aggregate query with non-aggregate subquery with group by
query IR
SELECT i, (SELECT i+SUM(i1.i) FROM integers WHERE i=1) FROM integers i1 GROUP BY i ORDER BY i;
----
NULL NULL
1 2.000000
2 3.000000
3 4.000000
# subquery inside aggregate
query R
SELECT SUM((SELECT i+i1.i FROM integers WHERE i=1)) FROM integers i1;
----
9.000000
query IRR
SELECT i, SUM(i1.i), (SELECT SUM(i1.i)) AS k FROM integers i1 GROUP BY i ORDER BY i;
----
NULL NULL NULL
1 1.000000 1.000000
2 2.000000 2.000000
3 3.000000 3.000000
statement error
SELECT i, SUM(i1.i), (SELECT SUM(i1.i) FROM integers) AS k FROM integers i1 GROUP BY i ORDER BY i;
----
More than one row returned by a subquery
# aggregation of both entries inside subquery
# aggregate on group inside subquery
query IR
SELECT i1.i AS j, (SELECT SUM(j+i) FROM integers) AS k FROM integers i1 GROUP BY j ORDER BY j;
----
NULL NULL
1 9.000000
2 12.000000
3 15.000000
query R
SELECT (SELECT SUM(i1.i*i) FROM integers) FROM integers i1 ORDER BY i;
----
NULL
6.000000
12.000000
18.000000
query IRR
SELECT i, (SELECT SUM(i1.i)) AS k, (SELECT SUM(i1.i)) AS l FROM integers i1 GROUP BY i ORDER BY i;
----
NULL NULL NULL
1 1.000000 1.000000
2 2.000000 2.000000
3 3.000000 3.000000
# refer aggregation inside subquery
query IR
SELECT i, (SELECT SUM(i1.i)*SUM(i) FROM integers) AS k FROM integers i1 GROUP BY i ORDER BY i;
----
NULL NULL
1 6.000000
2 12.000000
3 18.000000
# refer to GROUP BY inside subquery
query IR
SELECT i AS j, (SELECT j*SUM(i) FROM integers) AS k FROM integers i1 GROUP BY j ORDER BY j;
----
NULL NULL
1 6.000000
2 12.000000
3 18.000000
# refer to GROUP BY without alias but with full name
query IR
SELECT i AS j, (SELECT i1.i*SUM(i) FROM integers) AS k FROM integers i1 GROUP BY j ORDER BY j;
----
NULL NULL
1 6.000000
2 12.000000
3 18.000000
# perform SUM on subquery
query IR
SELECT i, SUM((SELECT SUM(i)*i1.i FROM integers)) AS k FROM integers i1 GROUP BY i ORDER BY i;
----
NULL NULL
1 6.000000
2 12.000000
3 18.000000
# aggregate subqueries cannot be nested
statement error
SELECT i, SUM((SELECT SUM(i)*SUM(i1.i) FROM integers)) AS k FROM integers i1 GROUP BY i ORDER BY i;
----
# aggregation but ONLY inside subquery results in implicit aggregation
query R
SELECT (SELECT SUM(i1.i)) FROM integers i1;
----
6.000000
query IR
SELECT FIRST(i), (SELECT SUM(i1.i)) FROM integers i1;
----
1 6.000000
# aggregate that uses correlated column in aggregation
query II
SELECT i AS j, (SELECT MIN(i1.i) FROM integers GROUP BY i HAVING i=j) FROM integers i1 GROUP BY j ORDER BY j;
----
NULL NULL
1 1
2 2
3 3
# ORDER BY correlated subquery
query IR
SELECT i, SUM(i1.i) FROM integers i1 GROUP BY i ORDER BY (SELECT SUM(i1.i));
----
NULL NULL
1 1.000000
2 2.000000
3 3.000000
statement error
SELECT i, SUM(i1.i) FROM integers i1 GROUP BY i ORDER BY (SELECT SUM(i1.i) FROM integers);
----
More than one row returned by a subquery
# LIMIT 0 on correlated subquery
query IR
SELECT i, SUM((SELECT SUM(i)*i1.i FROM integers LIMIT 0)) AS k FROM integers i1 GROUP BY i ORDER BY i;
----
NULL NULL
1 NULL
2 NULL
3 NULL
# GROUP BY correlated subquery
query IR
SELECT (SELECT i+i1.i FROM integers WHERE i=1) AS k, SUM(i) AS j FROM integers i1 GROUP BY k ORDER BY 1;
----
NULL NULL
2 1.000000
3 2.000000
4 3.000000
# correlated subquery in WHERE
query R
SELECT SUM(i) FROM integers i1 WHERE i>(SELECT (i+i1.i)/2 FROM integers WHERE i=1);
----
5.000000
# correlated aggregate in WHERE
query R
SELECT SUM(i) FROM integers i1 WHERE i>(SELECT (SUM(i)+i1.i)/2 FROM integers WHERE i=1);
----
5.000000
# use scalar subquery as argument to ALL/ANY
query IT
SELECT i, (SELECT MIN(i) FROM integers WHERE i=i1.i) >= ALL(SELECT i FROM integers WHERE i IS NOT NULL) FROM integers i1 ORDER BY i;
----
NULL NULL
1 0
2 0
3 1
query IT
SELECT i, (SELECT MIN(i) FROM integers WHERE i<>i1.i) > ANY(SELECT i FROM integers WHERE i IS NOT NULL) FROM integers i1 ORDER BY i;
----
NULL NULL
1 1
2 0
3 0
query IT
SELECT i, NOT((SELECT MIN(i) FROM integers WHERE i<>i1.i) > ANY(SELECT i FROM integers WHERE i IS NOT NULL)) FROM integers i1 ORDER BY i;
----
NULL NULL
1 0
2 1
3 1
# aggregates with multiple parameters
query R
SELECT (SELECT COVAR_POP(i1.i, i2.i) FROM integers i2) FROM integers i1 ORDER BY 1
----
NULL
0.000000
0.000000
0.000000
query R
SELECT (SELECT COVAR_POP(i2.i, i1.i) FROM integers i2) FROM integers i1 ORDER BY 1
----
NULL
0.000000
0.000000
0.000000
query R
SELECT (SELECT COVAR_POP(i1.i+i2.i, i1.i+i2.i) FROM integers i2) FROM integers i1 ORDER BY 1
----
NULL
0.666667
0.666667
0.666667

62
external/duckdb/test/sql/subquery/scalar/test_correlated_grouping_set.test vendored Normal file
View File

@@ -0,0 +1,62 @@
# name: test/sql/subquery/scalar/test_correlated_grouping_set.test
# description: Test correlated aggregate subqueries
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
# aggregate with correlation in GROUPING SET
query II
SELECT i, (SELECT COUNT(*) FROM (SELECT i1.i FROM integers GROUP BY GROUPING SETS(i1.i)) tbl) AS j FROM integers i1 ORDER BY i;
----
NULL 1
1 1
2 1
3 1
# many grouping sets
query II
SELECT i, (SELECT COUNT(*) FROM (SELECT i1.i FROM integers GROUP BY GROUPING SETS((i1.i), (), (i1.i), (i1.i, i1.i))) tbl) AS j FROM integers i1 ORDER BY i;
----
NULL 4
1 4
2 4
3 4
# rollup
query II
SELECT i, (SELECT COUNT(*) FROM (SELECT i1.i FROM integers GROUP BY ROLLUP (i1.i, i1.i, i1.i, i1.i)) tbl) AS j FROM integers i1 ORDER BY i;
----
NULL 5
1 5
2 5
3 5
# cube
query II
SELECT i, (SELECT COUNT(*) FROM (SELECT i1.i FROM integers GROUP BY CUBE (i1.i, i1.i, i1.i, i1.i)) tbl) AS j FROM integers i1 ORDER BY i;
----
NULL 16
1 16
2 16
3 16
# aggregate with correlation in GROUPING SET and HAVING
# FIXME: this is borked, related to #2335
mode skip
query II
SELECT i, (SELECT MIN(i) FROM integers GROUP BY GROUPING SETS(i1.i, i) HAVING i1.i=i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 NULL
2 NULL
3 NULL
mode unskip

37
external/duckdb/test/sql/subquery/scalar/test_correlated_set_op.test vendored Normal file
View File

@@ -0,0 +1,37 @@
# name: test/sql/subquery/scalar/test_correlated_set_op.test
# description: Test correlated subqueries with set operations
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
# scalar select with correlation in different UNION ALL branches
query II
SELECT i, (SELECT SUM(x) FROM (SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT i1.i) t(x)) FROM integers i1 ORDER BY i;
----
NULL 3
1 4
2 5
3 6
query II
SELECT i, (SELECT SUM(x) FROM (SELECT i1.i UNION ALL SELECT 2 UNION ALL SELECT 1) t(x)) FROM integers i1 ORDER BY i;
----
NULL 3
1 4
2 5
3 6
query II
SELECT i, (SELECT SUM(x) FROM (SELECT 2 UNION ALL SELECT i1.i UNION ALL SELECT 1) t(x)) FROM integers i1 ORDER BY i;
----
NULL 3
1 4
2 5
3 6

15
external/duckdb/test/sql/subquery/scalar/test_correlated_side_effects.test vendored Normal file
View File

@@ -0,0 +1,15 @@
# name: test/sql/subquery/scalar/test_correlated_side_effects.test
# description: Test correlated subqueries with side effects
# group: [scalar]
# FIXME: we should not perform duplicate elimination for subqueries that have side-effects
mode skip
query I
SELECT COUNT(DISTINCT
(SELECT concat(gen_random_uuid()::VARCHAR, r::VARCHAR))
) as total_seats
FROM (SELECT 1 FROM generate_series(1, 100, 1)) AS t(r)
----
100

198
external/duckdb/test/sql/subquery/scalar/test_correlated_subquery.test vendored Normal file
View File

@@ -0,0 +1,198 @@
# name: test/sql/subquery/scalar/test_correlated_subquery.test
# description: Test correlated subqueries
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
# scalar select with correlation
query II
SELECT i, (SELECT 42+i1.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 43
2 44
3 45
# ORDER BY correlated subquery
query I
SELECT i FROM integers i1 ORDER BY (SELECT 100-i1.i);
----
NULL
3
2
1
# subquery returning multiple results
statement error
SELECT i, (SELECT 42+i1.i FROM integers) AS j FROM integers i1 ORDER BY i;
----
More than one row returned by a subquery used as an expression
statement ok
SET scalar_subquery_error_on_multiple_rows=false
query II
SELECT i, (SELECT 42+i1.i FROM integers) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 43
2 44
3 45
statement ok
SET scalar_subquery_error_on_multiple_rows=true
# subquery with LIMIT
query II
SELECT i, (SELECT 42+i1.i FROM integers LIMIT 1) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 43
2 44
3 45
# subquery with LIMIT 0
query II
SELECT i, (SELECT 42+i1.i FROM integers LIMIT 0) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 NULL
2 NULL
3 NULL
# subquery with WHERE clause that is always FALSE
query II
SELECT i, (SELECT i FROM integers WHERE 1=0 AND i1.i=i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 NULL
2 NULL
3 NULL
# correlated EXISTS with WHERE clause that is always FALSE
query IT
SELECT i, EXISTS(SELECT i FROM integers WHERE 1=0 AND i1.i=i) AS j FROM integers i1 ORDER BY i;
----
NULL 0
1 0
2 0
3 0
# correlated ANY with WHERE clause that is always FALSE
query IT
SELECT i, i=ANY(SELECT i FROM integers WHERE 1=0 AND i1.i=i) AS j FROM integers i1 ORDER BY i;
----
NULL 0
1 0
2 0
3 0
# subquery with OFFSET
query II
SELECT i, (SELECT i+i1.i FROM integers ORDER BY ALL LIMIT 1 OFFSET 1) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 2
2 3
3 4
# subquery with OFFSET and without LIMIT
query I
select (select val + i from generate_series(1, 2, 1) t(i) offset 1) from (select 42 val) t;
----
44
# subquery with OFFSET and without LIMIT with ORDER BY
query II
select i, (select i1.i + i + i from generate_series(1, 100, 1) t(i) ORDER BY i DESC OFFSET 99) from integers i1 order by i;
----
NULL NULL
1 3
2 4
3 5
# subquery with ORDER BY
query II
SELECT i, (SELECT i+i1.i FROM integers ORDER BY i NULLS LAST LIMIT 1) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 2
2 3
3 4
query II
SELECT i, (SELECT i+i1.i FROM integers ORDER BY i NULLS LAST LIMIT 1 OFFSET 1) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 3
2 4
3 5
# correlated filter without FROM clause
query II
SELECT i, (SELECT 42 WHERE i1.i>2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 NULL
2 NULL
3 42
# correlated filter with matching entry on NULL
query II
SELECT i, (SELECT 42 WHERE i1.i IS NULL) AS j FROM integers i1 ORDER BY i;
----
NULL 42
1 NULL
2 NULL
3 NULL
# scalar select with correlation in projection
query II
SELECT i, (SELECT i+i1.i FROM integers WHERE i=1) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 2
2 3
3 4
# scalar select with correlation in filter
query II
SELECT i, (SELECT i FROM integers WHERE i=i1.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1
2 2
3 3
# scalar select with operation in projection
query II
SELECT i, (SELECT i+1 FROM integers WHERE i=i1.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 2
2 3
3 4
# correlated scalar select with constant in projection
query II
SELECT i, (SELECT 42 FROM integers WHERE i=i1.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 42
2 42
3 42
query II
SELECT i, (SELECT CASE WHEN sum(i) > 1 THEN 0 ELSE 1 END FROM integers WHERE i=i1.i) FROM integers i1;
----
1 1
2 0
3 0
NULL 1

167
external/duckdb/test/sql/subquery/scalar/test_correlated_subquery_cte.test vendored Normal file
View File

@@ -0,0 +1,167 @@
# name: test/sql/subquery/scalar/test_correlated_subquery_cte.test
# description: Test correlated subqueries
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL)
require no_alternative_verify
# scalar select with correlation
query II
SELECT i, (WITH i2 AS (SELECT 42+i1.i AS j) SELECT j FROM i2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 43
2 44
3 45
# ORDER BY correlated subquery
query I
SELECT i FROM integers i1 ORDER BY (WITH i2 AS (SELECT 100-i1.i as j) SELECT j FROM i2);
----
NULL
3
2
1
# subquery returning multiple results
statement error
SELECT i, (WITH i2 AS (SELECT 42+i1.i AS j FROM integers) SELECT j FROM i2) AS j FROM integers i1 ORDER BY i;
----
More than one row returned by a subquery
statement ok
SET scalar_subquery_error_on_multiple_rows=false
query II
SELECT i, (WITH i2 AS (SELECT 42+i1.i AS j FROM integers) SELECT j FROM i2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 43
2 44
3 45
# subquery with LIMIT
query II
SELECT i, (WITH i2 AS (SELECT 42+i1.i AS j FROM integers) SELECT j FROM i2 LIMIT 1) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 43
2 44
3 45
# subquery with LIMIT 0
query II
SELECT i, (WITH i2 AS (SELECT 42+i1.i AS j FROM integers) SELECT j FROM i2 LIMIT 0) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 NULL
2 NULL
3 NULL
# subquery with WHERE clause that is always FALSE
query II
SELECT i, (WITH i2 AS (SELECT i FROM integers WHERE 1=0 AND i1.i=i) SELECT i FROM i2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 NULL
2 NULL
3 NULL
# correlated EXISTS with WHERE clause that is always FALSE
query IT
SELECT i, EXISTS(WITH i2 AS (SELECT i FROM integers WHERE 1=0 AND i1.i=i) SELECT i FROM i2) AS j FROM integers i1 ORDER BY i;
----
NULL 0
1 0
2 0
3 0
# correlated ANY with WHERE clause that is always FALSE
query IT
SELECT i, i=ANY(WITH i2 AS (SELECT i FROM integers WHERE 1=0 AND i1.i=i) SELECT i FROM i2) AS j FROM integers i1 ORDER BY i;
----
NULL 0
1 0
2 0
3 0
# subquery with OFFSET
query II
SELECT i, (WITH i2 AS (SELECT i+i1.i FROM integers ORDER BY ALL LIMIT 1 OFFSET 1) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 2
2 3
3 4
# subquery with ORDER BY
query II
SELECT i, (WITH i2 AS (SELECT i+i1.i FROM integers ORDER BY 1 NULLS LAST LIMIT 1 OFFSET 1) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 3
2 4
3 5
# correlated filter without FROM clause
query II
SELECT i, (WITH i2 AS (SELECT 42 WHERE i1.i>2) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 NULL
2 NULL
3 42
# correlated filter with matching entry on NULL
query II
SELECT i, (WITH i2 AS (SELECT 42 WHERE i1.i IS NULL) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i;
----
NULL 42
1 NULL
2 NULL
3 NULL
# scalar select with correlation in projection
query II
SELECT i, (WITH i2 AS (SELECT i+i1.i FROM integers WHERE i=1) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 2
2 3
3 4
# scalar select with correlation in filter
query II
SELECT i, (WITH i2 AS (SELECT i FROM integers WHERE i=i1.i) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1
2 2
3 3
# scalar select with operation in projection
query II
SELECT i, (WITH i2 AS (SELECT i+1 FROM integers WHERE i=i1.i) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 2
2 3
3 4
# correlated scalar select with constant in projection
query II
SELECT i, (WITH i2 AS (SELECT 42 FROM integers WHERE i=i1.i) SELECT * FROM i2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 42
2 42
3 42

20
external/duckdb/test/sql/subquery/scalar/test_correlated_subquery_where.test vendored Normal file
View File

@@ -0,0 +1,20 @@
# name: test/sql/subquery/scalar/test_correlated_subquery_where.test
# description: Test correlated subqueries in WHERE clause
# group: [scalar]
statement ok
CREATE TABLE test AS FROM VALUES (1, 22), (1, 21), (2, 22) v(id, b);
# correlated subquery with one correlated expression
query II rowsort
SELECT * FROM test WHERE b=(SELECT MIN(b) FROM test AS a WHERE a.id=test.id)
----
1 21
2 22
# correlated subquery with two correlated expressions
query II rowsort
SELECT * FROM test WHERE b=(SELECT MIN(b) FROM test AS a WHERE a.id=test.id AND a.id < test.b)
----
1 21
2 22

51
external/duckdb/test/sql/subquery/scalar/test_correlated_window.test vendored Normal file
View File

@@ -0,0 +1,51 @@
# name: test/sql/subquery/scalar/test_correlated_window.test
# description: Test correlated window functions
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
# FIXME - why not?
statement error
SELECT i, (SELECT SUM(i + 1) OVER ()) FROM integers ORDER BY i
----
not supported
query II
SELECT i, (SELECT SUM((SELECT i + 1)) OVER ()) FROM integers ORDER BY i
----
NULL NULL
1 2
2 3
3 4
query II
SELECT i, (SELECT SUM((SELECT i + 1)) OVER () WHERE i>=2) FROM integers ORDER BY i
----
NULL NULL
1 NULL
2 3
3 4
# mix of aggregates and windows
query II
SELECT i, (SELECT SUM((SELECT SUM(i))) OVER ()) FROM integers GROUP BY i ORDER BY i
----
NULL NULL
1 1
2 2
3 3
query II
SELECT i, (SELECT SUM(win) FROM (SELECT SUM((SELECT i1.i + integers.i)) OVER () AS win FROM integers i1) t) FROM integers ORDER BY i
----
NULL NULL
1 36
2 48
3 60

100
external/duckdb/test/sql/subquery/scalar/test_count_star_subquery.test vendored Normal file
View File

@@ -0,0 +1,100 @@
# name: test/sql/subquery/scalar/test_count_star_subquery.test
# description: Test for COUNT(*) and SUM(i) IS NULL in subqueries
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
# COUNT(*) and SUM(i) IS NULL aggregates
query II
SELECT i, (SELECT i FROM integers i2 WHERE i=(SELECT SUM(i) FROM integers i2 WHERE i2.i>i1.i)) FROM integers i1 ORDER BY 1;
----
NULL NULL
1 NULL
2 3
3 NULL
query IT
SELECT i, (SELECT SUM(i) IS NULL FROM integers i2 WHERE i2.i>i1.i) FROM integers i1 ORDER BY i;
----
NULL 1
1 0
2 0
3 1
query II
SELECT i, (SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i) FROM integers i1 ORDER BY i;
----
NULL 0
1 2
2 1
3 0
query II
SELECT i, (SELECT COUNT(i) FROM integers i2 WHERE i2.i>i1.i OR i2.i IS NULL) FROM integers i1 ORDER BY i;
----
NULL 0
1 2
2 1
3 0
query II
SELECT i, (SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i OR i2.i IS NULL) FROM integers i1 ORDER BY i;
----
NULL 1
1 3
2 2
3 1
query II
SELECT i, (SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i OR (i1.i IS NULL AND i2.i IS NULL)) FROM integers i1 ORDER BY i;
----
NULL 1
1 2
2 1
3 0
query I
SELECT i FROM integers i1 WHERE (SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i)=0 ORDER BY i;
----
NULL
3
query II
SELECT i, (SELECT i FROM integers i2 WHERE i-2=(SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i)) FROM integers i1 ORDER BY 1;
----
NULL 2
1 NULL
2 3
3 2
query II
SELECT i, (SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i GROUP BY i1.i) FROM integers i1 ORDER BY i;
----
NULL NULL
1 2
2 1
3 NULL
query II
SELECT i, (SELECT CASE WHEN (SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i)=0 THEN 1 ELSE 0 END) FROM integers i1 ORDER BY i;
----
NULL 1
1 0
2 0
3 1
query II
SELECT i, (SELECT COUNT(*) FROM integers i2 WHERE i2.i>i1.i) FROM integers i1 ORDER BY i;
----
NULL 0
1 2
2 1
3 0

31
external/duckdb/test/sql/subquery/scalar/test_delete_subquery.test vendored Normal file
View File

@@ -0,0 +1,31 @@
# name: test/sql/subquery/scalar/test_delete_subquery.test
# description: Test subqueries in delete
# group: [scalar]
statement ok
CREATE TABLE integers(id INTEGER, i INTEGER)
statement ok
INSERT INTO integers VALUES (1, 1), (2, 2), (3, 3), (4, NULL)
# correlated subquery in delete
statement ok
DELETE FROM integers i1 WHERE i>(SELECT MAX(i) FROM integers WHERE i1.i<>i)
query II
SELECT id, i FROM integers ORDER BY id
----
1 1
2 2
4 NULL
# uncorrelated subquery in delete
statement ok
DELETE FROM integers i1 WHERE i=(SELECT MAX(i) FROM integers)
query II
SELECT id, i FROM integers ORDER BY id
----
1 1
4 NULL

141
external/duckdb/test/sql/subquery/scalar/test_grouped_correlated_subquery.test vendored Normal file
View File

@@ -0,0 +1,141 @@
# name: test/sql/subquery/scalar/test_grouped_correlated_subquery.test
# description: Test correlated subquery with grouping columns
# group: [scalar]
statement ok
CREATE TABLE tbl_ProductSales (ColID int, Product_Category varchar(64), Product_Name varchar(64), TotalSales int);
statement ok
CREATE TABLE another_T (col1 INT, col2 INT, col3 INT, col4 INT, col5 INT, col6 INT, col7 INT, col8 INT);
statement ok
INSERT INTO tbl_ProductSales VALUES (1,'Game','Mobo Game',200),(2,'Game','PKO Game',400),(3,'Fashion','Shirt',500),(4,'Fashion','Shorts',100);
statement ok
INSERT INTO another_T VALUES (1,2,3,4,5,6,7,8), (11,22,33,44,55,66,77,88), (111,222,333,444,555,666,777,888), (1111,2222,3333,4444,5555,6666,7777,8888);
query T
SELECT col1 IN (SELECT ColID FROM tbl_ProductSales) FROM another_T;
----
1
0
0
0
query T
SELECT col1 IN (SELECT ColID + col1 FROM tbl_ProductSales) FROM another_T;
----
0
0
0
0
query T
SELECT col1 IN (SELECT ColID + col1 FROM tbl_ProductSales) FROM another_T GROUP BY col1;
----
0
0
0
0
query T
SELECT col1 IN (SELECT ColID + another_T.col1 FROM tbl_ProductSales) FROM another_T GROUP BY col1;
----
0
0
0
0
query IT
SELECT (col1 + 1) AS k, k IN (SELECT ColID + k FROM tbl_ProductSales) FROM another_T GROUP BY k ORDER BY 1;
----
2 0
12 0
112 0
1112 0
# controversial: this fails in postgres but succeeds in sqlite
# col1 + 1 is a grouping column so could theoretically be used in the subquery
# but as it is not a column reference directly we fail to bind it here
statement error
SELECT (col1 + 1) IN (SELECT ColID + (col1 + 1) FROM tbl_ProductSales) FROM another_T GROUP BY (col1 + 1);
----
<REGEX>:.*Binder Error.*must be part of an aggregate function.*
# this should fail, col1 + 42 is not a grouping column
statement error
SELECT col1+1, col1+42 FROM another_T GROUP BY col1+1;
----
<REGEX>:.*Binder Error.*must be part of an aggregate function.*
# this should also fail, col1 + 42 is not a grouping column
statement error
SELECT (col1 + 1) IN (SELECT ColID + (col1 + 42) FROM tbl_ProductSales) FROM another_T GROUP BY (col1 + 1);
----
<REGEX>:.*Binder Error.*must be part of an aggregate function.*
# having without GROUP BY in subquery
query T
SELECT col5 = ALL (SELECT 1 FROM tbl_ProductSales HAVING MIN(col8) IS NULL) FROM another_T GROUP BY col1, col2, col5, col8;
----
1
1
1
1
query I
SELECT CASE WHEN 1 IN (SELECT MAX(col7) UNION ALL (SELECT MIN(ColID) FROM tbl_ProductSales INNER JOIN another_T t2 ON t2.col5 = t2.col1)) THEN 2 ELSE NULL END FROM another_T t1;
----
NULL
query I
SELECT CASE WHEN 1 IN (SELECT (SELECT MAX(col7))) THEN 2 ELSE NULL END FROM another_T t1;
----
NULL
# UNION ALL with correlated subquery on either side
query I
SELECT CASE WHEN 1 IN (SELECT (SELECT MAX(col7)) UNION ALL (SELECT MIN(ColID) FROM tbl_ProductSales INNER JOIN another_T t2 ON t2.col5 = t2.col1)) THEN 2 ELSE NULL END FROM another_T t1;
----
NULL
query I
SELECT CASE WHEN 1 IN (SELECT (SELECT MIN(ColID) FROM tbl_ProductSales INNER JOIN another_T t2 ON t2.col5 = t2.col1) UNION ALL (SELECT MAX(col7))) THEN 2 ELSE NULL END FROM another_T t1;
----
NULL
# correlated column comparison with correlated subquery
query I
SELECT (SELECT MIN(ColID) FROM tbl_ProductSales INNER JOIN another_T t2 ON t1.col7 <> (SELECT MAX(t1.col1 + t3.col4) FROM another_T t3)) FROM another_T t1;
----
1
1
1
1
query I
SELECT (SELECT MIN(ColID) FROM tbl_ProductSales INNER JOIN another_T t2 ON t1.col7 <> ANY(SELECT MAX(t1.col1 + t3.col4) FROM another_T t3)) FROM another_T t1;
----
1
1
1
1
# LEFT JOIN between correlated columns not supported for now
statement error
SELECT CASE WHEN NOT col1 NOT IN (SELECT (SELECT MAX(col7)) UNION (SELECT MIN(ColID) FROM tbl_ProductSales LEFT JOIN another_T t2 ON t2.col5 = t1.col1)) THEN 1 ELSE 2 END FROM another_T t1 GROUP BY col1 ORDER BY 1;
----
<REGEX>:.*Not implemented Error.*Non-inner join on correlated columns not supported.*
# REQUIRE(CHECK_COLUMN(result, 0, {1, 2, 2, 2}));
# correlated columns in window functions not supported yet
statement error
SELECT EXISTS (SELECT RANK() OVER (PARTITION BY SUM(DISTINCT col5))) FROM another_T t1;
----
<REGEX>:.*Binder Error.*not supported.*
# REQUIRE(CHECK_COLUMN(result, 0, {true}));
statement error
SELECT (SELECT SUM(col2) OVER (PARTITION BY SUM(col2) ORDER BY MAX(col1 + ColID) ROWS UNBOUNDED PRECEDING) FROM tbl_ProductSales) FROM another_T t1 GROUP BY col1
----
<REGEX>:.*Binder Error.*not supported.*

29
external/duckdb/test/sql/subquery/scalar/test_issue_4216.test vendored Normal file
View File

@@ -0,0 +1,29 @@
# name: test/sql/subquery/scalar/test_issue_4216.test
# description: Issue 4216: DELIM_JOIN doesn't propagate statistics correctly.
# group: [scalar]
statement ok
CREATE TABLE test (x INT, y INT)
statement ok
INSERT INTO test VALUES (1, 1), (2, 2)
query I
SELECT (SELECT y FROM test t2 WHERE t1.x = 5) FROM test t1
----
NULL
NULL
query I
SELECT (SELECT y FROM test t2 WHERE t1.x = 5) IS NULL FROM test t1
----
TRUE
TRUE
query I
SELECT (SELECT y FROM test t2 WHERE t1.x = 5) IS NOT NULL FROM test t1
----
FALSE
FALSE

61
external/duckdb/test/sql/subquery/scalar/test_issue_6136.test vendored Normal file
View File

@@ -0,0 +1,61 @@
# name: test/sql/subquery/scalar/test_issue_6136.test
# description: Issue 6136: Segfault when running query with correlated subqueries
# group: [scalar]
statement ok
create table r as select * from values (1, 1, 'a', 'A'), (1, null, 'b', 'B'), (1, 2, 'c', 'C'), (2, null, 'd', 'D') t(ra, rb, x, y);
statement ok
create table b as select * from values (1, 1, 1), (2, 1, 2), (3, 1, 3), (4, 1, null), (5, 2, 1), (6, 2, null), (7, 99, 99) t(id, ba, bb);
statement ok
select
(select {'__matches': count(*)} from r where ba = ra and bb = rb group by ra, rb) as ref1,
from b;
statement error
select
id,
ba,
bb,
coalesce((select {'x': first(x), 'y': first(y), '__matches': count(*)} from r where ba = ra and bb = rb group by ra, rb), {'x': null, 'y': null, '__matches': 0}) as ref1,
coalesce((select {'x': first(x), 'y': first(y), '__matches': count(*)} from r where ba = ra and (bb = rb or rb is null) group by ra, rb order by bb = rb), {'x': null, 'y': null, '__matches': 0}) as ref2,
coalesce((select {'x': first(x), 'y': first(y), '__matches': count(*)} from r where (ba = ra or ra is null) and (bb = rb or rb is null) group by ra, rb order by ba = ra, bb = rb), {'x': null, 'y': null, '__matches': 0}) as ref3,
coalesce((select {'x': first(x), 'y': first(y), '__matches': count(*)} from r where (ba = ra or ra is null) group by ra order by ba = ra), {'x': null, 'y': null, '__matches': 0}) as ref4,
from b
----
More than one row returned by a subquery
statement ok
SET scalar_subquery_error_on_multiple_rows=false
# this is non-deterministic since the subqueries return multiple rows
statement ok
select
id,
ba,
bb,
coalesce((select {'x': first(x), 'y': first(y), '__matches': count(*)} from r where ba = ra and bb = rb group by ra, rb), {'x': null, 'y': null, '__matches': 0}) as ref1,
coalesce((select {'x': first(x), 'y': first(y), '__matches': count(*)} from r where ba = ra and (bb = rb or rb is null) group by ra, rb order by bb = rb), {'x': null, 'y': null, '__matches': 0}) as ref2,
coalesce((select {'x': first(x), 'y': first(y), '__matches': count(*)} from r where (ba = ra or ra is null) and (bb = rb or rb is null) group by ra, rb order by ba = ra, bb = rb), {'x': null, 'y': null, '__matches': 0}) as ref3,
coalesce((select {'x': first(x), 'y': first(y), '__matches': count(*)} from r where (ba = ra or ra is null) group by ra order by ba = ra), {'x': null, 'y': null, '__matches': 0}) as ref4,
from b
# postgres compatible variant
query IIIII
select
id,
ba,
bb,
coalesce((select ROW(min(x), min(y), count(*)) from r where ba = ra and bb = rb group by ra, rb), ROW(null, null, 0)) as ref1,
coalesce((select ROW(min(x), min(y), count(*)) from r where (ba = ra or ra is null) group by ra order by ba = ra), ROW(null, null, 0)) as ref4
from b
ORDER BY 1, 2, 3;
----
1 1 1 (a, A, 1) (a, A, 3)
2 1 2 (c, C, 1) (a, A, 3)
3 1 3 (NULL, NULL, 0) (a, A, 3)
4 1 NULL (NULL, NULL, 0) (a, A, 3)
5 2 1 (NULL, NULL, 0) (d, D, 1)
6 2 NULL (NULL, NULL, 0) (d, D, 1)
7 99 99 (NULL, NULL, 0) (NULL, NULL, 0)

84
external/duckdb/test/sql/subquery/scalar/test_issue_6184.test vendored Normal file
View File

@@ -0,0 +1,84 @@
# name: test/sql/subquery/scalar/test_issue_6184.test
# description: Issue 6184: INTERNAL Error: Invalid PhysicalType for GetTypeIdSize for certain queries
# group: [scalar]
statement ok
CREATE TABLE t1(fuel_type VARCHAR, location_country VARCHAR);
statement ok
INSERT INTO t1 VALUES('natural_gas', 'US');
statement ok
CREATE TABLE t2(__input_row_id BIGINT, "__input.fuel" VARCHAR);
statement ok
INSERT INTO t2 VALUES(1, 'natural_gas');
query I
SELECT (
SELECT NULL
FROM
(
SELECT fuel_type, location_country
FROM "t1"
WHERE "fuel_type" IS NOT DISTINCT FROM "__input.fuel"
LIMIT 1
) t1)
FROM t2 AS __p;
----
NULL
require json
statement ok
WITH __activity_data AS
(
SELECT *
FROM
(
VALUES ( 'natural_gas', 'US', 'PGE', 'CA', 'SF', json('{}'))
) AS t("fuel", "country", "grid", "state", "city", tags)
), "fuel_kgco2e_per_mmbtu" AS
(
SELECT *
,ROW_NUMBER() over () AS row_id
FROM
( VALUES ('natural_gas', 'US', NULL, 'CA', 'SF', 2),
) AS t( fuel_type, location_country, location_grid, location_state, location_city, kgco2e_per_mmbtu)
), __input AS
(
SELECT *
,ROW_NUMBER() OVER () AS __input_row_id
FROM "__activity_data"
), "fuel_kgco2e_per_mmbtu__1" AS
(
SELECT *
,ROW_NUMBER() OVER () AS __row_id
FROM "fuel_kgco2e_per_mmbtu"
), __stage0 AS
(
SELECT __input_row_id
,fuel AS "__input.fuel"
,country AS "__input.country"
,grid AS "__input.grid"
,state AS "__input.state"
,city AS "__input.city"
FROM __input
)
SELECT __p.*
,(
SELECT { 'kgco2e_per_mmbtu': FIRST("kgco2e_per_mmbtu")
,__row_id: FIRST(__row_id)
,__candidates: LIST(__row_id) }
FROM
(
SELECT *
FROM "fuel_kgco2e_per_mmbtu__1"
WHERE "fuel_type" IS NOT DISTINCT
FROM "__input.fuel"
ORDER BY "location_country" IS NOT NULL DESC, "location_grid" IS NOT NULL DESC, "location_state" IS NOT NULL DESC, "location_city" IS NOT NULL DESC
LIMIT 1
)
GROUP BY TRUE ) AS __ref1
,CAST(1 AS DOUBLE) AS "__p.__functional_unit__"
FROM __stage0 AS __p;

43
external/duckdb/test/sql/subquery/scalar/test_issue_7079.test vendored Normal file
View File

@@ -0,0 +1,43 @@
# name: test/sql/subquery/scalar/test_issue_7079.test
# description: Issue 7079: Coalesce function not functioning properly in DuckDB macro function
# group: [scalar]
statement ok
CREATE MACRO array_rv(arr) AS (
SELECT CASE WHEN l IS NOT NULL THEN l ELSE arr END
FROM (
SELECT array_agg(elm ORDER BY g DESC) as l
FROM (SELECT generate_subscripts(arr, 1) AS g, arr[g] AS elm)
)
);
statement ok
CREATE MACRO array_rv_coal(arr) AS (
SELECT COALESCE(l,arr)
FROM (
SELECT array_agg(elm ORDER BY g DESC) as l
FROM (SELECT generate_subscripts(arr, 1) AS g, arr[g] AS elm)
)
);
statement ok
CREATE TABLE t AS (
SELECT [1, 2, 3] AS arr UNION ALL
SELECT [4, 5] AS arr UNION ALL
SELECT [] AS arr
);
query I
SELECT array_rv(arr) FROM t ORDER BY arr;
----
[]
[3, 2, 1]
[5, 4]
query I
SELECT array_rv_coal(arr) FROM t ORDER BY arr;
----
[]
[3, 2, 1]
[5, 4]

19
external/duckdb/test/sql/subquery/scalar/test_join_in_subquery.test vendored Normal file
View File

@@ -0,0 +1,19 @@
# name: test/sql/subquery/scalar/test_join_in_subquery.test
# description: Joins in subqueries
# group: [scalar]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE test AS FROM VALUES (1, 22), (1, 21), (2, 22) v(id, test_value);
statement ok
CREATE TABLE test2 AS FROM VALUES (1, 44), (2, 42) v(id, test2_value);
query IIII rowsort
SELECT * FROM test, test2 WHERE test.id=test2.id AND test_value*test2_value=(SELECT MIN(test_value*test2_value) FROM test AS a, test2 WHERE a.id=test.id AND a.id=test2.id)
----
1 21 1 44
2 22 2 42

68
external/duckdb/test/sql/subquery/scalar/test_many_correlated_columns.test vendored Normal file
View File

@@ -0,0 +1,68 @@
# name: test/sql/subquery/scalar/test_many_correlated_columns.test
# description: Test multiple correlated columns and strings
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
# multiple correlated columns and strings
statement ok
CREATE TABLE test (a INTEGER, b INTEGER, str VARCHAR);
statement ok
INSERT INTO test VALUES (11, 1, 'a'), (12, 2, 'b'), (13, 3, 'c')
statement ok
CREATE TABLE test2 (a INTEGER, c INTEGER, str2 VARCHAR);
statement ok
INSERT INTO test2 VALUES (11, 1, 'a'), (12, 1, 'b'), (13, 4, 'b')
query IRR
SELECT a, SUM(a), (SELECT SUM(a)+SUM(t1.b) FROM test) FROM test t1 GROUP BY a ORDER BY a;
----
11 11.000000 37.000000
12 12.000000 38.000000
13 13.000000 39.000000
# scalar query with multiple correlated columns
query R
SELECT (SELECT test.a+test.b+SUM(test2.a) FROM test2 WHERE str=str2) FROM test ORDER BY 1;
----
NULL
23.000000
39.000000
# exists with multiple correlated columns
query IIT
SELECT * FROM test WHERE EXISTS(SELECT * FROM test2 WHERE test.a=test2.a AND test.b<>test2.c) order by b;
----
12 2 b
13 3 c
# ANY with multiple correlated columns
query IT
SELECT a, a>=ANY(SELECT test2.a+c-b FROM test2 WHERE c>=b AND str=str2) FROM test ORDER BY 1;
----
11 1
12 0
13 0
# string comparison
query TT
SELECT str, str=ANY(SELECT str2 FROM test2) FROM test
----
a 1
b 1
c 0
query TT
SELECT str, str=ANY(SELECT str2 FROM test2 WHERE test.a<>test2.a) FROM test
----
a 0
b 1
c 0

333
external/duckdb/test/sql/subquery/scalar/test_nested_correlated_subquery.test_slow vendored Normal file
View File

@@ -0,0 +1,333 @@
# name: test/sql/subquery/scalar/test_nested_correlated_subquery.test_slow
# description: Test nested correlated subqueries
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL)
# nested correlated queries
query II
SELECT i, (SELECT (SELECT 42+i1.i)+42+i1.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 86
2 88
3 90
query II
SELECT i, (SELECT (SELECT (SELECT (SELECT 42+i1.i)++i1.i)+42+i1.i)+42+i1.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 130
2 134
3 138
query IR
SELECT i, (SELECT (SELECT i1.i+SUM(i2.i)) FROM integers i2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 7.000000
2 8.000000
3 9.000000
# correlated query inside uncorrelated query
query II
SELECT i, (SELECT (SELECT (SELECT (SELECT i1.i+i1.i+i1.i+i1.i+i1.i)))) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 5
2 10
3 15
query IR
SELECT i, (SELECT SUM(i)+(SELECT 42+i1.i) FROM integers) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 49.000000
2 50.000000
3 51.000000
query IR
SELECT i, (SELECT ((SELECT ((SELECT ((SELECT SUM(i)+SUM(i4.i)+SUM(i3.i)+SUM(i2.i)+SUM(i1.i) FROM integers i5)) FROM integers i4)) FROM integers i3)) FROM integers i2) AS j FROM integers i1 GROUP BY i ORDER BY i;
----
NULL NULL
1 25.000000
2 26.000000
3 27.000000
query II
SELECT i, (SELECT (SELECT (SELECT (SELECT i1.i+i1.i+i1.i+i1.i+i1.i+i2.i) FROM integers i2 WHERE i2.i=i1.i))) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 6
2 12
3 18
query R
SELECT (SELECT (SELECT SUM(i1.i)+SUM(i2.i)+SUM(i3.i) FROM integers i3) FROM integers i2) FROM integers i1 ORDER BY 1
----
18.000000
# explicit join on subquery
query IR
SELECT i, (SELECT SUM(s1.i) FROM integers s1 INNER JOIN integers s2 ON (SELECT i1.i+s1.i)=(SELECT i1.i+s2.i)) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 6.000000
2 6.000000
3 6.000000
# nested aggregate queries
query IRR
SELECT i, SUM(i), (SELECT (SELECT SUM(i)+SUM(i1.i)+SUM(i2.i) FROM integers) FROM integers i2) FROM integers i1 GROUP BY i ORDER BY i;
----
NULL NULL NULL
1 1.000000 13.000000
2 2.000000 14.000000
3 3.000000 15.000000
# correlated ANY inside subquery
query IR
SELECT i, (SELECT SUM(ss1.i) FROM (SELECT i FROM integers s1 WHERE i>ANY(SELECT i FROM integers WHERE i<>s1.i)) ss1) AS j FROM integers i1 ORDER BY i;
----
NULL 5.000000
1 5.000000
2 5.000000
3 5.000000
query IR
SELECT i, (SELECT SUM(ss2.i) FROM (SELECT i FROM integers s1 WHERE i=i1.i AND i=ANY(SELECT i FROM integers WHERE i=s1.i)) ss2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1.000000
2 2.000000
3 3.000000
# left outer join on correlated subquery within subquery
# not supported yet: left outer join on JoinSide::BOTH
statement error
SELECT i, (SELECT SUM(s1.i) FROM integers s1 LEFT OUTER JOIN integers s2 ON (SELECT i1.i+s1.i)=(SELECT i1.i+s2.i)) AS j FROM integers i1 ORDER BY i;
----
# REQUIRE(CHECK_COLUMN(result, 0, {Value(), 1, 2, 3}));
# REQUIRE(CHECK_COLUMN(result, 1, {6, 6, 6, 6}));
query IR
SELECT i, (SELECT SUM(ss1.i)+SUM(ss2.i) FROM (SELECT i FROM integers s1 WHERE i>ANY(SELECT i FROM integers WHERE i<>s1.i)) ss1 LEFT OUTER JOIN (SELECT i FROM integers s1 WHERE i=ANY(SELECT i FROM integers WHERE i=s1.i)) ss2 ON ss1.i=ss2.i) AS j FROM integers i1 ORDER BY i;
----
NULL 10.000000
1 10.000000
2 10.000000
3 10.000000
# left outer join with correlation on LHS
query IR
SELECT i, (SELECT SUM(s1.i) FROM (SELECT i FROM integers WHERE i=i1.i) s1 LEFT OUTER JOIN integers s2 ON s1.i=s2.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1.000000
2 2.000000
3 3.000000
query IR
SELECT i, (SELECT SUM(s1.i) FROM (SELECT i FROM integers WHERE i<>i1.i) s1 LEFT OUTER JOIN integers s2 ON s1.i=s2.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 5.000000
2 4.000000
3 3.000000
# left outer join with correlation on RHS
query IR
SELECT i, (SELECT SUM(s2.i) FROM integers s1 LEFT OUTER JOIN (SELECT i FROM integers WHERE i=i1.i) s2 ON s1.i=s2.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1.000000
2 2.000000
3 3.000000
query IR
SELECT i, (SELECT SUM(s2.i) FROM integers s1 LEFT OUTER JOIN (SELECT i FROM integers WHERE i<>i1.i) s2 ON s1.i=s2.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 5.000000
2 4.000000
3 3.000000
query IR
SELECT i, (SELECT SUM(ss2.i) FROM (SELECT i FROM integers s1 WHERE CASE WHEN (i=i1.i AND i=ANY(SELECT i FROM integers WHERE i=s1.i)) THEN true ELSE false END) ss2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1.000000
2 2.000000
3 3.000000
query IR
SELECT i, (SELECT SUM(ss2.i) FROM (SELECT i FROM integers s1 WHERE i=i1.i AND i=ANY(SELECT i FROM integers WHERE i=s1.i)) ss2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1.000000
2 2.000000
3 3.000000
query IR
SELECT i, (SELECT SUM(ss2.i) FROM (SELECT i FROM integers s1 WHERE i=i1.i) ss2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1.000000
2 2.000000
3 3.000000
query IR
SELECT i, (SELECT SUM(ss2.i) FROM (SELECT i FROM integers s1 WHERE i=ANY(SELECT i FROM integers WHERE i=s1.i)) ss2) AS j FROM integers i1 ORDER BY i;
----
NULL 6.000000
1 6.000000
2 6.000000
3 6.000000
query IT
SELECT i, (SELECT i=ANY(SELECT i FROM integers WHERE i=s1.i) FROM integers s1 WHERE i=i1.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1
2 1
3 1
query IR
SELECT i, (SELECT SUM(ss2.i) FROM (SELECT i FROM integers s1 WHERE i=i1.i OR i=ANY(SELECT i FROM integers WHERE i=s1.i)) ss2) AS j FROM integers i1 ORDER BY i;
----
NULL 6.000000
1 6.000000
2 6.000000
3 6.000000
query IR
SELECT i, (SELECT SUM(ss2.i) FROM (SELECT i FROM integers s1 WHERE CASE WHEN (i=i1.i AND i=ANY(SELECT i FROM integers WHERE i=s1.i)) THEN true ELSE false END) ss2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1.000000
2 2.000000
3 3.000000
query IR
SELECT i, (SELECT SUM(ss2.i) FROM (SELECT i FROM integers s1 WHERE i=i1.i AND EXISTS(SELECT i FROM integers WHERE i=s1.i)) ss2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1.000000
2 2.000000
3 3.000000
# complex left outer join with correlation on RHS
query IR
SELECT i, (SELECT SUM(ss1.i) FROM (SELECT i FROM integers s1 WHERE i>ANY(SELECT i FROM integers WHERE i<>s1.i)) ss1) AS j FROM integers i1 ORDER BY i;
----
NULL 5.000000
1 5.000000
2 5.000000
3 5.000000
query IR
SELECT i, (SELECT SUM(ss1.i) FROM (SELECT i FROM integers s1 WHERE i>ANY(SELECT i FROM integers WHERE i<>s1.i)) ss1 LEFT OUTER JOIN (SELECT i FROM integers s1 WHERE i=i1.i AND i=ANY(SELECT i FROM integers WHERE i=s1.i)) ss2 ON ss1.i=ss2.i) AS j FROM integers i1 ORDER BY i;
----
NULL 5.000000
1 5.000000
2 5.000000
3 5.000000
query IR
SELECT i, (SELECT SUM(ss2.i) FROM (SELECT i FROM integers s1 WHERE i>ANY(SELECT i FROM integers WHERE i<>s1.i)) ss1 LEFT OUTER JOIN (SELECT i FROM integers s1 WHERE i=i1.i AND i=ANY(SELECT i FROM integers WHERE i=s1.i)) ss2 ON ss1.i=ss2.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 NULL
2 2.000000
3 3.000000
query IR
SELECT i, (SELECT SUM(ss1.i)+SUM(ss2.i) FROM (SELECT i FROM integers s1 WHERE i>ANY(SELECT i FROM integers WHERE i<>s1.i)) ss1 LEFT OUTER JOIN (SELECT i FROM integers s1 WHERE i=i1.i AND i=ANY(SELECT i FROM integers WHERE i=s1.i)) ss2 ON ss1.i=ss2.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 NULL
2 7.000000
3 8.000000
# complex left outer join with correlation on LHS
query IR
SELECT i, (SELECT SUM(ss1.i)+SUM(ss2.i) FROM (SELECT i FROM integers s1 WHERE i=i1.i AND i>ANY(SELECT i FROM integers WHERE i<>s1.i)) ss1 LEFT OUTER JOIN (SELECT i FROM integers s1 WHERE i=ANY(SELECT i FROM integers WHERE i=s1.i)) ss2 ON ss1.i=ss2.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 NULL
2 4.000000
3 6.000000
# complex left outer join with correlation on both sides
query IR
SELECT i, (SELECT SUM(ss1.i)+SUM(ss2.i) FROM (SELECT i FROM integers s1 WHERE i=i1.i AND i>ANY(SELECT i FROM integers WHERE i<>s1.i)) ss1 LEFT OUTER JOIN (SELECT i FROM integers s1 WHERE i<>i1.i OR i=ANY(SELECT i FROM integers WHERE i=s1.i)) ss2 ON ss1.i=ss2.i) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 NULL
2 4.000000
3 6.000000
# test correlated queries with correlated expressions inside FROM clause
# subquery
query II
SELECT i, (SELECT * FROM (SELECT (SELECT 42+i1.i)) s1) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 43
2 44
3 45
# cross product
query II
SELECT i, (SELECT s1.k+s2.k FROM (SELECT (SELECT 42+i1.i) AS k) s1, (SELECT (SELECT 42+i1.i) AS k) s2) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 86
2 88
3 90
# join
query II
SELECT i, (SELECT s1.k+s2.k FROM (SELECT (SELECT 42+i1.i) AS k) s1 LEFT OUTER JOIN (SELECT (SELECT 42+i1.i) AS k) s2 ON s1.k=s2.k) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 86
2 88
3 90
# IN list inside correlated subquery
query IT
SELECT i, (SELECT i1.i IN (1, 2, 3, 4, 5, 6, 7, 8)) AS j FROM integers i1 ORDER BY i;
----
NULL NULL
1 1
2 1
3 1
# nested correlated subqueries with multiple aggregate parameters
query R
SELECT (SELECT (SELECT COVAR_POP(i1.i, i3.i) FROM integers i3) FROM integers i2 LIMIT 1) FROM integers i1 ORDER BY 1
----
NULL
0.000000
0.000000
0.000000
query R
SELECT (SELECT (SELECT COVAR_POP(i2.i, i3.i) FROM integers i3) FROM integers i2 ORDER BY i NULLS LAST LIMIT 1) FROM integers i1 ORDER BY 1
----
0.000000
0.000000
0.000000
0.000000

163
external/duckdb/test/sql/subquery/scalar/test_scalar_subquery.test vendored Normal file
View File

@@ -0,0 +1,163 @@
# name: test/sql/subquery/scalar/test_scalar_subquery.test
# description: Test subqueries
# group: [scalar]
statement ok
PRAGMA enable_verification
query I
SELECT 1+(SELECT 1)
----
2
query T
SELECT 1=(SELECT 1)
----
1
query T
SELECT 1<>(SELECT 1)
----
0
query T
SELECT 1=(SELECT NULL)
----
NULL
query T
SELECT NULL=(SELECT 1)
----
NULL
# scalar subquery
query I
SELECT (SELECT 42)
----
42
# nested subquery
query I
SELECT (SELECT (SELECT 42))
----
42
# test aliasing of subquery
query I
SELECT * FROM (SELECT 42) v1(a);
----
42
# not enough aliases: defaults to using names for missing columns
query II
SELECT * FROM (SELECT 42, 41 AS x) v1(a);
----
42 41
# too many aliases: fails
statement error
SELECT * FROM (SELECT 42, 41 AS x) v1(a, b, c);
----
statement ok
CREATE TABLE test (a INTEGER, b INTEGER);
statement ok
INSERT INTO test VALUES (11, 22)
statement ok
INSERT INTO test VALUES (12, 21)
statement ok
INSERT INTO test VALUES (13, 22)
# select single tuple only in scalar subquery
statement error
SELECT (SELECT a * 42 FROM test)
----
More than one row returned by a subquery used as an expression
statement ok
SET scalar_subquery_error_on_multiple_rows=false
query I
SELECT (SELECT a * 42 FROM test)
----
462
# operations on subquery
query I
SELECT a*(SELECT 42) FROM test
----
462
504
546
statement ok
CREATE TABLE t1(a INTEGER, b INTEGER, c INTEGER, d INTEGER, e INTEGER)
statement ok
INSERT INTO t1(e,c,b,d,a) VALUES(103,102,100,101,104)
statement ok
INSERT INTO t1(a,c,d,e,b) VALUES(107,106,108,109,105)
query R
SELECT c-(SELECT sum(c) FROM t1) FROM t1
----
-106.000000
-102.000000
query I
SELECT CASE WHEN c>(SELECT sum(c)/count(*) FROM t1) THEN a*2 ELSE b*10 END FROM t1
----
1000
214
# correlated subqueries
query IR
SELECT a, (SELECT SUM(b) FROM test tsub WHERE test.a=tsub.a) FROM test
----
11 22.000000
12 21.000000
13 22.000000
query II
SELECT a, (SELECT CASE WHEN test.a=11 THEN 22 ELSE NULL END) FROM test ORDER BY a
----
11 22
12 NULL
13 NULL
query II
SELECT a, (SELECT CASE WHEN test.a=11 THEN b ELSE NULL END FROM test tsub) FROM test ORDER BY a
----
11 22
12 NULL
13 NULL
query II
SELECT a, (SELECT CASE WHEN test.a=11 THEN b ELSE NULL END FROM test tsub LIMIT 1) FROM test ORDER BY a
----
11 22
12 NULL
13 NULL
query II
SELECT * from test where a=(SELECT MIN(a) FROM test t WHERE t.b=test.b) ORDER BY a
----
11 22
12 21
# exists / in / any subqueries
query II
SELECT * FROM test WHERE EXISTS (SELECT a FROM test ts WHERE ts.a = test.a AND b>21)
----
11 22
13 22
# duplicate name in subquery
query II
SELECT * FROM (SELECT 42 AS a, 44 AS a) tbl1
----
42 44

169
external/duckdb/test/sql/subquery/scalar/test_scalar_subquery_cte.test vendored Normal file
View File

@@ -0,0 +1,169 @@
# name: test/sql/subquery/scalar/test_scalar_subquery_cte.test
# description: Test subqueries with CTEs
# group: [scalar]
statement ok
PRAGMA enable_verification
query I
SELECT 1+(WITH cte AS (SELECT 1) SELECT * FROM cte)
----
2
query T
SELECT 1=(WITH cte AS (SELECT 1) SELECT * FROM cte)
----
1
query T
SELECT 1<>(WITH cte AS (SELECT 1) SELECT * FROM cte)
----
0
query T
SELECT 1=(WITH cte AS (SELECT NULL) SELECT * FROM cte)
----
NULL
query T
SELECT NULL=(SELECT 1)
----
NULL
# scalar subquery
query I
SELECT (WITH cte AS (SELECT 42) SELECT * FROM cte)
----
42
# nested subquery
query I
SELECT (WITH cte1 AS (WITH cte2 AS (SELECT 42) SELECT * FROM cte2) SELECT * FROM cte1)
----
42
# test aliasing of subquery
query I
SELECT * FROM (WITH cte(x) AS (SELECT 42) SELECT x FROM cte) v1(a);
----
42
# not enough aliases: defaults to using names for missing columns
query II
SELECT * FROM (WITH cte AS (SELECT 42, 41 AS x) SELECT * FROM cte) v1(a);
----
42 41
# too many aliases: fails
statement error
SELECT * FROM (WITH cte AS (SELECT 42, 41 AS x) SELECT * FROM cte) v1(a, b, c);
----
statement ok
CREATE TABLE test (a INTEGER, b INTEGER);
statement ok
INSERT INTO test VALUES (11, 22)
statement ok
INSERT INTO test VALUES (12, 21)
statement ok
INSERT INTO test VALUES (13, 22)
# select single tuple only in scalar subquery
statement error
SELECT (WITH cte AS (SELECT a * 42 FROM test) SELECT * FROM cte)
----
More than one row returned by a subquery
statement ok
SET scalar_subquery_error_on_multiple_rows=false
# the result is non-deterministic, so any of the values can be returned
query I
SELECT (WITH cte AS (SELECT a * 42 FROM test) SELECT * FROM cte) IN (462, 504, 546)
----
true
# operations on subquery
query I
SELECT a*(WITH cte AS (SELECT 42) SELECT * FROM cte) FROM test
----
462
504
546
statement ok
CREATE TABLE t1(a INTEGER, b INTEGER, c INTEGER, d INTEGER, e INTEGER)
statement ok
INSERT INTO t1(e,c,b,d,a) VALUES(103,102,100,101,104)
statement ok
INSERT INTO t1(a,c,d,e,b) VALUES(107,106,108,109,105)
query R
SELECT c-(WITH cte AS (SELECT sum(c) FROM t1) SELECT * FROM cte) FROM t1
----
-106.000000
-102.000000
query I
SELECT CASE WHEN c>(WITH cte AS (SELECT sum(c)/count(*) FROM t1) SELECT * FROM cte) THEN a*2 ELSE b*10 END FROM t1
----
1000
214
# temporary solution until decorrelation of materialized CTEs is implemented
require no_alternative_verify
# correlated subqueries
query IR
SELECT a, (WITH cte AS (SELECT SUM(b) FROM test tsub WHERE test.a=tsub.a) SELECT * FROM cte) FROM test
----
11 22.000000
12 21.000000
13 22.000000
query II
SELECT a, (WITH cte AS (SELECT CASE WHEN test.a=11 THEN 22 ELSE NULL END) SELECT * FROM cte) FROM test ORDER BY a
----
11 22
12 NULL
13 NULL
# This test case is broken with PR #17459. Without CTE inlining, the result is arbitrary due to the materialization of the CTE.
# Previously no_alternative_verify prevented that, but now it does not suffice anymore.
# query II
# SELECT a, (WITH cte AS (SELECT CASE WHEN test.a=11 THEN b ELSE NULL END FROM test tsub) SELECT * FROM cte) FROM test ORDER BY a
# ----
# 11 22
# 12 NULL
# 13 NULL
query II
SELECT a, (WITH cte AS (SELECT CASE WHEN test.a=11 THEN b ELSE NULL END FROM test tsub LIMIT 1) SELECT * FROM cte) FROM test ORDER BY a
----
11 22
12 NULL
13 NULL
query II
SELECT * from test where a=(WITH cte AS (SELECT a FROM test t WHERE t.b=test.b) SELECT min(a) FROM cte)
----
11 22
12 21
# exists / in / any subqueries
query II
SELECT * FROM test WHERE EXISTS (WITH cte AS (SELECT * FROM test ts WHERE ts.a = test.a AND b>21) SELECT a FROM cte)
----
11 22
13 22
# duplicate name in subquery
query II
SELECT * FROM (WITH cte AS (SELECT 42 AS a, 44 AS a) SELECT * FROM cte) tbl1
----
42 44

79
external/duckdb/test/sql/subquery/scalar/test_subquery_any_join.test vendored Normal file
View File

@@ -0,0 +1,79 @@
# name: test/sql/subquery/scalar/test_subquery_any_join.test
# description: Test subqueries on ANY join
# group: [scalar]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
# correlated expressions in inner/left/right joins
query I
SELECT i IN (SELECT i1.i FROM (SELECT * FROM integers i1 WHERE i1.i=integers.i) i1 JOIN generate_series(1, 2, 1) tbl(i) ON i1.i=tbl.i) FROM integers ORDER BY i NULLS LAST;
----
true
true
false
false
query I
SELECT i IN (SELECT i1.i FROM (SELECT * FROM integers i1 WHERE i1.i=integers.i) i1 LEFT JOIN generate_series(1, 2, 1) tbl(i) ON i1.i=tbl.i) FROM integers ORDER BY i NULLS LAST;
----
true
true
true
false
query I
SELECT i IN (SELECT i1.i FROM (SELECT * FROM integers i1 WHERE i1.i=integers.i) i1 RIGHT JOIN generate_series(1, 2, 1) tbl(i) ON i1.i=tbl.i) FROM integers ORDER BY i NULLS LAST;
----
true
true
NULL
NULL
# other way around
query I
SELECT i IN (SELECT i1.i FROM generate_series(1, 2, 1) tbl(i) LEFT JOIN (SELECT * FROM integers i1 WHERE i1.i=integers.i) i1 ON i1.i=tbl.i) FROM integers ORDER BY i NULLS LAST;
----
true
true
NULL
NULL
query I
SELECT i IN (SELECT i1.i FROM generate_series(1, 2, 1) tbl(i) RIGHT JOIN (SELECT * FROM integers i1 WHERE i1.i=integers.i) i1 ON i1.i=tbl.i) FROM integers ORDER BY i NULLS LAST;
----
true
true
true
false
# complex join condition
query I
SELECT i IN (SELECT i1.i FROM (SELECT * FROM integers i1 WHERE i1.i IS NOT DISTINCT FROM integers.i) i1 JOIN generate_series(1, 2, 1) tbl(i) ON i1.i=tbl.i OR (i1.i IS NULL AND tbl.i IS NULL)) FROM integers ORDER BY i NULLS LAST;
----
true
true
false
false
query I
SELECT i IN (SELECT i1.i FROM (SELECT * FROM integers i1 WHERE i1.i IS NOT DISTINCT FROM integers.i) i1 LEFT JOIN generate_series(1, 2, 1) tbl(i) ON i1.i=tbl.i OR (i1.i IS NULL AND tbl.i IS NULL)) FROM integers ORDER BY i NULLS LAST;
----
true
true
true
NULL
query I
SELECT i IN (SELECT i1.i FROM (SELECT * FROM integers i1 WHERE i1.i IS NOT DISTINCT FROM integers.i) i1 RIGHT JOIN generate_series(1, 2, 1) tbl(i) ON i1.i=tbl.i OR (i1.i IS NULL AND tbl.i IS NULL)) FROM integers ORDER BY i NULLS LAST;
----
true
true
NULL
NULL

18
external/duckdb/test/sql/subquery/scalar/test_tpcds_correlated_subquery.test vendored Normal file
View File

@@ -0,0 +1,18 @@
# name: test/sql/subquery/scalar/test_tpcds_correlated_subquery.test
# description: Test correlated subqueries based on TPC-DS
# group: [scalar]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE item(i_manufact INTEGER)
query I
SELECT * FROM item i1 WHERE (SELECT count(*) AS item_cnt FROM item WHERE (i_manufact = i1.i_manufact AND i_manufact=3) OR (i_manufact = i1.i_manufact AND i_manufact=3)) > 0 ORDER BY 1 LIMIT 100;
----
query I
SELECT * FROM item i1 WHERE (SELECT count(*) AS item_cnt FROM item WHERE (i_manufact = i1.i_manufact AND i_manufact=3) OR (i_manufact = i1.i_manufact AND i_manufact=3)) ORDER BY 1 LIMIT 100;
----

141
external/duckdb/test/sql/subquery/scalar/test_uncorrelated_scalar_subquery.test vendored Normal file
View File

@@ -0,0 +1,141 @@
# name: test/sql/subquery/scalar/test_uncorrelated_scalar_subquery.test
# description: Test uncorrelated subqueries
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL)
# scalar subqueries
query I
SELECT * FROM integers WHERE i=(SELECT 1)
----
1
query I
SELECT * FROM integers WHERE i=(SELECT SUM(1))
----
1
query I
SELECT * FROM integers WHERE i=(SELECT MIN(i) FROM integers)
----
1
query I
SELECT * FROM integers WHERE i=(SELECT MAX(i) FROM integers)
----
3
query II
SELECT *, (SELECT MAX(i) FROM integers) FROM integers ORDER BY i
----
NULL 3
1 3
2 3
3 3
# group by on subquery
query II
SELECT (SELECT 42) AS k, MAX(i) FROM integers GROUP BY k
----
42 3
# subquery as parameter to aggregate
query II
SELECT i, MAX((SELECT 42)) FROM integers GROUP BY i ORDER BY i
----
NULL 42
1 42
2 42
3 42
# scalar subquery returning zero results should result in NULL
query I
SELECT (SELECT * FROM integers WHERE i>10) FROM integers
----
NULL
NULL
NULL
NULL
# return more than one row in a scalar subquery
# controversial: in postgres this gives an error
# but SQLite accepts it and just uses the first value
# we choose to agree with Postgres here
statement error
SELECT * FROM integers WHERE i=(SELECT i FROM integers WHERE i IS NOT NULL ORDER BY i)
----
More than one row returned by a subquery
statement ok
SET scalar_subquery_error_on_multiple_rows=false
query I
SELECT * FROM integers WHERE i=(SELECT i FROM integers WHERE i IS NOT NULL ORDER BY i)
----
1
# i.e. the above query is equivalent to this query
query I
SELECT * FROM integers WHERE i=(SELECT i FROM integers WHERE i IS NOT NULL ORDER BY i LIMIT 1)
----
1
# returning multiple columns should fail though
statement error
SELECT * FROM integers WHERE i=(SELECT 1, 2)
----
statement error
SELECT * FROM integers WHERE i=(SELECT i, i + 2 FROM integers)
----
# but not for EXISTS queries!
query I
SELECT * FROM integers WHERE EXISTS (SELECT 1, 2)
----
1
2
3
NULL
query I
SELECT * FROM integers WHERE EXISTS (SELECT i, i + 2 FROM integers)
----
1
2
3
NULL
# SELECT * should be fine if the star only expands to a single column
query I
SELECT (SELECT * FROM integers WHERE i=1)
----
1
# but not if the star expands to more than one column!
statement error
SELECT (SELECT * FROM integers i1, integers i2)
----
# uncorrelated subquery in SELECT
query I
SELECT (SELECT i FROM integers WHERE i=1)
----
1
query I
SELECT * FROM integers WHERE i > (SELECT i FROM integers WHERE i=1) ORDER BY 1
----
2
3

68
external/duckdb/test/sql/subquery/scalar/test_uncorrelated_varchar_subquery.test vendored Normal file
View File

@@ -0,0 +1,68 @@
# name: test/sql/subquery/scalar/test_uncorrelated_varchar_subquery.test
# description: Test uncorrelated VARCHAR subqueries
# group: [scalar]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL)
# varchar tests
statement ok
CREATE TABLE strings(v VARCHAR)
statement ok
INSERT INTO strings VALUES ('hello'), ('world'), (NULL)
# ANY
query T
SELECT NULL IN (SELECT * FROM strings)
----
NULL
query T
SELECT 'hello' IN (SELECT * FROM strings)
----
1
query T
SELECT 'bla' IN (SELECT * FROM strings)
----
NULL
query T
SELECT 'bla' IN (SELECT * FROM strings WHERE v IS NOT NULL)
----
0
# EXISTS
query T
SELECT * FROM strings WHERE EXISTS(SELECT NULL)
----
hello
world
NULL
query T
SELECT * FROM strings WHERE EXISTS(SELECT v FROM strings WHERE v='bla')
----
# scalar query
query T
SELECT (SELECT v FROM strings WHERE v='hello') FROM strings
----
hello
hello
hello
query T
SELECT (SELECT v FROM strings WHERE v='bla') FROM strings
----
NULL
NULL
NULL

114
external/duckdb/test/sql/subquery/scalar/test_unnest_subquery.test vendored Normal file
View File

@@ -0,0 +1,114 @@
# name: test/sql/subquery/scalar/test_unnest_subquery.test
# description: Test unnest in subqueries
# group: [scalar]
statement ok
PRAGMA enable_verification
# uncorrelated
query I
SELECT (SELECT UNNEST([1]))
----
1
query I
SELECT (SELECT UNNEST([NULL]))
----
NULL
query I
SELECT (SELECT UNNEST([]))
----
NULL
# correlated
query I
SELECT (SELECT UNNEST(i)) FROM (VALUES ([1])) tbl(i);
----
1
query I
SELECT (SELECT UNNEST(i)) FROM (VALUES ([NULL])) tbl(i);
----
NULL
query I
SELECT (SELECT UNNEST(i)) FROM (VALUES ([])) tbl(i);
----
NULL
# now with an aggregate
query I
SELECT (SELECT SUM(k) FROM (SELECT UNNEST(i)) tbl(k)) FROM (VALUES ([1, 2, 3])) tbl(i);
----
6
query I
SELECT (SELECT SUM(k)+SUM(l) FROM (SELECT UNNEST(i), UNNEST(j) FROM (VALUES ([1, 2, 3])) tbl(j)) tbl(k, l)) FROM (VALUES ([1, 2, 3])) tbl(i);
----
12
# ANY
query I
SELECT 1=ANY(SELECT UNNEST(i)) FROM (VALUES ([1, 2, 3])) tbl(i);
----
true
query I
SELECT 4=ANY(SELECT UNNEST(i)) FROM (VALUES ([1, 2, 3])) tbl(i);
----
false
query I
SELECT NULL=ANY(SELECT UNNEST(i)) FROM (VALUES ([1, 2, 3])) tbl(i);
----
NULL
query I
SELECT 4=ANY(SELECT UNNEST(i)) FROM (VALUES ([1, 2, 3, NULL])) tbl(i);
----
NULL
# IN
query I
SELECT 1 IN (SELECT UNNEST(i)) FROM (VALUES ([1, 2, 3])) tbl(i);
----
true
# INSIDE a subquery
query I
SELECT (SELECT 1=ANY(SELECT UNNEST(i))) FROM (VALUES ([1, 2, 3])) tbl(i);
----
true
query I
SELECT (SELECT 4=ANY(SELECT UNNEST(i))) FROM (VALUES ([1, 2, 3])) tbl(i);
----
false
query I
SELECT (SELECT 4=ANY(SELECT UNNEST(i))) FROM (VALUES ([1, 2, 3, NULL])) tbl(i);
----
NULL
# INSIDE a subquery
query I
SELECT (SELECT 1=ANY(SELECT UNNEST(i))) FROM (VALUES ([1, 2, 3])) tbl(i);
----
true
query I
SELECT (SELECT 4=ANY(SELECT UNNEST(i))) FROM (VALUES ([1, 2, 3])) tbl(i);
----
false
query I
SELECT (SELECT 4=ANY(SELECT UNNEST(i))) FROM (VALUES ([1, 2, 3, NULL])) tbl(i);
----
NULL
# double correlated subqueries
query I
SELECT (SELECT 1+i[1]=ANY(SELECT UNNEST(i))) FROM (VALUES ([1, 2, 3])) tbl(i);
----
true

73
external/duckdb/test/sql/subquery/scalar/test_update_subquery.test vendored Normal file
View File

@@ -0,0 +1,73 @@
# name: test/sql/subquery/scalar/test_update_subquery.test
# description: Test subqueries in update
# group: [scalar]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(id INTEGER, i INTEGER)
statement ok
INSERT INTO integers VALUES (1, 1), (2, 2), (3, 3), (4, NULL)
# correlated subquery in update
statement ok
UPDATE integers i1 SET i=(SELECT MAX(i) FROM integers WHERE i1.i<>i)
query II
SELECT id, i FROM integers ORDER BY id
----
1 3
2 3
3 2
4 NULL
# uncorrelated subquery in update
statement ok
UPDATE integers i1 SET i=(SELECT MAX(i) FROM integers) WHERE i=(SELECT MIN(i) FROM integers)
query II
SELECT id, i FROM integers ORDER BY id
----
1 3
2 3
3 3
4 NULL
# use different correlated column in subquery
statement ok
UPDATE integers i1 SET i=(SELECT MAX(id) FROM integers WHERE id<i1.id)
query II
SELECT id, i FROM integers ORDER BY id
----
1 NULL
2 1
3 2
4 3
# correlated subquery in WHERE
statement ok
UPDATE integers i1 SET i=2 WHERE i<(SELECT MAX(id) FROM integers WHERE i1.id<id);
query II
SELECT id, i FROM integers ORDER BY id
----
1 NULL
2 2
3 2
4 3
# use DEFAULT with correlated subquery in WHERE
statement ok
UPDATE integers i1 SET i=DEFAULT WHERE i=(SELECT MIN(i) FROM integers WHERE i1.id<id);
query II
SELECT id, i FROM integers ORDER BY id
----
1 NULL
2 NULL
3 2
4 3

101
external/duckdb/test/sql/subquery/scalar/test_varchar_correlated_subquery.test vendored Normal file
View File

@@ -0,0 +1,101 @@
# name: test/sql/subquery/scalar/test_varchar_correlated_subquery.test
# description: Test varchar correlated subqueries
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
# varchar tests
statement ok
CREATE TABLE strings(v VARCHAR)
statement ok
INSERT INTO strings VALUES ('hello'), ('world'), (NULL)
# ANY
query T
SELECT NULL IN (SELECT * FROM strings WHERE v=s1.v) FROM strings s1 ORDER BY v
----
0
NULL
NULL
statement error
SELECT 3 IN (SELECT * FROM strings WHERE v=s1.v) FROM strings s1 ORDER BY v
----
explicit cast is required
query T
SELECT '3' IN (SELECT * FROM strings WHERE v=s1.v) FROM strings s1 ORDER BY v
----
0
0
0
query T
SELECT 'hello' IN (SELECT * FROM strings WHERE v=s1.v) FROM strings s1 ORDER BY v
----
0
1
0
query T
SELECT 'bla' IN (SELECT * FROM strings WHERE v=s1.v) FROM strings s1 ORDER BY v
----
0
0
0
query T
SELECT 'hello' IN (SELECT * FROM strings WHERE v=s1.v or v IS NULL) FROM strings s1 ORDER BY v
----
NULL
1
NULL
query T
SELECT 'bla' IN (SELECT * FROM strings WHERE v=s1.v or v IS NULL) FROM strings s1 ORDER BY v
----
NULL
NULL
NULL
# EXISTS
query T
SELECT * FROM strings WHERE EXISTS(SELECT NULL, v) ORDER BY v
----
NULL
hello
world
query T
SELECT * FROM strings s1 WHERE EXISTS(SELECT v FROM strings WHERE v=s1.v OR v IS NULL) ORDER BY v
----
NULL
hello
world
query T
SELECT * FROM strings s1 WHERE EXISTS(SELECT v FROM strings WHERE v=s1.v) ORDER BY v
----
hello
world
# scalar query
query T
SELECT (SELECT v FROM strings WHERE v=s1.v) FROM strings s1 ORDER BY v
----
NULL
hello
world
query T
SELECT (SELECT v FROM strings WHERE v=s1.v OR (v='hello' AND s1.v IS NULL)) FROM strings s1 ORDER BY v
----
hello
hello
world

81
external/duckdb/test/sql/subquery/scalar/test_window_function_subquery.test vendored Normal file
View File

@@ -0,0 +1,81 @@
# name: test/sql/subquery/scalar/test_window_function_subquery.test
# description: Test window functions in correlated subqueries
# group: [scalar]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL)
# window functions in correlated subquery
query II
SELECT i, (SELECT row_number() OVER (ORDER BY i) FROM integers WHERE i1.i=i) FROM integers i1 ORDER BY i;
----
NULL NULL
1 1
2 1
3 1
query II
SELECT i1.i, (SELECT rank() OVER (ORDER BY i) FROM integers WHERE i1.i=i) FROM integers i1, integers i2 ORDER BY i1.i;
----
NULL NULL
NULL NULL
NULL NULL
NULL NULL
1 1
1 1
1 1
1 1
2 1
2 1
2 1
2 1
3 1
3 1
3 1
3 1
query II
SELECT i1.i, (SELECT row_number() OVER (ORDER BY i) FROM integers WHERE i1.i=i) FROM integers i1, integers i2 ORDER BY i1.i;
----
NULL NULL
NULL NULL
NULL NULL
NULL NULL
1 1
1 1
1 1
1 1
2 1
2 1
2 1
2 1
3 1
3 1
3 1
3 1
query IR
SELECT i, (SELECT SUM(i) OVER (ORDER BY i) FROM integers WHERE i1.i=i) FROM integers i1 ORDER BY i;
----
NULL NULL
1 1.000000
2 2.000000
3 3.000000
query IR
SELECT i, (SELECT SUM(s1.i) OVER (ORDER BY s1.i) FROM integers s1, integers s2 WHERE i1.i=s1.i LIMIT 1) FROM integers i1 ORDER BY i;
----
NULL NULL
1 4.000000
2 8.000000
3 12.000000

11
external/duckdb/test/sql/subquery/scalar/values_list_large.test_slow vendored Normal file
View File

@@ -0,0 +1,11 @@
# name: test/sql/subquery/scalar/values_list_large.test_slow
# description: Test large correlated subquery with VALUES list
# group: [scalar]
statement ok
CREATE TABLE test AS SELECT CASE WHEN i%7=2 THEN NULL ELSE i::INTEGER END AS i, CASE WHEN i%9=2 THEN NULL ELSE i::INTEGER+2 END AS j FROM generate_series(0, 9999999, 1) tbl(i);
query III
SELECT SUM(i), SUM(j), SUM((SELECT max(x) FROM (VALUES (i), (j)) AS X(x))) as maxn FROM test;
----
42857134285714 44444461111111 49206358253971

23
external/duckdb/test/sql/subquery/table/test_aliasing.test vendored Normal file
View File

@@ -0,0 +1,23 @@
# name: test/sql/subquery/table/test_aliasing.test
# description: Aliasing and aggregation in subqueries
# group: [table]
statement ok
PRAGMA enable_verification
statement ok
create table a(i integer)
statement ok
insert into a values (42)
query I
select * from (select i as j from a group by j) sq1 where j = 42
----
42
query I
select * from (select i as j from a group by i) sq1 where j = 42
----
42

27
external/duckdb/test/sql/subquery/table/test_nested_table_subquery.test_slow vendored Normal file
View File

@@ -0,0 +1,27 @@
# name: test/sql/subquery/table/test_nested_table_subquery.test_slow
# description: Nested table subquery
# group: [table]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE test (i INTEGER, j INTEGER)
statement ok
INSERT INTO test VALUES (3, 4), (4, 5), (5, 6);
query IIIIII
SELECT * FROM (SELECT i, j FROM (SELECT j AS i, i AS j FROM (SELECT j AS i, i AS j FROM test) AS a) AS a) AS a, (SELECT i+1 AS r,j FROM test) AS b, test WHERE a.i=b.r AND test.j=a.i ORDER BY 1;
----
4 5 4 4 3 4
5 6 5 5 4 5
# 100 nesting levels
query I
SELECT i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM (SELECT i + 1 AS i FROM test) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a) AS a;
----
103
104
105

13
external/duckdb/test/sql/subquery/table/test_subquery_union.test vendored Normal file
View File

@@ -0,0 +1,13 @@
# name: test/sql/subquery/table/test_subquery_union.test
# description: UNIONS of subqueries
# group: [table]
statement ok
PRAGMA enable_verification
query I
select * from (select 42) sq1 union all select * from (select 43) sq2;
----
42
43

54
external/duckdb/test/sql/subquery/table/test_table_subquery.test vendored Normal file
View File

@@ -0,0 +1,54 @@
# name: test/sql/subquery/table/test_table_subquery.test
# description: Table subquery
# group: [table]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE test (i INTEGER, j INTEGER)
statement ok
INSERT INTO test VALUES (3, 4), (4, 5), (5, 6);
query II
SELECT * FROM (SELECT i, j AS d FROM test ORDER BY i) AS b;
----
3 4
4 5
5 6
# check column names for simple projections and aliases
query I
SELECT b.d FROM (SELECT i * 2 + j AS d FROM test) AS b;
----
10
13
16
# join with subqueries
query IIII
SELECT a.i,a.j,b.r,b.j FROM (SELECT i, j FROM test) AS a INNER JOIN (SELECT i+1 AS r,j FROM test) AS b ON a.i=b.r ORDER BY 1;
----
4 5 4 4
5 6 5 5
# check that * is in the correct order
query IIIIII
SELECT * FROM (SELECT i, j FROM test) AS a, (SELECT i+1 AS r,j FROM test) AS b, test WHERE a.i=b.r AND test.j=a.i ORDER BY 1;
----
4 5 4 4 3 4
5 6 5 5 4 5
# subquery group cols are visible
query R
select sum(x) from (select i as x from test group by i) sq;
----
12.000000
# subquery group aliases are visible
query R
select sum(x) from (select i+1 as x from test group by x) sq;
----
15.000000

45
external/duckdb/test/sql/subquery/table/test_unnamed_subquery.test vendored Normal file
View File

@@ -0,0 +1,45 @@
# name: test/sql/subquery/table/test_unnamed_subquery.test
# description: Test unnamed subqueries
# group: [table]
statement ok
PRAGMA enable_verification
query I
SELECT a FROM (SELECT 42 a)
----
42
query II
SELECT * FROM (SELECT 42 a), (SELECT 43 b)
----
42 43
query II
SELECT * FROM (VALUES (42, 43))
----
42 43
# longer chains
query IIII
SELECT * FROM (SELECT 42 a), (SELECT 43 b), (SELECT 44 c), (SELECT 45 d)
----
42 43 44 45
# nested
query IIII
SELECT * FROM (FROM (SELECT 42 a), (SELECT 43 b)) JOIN (SELECT 44 c) ON (true) JOIN (SELECT 45 d) ON (true)
----
42 43 44 45
# names are predictable
query II
SELECT * FROM (SELECT unnamed_subquery.a FROM (SELECT 42 a)), (SELECT unnamed_subquery.b FROM (SELECT 43 b))
----
42 43
# names are predictable
query II
SELECT unnamed_subquery.a, unnamed_subquery2.b FROM (SELECT 42 a), (SELECT 43 b)
----
42 43

50
external/duckdb/test/sql/subquery/test_neumann.test vendored Normal file
View File

@@ -0,0 +1,50 @@
# name: test/sql/subquery/test_neumann.test
# description: Test subqueries from the paper 'Unnesting Arbitrary Subqueries'
# group: [subquery]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE students(id INTEGER, name VARCHAR, major VARCHAR, year INTEGER)
statement ok
CREATE TABLE exams(sid INTEGER, course VARCHAR, curriculum VARCHAR, grade INTEGER, year INTEGER)
statement ok
INSERT INTO students VALUES (1, 'Mark', 'CS', 2017)
statement ok
INSERT INTO students VALUES (2, 'Dirk', 'CS', 2017)
statement ok
INSERT INTO exams VALUES (1, 'Database Systems', 'CS', 10, 2015)
statement ok
INSERT INTO exams VALUES (1, 'Graphics', 'CS', 9, 2016)
statement ok
INSERT INTO exams VALUES (2, 'Database Systems', 'CS', 7, 2015)
statement ok
INSERT INTO exams VALUES (2, 'Graphics', 'CS', 7, 2016)
query TTI
SELECT s.name, e.course, e.grade FROM students s, exams e WHERE s.id=e.sid AND e.grade=(SELECT MAX(e2.grade) FROM exams e2 WHERE s.id=e2.sid) ORDER BY name, course;
----
Dirk Database Systems 7
Dirk Graphics 7
Mark Database Systems 10
query TTI
SELECT s.name, e.course, e.grade FROM students s, exams e WHERE s.id=e.sid AND (s.major = 'CS' OR s.major = 'Games Eng') AND e.grade <= (SELECT AVG(e2.grade) - 1 FROM exams e2 WHERE s.id=e2.sid OR (e2.curriculum=s.major AND s.year>=e2.year)) ORDER BY name, course;
----
Dirk Database Systems 7
Dirk Graphics 7
query TT
SELECT name, major FROM students s WHERE EXISTS(SELECT * FROM exams e WHERE e.sid=s.id AND grade=10) OR s.name='Dirk' ORDER BY name
----
Dirk CS
Mark CS

8
external/duckdb/test/sql/subquery/test_offset.test vendored Normal file
View File

@@ -0,0 +1,8 @@
# name: test/sql/subquery/test_offset.test
# description: Test bound offset in subquery
# group: [subquery]
query I
SELECT (SELECT c0 OFFSET 1) FROM (VALUES(1)) c0;
----
NULL