sqlglot 27.3.1__tar.gz → 27.4.0__tar.gz

{sqlglot-27.3.1 → sqlglot-27.4.0}/CHANGELOG.md

@@ -1,6 +1,20 @@
 Changelog
 =========
 
+## [v27.3.1] - 2025-07-24
+### :boom: BREAKING CHANGES
+- due to [`48703c4`](https://github.com/tobymao/sqlglot/commit/48703c4fadd9f24de151a63d1bfa74f4b8e71133) - temporarily move VARCHAR length inference logic to Fabric *(commit by [@georgesittas](https://github.com/georgesittas))*:
+
+  temporarily move VARCHAR length inference logic to Fabric
+
+
+### :sparkles: New Features
+- [`4cc321c`](https://github.com/tobymao/sqlglot/commit/4cc321cc1995d538ab0c48a7a0a473c31e76ddff) - **singlestore**: Added initial implementation of SingleStore dialect *(PR [#5447](https://github.com/tobymao/sqlglot/pull/5447) by [@AdalbertMemSQL](https://github.com/AdalbertMemSQL))*
+
+### :wrench: Chores
+- [`48703c4`](https://github.com/tobymao/sqlglot/commit/48703c4fadd9f24de151a63d1bfa74f4b8e71133) - **tsql**: temporarily move VARCHAR length inference logic to Fabric *(commit by [@georgesittas](https://github.com/georgesittas))*
+
+
 ## [v27.3.0] - 2025-07-24
 ### :boom: BREAKING CHANGES
 - due to [`d7ccb48`](https://github.com/tobymao/sqlglot/commit/d7ccb48e542c49258e31cc4df45f49beebc2e238) - week/quarter support *(PR [#5374](https://github.com/tobymao/sqlglot/pull/5374) by [@eakmanrq](https://github.com/eakmanrq))*:
@@ -6291,3 +6305,4 @@ Changelog
 [v27.1.0]: https://github.com/tobymao/sqlglot/compare/v26.31.2...v27.1.0
 [v27.2.0]: https://github.com/tobymao/sqlglot/compare/v27.1.0...v27.2.0
 [v27.3.0]: https://github.com/tobymao/sqlglot/compare/v27.0.1...v27.3.0
+[v27.3.1]: https://github.com/tobymao/sqlglot/compare/v27.3.0...v27.3.1

{sqlglot-27.3.1 → sqlglot-27.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 27.3.1
+Version: 27.4.0
 Summary: An easily customizable SQL parser and transpiler
 Author-email: Toby Mao <toby.mao@gmail.com>
 License: MIT License

{sqlglot-27.3.1 → sqlglot-27.4.0}/sqlglot/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '27.3.1'
-__version_tuple__ = version_tuple = (27, 3, 1)
+__version__ = version = '27.4.0'
+__version_tuple__ = version_tuple = (27, 4, 0)

{sqlglot-27.3.1 → sqlglot-27.4.0}/sqlglot/dialects/bigquery.py

@@ -365,6 +365,31 @@ def _annotate_concat(self: TypeAnnotator, expression: exp.Concat) -> exp.Concat:
     return annotated
 
 
+def _annotate_array(self: TypeAnnotator, expression: exp.Array) -> exp.Array:
+    array_args = expression.expressions
+
+    # BigQuery behaves as follows:
+    #
+    # SELECT t, TYPEOF(t) FROM (SELECT 'foo') AS t            -- foo, STRUCT<STRING>
+    # SELECT ARRAY(SELECT 'foo'), TYPEOF(ARRAY(SELECT 'foo')) -- foo, ARRAY<STRING>
+    if (
+        len(array_args) == 1
+        and isinstance(select := array_args[0].unnest(), exp.Select)
+        and (query_type := select.meta.get("query_type")) is not None
+        and query_type.is_type(exp.DataType.Type.STRUCT)
+        and len(query_type.expressions) == 1
+    ):
+        projection_type = query_type.expressions[0].kind.copy()
+        array_type = exp.DataType(
+            this=exp.DataType.Type.ARRAY,
+            expressions=[projection_type],
+            nested=True,
+        )
+        return self._annotate_with_type(expression, array_type)
+
+    return self._annotate_by_args(expression, "expressions", array=True)
+
+
 class BigQuery(Dialect):
     WEEK_OFFSET = -1
     UNNEST_COLUMN_ONLY = True
@@ -445,6 +470,7 @@ class BigQuery(Dialect):
                 exp.Substring,
             )
         },
+        exp.Array: _annotate_array,
         exp.ArrayConcat: lambda self, e: self._annotate_by_args(e, "this", "expressions"),
         exp.Ascii: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
         exp.BitwiseAndAgg: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),

{sqlglot-27.3.1 → sqlglot-27.4.0}/sqlglot/dialects/exasol.py

@@ -13,6 +13,12 @@ from sqlglot.generator import unsupported_args
 from sqlglot.tokens import TokenType
 
 
+def _sha2_sql(self: Exasol.Generator, expression: exp.SHA2) -> str:
+    length = expression.text("length")
+    func_name = "HASH_SHA256" if length == "256" else "HASH_SHA512"
+    return self.func(func_name, expression.this)
+
+
 class Exasol(Dialect):
     TIME_MAPPING = {
         "yyyy": "%Y",
@@ -59,6 +65,10 @@ class Exasol(Dialect):
             "BIT_RSHIFT": binary_from_function(exp.BitwiseRightShift),
             "EVERY": lambda args: exp.All(this=seq_get(args, 0)),
             "EDIT_DISTANCE": exp.Levenshtein.from_arg_list,
+            "HASH_SHA": exp.SHA.from_arg_list,
+            "HASH_SHA1": exp.SHA.from_arg_list,
+            "HASH_MD5": exp.MD5.from_arg_list,
+            "HASHTYPE_MD5": exp.MD5Digest.from_arg_list,
             "REGEXP_REPLACE": lambda args: exp.RegexpReplace(
                 this=seq_get(args, 0),
                 expression=seq_get(args, 1),
@@ -66,6 +76,12 @@ class Exasol(Dialect):
                 position=seq_get(args, 3),
                 occurrence=seq_get(args, 4),
             ),
+            "HASH_SHA256": lambda args: exp.SHA2(
+                this=seq_get(args, 0), length=exp.Literal.number(256)
+            ),
+            "HASH_SHA512": lambda args: exp.SHA2(
+                this=seq_get(args, 0), length=exp.Literal.number(512)
+            ),
             "VAR_POP": exp.VariancePop.from_arg_list,
             "APPROXIMATE_COUNT_DISTINCT": exp.ApproxDistinct.from_arg_list,
             "TO_CHAR": build_formatted_time(exp.ToChar, "exasol"),
@@ -173,6 +189,14 @@ class Exasol(Dialect):
                     self, e, func_name="INSTR", supports_position=True, supports_occurrence=True
                 )
             ),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/hash_sha%5B1%5D.htm#HASH_SHA%5B1%5D
+            exp.SHA: rename_func("HASH_SHA"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/hash_sha256.htm
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/hash_sha512.htm
+            exp.SHA2: _sha2_sql,
+            exp.MD5: rename_func("HASH_MD5"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/hashtype_md5.htm
+            exp.MD5Digest: rename_func("HASHTYPE_MD5"),
             # https://docs.exasol.com/db/latest/sql/create_view.htm
             exp.CommentColumnConstraint: lambda self, e: f"COMMENT IS {self.sql(e, 'this')}",
         }

{sqlglot-27.3.1 → sqlglot-27.4.0}/sqlglot/dialects/snowflake.py

@@ -1673,3 +1673,17 @@ class Snowflake(Dialect):
                 to=exp.DataType(this=exp.DataType.Type.DATE),
             )
             return self.sql(expr)
+
+        def dot_sql(self, expression: exp.Dot) -> str:
+            this = expression.this
+
+            if not this.type:
+                from sqlglot.optimizer.annotate_types import annotate_types
+
+                this = annotate_types(this, dialect=self.dialect)
+
+            if not isinstance(this, exp.Dot) and this.is_type(exp.DataType.Type.STRUCT):
+                # Generate colon notation for the top level STRUCT
+                return f"{self.sql(this)}:{self.sql(expression, 'expression')}"
+
+            return super().dot_sql(expression)

{sqlglot-27.3.1 → sqlglot-27.4.0}/sqlglot/dialects/sqlite.py

@@ -96,7 +96,12 @@ class SQLite(Dialect):
 
         NESTED_COMMENTS = False
 
-        KEYWORDS = tokens.Tokenizer.KEYWORDS.copy()
+        KEYWORDS = {
+            **tokens.Tokenizer.KEYWORDS,
+            "ATTACH": TokenType.ATTACH,
+            "DETACH": TokenType.DETACH,
+        }
+
         KEYWORDS.pop("/*+")
 
         COMMANDS = {*tokens.Tokenizer.COMMANDS, TokenType.REPLACE}
@@ -114,6 +119,12 @@ class SQLite(Dialect):
             "TIME": lambda args: exp.Anonymous(this="TIME", expressions=args),
         }
 
