sqlglotc 30.16.0__tar.gz → 30.17.0__tar.gz

{sqlglotc-30.16.0/sqlglotc.egg-info → sqlglotc-30.17.0}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.16.0
+Version: 30.17.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.16.0
+Requires-Dist: sqlglot==30.17.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"
-Requires-Dist: sqlglot-mypy>=2.1.0.post9; extra == "dev"
+Requires-Dist: sqlglot-mypy>=2.3.0.post1; extra == "dev"
 Dynamic: requires-dist

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/pyproject.toml

@@ -7,7 +7,7 @@ license = "MIT"
 requires-python = ">= 3.10"
 
 [project.optional-dependencies]
-dev = ["setuptools >= 61.0", "setuptools_scm", "sqlglot-mypy >= 2.1.0.post9"]
+dev = ["setuptools >= 61.0", "setuptools_scm", "sqlglot-mypy >= 2.3.0.post1"]
 
 [project.urls]
 Homepage = "https://sqlglot.com/"
@@ -17,7 +17,7 @@ Repository = "https://github.com/tobymao/sqlglot"
 requires = [
     "setuptools >= 61.0",
     "setuptools_scm",
-    "sqlglot-mypy >= 2.1.0.post9",
+    "sqlglot-mypy >= 2.3.0.post1",
     "types-python-dateutil",
     "sqlglot",
 ]

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/expressions/core.py

@@ -1699,7 +1699,16 @@ class AggFunc(Func):
 
 
 class Column(Expression, Condition):
-    arg_types = {"this": True, "table": False, "db": False, "catalog": False, "join_mark": False}
+    # "shadow" marks a column whose qualifier is shadowed by a projection alias, so it must be
+    # rendered unqualified in dialects where PROJECTION_ALIASES_SHADOW_SOURCE_NAMES is set
+    arg_types = {
+        "this": True,
+        "table": False,
+        "db": False,
+        "catalog": False,
+        "join_mark": False,
+        "shadow": False,
+    }
 
     @property
     def table(self) -> str:

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/expressions/query.py

@@ -1050,6 +1050,11 @@ class SetOperation(Expression, Query):
     def named_selects(self) -> list[str]:
         expr: Expr = self
         while isinstance(expr, SetOperation):
+            if expr.args.get("by_name"):
+                left = t.cast(Selectable, expr.this.unnest()).named_selects
+                right = t.cast(Selectable, expr.expression.unnest()).named_selects
+                return list(dict.fromkeys(left + right))
+
             expr = expr.this.unnest()
         return _named_selects(expr)
 
@@ -2124,7 +2129,23 @@ class CaseStatement(Expression):
 
 
 class WhileBlock(Expression):
-    arg_types = {"this": True, "body": True}
+    arg_types = {"this": True, "body": True, "label": False}
+
+
+class LoopBlock(Expression):
+    arg_types = {"body": True, "label": False}
+
+
+class RepeatBlock(Expression):
+    arg_types = {"body": True, "until": True, "label": False}
+
+
+class Leave(Expression):
+    pass
+
+
+class Iterate(Expression):
+    pass
 
 
 class EndStatement(Expression):

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/generator.py

@@ -1151,6 +1151,10 @@ class Generator:
         return f"{default}CHARACTER SET={self.sql(expression, 'this')}"
 
     def column_parts(self, expression: exp.Column) -> str:
