python/sqlglot
1
0
Fork 0
Code Issues Activity

Merging upstream version 26.29.0.

Browse source 
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
Daniel Baumann 2025-06-19 07:53:46 +02:00
parent 141a93f866
commit 4c1ec9be5a
Signed by: daniel
GPG key ID: FBB4F0E80A80222F
58 changed files with 17605 additions and 17151 deletions
Download patch file Download diff file Expand all files Collapse all files

4
tests/dialects/test_athena.py
View file

@ -7,6 +7,7 @@ class TestAthena(Validator):
maxDiff = None
def test_athena(self):
self.validate_identity("SELECT 'foo''bar'")
self.validate_identity(
"CREATE TABLE IF NOT EXISTS t (name STRING) LOCATION 's3://bucket/tmp/mytable/' TBLPROPERTIES ('table_type'='iceberg', 'FORMAT'='parquet')"
)
@ -39,6 +40,9 @@ class TestAthena(Validator):
def test_ddl(self):
# Hive-like, https://docs.aws.amazon.com/athena/latest/ug/create-table.html
self.validate_identity("CREATE EXTERNAL TABLE foo (id INT) COMMENT 'test comment'")
self.validate_identity(
"CREATE EXTERNAL TABLE my_table (id BIGINT COMMENT 'this is the row\\'s id') LOCATION 's3://my-s3-bucket'"
)
self.validate_identity(
"CREATE EXTERNAL TABLE foo (id INT, val STRING) CLUSTERED BY (id, val) INTO 10 BUCKETS"
)

23
tests/dialects/test_duckdb.py
View file

@ -1494,7 +1494,11 @@ class TestDuckDB(Validator):
# DETACH
self.validate_identity("DETACH new_database")
self.validate_identity("DETACH IF EXISTS file")
# when 'if exists' is set, the syntax is DETACH DATABASE, not DETACH
# ref: https://duckdb.org/docs/stable/sql/statements/attach.html#detach-syntax
self.validate_identity("DETACH IF EXISTS file", "DETACH DATABASE IF EXISTS file")
self.validate_identity("DETACH DATABASE IF EXISTS file", "DETACH DATABASE IF EXISTS file")
self.validate_identity("DETACH DATABASE db", "DETACH db")
@ -1652,3 +1656,20 @@ class TestDuckDB(Validator):
def test_show_tables(self):
self.validate_identity("SHOW TABLES").assert_is(exp.Show)
self.validate_identity("SHOW ALL TABLES").assert_is(exp.Show)
def test_extract_date_parts(self):
for part in ("WEEK", "WEEKOFYEAR"):
# Both are synonyms for ISO week
self.validate_identity(f"EXTRACT({part} FROM foo)", "EXTRACT(WEEK FROM foo)")
for part in (
"WEEKDAY",
"ISOYEAR",
"ISODOW",
"YEARWEEK",
"TIMEZONE_HOUR",
"TIMEZONE_MINUTE",
):
with self.subTest(f"Testing DuckDB EXTRACT({part} FROM foo)"):
# All of these should remain as is, they don't have synonyms
self.validate_identity(f"EXTRACT({part} FROM foo)")

168
tests/dialects/test_pipe_syntax.py
View file