+        STATEMENT_PARSERS = {
+            **parser.Parser.STATEMENT_PARSERS,
+            TokenType.ATTACH: lambda self: self._parse_attach_detach(),
+            TokenType.DETACH: lambda self: self._parse_attach_detach(is_attach=False),
+        }
+
         def _parse_unique(self) -> exp.UniqueColumnConstraint:
             # Do not consume more tokens if UNIQUE is used as a standalone constraint, e.g:
             # CREATE TABLE foo (bar TEXT UNIQUE REFERENCES baz ...)
@@ -122,6 +133,16 @@ class SQLite(Dialect):
 
             return super()._parse_unique()
 
+        def _parse_attach_detach(self, is_attach=True) -> exp.Attach | exp.Detach:
+            self._match(TokenType.DATABASE)
+            this = self._parse_expression()
+
+            return (
+                self.expression(exp.Attach, this=this)
+                if is_attach
+                else self.expression(exp.Detach, this=this)
+            )
+
     class Generator(generator.Generator):
         JOIN_HINTS = False
         TABLE_HINTS = False

{sqlglot-27.3.1 → sqlglot-27.4.0}/sqlglot/expressions.py

@@ -4942,7 +4942,7 @@ class AddConstraint(Expression):
 
 
 class AddPartition(Expression):