+        if expression.args.get("shadow") and self.dialect.PROJECTION_ALIASES_SHADOW_SOURCE_NAMES:
+            # The qualifier would be captured by a colliding projection alias (see qualify_columns)
+            return self.sql(expression, "this")
+
         return ".".join(
             self.sql(part)
             for part in (
@@ -6319,6 +6323,22 @@ class Generator:
         self.unsupported("Unsupported While block syntax")
         return ""
 
+    def loopblock_sql(self, expression: exp.LoopBlock) -> str:
+        self.unsupported("Unsupported Loop block syntax")
+        return ""
+
+    def repeatblock_sql(self, expression: exp.RepeatBlock) -> str:
+        self.unsupported("Unsupported Repeat block syntax")
+        return ""
+
+    def leave_sql(self, expression: exp.Leave) -> str:
+        self.unsupported("Unsupported Leave syntax")
+        return ""
+
+    def iterate_sql(self, expression: exp.Iterate) -> str:
+        self.unsupported("Unsupported Iterate syntax")
+        return ""
+
     def execute_sql(self, expression: exp.Execute) -> str:
         self.unsupported("Unsupported Execute syntax")
         return ""

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/generators/python.py

@@ -58,6 +58,15 @@ def _lambda_sql(self, e: exp.Lambda) -> str:
     return f"lambda {self.expressions(e, flat=True)}: {self.sql(e, 'this')}"
 
 
+def _like_sql(self: generator.Generator, e: exp.Like | exp.ILike) -> str:
+    sql = self.func(e.key, e.this, e.expression)
+
+    if e.args.get("negate"):
+        sql = f"NOT({sql})"
+
+    return sql
+
+
 def _div_sql(self: generator.Generator, e: exp.Div) -> str:
     denominator = self.sql(e, "expression")
 
@@ -66,7 +75,9 @@ def _div_sql(self: generator.Generator, e: exp.Div) -> str:
 
     sql = f"DIV({self.sql(e, 'this')}, {denominator})"
 
-    if e.args.get("typed"):
+    if e.args.get("typed") and not (
+        e.this.is_type(*exp.DataType.REAL_TYPES) or e.expression.is_type(*exp.DataType.REAL_TYPES)
+    ):
         sql = f"int({sql})"
 
     return sql
@@ -90,6 +101,7 @@ class PythonGenerator(generator.Generator):
         exp.Distinct: lambda self, e: f"set({self.sql(e, 'this')})",
         exp.Div: _div_sql,
         exp.Extract: lambda self, e: f"EXTRACT('{e.name.lower()}', {self.sql(e, 'expression')})",
+        exp.ILike: _like_sql,
         exp.In: lambda self, e: self.func("IN", e.this, *e.expressions),
         exp.Interval: lambda self, e: f"INTERVAL({self.sql(e.this)}, '{self.sql(e.unit)}')",
         exp.Is: lambda self, e: (
@@ -102,6 +114,7 @@ class PythonGenerator(generator.Generator):
         exp.JSONPathKey: lambda self, e: f"'{self.sql(e.this)}'",
         exp.JSONPathSubscript: lambda self, e: f"'{e.this}'",
         exp.Lambda: _lambda_sql,
+        exp.Like: _like_sql,
         exp.Not: lambda self, e: self.func("NOT", e.this),
         exp.Null: lambda *_: "None",
         exp.Or: lambda self, e: f"OR(lambda: {self.sql(e.left)}, lambda: {self.sql(e.right)})",

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/generators/sqlite.py

@@ -69,7 +69,9 @@ def _generated_to_auto_increment(expression: exp.Expr) -> exp.Expr:
 
     generated = expression.find(exp.GeneratedAsIdentityColumnConstraint)
 
-    if generated:
+    # Only rewrite true identity columns. Expression-bearing forms are computed
+    # columns (GENERATED ALWAYS AS (expr)) and must keep their expression.
+    if generated and generated.expression is None:
         t.cast(exp.ColumnConstraint, generated.parent).pop()
 
         not_null = expression.find(exp.NotNullColumnConstraint)
@@ -253,6 +255,19 @@ class SQLiteGenerator(generator.Generator):
 
         return super().cast_sql(expression)
 
+    # https://www.sqlite.org/gencol.html
+    # Inline unsupported check: mypyc cannot compile @unsupported_args on an
+    # override of an undecorated base-class method.
+    def computedcolumnconstraint_sql(self, expression: exp.ComputedColumnConstraint) -> str:
+        if expression.args.get("data_type"):
+            self.unsupported("SQLite generated columns do not support a data type")
+
+        this = expression.this
+        this_sql = self.sql(this) if isinstance(this, exp.Paren) else f"({self.sql(this)})"
+        storage = " STORED" if expression.args.get("persisted") else ""
+        not_null = " NOT NULL" if expression.args.get("not_null") else ""
+        return f"AS {this_sql}{storage}{not_null}"
+
     # Note: SQLite's TRUNC always returns REAL (e.g., trunc(10.99) -> 10.0), not INTEGER.
     # This creates a transpilation gap affecting division semantics, similar to Presto.
     # Unlike Presto where this only affects decimals=0, SQLite has no decimals parameter

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/generators/trino.py

@@ -98,6 +98,32 @@ class TrinoGenerator(PrestoGenerator):
         branches.append("END CASE")
         return " ".join(branches)
 
+    def whileblock_sql(self, expression: exp.WhileBlock) -> str:
+        label = expression.args.get("label")
+        label_sql = f"{self.sql(label)}: " if label else ""
+        condition = self.sql(expression, "this")
+        body = self.sql(expression, "body")
+        return f"{label_sql}WHILE {condition} DO {body}; END WHILE"
+
+    def loopblock_sql(self, expression: exp.LoopBlock) -> str:
+        label = expression.args.get("label")
+        label_sql = f"{self.sql(label)}: " if label else ""
+        body = self.sql(expression, "body")
+        return f"{label_sql}LOOP {body}; END LOOP"
+
+    def repeatblock_sql(self, expression: exp.RepeatBlock) -> str:
+        label = expression.args.get("label")
+        label_sql = f"{self.sql(label)}: " if label else ""
+        body = self.sql(expression, "body")
+        until = self.sql(expression, "until")
+        return f"{label_sql}REPEAT {body}; UNTIL {until} END REPEAT"
+
+    def leave_sql(self, expression: exp.Leave) -> str:
+        return f"LEAVE {self.sql(expression, 'this')}"
+
+    def iterate_sql(self, expression: exp.Iterate) -> str:
+        return f"ITERATE {self.sql(expression, 'this')}"
+
     def jsonextract_sql(self, expression: exp.JSONExtract) -> str:
         if not expression.args.get("json_query"):
             return super().jsonextract_sql(expression)

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/optimizer/annotate_types.py

@@ -385,8 +385,9 @@ class TypeAnnotator:
 
             return {alias: column.type for alias, column in zip(alias_column_names, values)}
 
-        if isinstance(expression, exp.SetOperation) and len(expression.this.selects) == len(
-            expression.expression.selects
+        if isinstance(expression, exp.SetOperation) and (
+            expression.args.get("by_name")
+            or len(expression.this.selects) == len(expression.expression.selects)
         ):
             return self._get_setop_column_types(expression)
 
@@ -522,7 +523,13 @@ class TypeAnnotator:
                     i = iter(dot_parts)
                     parent = expr.parent
                     while isinstance(parent, exp.Dot):
-                        parent.expression.replace(exp.to_identifier(next(i), quoted=True))
+                        identifier = parent.expression
+                        if isinstance(identifier, exp.Identifier):
+                            # Rename in place to preserve the identifier's meta, e.g. token positions
+                            identifier.set("this", next(i))
+                            identifier.set("quoted", True)
+                        else:
+                            identifier.replace(exp.to_identifier(next(i), quoted=True))
                         parent = parent.parent
 
                     expr.meta.pop("dot_parts", None)
@@ -633,12 +640,16 @@ class TypeAnnotator:
 
         col_types: dict[str, exp.DataType | exp.DType] = {}
 
-        # Validate that left and right have same number of projections
+        # Validate that left and right have same number of projections (BY NAME
+        # operations match columns by name, so their counts are allowed to differ)
         if not (
             isinstance(setop, exp.SetOperation)
             and setop.this.selects
             and setop.expression.selects
-            and len(setop.this.selects) == len(setop.expression.selects)
+            and (
+                setop.args.get("by_name")
+                or len(setop.this.selects) == len(setop.expression.selects)
+            )
         ):
             return col_types
 
@@ -650,14 +661,18 @@ class TypeAnnotator:
                 continue
 
             if set_op.args.get("by_name"):
+                # Columns missing from one side are filled with NULLs, so the other
+                # side's type is preserved (NULL is the identity for _maybe_coerce)
                 r_type_by_select = {s.alias_or_name: s.type for s in set_op.expression.selects}
                 setop_cols = {
                     s.alias_or_name: self._maybe_coerce(
                         t.cast(exp.DataType, s.type),
-                        r_type_by_select.get(s.alias_or_name) or exp.DType.UNKNOWN,
+                        r_type_by_select.pop(s.alias_or_name, exp.DType.NULL) or exp.DType.UNKNOWN,
                     )
                     for s in set_op.this.selects
                 }
+                for name, r_type in r_type_by_select.items():
+                    setop_cols[name] = r_type or exp.DType.UNKNOWN
             else:
                 setop_cols = {
                     ls.alias_or_name: self._maybe_coerce(

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/optimizer/canonicalize_internal_names.py

@@ -30,11 +30,13 @@ def canonicalize_internal_names(expression: E) -> E:
         >>> canonicalize_internal_names(qualify(sqlglot.parse_one("WITH t AS (SELECT c1, c2 FROM c.db.src) SELECT * FROM t"), schema=schema)).sql()
         'WITH "_t1" AS (SELECT "_t0"."c1" AS "_c0", "_t0"."c2" AS "_c1" FROM "c"."db"."src" AS "_t0") SELECT "_t1"."_c0" AS "c1", "_t1"."_c1" AS "c2" FROM "_t1" AS "_t1"'
     """
+    # Skip non-queries for now (e.g., UPDATE ... SET x = s.x FROM (SELECT ...) AS s)
+    if not isinstance(expression, exp.Query):
+        return expression
 
-    # Top-level output scopes: their aliases are the query's data contract.
-    # Regular UNION takes names from the left branch; UNION BY NAME takes names
-    # from the union of all branches, so both sides of a by_name SetOperation
-    # contribute.
+    # Top-level output scopes: their aliases are the query's data contract. Regular UNION takes names
+    # from the left branch; UNION BY NAME takes names from the union of all branches, so both sides of
+    # a by_name SetOperation contribute.
     output_scope_exprs: set[int] = set()
     stack: list[exp.Expr] = [expression]
     while stack:

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/optimizer/qualify_columns.py

@@ -9,7 +9,14 @@ from sqlglot.dialects.dialect import Dialect, DialectType
 from sqlglot.errors import OptimizeError, highlight_sql
 from sqlglot.optimizer.annotate_types import TypeAnnotator
 from sqlglot.optimizer.resolver import Resolver
-from sqlglot.optimizer.scope import Scope, build_scope, find_in_scope, traverse_scope, walk_in_scope
+from sqlglot.optimizer.scope import (
+    Scope,
+    build_scope,
+    find_all_in_scope,
+    find_in_scope,
+    traverse_scope,
+    walk_in_scope,
+)
 from sqlglot.optimizer.simplify import simplify_parens
 from sqlglot.schema import Schema, ensure_schema
 
@@ -382,20 +389,6 @@ def _expand_alias_refs(
                         node.parts[0].name in projections
                         for node in alias_expr.find_all(exp.Column)
                     )
-            elif dialect.PROJECTION_ALIASES_SHADOW_SOURCE_NAMES and (
-                is_group_by or is_having or is_qualify
-            ):
-                column_table = table.name if table else column.table
-                if column_table in projections:
-                    # BigQuery's GROUP BY and HAVING clauses get confused if the column name
-                    # matches a source name and a projection. For instance:
-                    # SELECT id, ARRAY_AGG(col) AS custom_fields FROM custom_fields GROUP BY id HAVING id >= 1
-                    # We should not qualify "id" with "custom_fields" in either clause, since the aggregation shadows the actual table
-                    # and we'd get the error: "Column custom_fields contains an aggregation function, which is not allowed in GROUP BY clause"
-                    column.replace(exp.to_identifier(column.name))
-                    replaced = True
-                    return
-
             if table and (not alias_expr or skip_replace):
                 column.set("table", table)
             elif not column.table and alias_expr and not skip_replace:
@@ -460,6 +453,25 @@ def _expand_alias_refs(
         for join in expression.args.get("joins") or []:
             replace_columns(join)
 
+    if dialect.PROJECTION_ALIASES_SHADOW_SOURCE_NAMES:
+        # In BigQuery's GROUP BY, HAVING and QUALIFY clauses, a qualifier that collides with a
+        # projection alias resolves to the projection instead of the source. For instance:
+        # SELECT id, ARRAY_AGG(col) AS custom_fields FROM custom_fields GROUP BY custom_fields.id
+        # fails with "Column custom_fields contains an aggregation function, which is not
+        # allowed in GROUP BY", so such references must be rendered as bare names. We keep the
+        # columns qualified and mark them, deferring to Generator.column_parts
+        for clause in (
+            expression.args.get("group"),
+            expression.args.get("having"),
+            expression.args.get("qualify"),
+        ):
+            if not clause:
+                continue
+
+            for column in find_all_in_scope(clause, exp.Column):
+                if column.table and not column.db:
+                    column.set("shadow", column.table in projections or None)
+
     if replaced:
         scope.clear_cache()
 

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/optimizer/qualify_tables.py

@@ -112,10 +112,23 @@ def qualify_tables(
         local_columns = scope.local_columns
         canonical_aliases: dict[str, str] = {}
 
-        for query in scope.subqueries:
+        queries: list[exp.Expr] = list(scope.subqueries)
+
+        # Subquery wrappers around a DML / DDL query fragment, e.g., a CREATE FUNCTION body or
+        # an UPDATE's SET subquery, don't belong to any scope, so they aren't collected above
+        if scope.is_root and isinstance(scope.expression, exp.Subquery):
+            queries.append(scope.expression.unnest())
+        elif scope.is_subquery:
+            queries.append(scope.expression)
+
+        for query in queries:
             subquery = query.parent
             if isinstance(subquery, exp.Subquery):
                 unwrapped = subquery.unwrap()
+                if isinstance(unwrapped.parent, (exp.From, exp.Join)):
+                    # We can reach this from a wrapped derived table, which must keep its alias
+                    continue
+
                 if isinstance(unwrapped.parent, exp.Create) and unwrapped is not subquery:
                     # Function bodies may require wrapping parentheses, e.g. in BigQuery
                     # `... AS ((SELECT 1))` the outer parens delimit the body itself

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/optimizer/scope.py

@@ -189,6 +189,12 @@ class Scope:
         self._semi_anti_join_tables = set()
         self._column_index = set()
 
+        # The inner query of a Subquery-rooted scope is scoped as a derived table by
+        # `_traverse_tables`, so it must not also be collected as a subquery
+        inner_query = (
+            self.expression.unnest() if isinstance(self.expression, exp.Subquery) else None
+        )
+
         for node in self.walk():
             # Most nodes (identifiers, literals, operators etc.) aren't collectible, so a
             # single isinstance gate lets them skip the classification chain below.
@@ -220,7 +226,11 @@ class Scope:
                 self._ctes.append(node)
             elif _is_derived_table(node) and _is_from_or_join(node):
                 self._derived_tables.append(t.cast(exp.Subquery, node))
-            elif isinstance(node, exp.UNWRAPPED_QUERIES) and not _is_from_or_join(node):
+            elif (
+                isinstance(node, exp.UNWRAPPED_QUERIES)
+                and not _is_from_or_join(node)
+                and node is not inner_query
+            ):
                 self._subqueries.append(node)
             elif isinstance(node, exp.TableColumn):
                 self._table_columns.append(node)
@@ -705,10 +715,47 @@ def _traverse_scope(scope: Scope) -> Iterator[Scope]:
         return
     elif isinstance(expression, exp.DML):
         yield from _traverse_ctes(scope)
+
+        # Bare tables in relation position (e.g. UPDATE ... FROM t, DELETE / MERGE ... USING t)
+        # aren't part of any query, so they're scoped as standalone tables; `_traverse_tables`
+        # also picks up any joins hanging off of them
+        relations: list[exp.Expr] = []
+        from_ = expression.args.get("from_")
+
+        if isinstance(from_, exp.From):
+            relations.append(from_.this)
+
+        using = expression.args.get("using")
+        if isinstance(using, list):
+            relations.extend(using)
+        elif isinstance(using, exp.Expr):
+            relations.append(using)
+
+        for relation in relations:
+            if isinstance(relation, exp.Table):
+                yield from _traverse_scope(Scope(relation, cte_sources=scope.cte_sources))
+
         for query in find_all_in_scope(expression, exp.Query):
             # This check ensures we don't yield the CTE/nested queries twice
-            if not isinstance(query.parent, (exp.CTE, exp.Subquery)):
+            if isinstance(query.parent, (exp.CTE, exp.Subquery)):
+                continue
+
+            if _is_from_or_join(query):
+                parent = query.parent
+                if isinstance(parent, exp.Join) and isinstance(
+                    parent.parent, (exp.Subquery, exp.Table)
+                ):
+                    # Scoped by the FROM-position relation (wrapper or table) it's joined to
+                    continue
+
+                # A query in FROM/JOIN position (e.g. UPDATE ... FROM (SELECT ...) AS s) acts
+                # like a derived table, so its scope stays rooted at the Subquery wrapper to
+                # pick up the wrapper's alias, column list and joins
                 yield from _traverse_scope(Scope(query, cte_sources=scope.cte_sources))
+            else:
+                # Queries in value position (SET, WHERE, USING, ...) are scoped as subqueries,
+                # e.g. so their columns can be correlated to the DML's target table
+                yield from _traverse_scope(scope.branch(query, scope_type=ScopeType.SUBQUERY))
         return
     else:
         logger.warning("Cannot traverse scope %s with type '%s'", expression, type(expression))
@@ -835,7 +882,10 @@ def _traverse_tables(scope: Scope) -> Iterator[Scope]:
     for join in scope.expression.args.get("joins") or []:
         expressions.append(join.this)
 
-    if isinstance(scope.expression, exp.Table):
+    if isinstance(scope.expression, (exp.Table, exp.Subquery)):
+        # A Subquery-rooted scope, e.g., the FROM clause of a DML statement, a DDL source or
+        # a parenthesized query like (SELECT ...) LIMIT 1, scopes its own inner query as a
+        # derived table
         expressions.append(scope.expression)
 
     expressions.extend(scope.expression.args.get("laterals") or [])
@@ -880,11 +930,14 @@ def _traverse_tables(scope: Scope) -> Iterator[Scope]:
             lateral_sources = None
             scope_type = ScopeType.DERIVED_TABLE
             scopes = scope.derived_table_scopes
-            expressions.extend(join.this for join in node.args.get("joins") or [])
+            if node is not scope.expression:
+                # The scope expression's own joins were already added above
+                expressions.extend(join.this for join in node.args.get("joins") or [])
         else:
             # Makes sure we check for possible sources in nested table constructs
             expressions.append(node.this)
-            expressions.extend(join.this for join in node.args.get("joins") or [])
+            if node is not scope.expression:
+                expressions.extend(join.this for join in node.args.get("joins") or [])
             continue
 
         child_scope: Scope | None = None

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/optimizer/simplify.py

@@ -1662,7 +1662,11 @@ class Gen:
             name = this.upper()
         elif isinstance(this, exp.Identifier):
             name = this.this
-            name = f'"{name}"' if this.quoted else name.upper()
+            if this.quoted:
+                escaped = name.replace('"', '""')
+                name = f'"{escaped}"'
+            else:
+                name = name.upper()
         else:
             raise ValueError(
                 f"Anonymous.this expects a str or an Identifier, got '{this.__class__.__name__}'."
@@ -1729,7 +1733,11 @@ class Gen:
         self._binary(e, " >= ")
 
     def identifier_sql(self, e: exp.Identifier) -> None:
-        self.stack.append(f'"{e.this}"' if e.quoted else e.this)
+        if e.quoted:
+            escaped = e.this.replace('"', '""')
+            self.stack.append(f'"{escaped}"')
+        else:
+            self.stack.append(e.this)
 
     def ilike_sql(self, e: exp.ILike) -> None:
         self._binary(e, " NOT ILIKE " if e.args.get("negate") else " ILIKE ")
@@ -1755,7 +1763,11 @@ class Gen:
         self._binary(e, " NOT Like " if e.args.get("negate") else " Like ")
 
     def literal_sql(self, e: exp.Literal) -> None:
-        self.stack.append(f"'{e.this}'" if e.is_string else e.this)
+        if e.is_string:
+            escaped = e.this.replace("'", "''")
+            self.stack.append(f"'{escaped}'")
+        else:
+            self.stack.append(e.this)
 
     def lt_sql(self, e: exp.LT) -> None:
         self._binary(e, " < ")
@@ -1847,7 +1859,8 @@ class Gen:
             v = node.args.get(k)
 
             if v is not None:
-                kvs.append([f":{k}", v])
+                # repr() plain strings so their content can't mimic gen's structural text
+                kvs.append([f":{k}", repr(v) if isinstance(v, str) else v])
         if kvs:
             self.stack.append(kvs)
             return True

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/parser.py

@@ -6198,14 +6198,18 @@ class Parser:
 
             self._retreat(index)
 
+        unit_index = self._index
         if interval_span_units_omitted:
             unit = None
         else:
-            unit = self._parse_function() if parse_function_unit else None
-            if not unit and (
+            # Only attempt to parse a unit if the current token can actually be one, so that a
+            # trailing operator isn't swallowed, e.g. INTERVAL '1 day' AND (x)
+            is_unit = self._curr is not None and (
                 self._curr.token_type == TokenType.VAR
                 or self._curr.text.upper() in self.dialect.VALID_INTERVAL_UNITS
-            ):
+            )
+            unit = self._parse_function() if parse_function_unit and is_unit else None
+            if not unit and is_unit:
                 unit = self._parse_var(any_token=True, upper=True)
 
         # Most dialects support, e.g., the form INTERVAL '5' day, thus we try to parse
@@ -6220,7 +6224,7 @@ class Parser:
             if parts and unit:
                 # Unconsume the eagerly-parsed unit, since the real unit was part of the string
                 unit = None
-                self._retreat(self._index - 1)
+                self._retreat(unit_index)
 
             if len(parts) == 1:
                 this = exp.Literal.string(parts[0][0])
@@ -7173,6 +7177,14 @@ class Parser:
     def _parse_function_args(self, alias: bool = False) -> list[exp.Expr]:
         return self._parse_csv(lambda: self._parse_lambda(alias=alias))
 
+    def _parse_connector_function(self, connector: t.Callable[..., exp.Condition]) -> exp.Paren:
+        args = self._parse_function_args(alias=False)
+        if not args:
+            self.raise_error("Expected at least one argument")
+
+        # Wrapped so the connector keeps its precedence in the parent context
+        return exp.Paren(this=connector(*args, copy=False))
+
     def _parse_function_call(
         self,
         functions: dict[str, t.Callable] | None = None,
@@ -7499,10 +7511,18 @@ class Parser:
         if (not kind and self._match(TokenType.ALIAS)) or self._match_texts(
             ("ALIAS", "MATERIALIZED")
         ):
+            # Match storage before _parse_types so STORED is not treated as a data type
+            # (needed for typeless columns, e.g. SQLite `b AS (a * 2) STORED`).
             persisted = self._prev.text.upper() == "MATERIALIZED"
+            expression = self._parse_disjunction()
+            if not persisted:
+                if self._match_text_seq("PERSISTED"):
+                    persisted = True
+                elif self._match_texts(("STORED", "VIRTUAL")):
+                    persisted = self._prev.text.upper() == "STORED"
             constraint_kind = exp.ComputedColumnConstraint(
-                this=self._parse_disjunction(),
-                persisted=persisted or self._match_text_seq("PERSISTED"),
+                this=expression,
+                persisted=persisted,
                 data_type=exp.Var(this="AUTO")
                 if self._match_text_seq("AUTO")
                 else self._parse_types(),

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/parsers/clickhouse.py

@@ -382,8 +382,8 @@ class ClickHouseParser(parser.Parser):
         "MEDIAN": lambda self: self._parse_quantile(),
         "COLUMNS": lambda self: self._parse_columns(),
         "TUPLE": lambda self: exp.Struct.from_arg_list(self._parse_function_args(alias=True)),
-        "AND": lambda self: exp.and_(*self._parse_function_args(alias=False)),
-        "OR": lambda self: exp.or_(*self._parse_function_args(alias=False)),
+        "AND": lambda self: self._parse_connector_function(exp.and_),
+        "OR": lambda self: self._parse_connector_function(exp.or_),
         "XOR": lambda self: exp.xor(*self._parse_function_args(alias=False)),
     }
 

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/parsers/prql.py

@@ -8,7 +8,7 @@ from sqlglot.tokens import TokenType
 from collections.abc import Collection
 
 
-def _select_all(table: exp.Expr) -> exp.Select | None:
+def _select_all(table: exp.Expr | None) -> exp.Select | None:
     return exp.select("*").from_(table, copy=False) if table else None
 
 

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/parsers/spark2.py

@@ -11,6 +11,7 @@ from sqlglot.dialects.dialect import (
 from sqlglot.helper import ensure_list, seq_get
 from sqlglot.parsers.hive import HiveParser
 from sqlglot.parser import build_trim
+from sqlglot.tokens import TokenType
 
 
 def build_as_cast(to_type: str) -> t.Callable[[list], exp.Expr]:
@@ -22,6 +23,8 @@ class Spark2Parser(HiveParser):
     CHANGE_COLUMN_ALTER_SYNTAX = True
     PIVOT_COLUMN_NAMING = "agg_name_if_multiple"
 
+    FUNC_TOKENS = HiveParser.FUNC_TOKENS | {TokenType.AND, TokenType.OR}
+
     FUNCTIONS = {
         **HiveParser.FUNCTIONS,
         "AGGREGATE": exp.Reduce.from_arg_list,
@@ -80,11 +83,13 @@ class Spark2Parser(HiveParser):
 
     FUNCTION_PARSERS = {
         **HiveParser.FUNCTION_PARSERS,
+        "AND": lambda self: self._parse_connector_function(exp.and_),
         "APPROX_PERCENTILE": lambda self: self._parse_distinct_arg_function(exp.ApproxQuantile),
         "BROADCAST": lambda self: self._parse_join_hint("BROADCAST"),
         "BROADCASTJOIN": lambda self: self._parse_join_hint("BROADCASTJOIN"),
         "MAPJOIN": lambda self: self._parse_join_hint("MAPJOIN"),
         "MERGE": lambda self: self._parse_join_hint("MERGE"),
+        "OR": lambda self: self._parse_connector_function(exp.or_),
         "SHUFFLEMERGE": lambda self: self._parse_join_hint("SHUFFLEMERGE"),
         "MERGEJOIN": lambda self: self._parse_join_hint("MERGEJOIN"),
         "SHUFFLE_HASH": lambda self: self._parse_join_hint("SHUFFLE_HASH"),

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/parsers/sqlite.py

@@ -98,9 +98,7 @@ class SQLiteParser(parser.Parser):
     }
 
     def _parse_factor_operand(self) -> exp.Expr | None:
-        in_arithmetic_operand = (
-            self._prev is not None and self._prev.token_type in self.ARITHMETIC_TOKENS
-        )
+        in_arithmetic_operand = self._prev.token_type in self.ARITHMETIC_TOKENS
         this = self._parse_concat_operand()
         parsed_op = False
 
@@ -178,3 +176,29 @@ class SQLiteParser(parser.Parser):
             if is_attach
             else self.expression(exp.Detach(this=this))
         )
+
+    # https://www.sqlite.org/gencol.html
+    def _parse_generated_as_identity(
+        self,
+    ) -> (
+        exp.GeneratedAsIdentityColumnConstraint
+        | exp.ComputedColumnConstraint
+        | exp.GeneratedAsRowColumnConstraint
+    ):
+        this = super()._parse_generated_as_identity()
+
+        # Only expression-bearing GENERATED ALWAYS AS (expr) forms are computed
+        # columns. Match STORED/VIRTUAL inside this branch so true identity
+        # (AS IDENTITY) does not silently consume a trailing storage keyword.
+        if (
+            isinstance(this, exp.GeneratedAsIdentityColumnConstraint)
+            and this.expression is not None
+        ):
+            persisted = (
+                self._match_texts(("STORED", "VIRTUAL")) and self._prev.text.upper() == "STORED"
+            )
+            return self.expression(
+                exp.ComputedColumnConstraint(this=this.expression, persisted=persisted)
+            )
+
+        return this

{sqlglotc-30.16.0 → sqlglotc-30.17.0}/sqlglot/parsers/trino.py

@@ -199,7 +199,37 @@ class TrinoParser(PrestoParser):
         self._match_text_seq("CASE")
         return self.expression(exp.CaseStatement(this=this, ifs=ifs, default=default))
 
+    def _parse_routine_while(self, label: exp.Expr | None = None) -> exp.WhileBlock:
+        # https://trino.io/docs/current/udf/sql/while.html
+        condition = self._parse_disjunction()
+        self._match_text_seq("DO")
+        body = self.expression(exp.Block(expressions=self._parse_routine_statements("END")))
+        self._match_text_seq("WHILE")
+        return self.expression(exp.WhileBlock(this=condition, body=body, label=label))
+
+    def _parse_routine_loop(self, label: exp.Expr | None = None) -> exp.LoopBlock:
+        # https://trino.io/docs/current/udf/sql/loop.html
+        body = self.expression(exp.Block(expressions=self._parse_routine_statements("END")))
+        self._match_text_seq("LOOP")
+        return self.expression(exp.LoopBlock(body=body, label=label))
+
+    def _parse_routine_repeat(self, label: exp.Expr | None = None) -> exp.RepeatBlock:
+        # https://trino.io/docs/current/udf/sql/repeat.html - unlike WHILE/LOOP,
+        # the body is evaluated at least once, with UNTIL <condition> tested after
+        body = self.expression(exp.Block(expressions=self._parse_routine_statements("UNTIL")))
+        until = self._parse_disjunction()
+        self._match_text_seq("END", "REPEAT")
+        return self.expression(exp.RepeatBlock(body=body, until=until, label=label))
+
     def _parse_routine_statement(self) -> exp.Expr | None:
+        # An optional `label :` can precede WHILE, LOOP, or REPEAT to name the block for ITERATE/LEAVE.
+        # Any non-reserved keyword (SET, IF, ITERATE etc) is a valid label name, so the colon lookahead
+        # has to run first, before the statement keywords are matched.
+        label = None
+        if self._next and self._next.token_type == TokenType.COLON:
+            label = self._parse_id_var()
+            self._match(TokenType.COLON)
+
         if self._match(TokenType.BEGIN, advance=False):
             return self._parse_routine_block()
 
@@ -218,5 +248,20 @@ class TrinoParser(PrestoParser):
         if self._match(TokenType.SET):
             return self._parse_set()
 
+        if self._match_text_seq("ITERATE"):
+            return self.expression(exp.Iterate(this=self._parse_id_var()))
+
+        if self._match_text_seq("LEAVE"):
+            return self.expression(exp.Leave(this=self._parse_id_var()))
+
+        if self._match_text_seq("WHILE"):
+            return self._parse_routine_while(label=label)
+
+        if self._match_text_seq("LOOP"):
+            return self._parse_routine_loop(label=label)
+
+        if self._match_text_seq("REPEAT"):
+            return self._parse_routine_repeat(label=label)
+
         self.raise_error("Expected routine statement")
         return None

{sqlglotc-30.16.0 → sqlglotc-30.17.0/sqlglotc.egg-info}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.16.0
+Version: 30.17.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.16.0
+Requires-Dist: sqlglot==30.17.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"
-Requires-Dist: sqlglot-mypy>=2.1.0.post9; extra == "dev"
+Requires-Dist: sqlglot-mypy>=2.3.0.post1; extra == "dev"
 Dynamic: requires-dist

sqlglotc-30.17.0/sqlglotc.egg-info/requires.txt

@@ -0,0 +1,6 @@
+sqlglot==30.17.0
+
+[dev]
+setuptools>=61.0
+setuptools_scm
+sqlglot-mypy>=2.3.0.post1

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

@@ -0,0 +1,8 @@
+{
+  "tag": "30.17.0",
+  "distance": 0,
+  "node": "g9a8129b6f2667673f24713f4b49162ebae1f699d",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-12"
+}

sqlglotc-30.16.0/sqlglotc.egg-info/requires.txt

@@ -1,6 +0,0 @@
-sqlglot==30.16.0
-
-[dev]
-setuptools>=61.0
-setuptools_scm
-sqlglot-mypy>=2.1.0.post9

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

@@ -1,8 +0,0 @@
-{
-  "tag": "30.16.0",
-  "distance": 0,
-  "node": "gbbfb497f16002da3cda10c927683a404a2fb694e",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-08-10"
-}