@ -21,7 +21,7 @@ class TestPipeSyntax(Validator):
)
self.validate_identity(
"FROM x |> SELECT x1 + 1 as x1_a, x2 - 1 as x2_a |> WHERE x1_a > 1 |> SELECT x2_a",
"WITH __tmp1 AS (SELECT x1 + 1 AS x1_a, x2 - 1 AS x2_a FROM x), __tmp2 AS (SELECT * FROM __tmp1 WHERE x1_a > 1) SELECT x2_a FROM __tmp2",
"WITH __tmp1 AS (SELECT x1 + 1 AS x1_a, x2 - 1 AS x2_a FROM x), __tmp2 AS (SELECT x2_a FROM __tmp1 WHERE x1_a > 1) SELECT * FROM __tmp2",
)
self.validate_identity(
"FROM x |> WHERE x1 > 0 OR x2 > 0 |> WHERE x3 > 1 AND x4 > 1 |> SELECT x1, x4",
@ -33,7 +33,7 @@ class TestPipeSyntax(Validator):
)
self.validate_identity(
"FROM x |> WHERE x1 > 1 AND x2 > 2 |> SELECT x1 as gt1, x2 as gt2 |> SELECT gt1 * 2 + gt2 * 2 AS gt2_2",
"WITH __tmp1 AS (SELECT x1 AS gt1, x2 AS gt2 FROM x WHERE x1 > 1 AND x2 > 2), __tmp2 AS (SELECT * FROM __tmp1) SELECT gt1 * 2 + gt2 * 2 AS gt2_2 FROM __tmp2",
"WITH __tmp1 AS (SELECT x1 AS gt1, x2 AS gt2 FROM x WHERE x1 > 1 AND x2 > 2), __tmp2 AS (SELECT gt1 * 2 + gt2 * 2 AS gt2_2 FROM __tmp1) SELECT * FROM __tmp2",
)
def test_order_by(self):
@ -87,7 +87,7 @@ class TestPipeSyntax(Validator):
)
self.validate_identity(
"FROM x |> AGGREGATE SUM(x1) AS s_x1 |> SELECT s_x1",
"WITH __tmp1 AS (SELECT SUM(x1) AS s_x1 FROM x), __tmp2 AS (SELECT * FROM __tmp1) SELECT s_x1 FROM __tmp2",
"WITH __tmp1 AS (SELECT SUM(x1) AS s_x1 FROM x), __tmp2 AS (SELECT s_x1 FROM __tmp1) SELECT * FROM __tmp2",
)
self.validate_identity(
"FROM x |> AGGREGATE SUM(x1), MAX(x2), MIN(x3) GROUP BY x4, x5",
@ -99,7 +99,7 @@ class TestPipeSyntax(Validator):
)
self.validate_identity(
"FROM x |> AGGREGATE SUM(x1) as s_x1 GROUP BY x1 |> SELECT s_x1, x1 as ss_x1",
"WITH __tmp1 AS (SELECT SUM(x1) AS s_x1, x1 FROM x GROUP BY x1), __tmp2 AS (SELECT * FROM __tmp1) SELECT s_x1, x1 AS ss_x1 FROM __tmp2",
"WITH __tmp1 AS (SELECT SUM(x1) AS s_x1, x1 FROM x GROUP BY x1), __tmp2 AS (SELECT s_x1, x1 AS ss_x1 FROM __tmp1) SELECT * FROM __tmp2",
)
self.validate_identity(
"FROM x |> AGGREGATE SUM(x1) GROUP",
@ -127,7 +127,7 @@ class TestPipeSyntax(Validator):
f"Testing pipe syntax AGGREGATE with GROUP AND ORDER BY for order option: {order_option}"
):
self.validate_all(
f"WITH __tmp1 AS (SELECT SUM(x1) AS x_s, x1 AS g_x1 FROM x GROUP BY g_x1 ORDER BY g_x1 {order_option}), __tmp2 AS (SELECT * FROM __tmp1) SELECT g_x1, x_s FROM __tmp2",
f"WITH __tmp1 AS (SELECT SUM(x1) AS x_s, x1 AS g_x1 FROM x GROUP BY g_x1 ORDER BY g_x1 {order_option}), __tmp2 AS (SELECT g_x1, x_s FROM __tmp1) SELECT * FROM __tmp2",
read={
"bigquery": f"FROM x |> AGGREGATE SUM(x1) AS x_s GROUP AND ORDER BY x1 AS g_x1 {order_option} |> SELECT g_x1, x_s",
},
@ -136,7 +136,7 @@ class TestPipeSyntax(Validator):
def test_set_operators(self):
self.validate_identity(
"FROM x |> SELECT x.x1 |> UNION ALL (SELECT 1 AS c)",
"WITH __tmp1 AS (SELECT x.x1 FROM x), __tmp2 AS (SELECT * FROM __tmp1), __tmp3 AS (SELECT * FROM __tmp2 UNION ALL (SELECT 1 AS c)) SELECT * FROM __tmp3",
"WITH __tmp1 AS (SELECT x.x1 FROM x), __tmp2 AS (SELECT * FROM __tmp1), __tmp3 AS (SELECT * FROM __tmp2 UNION ALL SELECT 1 AS c) SELECT * FROM __tmp3",
)
for op_operator in (
@ -149,7 +149,7 @@ class TestPipeSyntax(Validator):
self.validate_all(
f"FROM x|> {op_operator} (SELECT y1 FROM y), (SELECT z1 FROM z)",
write={
"bigquery": f"WITH __tmp1 AS (SELECT * FROM x), __tmp2 AS (SELECT * FROM __tmp1 {op_operator} (SELECT y1 FROM y) {op_operator} (SELECT z1 FROM z)) SELECT * FROM __tmp2"
"bigquery": f"WITH __tmp1 AS (SELECT * FROM x), __tmp2 AS (SELECT * FROM __tmp1 {op_operator} SELECT y1 FROM y {op_operator} SELECT z1 FROM z) SELECT * FROM __tmp2"
},
)
@ -164,7 +164,7 @@ class TestPipeSyntax(Validator):
self.validate_all(
f"FROM x|> SELECT x1, x2 |> {op_prefix} {op_operator} BY NAME (SELECT y1, y2 FROM y), (SELECT z1, z2 FROM z)",
write={
"bigquery": f"WITH __tmp1 AS (SELECT x1, x2 FROM x), __tmp2 AS (SELECT * FROM __tmp1), __tmp3 AS (SELECT * FROM __tmp2 {op_prefix} {op_operator} BY NAME (SELECT y1, y2 FROM y) {op_prefix} {op_operator} BY NAME (SELECT z1, z2 FROM z)) SELECT * FROM __tmp3",
"bigquery": f"WITH __tmp1 AS (SELECT x1, x2 FROM x), __tmp2 AS (SELECT * FROM __tmp1), __tmp3 AS (SELECT * FROM __tmp2 {op_prefix} {op_operator} BY NAME SELECT y1, y2 FROM y {op_prefix} {op_operator} BY NAME SELECT z1, z2 FROM z) SELECT * FROM __tmp3",
},
)
@ -183,34 +183,30 @@ class TestPipeSyntax(Validator):
*
FROM __tmp2
UNION
(
SELECT
2 AS a1
)
SELECT
2 AS a1
), __tmp4 AS (
SELECT
*
x1
FROM __tmp3
), __tmp5 AS (
SELECT
x1
*
FROM __tmp4
), __tmp6 AS (
SELECT
*
FROM __tmp5
UNION
(
SELECT
3 AS a2
)
SELECT
3 AS a2
), __tmp7 AS (
SELECT
*
x1
FROM __tmp6
)
SELECT
x1
*
FROM __tmp7
WHERE
x1 > 100""",
@ -227,14 +223,11 @@ WHERE
*
FROM __tmp1
UNION ALL
(
SELECT
2 AS a1,
'2' AS a2
)
SELECT
2 AS a1,
'2' AS a2
), __tmp3 AS (
SELECT
*,
AVG(x1) AS m_x1
FROM __tmp2
), __tmp4 AS (
@ -250,18 +243,16 @@ WHERE
*
FROM __tmp5
UNION ALL
(
SELECT
y1
FROM c.y
)
SELECT
y1
FROM c.y
), __tmp7 AS (
SELECT
*
m_x1
FROM __tmp6
)
SELECT
m_x1
*
FROM __tmp7""",
pretty=True,
)
@ -277,11 +268,9 @@ FROM __tmp7""",
*
FROM __tmp1
UNION ALL
(
SELECT
2 AS a1,
'2' AS a2
)
SELECT
2 AS a1,
'2' AS a2
), __tmp3 AS (
SELECT
*
@ -291,11 +280,9 @@ FROM __tmp7""",
*
FROM __tmp3
UNION ALL
(
SELECT
y1
FROM c.y
)
SELECT
y1
FROM c.y
)
SELECT
*
@ -346,11 +333,9 @@ WHERE
*
FROM __tmp2
UNION ALL
(
SELECT
1,
2
)
SELECT
1,
2
)
SELECT
*
@ -378,3 +363,90 @@ WHERE
"FROM x |> JOIN y on x.id = y.id |> UNPIVOT(col FOR item IN (foo1, foo2))",
"WITH __tmp1 AS (SELECT * FROM x UNPIVOT(col FOR item IN (foo1, foo2)) JOIN y ON x.id = y.id) SELECT * FROM __tmp1",
)
def test_as(self):
self.validate_identity(
"FROM x |> AS a_x |> WHERE a_x.x1 > 0",
"WITH a_x AS (SELECT * FROM x) SELECT * FROM a_x WHERE a_x.x1 > 0",
)
self.validate_identity(
"FROM x AS t |> AGGREGATE SUM(x1) AS s_x1 GROUP BY id, x2 |> AS t1 |> JOIN y AS t2 ON t1.id = t2.id |> SELECT t2.id, s_x1",
"WITH __tmp1 AS (SELECT SUM(x1) AS s_x1, id, x2 FROM x AS t GROUP BY id, x2), t1 AS (SELECT * FROM __tmp1), __tmp2 AS (SELECT t2.id, s_x1 FROM t1 JOIN y AS t2 ON t1.id = t2.id) SELECT * FROM __tmp2",
)
self.validate_identity(
"FROM x |> JOIN y ON x.x1 = y.y1 |> AS a |> WHERE a.x2 > 1",
"WITH a AS (SELECT * FROM x JOIN y ON x.x1 = y.y1) SELECT * FROM a WHERE a.x2 > 1",
)
def test_extend(self):
self.validate_identity(
"FROM x |> EXTEND id IN (1, 2) AS is_1_2, id + 1 as a_id",
"WITH __tmp1 AS (SELECT *, id IN (1, 2) AS is_1_2, id + 1 AS a_id FROM x) SELECT * FROM __tmp1",
)
self.validate_identity(
"FROM x |> SELECT x.x1, x.x2 |> EXTEND x1 + 1 as x1_1, x2 + 1 as x2_1 |> WHERE x1_1 > 0 AND x2_1 > 0",
"WITH __tmp1 AS (SELECT x.x1, x.x2 FROM x), __tmp2 AS (SELECT *, x1 + 1 AS x1_1, x2 + 1 AS x2_1 FROM __tmp1) SELECT * FROM __tmp2 WHERE x1_1 > 0 AND x2_1 > 0",
)
self.validate_identity(
"FROM (SELECT 'foo1' AS item1, 2 AS item2 UNION ALL SELECT 'foo2' AS item1, 5 AS item2) |> EXTEND SUM(item2) OVER() AS item2_sum",
"WITH __tmp1 AS (SELECT *, SUM(item2) OVER () AS item2_sum FROM (SELECT 'foo1' AS item1, 2 AS item2 UNION ALL SELECT 'foo2' AS item1, 5 AS item2)) SELECT * FROM __tmp1",
)
def test_drop(self):
self.validate_identity(
"FROM x |> DROP x1, x2",
"SELECT * EXCEPT (x1, x2) FROM x",
)
self.validate_identity("FROM x |> DROP x1 |> DROP x2", "SELECT * EXCEPT (x1, x2) FROM x")
self.validate_identity(
"FROM x |> SELECT x.x1, x.x2, x.x3 |> DROP x1, x2 |> WHERE x3 > 0",
"WITH __tmp1 AS (SELECT x.x1, x.x2, x.x3 FROM x) SELECT * EXCEPT (x1, x2) FROM __tmp1 WHERE x3 > 0",
)
self.validate_identity(
"FROM x |> SELECT x.x1, x.x2, x.x3 |> DROP x1, x2 |> WHERE x3 > 0",
"WITH __tmp1 AS (SELECT x.x1, x.x2, x.x3 FROM x) SELECT * EXCEPT (x1, x2) FROM __tmp1 WHERE x3 > 0",
)
self.validate_identity(
"FROM (SELECT 1 AS x, 2 AS y) AS t |> DROP x |> SELECT t.x AS original_x, y",
"WITH __tmp1 AS (SELECT * EXCEPT (x), t.x AS original_x FROM (SELECT 1 AS x, 2 AS y) AS t), __tmp2 AS (SELECT original_x, y FROM __tmp1) SELECT * FROM __tmp2",
)
self.validate_identity(
"FROM x |> PIVOT(SUM(sales) FOR quarter IN ('Q1', 'Q2')) |> DROP Q1 |> SELECT *",
"WITH __tmp1 AS (SELECT * FROM x PIVOT(SUM(sales) FOR quarter IN ('Q1', 'Q2'))), __tmp2 AS (SELECT * EXCEPT (Q1) FROM __tmp1), __tmp3 AS (SELECT * FROM __tmp2) SELECT * FROM __tmp3",
)
self.validate_identity(
"FROM x |> DROP x1 |> DROP x2 |> UNION ALL (SELECT 1 AS c)",
"WITH __tmp1 AS (SELECT * EXCEPT (x1, x2) FROM x), __tmp2 AS (SELECT * FROM __tmp1 UNION ALL SELECT 1 AS c) SELECT * FROM __tmp2",
)
def test_set(self):
self.validate_identity(
"FROM x |> SET x1 = 8 * x1", "SELECT * REPLACE (8 * x1 AS x1) FROM x"
)
self.validate_identity(
"FROM x |> SET x1 = 8 * x1 |> SET x2 = 2",
"SELECT * REPLACE (8 * x1 AS x1, 2 AS x2) FROM x",
)
self.validate_identity(
"FROM (SELECT 2 AS x, 3 AS y) AS t |> SET x = t.x * t.x, y = 8 |> SELECT t.x AS original_x, x, y",
"WITH __tmp1 AS (SELECT * REPLACE (t.x * t.x AS x, 8 AS y), t.x AS original_x FROM (SELECT 2 AS x, 3 AS y) AS t), __tmp2 AS (SELECT original_x, x, y FROM __tmp1) SELECT * FROM __tmp2",
)
self.validate_identity(
"FROM x |> DROP x1 |> DROP x2 |> SET x3 = 2 * x3 |> UNION ALL (SELECT 1 AS c)",
"WITH __tmp1 AS (SELECT * EXCEPT (x1, x2) REPLACE (2 * x3 AS x3) FROM x), __tmp2 AS (SELECT * FROM __tmp1 UNION ALL SELECT 1 AS c) SELECT * FROM __tmp2",
)
def test_tablesample(self):
self.validate_identity(
"FROM x |> TABLESAMPLE SYSTEM (1 PERCENT)",
"SELECT * FROM x TABLESAMPLE SYSTEM (1 PERCENT)",
)
self.validate_identity(
"FROM x |> SELECT x.x1 |> TABLESAMPLE SYSTEM (1 PERCENT)",
"WITH __tmp1 AS (SELECT x.x1 FROM x TABLESAMPLE SYSTEM (1 PERCENT)) SELECT * FROM __tmp1",
)
self.validate_identity(
"FROM x |> TABLESAMPLE SYSTEM (1 PERCENT) |> WHERE x.x1 > 0 |> SELECT x1, x2",
"WITH __tmp1 AS (SELECT x1, x2 FROM x WHERE x.x1 > 0 TABLESAMPLE SYSTEM (1 PERCENT)) SELECT * FROM __tmp1",
)