-    arg_types = {"this": True, "exists": False}
+    arg_types = {"this": True, "exists": False, "location": False}
 
 
 class AttachOption(Expression):

{sqlglot-27.3.1 → sqlglot-27.4.0}/sqlglot/generator.py

@@ -3549,7 +3549,9 @@ class Generator(metaclass=_Generator):
 
     def addpartition_sql(self, expression: exp.AddPartition) -> str:
         exists = "IF NOT EXISTS " if expression.args.get("exists") else ""
-        return f"ADD {exists}{self.sql(expression.this)}"
+        location = self.sql(expression, "location")
+        location = f" {location}" if location else ""
+        return f"ADD {exists}{self.sql(expression.this)}{location}"
 
     def distinct_sql(self, expression: exp.Distinct) -> str:
         this = self.expressions(expression, flat=True)

{sqlglot-27.3.1 → sqlglot-27.4.0}/sqlglot/optimizer/annotate_types.py

@@ -313,9 +313,11 @@ class TypeAnnotator(metaclass=_TypeAnnotator):
                 elif (
                     isinstance(source, Scope)
                     and isinstance(source.expression, exp.Query)
-                    and source.expression.is_type(exp.DataType.Type.STRUCT)
+                    and (
+                        source.expression.meta.get("query_type") or exp.DataType.build("UNKNOWN")
+                    ).is_type(exp.DataType.Type.STRUCT)
                 ):
