dbcli/sqlglot
1
0
Fork 0
Code Issues Activity

Merging upstream version 25.16.1.

Browse source 
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
Daniel Baumann 2025-02-13 21:52:32 +01:00
parent 7688e2bdf8
commit bad79d1f7c
Signed by: daniel
GPG key ID: FBB4F0E80A80222F
110 changed files with 75353 additions and 68092 deletions
Download patch file Download diff file Expand all files Collapse all files

68
tests/test_expressions.py
View file

@ -1,3 +1,4 @@
import sys
import datetime
import math
import unittest
@ -431,6 +432,31 @@ class TestExpressions(unittest.TestCase):
table = expression.find(exp.Table)
self.assertEqual(table.alias_column_names, ["a", "b"])
def test_cast(self):
expression = parse_one("select cast(x as DATE)")
casts = list(expression.find_all(exp.Cast))
self.assertEqual(len(casts), 1)
cast = casts[0]
self.assertTrue(cast.to.is_type(exp.DataType.Type.DATE))
# check that already cast values arent re-cast if wrapped in a cast to the same type
recast = exp.cast(cast, to=exp.DataType.Type.DATE)
self.assertEqual(recast, cast)
self.assertEqual(recast.sql(), "CAST(x AS DATE)")
# however, recasting is fine if the types are different
recast = exp.cast(cast, to=exp.DataType.Type.VARCHAR)
self.assertNotEqual(recast, cast)
self.assertEqual(len(list(recast.find_all(exp.Cast))), 2)
self.assertEqual(recast.sql(), "CAST(CAST(x AS DATE) AS VARCHAR)")
# check that dialect is used when casting strings
self.assertEqual(
exp.cast("x", to="regtype", dialect="postgres").sql(), "CAST(x AS REGTYPE)"
)
self.assertEqual(exp.cast("`x`", to="date", dialect="hive").sql(), 'CAST("x" AS DATE)')
def test_ctes(self):
expression = parse_one("SELECT a FROM x")
self.assertEqual(expression.ctes, [])
@ -657,7 +683,10 @@ class TestExpressions(unittest.TestCase):
self.assertIsInstance(parse_one("TIME_TO_TIME_STR(a)"), exp.Cast)
self.assertIsInstance(parse_one("TIME_TO_UNIX(a)"), exp.TimeToUnix)
self.assertIsInstance(parse_one("TIME_STR_TO_DATE(a)"), exp.TimeStrToDate)
self.assertIsInstance(parse_one("TIME_STR_TO_TIME(a)"), exp.TimeStrToTime)
(self.assertIsInstance(parse_one("TIME_STR_TO_TIME(a)"), exp.TimeStrToTime),)
self.assertIsInstance(
parse_one("TIME_STR_TO_TIME(a, 'America/Los_Angeles')"), exp.TimeStrToTime
)
self.assertIsInstance(parse_one("TIME_STR_TO_UNIX(a)"), exp.TimeStrToUnix)
self.assertIsInstance(parse_one("TRIM(LEADING 'b' FROM 'bla')"), exp.Trim)
self.assertIsInstance(parse_one("TS_OR_DS_ADD(a, 1, 'day')"), exp.TsOrDsAdd)
@ -791,6 +820,7 @@ class TestExpressions(unittest.TestCase):
def test_convert(self):
from collections import namedtuple
import pytz
PointTuple = namedtuple("Point", ["x", "y"])
@ -809,11 +839,17 @@ class TestExpressions(unittest.TestCase):
({"x": None}, "MAP(ARRAY('x'), ARRAY(NULL))"),
(
datetime.datetime(2022, 10, 1, 1, 1, 1, 1),
"TIME_STR_TO_TIME('2022-10-01 01:01:01.000001+00:00')",
"TIME_STR_TO_TIME('2022-10-01 01:01:01.000001')",
),
(
datetime.datetime(2022, 10, 1, 1, 1, 1, tzinfo=datetime.timezone.utc),
"TIME_STR_TO_TIME('2022-10-01 01:01:01+00:00')",
"TIME_STR_TO_TIME('2022-10-01 01:01:01+00:00', 'UTC')",
),
(
pytz.timezone("America/Los_Angeles").localize(
datetime.datetime(2022, 10, 1, 1, 1, 1)
),
"TIME_STR_TO_TIME('2022-10-01 01:01:01-07:00', 'America/Los_Angeles')",
),
(datetime.date(2022, 10, 1), "DATE_STR_TO_DATE('2022-10-01')"),
(math.nan, "NULL"),
@ -829,6 +865,21 @@ class TestExpressions(unittest.TestCase):
"MAP_FROM_ARRAYS(ARRAY('test'), ARRAY('value'))",
)
@unittest.skipUnless(sys.version_info >= (3, 9), "zoneinfo only available from python 3.9+")
def test_convert_python39(self):
import zoneinfo
for value, expected in [
(
datetime.datetime(
2022, 10, 1, 1, 1, 1, tzinfo=zoneinfo.ZoneInfo("America/Los_Angeles")
),
"TIME_STR_TO_TIME('2022-10-01 01:01:01-07:00', 'America/Los_Angeles')",
)
]:
with self.subTest(value):
self.assertEqual(exp.convert(value).sql(), expected)
def test_comment_alias(self):
sql = """
SELECT
@ -993,16 +1044,15 @@ FROM foo""",
self.assertEqual(exp.DataType.build("UNKNOWN", dialect="bigquery").sql(), "UNKNOWN")
self.assertEqual(exp.DataType.build("UNKNOWN", dialect="snowflake").sql(), "UNKNOWN")
self.assertEqual(exp.DataType.build("TIMESTAMP", dialect="bigquery").sql(), "TIMESTAMPTZ")
self.assertEqual(
exp.DataType.build("struct<x int>", dialect="spark").sql(), "STRUCT<x INT>"
)
self.assertEqual(exp.DataType.build("USER-DEFINED").sql(), "USER-DEFINED")
self.assertEqual(exp.DataType.build("ARRAY<UNKNOWN>").sql(), "ARRAY<UNKNOWN>")
self.assertEqual(exp.DataType.build("ARRAY<NULL>").sql(), "ARRAY<NULL>")
self.assertEqual(exp.DataType.build("varchar(100) collate 'en-ci'").sql(), "VARCHAR(100)")
self.assertEqual(exp.DataType.build("int[3]").sql(dialect="duckdb"), "INT[3]")
self.assertEqual(exp.DataType.build("int[3][3]").sql(dialect="duckdb"), "INT[3][3]")
self.assertEqual(
exp.DataType.build("struct<x int>", dialect="spark").sql(), "STRUCT<x INT>"
)
with self.assertRaises(ParseError):
exp.DataType.build("varchar(")
@ -1107,6 +1157,10 @@ FROM foo""",
dtype = exp.DataType.build("a.b.c", udt=True)
assert dtype.is_type("a.b.c")
dtype = exp.DataType.build("Nullable(Int32)", dialect="clickhouse")
assert dtype.is_type("int")
assert not dtype.is_type("int", check_nullable=True)
with self.assertRaises(ParseError):
exp.DataType.build("foo")