39
tests/dialects/test_snowflake.py
View file

@ -286,6 +286,14 @@ class TestSnowflake(Validator):
"CREATE TEMPORARY TABLE x (y NUMBER AUTOINCREMENT(0, 1))",
"CREATE TEMPORARY TABLE x (y DECIMAL(38, 0) AUTOINCREMENT START 0 INCREMENT 1)",
)
self.validate_identity(
"CREATE OR REPLACE TABLE x (y NUMBER(38, 0) NOT NULL AUTOINCREMENT START 1 INCREMENT 1 ORDER)",
"CREATE OR REPLACE TABLE x (y DECIMAL(38, 0) NOT NULL AUTOINCREMENT START 1 INCREMENT 1 ORDER)",
)
self.validate_identity(
"CREATE OR REPLACE TABLE x (y NUMBER(38, 0) NOT NULL AUTOINCREMENT START 1 INCREMENT 1 NOORDER)",
"CREATE OR REPLACE TABLE x (y DECIMAL(38, 0) NOT NULL AUTOINCREMENT START 1 INCREMENT 1 NOORDER)",
)
self.validate_identity(
"CREATE TABLE x (y NUMBER IDENTITY START 0 INCREMENT 1)",
"CREATE TABLE x (y DECIMAL(38, 0) AUTOINCREMENT START 0 INCREMENT 1)",
@ -325,13 +333,31 @@ class TestSnowflake(Validator):
"SELECT * FROM xxx, yyy, zzz",
)
self.validate_all(
"SELECT _u['foo'], bar, baz FROM TABLE(FLATTEN(INPUT => [OBJECT_CONSTRUCT('foo', 'x', 'bars', ['y', 'z'], 'bazs', ['w'])])) AS _t0(seq, key, path, index, _u, this), TABLE(FLATTEN(INPUT => _u['bars'])) AS _t1(seq, key, path, index, bar, this), TABLE(FLATTEN(INPUT => _u['bazs'])) AS _t2(seq, key, path, index, baz, this)",
read={
"bigquery": "SELECT _u.foo, bar, baz FROM UNNEST([struct('x' AS foo, ['y', 'z'] AS bars, ['w'] AS bazs)]) AS _u, UNNEST(_u.bars) AS bar, UNNEST(_u.bazs) AS baz",
},
)
self.validate_all(
"SELECT _u, _u['foo'], _u['bar'] FROM TABLE(FLATTEN(INPUT => [OBJECT_CONSTRUCT('foo', 'x', 'bar', 'y')])) AS _t0(seq, key, path, index, _u, this)",
read={
"bigquery": "select _u, _u.foo, _u.bar from unnest([struct('x' as foo, 'y' AS bar)]) as _u",
},
)
self.validate_all(
"SELECT _u['foo'][0].bar FROM TABLE(FLATTEN(INPUT => [OBJECT_CONSTRUCT('foo', [OBJECT_CONSTRUCT('bar', 1)])])) AS _t0(seq, key, path, index, _u, this)",
read={
"bigquery": "select _u.foo[0].bar from unnest([struct([struct(1 as bar)] as foo)]) as _u",
},
)
self.validate_all(
"SELECT ARRAY_INTERSECTION([1, 2], [2, 3])",
write={
"snowflake": "SELECT ARRAY_INTERSECTION([1, 2], [2, 3])",
"starrocks": "SELECT ARRAY_INTERSECT([1, 2], [2, 3])",
},
)
self.validate_all(
"CREATE TABLE test_table (id NUMERIC NOT NULL AUTOINCREMENT)",
write={
@ -1109,6 +1135,17 @@ class TestSnowflake(Validator):
},
)
self.validate_all(
"SELECT DATE_PART(DAYOFWEEKISO, foo)",
read={
"snowflake": "SELECT DATE_PART(WEEKDAY_ISO, foo)",
},
write={
"snowflake": "SELECT DATE_PART(DAYOFWEEKISO, foo)",
"duckdb": "SELECT EXTRACT(ISODOW FROM foo)",
},
)
def test_null_treatment(self):
self.validate_all(
r"SELECT FIRST_VALUE(TABLE1.COLUMN1) OVER (PARTITION BY RANDOM_COLUMN1, RANDOM_COLUMN2 ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS MY_ALIAS FROM TABLE1",

4
tests/dialects/test_tsql.py
View file

@ -1856,6 +1856,10 @@ WHERE
"spark": "SELECT * FROM A LIMIT 3",
},
)
self.validate_identity(
"CREATE TABLE schema.table AS SELECT a, id FROM (SELECT a, (SELECT id FROM tb ORDER BY t DESC LIMIT 1) as id FROM tbl) AS _subquery",
"SELECT * INTO schema.table FROM (SELECT a AS a, id AS id FROM (SELECT a AS a, (SELECT TOP 1 id FROM tb ORDER BY t DESC) AS id FROM tbl) AS _subquery) AS temp",
)
self.validate_identity("SELECT TOP 10 PERCENT")
self.validate_identity("SELECT TOP 10 PERCENT WITH TIES")