-                    self._set_type(table_column, source.expression.type)
+                    self._set_type(table_column, source.expression.meta["query_type"])
 
         # Then (possibly) annotate the remaining expressions in the scope
         self._maybe_annotate(scope.expression)
@@ -335,7 +337,10 @@ class TypeAnnotator(metaclass=_TypeAnnotator):
                 for cd in struct_type.expressions
                 if cd.kind
             ):
-                self._set_type(scope.expression, struct_type)
+                # We don't use `_set_type` on purpose here. If we annotated the query directly, then
+                # using it in other contexts (e.g., ARRAY(<query>)) could result in incorrect type
+                # annotations, i.e., it shouldn't be interpreted as a STRUCT value.
+                scope.expression.meta["query_type"] = struct_type
 
     def _maybe_annotate(self, expression: E) -> E:
         if id(expression) in self._visited:

{sqlglot-27.3.1 → sqlglot-27.4.0}/sqlglot/optimizer/optimize_joins.py

@@ -79,7 +79,8 @@ def normalize(expression):
         if join.kind == "CROSS":
             join.set("on", None)
         else:
-            join.set("kind", None)
+            if join.kind in ("INNER", "OUTER"):
+                join.set("kind", None)
 
             if not join.args.get("on") and not join.args.get("using"):
                 join.set("on", exp.true())

{sqlglot-27.3.1 → sqlglot-27.4.0}/sqlglot/parser.py

@@ -7394,7 +7394,11 @@ class Parser(metaclass=_Parser):
             exists = self._parse_exists(not_=True)
             if self._match_pair(TokenType.PARTITION, TokenType.L_PAREN, advance=False):
                 return self.expression(
-                    exp.AddPartition, exists=exists, this=self._parse_field(any_token=True)
+                    exp.AddPartition,
+                    exists=exists,
+                    this=self._parse_field(any_token=True),
+                    location=self._match_text_seq("LOCATION", advance=False)
+                    and self._parse_property(),
                 )
 
             return None

{sqlglot-27.3.1 → sqlglot-27.4.0}/sqlglot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 27.3.1
+Version: 27.4.0
 Summary: An easily customizable SQL parser and transpiler
 Author-email: Toby Mao <toby.mao@gmail.com>
 License: MIT License

{sqlglot-27.3.1 → sqlglot-27.4.0}/tests/dialects/test_bigquery.py

@@ -1762,6 +1762,14 @@ WHERE
         self.validate_identity("ARRAY_LAST(['a', 'b'])")
         self.validate_identity("JSON_TYPE(PARSE_JSON('1'))")
 
+        self.validate_all(
+            "SELECT CAST(col AS STRUCT<fld1 STRUCT<fld2 INT>>).fld1.fld2",
+            write={
+                "bigquery": "SELECT CAST(col AS STRUCT<fld1 STRUCT<fld2 INT64>>).fld1.fld2",
+                "snowflake": "SELECT CAST(col AS OBJECT(fld1 OBJECT(fld2 INT))):fld1.fld2",
+            },
+        )
+
     def test_errors(self):
         with self.assertRaises(ParseError):
             self.parse_one("SELECT * FROM a - b.c.d2")

{sqlglot-27.3.1 → sqlglot-27.4.0}/tests/dialects/test_exasol.py

@@ -398,3 +398,85 @@ class TestExasol(Validator):
                 "exasol": 'CREATE OR REPLACE VIEW "schema"."v" ("col" COMMENT IS \'desc\') AS SELECT "src_col" AS "col"',
             },
         )
