# LogicTest: default parallel-stmts distsql

# Tests for subqueries (SELECT statements which are part of a bigger statement).

query I
SELECT (SELECT 1)
----
1

query B
SELECT 1 IN (SELECT 1)
----
true

query B
SELECT (1, 2, 3) IN (SELECT 1, 2, 3)
----
true

query B
SELECT (1, 2, 3) = (SELECT 1, 2, 3)
----
true

query B
SELECT (1, 2, 3) != (SELECT 1, 2, 3)
----
false

query error subquery must return only one column, found 2
SELECT (SELECT 1, 2)

query error subquery must return only one column, found 2
SELECT 1 IN (SELECT 1, 2)

query error subquery must return 2 columns, found 1
SELECT (1, 2) IN (SELECT 1)

statement ok
CREATE TABLE abc (a INT PRIMARY KEY, b INT, c INT)

statement ok
INSERT INTO abc VALUES (1, 2, 3), (4, 5, 6)

query ITTT
EXPLAIN ALTER TABLE abc SPLIT AT VALUES ((SELECT 42))
----
0  split
1  values
1           size        1 column, 1 row
1           subqueries  1
2  limit
3  render
4  nullrow

statement ok
ALTER TABLE abc SPLIT AT VALUES ((SELECT 1))

query error subquery must return 2 columns
SELECT (1, 2) IN (SELECT * FROM abc)

query B
SELECT (1, 2) IN (SELECT a, b FROM abc)
----
true

query B
SELECT (1, 2) IN (SELECT a, b FROM abc WHERE false)
----
false

query error subquery must return only one column
SELECT (SELECT * FROM abc)

query error more than one row returned by a subquery used as an expression
SELECT (SELECT a FROM abc)

query ITTT
EXPLAIN SELECT EXISTS (SELECT a FROM abc)
----
0  render
0           subqueries  1
1  limit
2  render
3  scan
3           table       abc@primary
3           spans       ALL
1  nullrow

query I
SELECT (SELECT a FROM abc WHERE false)
----
NULL

query II
VALUES (1, (SELECT (2)))
----
1 2

statement ok
INSERT INTO abc VALUES ((SELECT 7), (SELECT 8), (SELECT 9))

query III
SELECT * FROM abc WHERE a = 7
----
7 8 9

statement error value type tuple{int, int, int} doesn't match type INT of column "a"
INSERT INTO abc VALUES ((SELECT (10, 11, 12)))

statement error subquery must return only one column, found 3
INSERT INTO abc VALUES ((SELECT 10, 11, 12))

statement ok
CREATE TABLE xyz (x INT PRIMARY KEY, y INT, z INT)

statement ok
INSERT INTO xyz SELECT * FROM abc

query III rowsort
SELECT * FROM xyz
----
1 2 3
4 5 6
7 8 9

statement ok
INSERT INTO xyz (x, y, z) VALUES (10, 11, 12)

statement ok
UPDATE xyz SET z = (SELECT 10) WHERE x = 7

query III rowsort
SELECT * FROM xyz
----
1 2 3
4 5 6
7 8 10
10 11 12

statement error value type tuple{int, int} doesn't match type INT of column "z"
UPDATE xyz SET z = (SELECT (10, 11)) WHERE x = 7

statement error subquery must return 2 columns, found 1
UPDATE xyz SET (y, z) = (SELECT (11, 12)) WHERE x = 7

#regression, see #6852
#statement ok
#UPDATE xyz SET (y, z) = (SELECT 11, 12) WHERE x = 7
#
#query III rowsort
#SELECT * FROM xyz
#----
#1 2  3
#4 5  6
#7 11 12
#10 11 12

query B
SELECT 1 IN (SELECT x FROM xyz ORDER BY x DESC)
----
true

query III
SELECT * FROM xyz WHERE x = (SELECT MIN(x) FROM xyz)
----
1 2 3

query III
SELECT * FROM xyz WHERE x = (SELECT MAX(x) FROM xyz)
----
10 11 12

statement ok
CREATE TABLE kv (k INT PRIMARY KEY, v STRING)

statement ok
INSERT INTO kv VALUES (1, 'one')

query IT
SELECT * FROM kv WHERE k = (SELECT k FROM kv WHERE (k, v) = (1, 'one'))
----
1 one

query B
SELECT EXISTS(SELECT 1 FROM kv AS x WHERE x.k = 1)
----
true

query B
SELECT EXISTS(SELECT 1 FROM kv WHERE k = 2)
----
false


# Tests for subquery in the FROM part of a SELECT

query II colnames,rowsort
SELECT * FROM (VALUES (1, 2)) AS foo
----
column1 column2
1 2

query II colnames,rowsort
SELECT * FROM (VALUES (1, 2))
----
column1 column2
1 2

query IT colnames,rowsort
SELECT * FROM (VALUES (1, 'one'), (2, 'two'), (3, 'three')) AS foo
----
column1 column2
1 one
2 two
3 three

query III colnames,rowsort
SELECT * FROM (VALUES (1, 2, 3), (4, 5, 6)) AS foo
----
column1 column2 column3
1       2       3
4       5       6

query III colnames,rowsort
SELECT * FROM (VALUES (1, 2, 3), (4, 5, 6)) AS foo (foo1, foo2, foo3)
----
foo1 foo2 foo3
1    2    3
4    5    6

