sqlglotc 30.19.0__tar.gz → 30.20.0__tar.gz

{sqlglotc-30.19.0/sqlglotc.egg-info → sqlglotc-30.20.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.19.0
+Version: 30.20.0
 Summary: mypyc-compiled extensions for sqlglot
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://sqlglot.com/
 Project-URL: Repository, https://github.com/tobymao/sqlglot
 Requires-Python: >=3.10
-Requires-Dist: sqlglot==30.19.0
+Requires-Dist: sqlglot==30.20.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"

{sqlglotc-30.19.0 → sqlglotc-30.20.0}/sqlglot/expressions/json.py

@@ -248,4 +248,4 @@ class ParseJSON(Expression, Func):
     # BigQuery, Snowflake have PARSE_JSON, Presto has JSON_PARSE
     # Snowflake also has TRY_PARSE_JSON, which is represented using `safe`
     _sql_names = ["PARSE_JSON", "JSON_PARSE"]
-    arg_types = {"this": True, "expression": False, "safe": False}
+    arg_types = {"this": True, "expression": False, "safe": False, "is_literal": False}

{sqlglotc-30.19.0 → sqlglotc-30.20.0}/sqlglot/generator.py

@@ -4942,15 +4942,20 @@ class Generator:
     def tonumber_sql(self, expression: exp.ToNumber) -> str:
         if not self.SUPPORTS_TO_NUMBER:
             self.unsupported("Unsupported TO_NUMBER function")
-            return self.sql(exp.cast(expression.this, exp.DType.DOUBLE))
+            return self._tonumber_cast_sql(expression)
 
         fmt = expression.args.get("format")
         if not fmt:
             self.unsupported("Conversion format is required for TO_NUMBER")
-            return self.sql(exp.cast(expression.this, exp.DType.DOUBLE))
+            return self._tonumber_cast_sql(expression)
 
         return self.func("TO_NUMBER", expression.this, fmt)
 
+    def _tonumber_cast_sql(self, expression: exp.ToNumber) -> str:
+        if expression.args.get("safe"):
+            return self.sql(exp.TryCast(this=expression.this, to=exp.DataType.build("DOUBLE")))
+        return self.sql(exp.cast(expression.this, exp.DType.DOUBLE))
+
     def dictproperty_sql(self, expression: exp.DictProperty) -> str:
         this = self.sql(expression, "this")
         kind = self.sql(expression, "kind")

{sqlglotc-30.19.0 → sqlglotc-30.20.0}/sqlglot/generators/bigquery.py

@@ -713,6 +713,11 @@ class BigQueryGenerator(generator.Generator):
 
         return self.func("CONTAINS_SUBSTR", this, expr, expression.args.get("json_scope"))
 
+    def parsejson_sql(self, expression: exp.ParseJSON) -> str:
+        if expression.args.get("is_literal"):
+            return f"JSON {self.sql(expression, 'this')}"
+        return super().parsejson_sql(expression)
+
     def cast_sql(self, expression: exp.Cast, safe_prefix: str | None = None) -> str:
         this = expression.this
 

{sqlglotc-30.19.0 → sqlglotc-30.20.0}/sqlglot/generators/duckdb.py

@@ -2577,11 +2577,10 @@ class DuckDBGenerator(generator.Generator):
         scale = expression.args.get("scale")
 
         if not fmt and precision and scale:
-            return self.sql(
-                exp.cast(
-                    expression.this, f"DECIMAL({precision.name}, {scale.name})", dialect="duckdb"
-                )
-            )
+            to = exp.DataType.build(f"DECIMAL({precision.name}, {scale.name})", dialect="duckdb")
+            if expression.args.get("safe"):
+                return self.sql(exp.TryCast(this=expression.this, to=to))
+            return self.sql(exp.cast(expression.this, to, dialect="duckdb"))
 
         return super().tonumber_sql(expression)
 
@@ -3075,6 +3074,9 @@ class DuckDBGenerator(generator.Generator):
         if milli or nano:
             expression.set("sec", sec)
 
+        if zone := expression.args.get("zone"):
+            return self.sql(exp.AtTimeZone(this=expression, zone=zone.pop()))
+
         return rename_func("MAKE_TIMESTAMP")(self, expression)
 
     @unsupported_args("nano")

{sqlglotc-30.19.0 → sqlglotc-30.20.0}/sqlglot/generators/mysql.py

@@ -154,9 +154,9 @@ class MySQLGenerator(generator.Generator):
         exp.DateDiff: remove_ts_or_ds_to_date(
             lambda self, e: self.func("DATEDIFF", e.this, e.expression), ("this", "expression")
         ),
-        exp.DateAdd: remove_ts_or_ds_to_date(date_add_sql("ADD")),
+        exp.DateAdd: date_add_sql("ADD"),
         exp.DateStrToDate: datestrtodate_sql,
-        exp.DateSub: remove_ts_or_ds_to_date(date_add_sql("SUB")),
+        exp.DateSub: date_add_sql("SUB"),
         exp.DateTrunc: _date_trunc_sql,
         exp.Day: remove_ts_or_ds_to_date(),
         exp.DayOfMonth: remove_ts_or_ds_to_date(rename_func("DAYOFMONTH")),

{sqlglotc-30.19.0 → sqlglotc-30.20.0}/sqlglot/generators/sqlite.py

@@ -20,7 +20,7 @@ from sqlglot.tokens import TokenType
 
 
 def _transform_create(expression: exp.Expr) -> exp.Expr:
-    """Move primary key to a column and enforce auto_increment on primary keys."""
+    """Move primary key to a column and place auto_increment after it."""
     schema = expression.this
 
     if isinstance(expression, exp.Create) and isinstance(schema, exp.Schema):
@@ -52,12 +52,9 @@ def _transform_create(expression: exp.Expr) -> exp.Expr:
                     auto_increment = constraint
                     auto_increment_index = i
 
-            if auto_increment is not None and (
-                primary_key_index == -1 or auto_increment_index < primary_key_index
-            ):
+            if auto_increment is not None and 0 <= auto_increment_index < primary_key_index:
                 column.constraints.remove(auto_increment)
-                if primary_key_index != -1:
-                    column.constraints.insert(primary_key_index, auto_increment)
+                column.constraints.insert(primary_key_index, auto_increment)
 
     return expression
 
@@ -206,6 +203,16 @@ class SQLiteGenerator(generator.Generator):
 
     LIMIT_FETCH = "LIMIT"
 
+    def autoincrementcolumnconstraint_sql(
+        self, expression: exp.AutoIncrementColumnConstraint
+    ) -> str:
+        column = expression.find_ancestor(exp.ColumnDef)
+        if column and column.find(exp.PrimaryKeyColumnConstraint):
+            return super().autoincrementcolumnconstraint_sql(expression)
+
+        self.unsupported("SQLite AUTOINCREMENT requires an INTEGER PRIMARY KEY")
+        return ""
+
     def insert_sql(self, expression: exp.Insert) -> str:
         if expression.args.get("ignore"):
             expression.set("ignore", False)

{sqlglotc-30.19.0 → sqlglotc-30.20.0}/sqlglot/generators/starrocks.py

@@ -12,6 +12,7 @@ from sqlglot.dialects.dialect import (
     property_sql,
     var_map_sql,
 )
+from sqlglot.generator import Generator
 from sqlglot.generators.mysql import MySQLGenerator
 
 
@@ -292,6 +293,24 @@ class StarRocksGenerator(MySQLGenerator):
         "with",
     }
 