+        self.validate_all(
+            "HASH_SHA(x)",
+            read={
+                "clickhouse": "SHA1(x)",
+                "exasol": "HASH_SHA1(x)",
+                "presto": "SHA1(x)",
+                "trino": "SHA1(x)",
+            },
+            write={
+                "exasol": "HASH_SHA(x)",
+                "clickhouse": "SHA1(x)",
+                "bigquery": "SHA1(x)",
+                "": "SHA(x)",
+                "presto": "SHA1(x)",
+                "trino": "SHA1(x)",
+            },
+        )
+        self.validate_all(
+            "HASH_MD5(x)",
+            write={
+                "exasol": "HASH_MD5(x)",
+                "": "MD5(x)",
+                "bigquery": "TO_HEX(MD5(x))",
+                "clickhouse": "LOWER(HEX(MD5(x)))",
+                "hive": "MD5(x)",
+                "presto": "LOWER(TO_HEX(MD5(x)))",
+                "spark": "MD5(x)",
+                "trino": "LOWER(TO_HEX(MD5(x)))",
+            },
+        )
+        self.validate_all(
+            "HASHTYPE_MD5(x)",
+            write={
+                "exasol": "HASHTYPE_MD5(x)",
+                "": "MD5_DIGEST(x)",
+                "bigquery": "MD5(x)",
+                "clickhouse": "MD5(x)",
+                "hive": "UNHEX(MD5(x))",
+                "presto": "MD5(x)",
+                "spark": "UNHEX(MD5(x))",
+                "trino": "MD5(x)",
+            },
+        )
+
+        self.validate_all(
+            "HASH_SHA256(x)",
+            read={
+                "clickhouse": "SHA256(x)",
+                "presto": "SHA256(x)",
+                "trino": "SHA256(x)",
+                "postgres": "SHA256(x)",
+                "duckdb": "SHA256(x)",
+            },
+            write={
+                "exasol": "HASH_SHA256(x)",
+                "bigquery": "SHA256(x)",
+                "spark2": "SHA2(x, 256)",
+                "clickhouse": "SHA256(x)",
+                "postgres": "SHA256(x)",
+                "presto": "SHA256(x)",
+                "redshift": "SHA2(x, 256)",
+                "trino": "SHA256(x)",
+                "duckdb": "SHA256(x)",
+                "snowflake": "SHA2(x, 256)",
+            },
+        )
+        self.validate_all(
+            "HASH_SHA512(x)",
+            read={
+                "clickhouse": "SHA512(x)",
+                "presto": "SHA512(x)",
+                "trino": "SHA512(x)",
+            },
+            write={
+                "exasol": "HASH_SHA512(x)",
+                "clickhouse": "SHA512(x)",
+                "bigquery": "SHA512(x)",
+                "spark2": "SHA2(x, 512)",
+                "presto": "SHA512(x)",
+                "trino": "SHA512(x)",
+            },
+        )

{sqlglot-27.3.1 → sqlglot-27.4.0}/tests/dialects/test_hive.py

@@ -216,6 +216,21 @@ class TestHive(Validator):
             },
         )
 
+        self.validate_all(
+            "ALTER TABLE db.example_table ADD PARTITION(col_a = 'a') LOCATION 'b'",
+            read={
+                "spark2": "ALTER TABLE db.example_table ADD PARTITION(col_a = 'a') LOCATION 'b'",
+                "spark": "ALTER TABLE db.example_table ADD PARTITION(col_a = 'a') LOCATION 'b'",
+                "databricks": "ALTER TABLE db.example_table ADD PARTITION(col_a = 'a') LOCATION 'b'",
+            },
+            write={
+                "hive": "ALTER TABLE db.example_table ADD PARTITION(col_a = 'a') LOCATION 'b'",
+                "spark2": "ALTER TABLE db.example_table ADD PARTITION(col_a = 'a') LOCATION 'b'",
+                "spark": "ALTER TABLE db.example_table ADD PARTITION(col_a = 'a') LOCATION 'b'",
+                "databricks": "ALTER TABLE db.example_table ADD PARTITION(col_a = 'a') LOCATION 'b'",
+            },
+        )
+
     def test_lateral_view(self):
         self.validate_all(
             "SELECT a, b FROM x LATERAL VIEW EXPLODE(y) t AS a LATERAL VIEW EXPLODE(z) u AS b",

{sqlglot-27.3.1 → sqlglot-27.4.0}/tests/dialects/test_sqlite.py

@@ -122,6 +122,22 @@ class TestSQLite(Validator):
             'CREATE TABLE "foo t" ("foo t id" TEXT NOT NULL PRIMARY KEY)',
         )
         self.validate_identity("REPLACE INTO foo (x, y) VALUES (1, 2)", check_command_warning=True)