query III colnames,rowsort
SELECT * FROM (VALUES (1, 2, 3), (4, 5, 6)) AS foo (foo1, foo2)
----
foo1 foo2 column3
1    2    3
4    5    6

query III colnames,rowsort
SELECT * FROM (SELECT * FROM xyz) AS foo WHERE x < 7
----
x y  z
1 2  3
4 5  6

query III colnames,rowsort
SELECT * FROM (SELECT * FROM xyz) AS foo (foo1) WHERE foo1 < 7
----
foo1 y  z
1    2  3
4    5  6

query III colnames,rowsort
SELECT * FROM (SELECT * FROM xyz AS moo (moo1, moo2, moo3)) as foo (foo1) WHERE foo1 < 7
----
foo1 moo2 moo3
1    2    3
4    5    6

query III colnames,rowsort
SELECT * FROM (SELECT * FROM xyz AS moo (moo1, moo2, moo3) ORDER BY moo1) as foo (foo1) WHERE foo1 < 7
----
foo1 moo2 moo3
1    2    3
4    5    6

query III colnames
SELECT * FROM (SELECT * FROM xyz AS moo (moo1, moo2, moo3) ORDER BY moo1) as foo (foo1) WHERE foo1 < 7 ORDER BY moo2 DESC
----
foo1 moo2 moo3
4    5    6
1    2    3

query III colnames
SELECT * FROM (SELECT * FROM (VALUES (1, 2, 3), (4, 5, 6)) AS moo (moo1, moo2, moo3) WHERE moo1 = 4) as foo (foo1)
----
foo1 moo2 moo3
4    5    6

query III colnames
SELECT * FROM (SELECT * FROM (VALUES (1, 8, 8), (3, 1, 1), (2, 4, 4)) AS moo (moo1, moo2, moo3) ORDER BY moo2) as foo (foo1) ORDER BY foo1
----
foo1 moo2 moo3
1    8    8
2    4    4
3    1    1

query ITTT
EXPLAIN SELECT * FROM (SELECT * FROM (VALUES (1, 8, 8), (3, 1, 1), (2, 4, 4)) AS moo (moo1, moo2, moo3) ORDER BY moo2) as foo (foo1) ORDER BY foo1
----
0  sort
0          order  +foo1
1  render
2  sort
2          order  +moo2
3  render
4  values
4          size   3 columns, 3 rows

query II colnames
SELECT a, b FROM (VALUES (1, 2, 3), (3, 4, 7), (5, 6, 10)) AS foo (a, b, c) WHERE a + b = c
----
a b
1 2
3 4

query I colnames
SELECT foo.a FROM (VALUES (1), (2), (3)) AS foo (a)
----
a
1
2
3

query IITT colnames
SELECT foo.a, a, column2, foo.column2 FROM (VALUES (1, 'one'), (2, 'two'), (3, 'three')) AS foo (a)
----
a a column2 column2
1 1 one     one
2 2 two     two
3 3 three   three

query I
SELECT x FROM xyz WHERE x IN (SELECT x FROM xyz WHERE x = 7)
----
7

query I
SELECT x FROM xyz WHERE x = 7 LIMIT (SELECT x FROM xyz WHERE x = 1)
----
7

query I
SELECT x FROM xyz ORDER BY x OFFSET (SELECT x FROM xyz WHERE x = 1)
----
4
7
10

query B
INSERT INTO xyz (x, y, z) VALUES (13, 11, 12) RETURNING (y IN (SELECT y FROM xyz))
----
true

# check that residual filters are not expanded twice
query ITTTTT
EXPLAIN (METADATA) SELECT x FROM xyz WHERE x IN (SELECT x FROM xyz)
----
0  render                           (x)
1  scan                             (x, y[omitted], z[omitted])
1          table       xyz@primary
1          spans       ALL
1          subqueries  1
2  render                           (x)
3  scan                             (x, y[omitted], z[omitted])
3          table       xyz@primary
3          spans       ALL

# This test checks that the double sub-query plan expansion caused by a
# sub-expression being shared by two or more plan nodes does not
# panic.
statement ok
CREATE TABLE tab4(col0 INTEGER, col1 FLOAT, col3 INTEGER, col4 FLOAT)

statement ok
INSERT INTO tab4 VALUES (1,1,1,1)

statement ok
CREATE INDEX idx_tab4_0 ON tab4 (col4,col0)

query I
SELECT col0 FROM tab4 WHERE (col0 <= 0 AND col4 <= 5.38) OR (col4 IN (SELECT col1 FROM tab4 WHERE col1 > 8.27)) AND (col3 <= 5 AND (col3 BETWEEN 7 AND 9))
----

query ITTT
EXPLAIN SELECT col0 FROM tab4 WHERE (col0 <= 0 AND col4 <= 5.38) OR (col4 IN (SELECT col1 FROM tab4 WHERE col1 > 8.27)) AND (col3 <= 5 AND (col3 BETWEEN 7 AND 9))
----
0  render
1  index-join
2  scan
2              table       tab4@idx_tab4_0
2              spans       /#-/5.38/1
2              subqueries  1
3  render
4  scan
4              table       tab4@primary
4              spans       ALL
2  scan
2              table       tab4@primary
2              subqueries  1
3  render
4  scan
4              table       tab4@primary
4              spans       ALL