+    def ignorenulls_sql(self, expression: exp.IgnoreNulls) -> str:
+        # IGNORE NULLS follows the first argument, e.g. LAG(x IGNORE NULLS, 1, 0)
+        # https://docs.starrocks.io/docs/sql-reference/sql-functions/Window_function/
+        func = expression.this
+        if isinstance(func, (exp.FirstValue, exp.LastValue, exp.Lag, exp.Lead)):
+            return self.func(
+                func.sql_name(),
+                Generator.ignorenulls_sql(self, exp.IgnoreNulls(this=func.this)),
+                func.args.get("offset"),
+                func.args.get("default"),
+            )
+
+        return super().ignorenulls_sql(expression)
+
+    def respectnulls_sql(self, expression: exp.RespectNulls) -> str:
+        # RESPECT NULLS is the default behavior, and StarRocks rejects the keyword
+        return self.sql(expression, "this")
+
     def create_sql(self, expression: exp.Create) -> str:
         # Starrocks' primary key is defined outside of the schema, so we need to move it there
         schema = expression.this

{sqlglotc-30.19.0 → sqlglotc-30.20.0}/sqlglot/optimizer/qualify_columns.py

@@ -492,6 +492,10 @@ def _expand_order_by_and_distinct_on(scope: Scope, resolver: Resolver) -> None:
     if not isinstance(expression, exp.Selectable):
         return
 