+        self.validate_identity(
+            "ATTACH DATABASE 'foo' AS schema_name", "ATTACH 'foo' AS schema_name"
+        )
+        self.validate_identity(
+            "ATTACH DATABASE NOT EXISTS(SELECT 1) AS schema_name",
+            "ATTACH NOT EXISTS(SELECT 1) AS schema_name",
+        )
+        self.validate_identity(
+            "ATTACH DATABASE IIF(NOT EXISTS(SELECT 1), 'foo1', 'foo2') AS schema_name",
+            "ATTACH IIF(NOT EXISTS(SELECT 1), 'foo1', 'foo2') AS schema_name",
+        )
+        self.validate_identity(
+            "ATTACH DATABASE 'foo' || '.foo2' AS schema_name",
+            "ATTACH 'foo' || '.foo2' AS schema_name",
+        )
+        self.validate_identity("DETACH DATABASE schema_name", "DETACH schema_name")
 
     def test_strftime(self):
         self.validate_identity("SELECT STRFTIME('%Y/%m/%d', 'now')")

{sqlglot-27.3.1 → sqlglot-27.4.0}/tests/fixtures/optimizer/optimize_joins.sql

@@ -36,3 +36,9 @@ SELECT * FROM x JOIN z USING (id);
 
 SELECT * FROM x CROSS JOIN z ON TRUE;
 SELECT * FROM x CROSS JOIN z;
+
+SELECT * FROM x LEFT ANTI JOIN y ON x.a = y.a; 
+SELECT * FROM x LEFT ANTI JOIN y ON x.a = y.a;
+
+SELECT * FROM x LEFT SEMI JOIN y ON x.a = y.a; 
+SELECT * FROM x LEFT SEMI JOIN y ON x.a = y.a;

{sqlglot-27.3.1 → sqlglot-27.4.0}/tests/test_optimizer.py

@@ -1589,7 +1589,7 @@ FROM READ_CSV('tests/fixtures/optimizer/tpc-h/nation.csv.gz', 'delimiter', '|')
         schema = {"d": {"s": {"t": {"c1": "int64", "c2": "struct<f1 int64, f2 string>"}}}}
 
         def _annotate(query: str) -> exp.Expression:
-            expression = parse_one(example_query, dialect=dialect)
+            expression = parse_one(query, dialect=dialect)
             qual = optimizer.qualify.qualify(expression, schema=schema, dialect=dialect)
             return optimizer.annotate_types.annotate_types(qual, schema=schema, dialect=dialect)
 
@@ -1620,3 +1620,8 @@ FROM READ_CSV('tests/fixtures/optimizer/tpc-h/nation.csv.gz', 'delimiter', '|')
         annotated = _annotate(example_query)
 
         self.assertTrue(annotated.selects[0].is_type("UNKNOWN"))
+
+        for query in ("SELECT 'foo'", "(SELECT 'foo')"):
+            query = f"SELECT ARRAY({query})"
+            with self.subTest(f"Annotating '{query}' in BigQuery"):
+                self.assertTrue(_annotate(query).selects[0].is_type("ARRAY<VARCHAR>"))