sqlglot 27.15.1__tar.gz → 27.15.2__tar.gz

{sqlglot-27.15.1 → sqlglot-27.15.2}/CHANGELOG.md

@@ -1,6 +1,11 @@
 Changelog
 =========
 
+## [v27.15.1] - 2025-09-17
+### :sparkles: New Features
+- [`1ee026d`](https://github.com/tobymao/sqlglot/commit/1ee026d22d4f6c3613c1809a6738cdea846c48a9) - **postgres**: support `SUBSTRING(value FOR length FROM start)` variant *(commit by [@georgesittas](https://github.com/georgesittas))*
+
+
 ## [v27.15.0] - 2025-09-17
 ### :boom: BREAKING CHANGES
 - due to [`96ae7a3`](https://github.com/tobymao/sqlglot/commit/96ae7a3bcbf9de1932150baa0bd704d4ce05c9f7) - Annotate and add tests for snowflake REPEAT and SPLIT functions *(PR [#5875](https://github.com/tobymao/sqlglot/pull/5875) by [@fivetran-amrutabhimsenayachit](https://github.com/fivetran-amrutabhimsenayachit))*:
@@ -7329,3 +7334,4 @@ Changelog
 [v27.13.2]: https://github.com/tobymao/sqlglot/compare/v27.13.1...v27.13.2
 [v27.14.0]: https://github.com/tobymao/sqlglot/compare/v27.13.2...v27.14.0
 [v27.15.0]: https://github.com/tobymao/sqlglot/compare/v27.14.0...v27.15.0
+[v27.15.1]: https://github.com/tobymao/sqlglot/compare/v27.15.0...v27.15.1

{sqlglot-27.15.1 → sqlglot-27.15.2}/PKG-INFO

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

{sqlglot-27.15.1 → sqlglot-27.15.2}/sqlglot/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '27.15.1'
-__version_tuple__ = version_tuple = (27, 15, 1)
+__version__ = version = '27.15.2'
+__version_tuple__ = version_tuple = (27, 15, 2)
 
-__commit_id__ = commit_id = 'g1ee026d22'
+__commit_id__ = commit_id = 'g16f317c04'

{sqlglot-27.15.1 → sqlglot-27.15.2}/sqlglot/dialects/duckdb.py

@@ -304,6 +304,8 @@ class DuckDB(Dialect):
             "CHAR": TokenType.TEXT,
             "DATETIME": TokenType.TIMESTAMPNTZ,
             "DETACH": TokenType.DETACH,
+            "FORCE": TokenType.FORCE,
+            "INSTALL": TokenType.INSTALL,
             "LOGICAL": TokenType.BOOLEAN,
             "ONLY": TokenType.ONLY,
             "PIVOT_WIDER": TokenType.PIVOT,
@@ -468,6 +470,8 @@ class DuckDB(Dialect):
             **parser.Parser.STATEMENT_PARSERS,
             TokenType.ATTACH: lambda self: self._parse_attach_detach(),
             TokenType.DETACH: lambda self: self._parse_attach_detach(is_attach=False),
+            TokenType.FORCE: lambda self: self._parse_force(),
+            TokenType.INSTALL: lambda self: self._parse_install(),
             TokenType.SHOW: lambda self: self._parse_show(),
         }
 
@@ -605,6 +609,24 @@ class DuckDB(Dialect):
         def _parse_show_duckdb(self, this: str) -> exp.Show:
             return self.expression(exp.Show, this=this)
 
+        def _parse_force(self) -> exp.Install | exp.Command:
+            # FORCE can only be followed by INSTALL or CHECKPOINT
+            # In the case of CHECKPOINT, we fallback
+            if not self._match(TokenType.INSTALL):
+                return self._parse_as_command(self._prev)
+
+            return self._parse_install(force=True)
+
+        def _parse_install(self, force: bool = False) -> exp.Install:
+            return self.expression(
+                exp.Install,
+                **{  # type: ignore
+                    "this": self._parse_id_var(),
+                    "from": self._parse_var_or_string() if self._match(TokenType.FROM) else None,
+                    "force": force,
+                },
+            )
+
         def _parse_primary(self) -> t.Optional[exp.Expression]:
             if self._match_pair(TokenType.HASH, TokenType.NUMBER):
                 return exp.PositionalColumn(this=exp.Literal.number(self._prev.text))
@@ -928,6 +950,13 @@ class DuckDB(Dialect):
         def show_sql(self, expression: exp.Show) -> str:
             return f"SHOW {expression.name}"
 
+        def install_sql(self, expression: exp.Install) -> str:
+            force = "FORCE " if expression.args.get("force") else ""
+            this = self.sql(expression, "this")
+            from_clause = expression.args.get("from")
+            from_clause = f" FROM {from_clause}" if from_clause else ""
+            return f"{force}INSTALL {this}{from_clause}"
+
         def fromiso8601timestamp_sql(self, expression: exp.FromISO8601Timestamp) -> str:
             return self.sql(exp.cast(expression.this, exp.DataType.Type.TIMESTAMPTZ))
 

{sqlglot-27.15.1 → sqlglot-27.15.2}/sqlglot/dialects/snowflake.py

@@ -746,6 +746,7 @@ class Snowflake(Dialect):
             "VECTOR_L2_DISTANCE": exp.EuclideanDistance.from_arg_list,
             "ZEROIFNULL": _build_if_from_zeroifnull,
         }