+    names = expression.named_selects
+    if len(names) != len(set(names)):
+        return
+
     # TODO (mypyc): rebind to exp.Expr to avoid Selectable trait vtable dispatch for .args
     expr: exp.Expr = expression
 

{sqlglotc-30.19.0 → sqlglotc-30.20.0}/sqlglot/optimizer/simplify.py

@@ -841,7 +841,10 @@ class Simplifier:
                 if complement_subquery_predicate:
                     right = complement_subquery_predicate(this=right.this)
 
-                return self.COMPLEMENT_COMPARISONS[this.__class__](this=this.this, expression=right)
+                return exp.paren(
+                    self.COMPLEMENT_COMPARISONS[this.__class__](this=this.this, expression=right),
+                    copy=False,
+                )
             if isinstance(this, exp.Paren):
                 condition = this.unnest()
                 if isinstance(condition, exp.And):

{sqlglotc-30.19.0 → sqlglotc-30.20.0}/sqlglot/parser.py

@@ -1633,7 +1633,9 @@ class Parser:
     SHOW_PARSERS: t.ClassVar[dict[str, t.Callable]] = {}
 
     TYPE_LITERAL_PARSERS: t.ClassVar = {
-        exp.DType.JSON: lambda self, this, _: self.expression(exp.ParseJSON(this=this)),
+        exp.DType.JSON: lambda self, this, _: self.expression(
+            exp.ParseJSON(this=this, is_literal=True)
+        ),
     }
 
     TYPE_CONVERTERS: t.ClassVar[dict[exp.DType, t.Callable[[exp.DataType], exp.DataType]]] = {}
@@ -3738,7 +3740,7 @@ class Parser:
         action = self._parse_var_from_options(self.CONFLICT_ACTIONS)
         if self._prev.token_type == TokenType.UPDATE:
             self._match(TokenType.SET)
-            expressions = self._parse_csv(self._parse_equality)
+            expressions = self._parse_csv(self._parse_update_assignment)
         else:
             expressions = None
 
@@ -3867,6 +3869,15 @@ class Parser:
             )
         )
 
+    def _parse_update_assignment(self) -> exp.Expr | None:
+        this = self._parse_comparison()
+        if self._match(TokenType.EQ):
+            comments = self._prev_comments
+            this = self.expression(
+                exp.EQ(this=this, expression=self._parse_disjunction()), comments=comments
+            )
+        return this
+
     def _parse_update(self) -> exp.Update:
         hint = self._parse_hint()
         kwargs: dict[str, object] = {
@@ -3875,7 +3886,7 @@ class Parser:
         }
         while self._curr:
             if self._match(TokenType.SET):
-                kwargs["expressions"] = self._parse_csv(self._parse_equality)
+                kwargs["expressions"] = self._parse_csv(self._parse_update_assignment)
             elif self._match(TokenType.RETURNING, advance=False):
                 kwargs["returning"] = self._parse_returning()
             elif self._match(TokenType.FROM, advance=False):
@@ -5766,7 +5777,7 @@ class Parser:
 
     def _parse_limit_options(self) -> exp.LimitOptions | None:
         percent = self._match_set((TokenType.PERCENT, TokenType.MOD))