+        FUNCTIONS.pop("PREDICT")
 
         FUNCTION_PARSERS = {
             **parser.Parser.FUNCTION_PARSERS,
@@ -852,6 +853,13 @@ class Snowflake(Dialect):
             ),
         }
 
+        COLUMN_OPERATORS = {
+            **parser.Parser.COLUMN_OPERATORS,
+            TokenType.EXCLAMATION: lambda self, this, attr: self.expression(
+                exp.ModelAttribute, this=this, expression=attr
+            ),
+        }
+
         def _parse_use(self) -> exp.Use:
             if self._match_text_seq("SECONDARY", "ROLES"):
                 this = self._match_texts(("ALL", "NONE")) and exp.var(self._prev.text.upper())
@@ -963,7 +971,7 @@ class Snowflake(Dialect):
                 # Keys are strings in Snowflake's objects, see also:
                 # - https://docs.snowflake.com/en/sql-reference/data-types-semistructured
                 # - https://docs.snowflake.com/en/sql-reference/functions/object_construct
-                return self._parse_slice(self._parse_string())
+                return self._parse_slice(self._parse_string()) or self._parse_assignment()
 
             return self._parse_slice(self._parse_alias(self._parse_assignment(), explicit=True))
 
@@ -1254,6 +1262,7 @@ class Snowflake(Dialect):
         SINGLE_TOKENS = {
             **tokens.Tokenizer.SINGLE_TOKENS,
             "$": TokenType.PARAMETER,
+            "!": TokenType.EXCLAMATION,
         }
 
         VAR_SINGLE_TOKENS = {"$"}
@@ -1303,6 +1312,7 @@ class Snowflake(Dialect):
             exp.BitwiseAndAgg: rename_func("BITANDAGG"),
             exp.BitwiseOrAgg: rename_func("BITORAGG"),
             exp.BitwiseXorAgg: rename_func("BITXORAGG"),
+            exp.BitwiseNot: rename_func("BITNOT"),
             exp.BitwiseLeftShift: rename_func("BITSHIFTLEFT"),
             exp.BitwiseRightShift: rename_func("BITSHIFTRIGHT"),
             exp.Create: transforms.preprocess([_flatten_structured_types_unless_iceberg]),
@@ -1623,6 +1633,12 @@ class Snowflake(Dialect):
             return f"CLUSTER BY ({self.expressions(expression, flat=True)})"
 
         def struct_sql(self, expression: exp.Struct) -> str:
+            if len(expression.expressions) == 1:
+                arg = expression.expressions[0]
+                if arg.is_star or (isinstance(arg, exp.ILike) and arg.left.is_star):
+                    # Wildcard syntax: https://docs.snowflake.com/en/sql-reference/data-types-semistructured#object
+                    return f"{{{self.sql(expression.expressions[0])}}}"
+
             keys = []
             values = []
 
@@ -1796,3 +1812,6 @@ class Snowflake(Dialect):
                 return f"{self.sql(this)}:{self.sql(expression, 'expression')}"
 
             return super().dot_sql(expression)
+
+        def modelattribute_sql(self, expression: exp.ModelAttribute) -> str:
+            return f"{self.sql(expression, 'this')}!{self.sql(expression, 'expression')}"

{sqlglot-27.15.1 → sqlglot-27.15.2}/sqlglot/expressions.py

@@ -1584,6 +1584,11 @@ class Detach(Expression):
     arg_types = {"this": True, "exists": False}
 
 
+# https://duckdb.org/docs/sql/statements/load_and_install.html
+class Install(Expression):
+    arg_types = {"this": True, "from": False, "force": False}
+
+
 # https://duckdb.org/docs/guides/meta/summarize.html
 class Summarize(Expression):
     arg_types = {"this": True, "table": False}
@@ -7027,6 +7032,12 @@ class MLForecast(Func):
     arg_types = {"this": True, "expression": False, "params_struct": False}
 
 
+# Represents Snowflake's <model>!<attribute> syntax. For example: SELECT model!PREDICT(INPUT_DATA => {*})
+# See: https://docs.snowflake.com/en/guides-overview-ml-functions
+class ModelAttribute(Expression):
+    arg_types = {"this": True, "expression": True}
+
+
 # https://cloud.google.com/bigquery/docs/reference/standard-sql/search_functions#vector_search
 class VectorSearch(Func):
     arg_types = {

{sqlglot-27.15.1 → sqlglot-27.15.2}/sqlglot/generator.py

@@ -5198,6 +5198,10 @@ class Generator(metaclass=_Generator):
         self.unsupported("Unsupported SHOW statement")
         return ""
 
+    def install_sql(self, expression: exp.Install) -> str:
+        self.unsupported("Unsupported INSTALL statement")
+        return ""
+
     def get_put_sql(self, expression: exp.Put | exp.Get) -> str:
         # Snowflake GET/PUT statements:
         #   PUT <file> <internalStage> <properties>
@@ -5302,3 +5306,7 @@ class Generator(metaclass=_Generator):
         starts = f" STARTS {starts}" if starts else ""
 
         return f"REFRESH {method} ON {kind}{every}{starts}"
+
+    def modelattribute_sql(self, expression: exp.ModelAttribute) -> str:
+        self.unsupported("The model!attribute syntax is not supported")
+        return ""

{sqlglot-27.15.1 → sqlglot-27.15.2}/sqlglot/tokens.py

@@ -88,6 +88,7 @@ class TokenType(AutoName):
     QMARK_AMP = auto()
     QMARK_PIPE = auto()
     HASH_DASH = auto()
+    EXCLAMATION = auto()
 
     URI_START = auto()
 
@@ -313,6 +314,7 @@ class TokenType(AutoName):
     INDEX = auto()
     INNER = auto()
     INSERT = auto()
+    INSTALL = auto()
     INTERSECT = auto()
     INTERVAL = auto()
     INTO = auto()

{sqlglot-27.15.1 → sqlglot-27.15.2}/sqlglot.egg-info/PKG-INFO

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

{sqlglot-27.15.1 → sqlglot-27.15.2}/tests/dialects/test_bigquery.py

@@ -2924,6 +2924,15 @@ OPTIONS (
             },
         )
 