-        rows = self._match_set((TokenType.ROW, TokenType.ROWS))
+        rows = self._match_texts(("ROW", "ROWS"))
         self._match_text_seq("ONLY")
         with_ties = self._match_text_seq("WITH", "TIES")
 
@@ -5830,7 +5841,11 @@ class Parser:
                 else "FIRST"
             )
 
-            count = self._parse_field(tokens=self.FETCH_TOKENS)
+            count = (
+                None
+                if self._match_texts(("ROW", "ROWS"), advance=False)
+                else self._parse_field(tokens=self.FETCH_TOKENS)
+            )
 
             return self.expression(
                 exp.Fetch(
@@ -5845,7 +5860,7 @@ class Parser:
             return this
 
         count = self._parse_term()
-        self._match_set((TokenType.ROW, TokenType.ROWS))
+        self._match_texts(("ROW", "ROWS"))
 
         return self.expression(
             exp.Offset(this=this, expression=count, expressions=self._parse_limit_by())
@@ -9577,7 +9592,7 @@ class Parser:
                     then = self.expression(
                         exp.Update(
                             expressions=self._match(TokenType.SET)
-                            and self._parse_csv(self._parse_equality),
+                            and self._parse_csv(self._parse_update_assignment),
                             where=self._parse_where(),
                         )
                     )

{sqlglotc-30.19.0 → sqlglotc-30.20.0}/sqlglot/parsers/clickhouse.py

@@ -633,13 +633,16 @@ class ClickHouseParser(parser.Parser):
 
         return bracket
 
-    def _parse_global_in(self, this: exp.Expr | None) -> exp.Not | exp.In:
+    def _parse_global_in(self, this: exp.Expr | None) -> exp.Not | exp.In | None:
+        index = self._index - 1
         is_negated = self._match(TokenType.NOT)
-        in_expr: exp.In | None = None
-        if self._match(TokenType.IN):
-            in_expr = self._parse_in(this)
-            in_expr.set("is_global", True)
-        return self.expression(exp.Not(this=in_expr)) if is_negated else t.cast(exp.In, in_expr)
+        if not self._match(TokenType.IN):
+            self._retreat(index)
+            return None
+
+        in_expr = self._parse_in(this)
+        in_expr.set("is_global", True)
+        return self.expression(exp.Not(this=in_expr)) if is_negated else in_expr
 
     def _parse_table(
         self,

{sqlglotc-30.19.0 → sqlglotc-30.20.0}/sqlglot/parsers/teradata.py

@@ -120,7 +120,8 @@ class TeradataParser(parser.Parser):
             exp.Update(
                 this=self._parse_table(alias_tokens=self.UPDATE_ALIAS_TOKENS),
                 from_=self._parse_from(joins=True),
-                expressions=self._match(TokenType.SET) and self._parse_csv(self._parse_equality),
+                expressions=self._match(TokenType.SET)
+                and self._parse_csv(self._parse_update_assignment),
                 where=self._parse_where(),
             )
         )

{sqlglotc-30.19.0 → sqlglotc-30.20.0/sqlglotc.egg-info}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.19.0
+Version: 30.20.0
 Summary: mypyc-compiled extensions for sqlglot
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://sqlglot.com/
 Project-URL: Repository, https://github.com/tobymao/sqlglot
 Requires-Python: >=3.10
-Requires-Dist: sqlglot==30.19.0
+Requires-Dist: sqlglot==30.20.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"

{sqlglotc-30.19.0 → sqlglotc-30.20.0}/sqlglotc.egg-info/requires.txt

@@ -1,4 +1,4 @@
-sqlglot==30.19.0
+sqlglot==30.20.0
 
 [dev]
 setuptools>=61.0

sqlglotc-30.20.0/sqlglotc.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "30.20.0",
+  "distance": 0,
+  "node": "g8bd768664197fbd0ed86158c0eca955c14f43328",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-26"
+}

sqlglotc-30.19.0/sqlglotc.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "30.19.0",
-  "distance": 0,
-  "node": "g02562228357e7d933ef66e27c56e257b88faad8f",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-09-22"
-}