+    def test_bitwise_not(self):
+        self.validate_all(
+            "SELECT ~1",
+            write={
+                "bigquery": "SELECT ~1",
+                "snowflake": "SELECT BITNOT(1)",
+            },
+        )
+
     def test_bit_aggs(self):
         self.validate_all(
             "BIT_AND(x)",

{sqlglot-27.15.1 → sqlglot-27.15.2}/tests/dialects/test_duckdb.py

@@ -1813,3 +1813,15 @@ class TestDuckDB(Validator):
         self.validate_identity("CREATE SEQUENCE serial START WITH 99 INCREMENT BY -1 MAXVALUE 99")
         self.validate_identity("CREATE SEQUENCE serial START WITH 1 MAXVALUE 10 NO CYCLE")
         self.validate_identity("CREATE SEQUENCE serial START WITH 1 MAXVALUE 10 CYCLE")
+
+    def test_install(self):
+        ast = self.validate_identity("INSTALL httpfs")
+        ast.assert_is(exp.Install).name == "httpfs"
+        assert isinstance(ast.this, exp.Identifier)
+
+        self.validate_identity("INSTALL httpfs FROM community")
+        self.validate_identity("INSTALL httpfs FROM 'https://extensions.duckdb.org'")
+        self.validate_identity("FORCE INSTALL httpfs").assert_is(exp.Install).name == "httpfs"
+        self.validate_identity("FORCE INSTALL httpfs FROM community")
+        self.validate_identity("FORCE INSTALL httpfs FROM 'https://extensions.duckdb.org'")
+        self.validate_identity("FORCE CHECKPOINT db", check_command_warning=True)

{sqlglot-27.15.1 → sqlglot-27.15.2}/tests/dialects/test_snowflake.py

@@ -29,6 +29,11 @@ class TestSnowflake(Validator):
         expr.selects[0].assert_is(exp.AggFunc)
         self.assertEqual(expr.sql(dialect="snowflake"), "SELECT APPROX_TOP_K(C4, 3, 5) FROM t")
 
+        self.validate_identity("SELECT {*} FROM my_table")
+        self.validate_identity("SELECT {my_table.*} FROM my_table")
+        self.validate_identity("SELECT {* ILIKE 'col1%'} FROM my_table")
+        self.validate_identity("SELECT {* EXCLUDE (col1)} FROM my_table")
+        self.validate_identity("SELECT {* EXCLUDE (col1, col2)} FROM my_table")
         self.validate_identity("SELECT a, b, COUNT(*) FROM x GROUP BY ALL LIMIT 100")
         self.validate_identity("STRTOK_TO_ARRAY('a b c')")
         self.validate_identity("STRTOK_TO_ARRAY('a.b.c', '.')")
@@ -3139,3 +3144,13 @@ FROM SEMANTIC_VIEW(
         self.validate_identity("MD5_BINARY(col)")
         self.validate_identity("MD5_NUMBER_LOWER64(col)")
         self.validate_identity("MD5_NUMBER_UPPER64(col)")
+
+    def test_model_attribute(self):
+        self.validate_identity("SELECT model!mladmin")
+        self.validate_identity("SELECT model!PREDICT(1)")
+        self.validate_identity("SELECT m!PREDICT(INPUT_DATA => {*}) AS p FROM tbl")
+        self.validate_identity("SELECT m!PREDICT(INPUT_DATA => {tbl.*}) AS p FROM tbl")
+        self.validate_identity("x.y.z!PREDICT(foo, bar, baz, bla)")
+        self.validate_identity(
+            "SELECT * FROM TABLE(model_trained_with_labeled_data!DETECT_ANOMALIES(INPUT_DATA => TABLE(view_with_data_to_analyze), TIMESTAMP_COLNAME => 'date', TARGET_COLNAME => 'sales', CONFIG_OBJECT => OBJECT_CONSTRUCT('prediction_interval', 0.99)))"
+        )