sqlglotc 30.10.0__tar.gz → 30.11.0__tar.gz

{sqlglotc-30.10.0/sqlglotc.egg-info → sqlglotc-30.11.0}/PKG-INFO

@@ -1,13 +1,15 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.10.0
+Version: 30.11.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.11.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"
 Requires-Dist: sqlglot-mypy>=2.1.0.post2; extra == "dev"
+Dynamic: requires-dist

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlglotc"
-dynamic = ["version"]
+dynamic = ["version", "dependencies"]
 description = "mypyc-compiled extensions for sqlglot"
 authors = [{ name = "Toby Mao", email = "toby.mao@gmail.com" }]
 license = "MIT"

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/setup.py

@@ -128,9 +128,42 @@ class sdist(_sdist):
             shutil.rmtree(local_sqlglot, ignore_errors=True)
 
 
+def _sqlglot_requirement():
+    """Pin sqlglot to the matching version so resolvers keep the two packages in lockstep."""
+    try:
+        pkg_info = os.path.join(os.path.dirname(os.path.abspath(__file__)), "PKG-INFO")
+        if os.path.isfile(pkg_info):
+            # Building from an sdist: no git metadata; the released version is frozen in PKG-INFO.
+            with open(pkg_info, encoding="utf-8") as fd:
+                version = next(
+                    (line.split(":", 1)[1].strip() for line in fd if line.startswith("Version:")),
+                    "",
+                )
+        else:
+            from setuptools_scm import get_version
+
+            version = get_version(
+                root="..",
+                relative_to=__file__,
+                local_scheme="no-local-version",
+                fallback_version="0.0.0",
+            )
+    except Exception as e:
+        print(f"sqlglotc: failed to determine the sqlglot version to pin: {e}")
+        version = ""
+
+    # Dev and fallback (no git metadata) builds have no matching sqlglot release on PyPI;
+    # depend on sqlglot unpinned since the extensions can't be imported without it.
+    if version in ("", "0.0.0") or ".dev" in version:
+        return ["sqlglot"]
+
+    return [f"sqlglot=={version}"]
+
+
 setup(
     name="sqlglotc",
     packages=[],
+    install_requires=_sqlglot_requirement(),
     ext_modules=mypycify(
         _source_paths(), opt_level=os.environ.get("MYPYC_OPT", "2"), separate=True, verbose=True
     ),

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/sqlglot/expressions/builders.py

@@ -319,6 +319,11 @@ def parse_identifier(name: str | Identifier, dialect: DialectType = None) -> Ide
     Returns:
         The identifier ast node.
     """
+    if isinstance(name, str) and SAFE_IDENTIFIER_RE.match(name):
+        # Simple names parse to a single unquoted identifier in all dialects, so we can
+        # avoid the tokenizer/parser round-trip for them.
+        return Identifier(this=name, quoted=False)
+
     try:
         expression = maybe_parse(name, dialect=dialect, into=Identifier)
     except (ParseError, TokenError):
@@ -822,7 +827,7 @@ def replace_tables(
     mapping = {normalize_table_name(k, dialect=dialect): v for k, v in mapping.items()}
 
     def _replace_tables(node: Expr) -> Expr:
-        if isinstance(node, Table) and node.meta.get("replace") is not False:
+        if isinstance(node, Table) and node.meta_get("replace") is not False:
             original = normalize_table_name(node, dialect=dialect)
             new_name = mapping.get(original)
 

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/sqlglot/expressions/core.py

@@ -240,6 +240,9 @@ class Expr:
     def meta(self) -> dict[str, t.Any]:
         raise NotImplementedError
 
+    def meta_get(self, key: str, default: t.Any = None) -> t.Any:
+        raise NotImplementedError
+
     def __deepcopy__(self, memo: t.Any) -> Expr:
         raise NotImplementedError
 
@@ -990,6 +993,11 @@ class Expression(Expr):
             self._meta = {}
         return self._meta
 
+    def meta_get(self, key: str, default: t.Any = None) -> t.Any:
+        """Reads a meta value without allocating the meta dict (unlike the `meta` property)."""
+        meta = self._meta
+        return meta.get(key, default) if meta is not None else default
+
     def __deepcopy__(self, memo: t.Any) -> Expr:
         root = self.__class__()
         stack: list[tuple[Expr, Expr]] = [(self, root)]

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/sqlglot/generator.py

@@ -4554,7 +4554,7 @@ class Generator:
                 args.append(arg_value)
 
         if self.dialect.PRESERVE_ORIGINAL_NAMES:
-            name = (expression._meta and expression.meta.get("name")) or expression.sql_name()
+            name = expression.meta_get("name") or expression.sql_name()
         else:
             name = expression.sql_name()
 
@@ -5258,7 +5258,7 @@ class Generator:
             )
             return self.sql(this)
 
-        if self.IGNORE_NULLS_IN_FUNC and not expression.meta.get("inline"):
+        if self.IGNORE_NULLS_IN_FUNC and not expression.meta_get("inline"):
             if self.IGNORE_NULLS_BEFORE_ORDER:
                 # The first modifier here will be the one closest to the AggFunc's arg
                 mods = sorted(

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/sqlglot/generators/bigquery.py

@@ -201,7 +201,7 @@ def _levenshtein_sql(self: BigQueryGenerator, expression: exp.Levenshtein) -> st
 
 
 def _json_extract_sql(self: BigQueryGenerator, expression: JSON_EXTRACT_TYPE) -> str:
-    name = (expression._meta and expression.meta.get("name")) or expression.sql_name()
+    name = expression.meta_get("name") or expression.sql_name()
     upper = name.upper()
 
     dquote_escaping = upper in DQUOTES_ESCAPING_JSON_FUNCTIONS
@@ -565,7 +565,7 @@ class BigQueryGenerator(generator.Generator):
         )
 
     def column_parts(self, expression: exp.Column) -> str:
-        if expression.meta.get("quoted_column"):
+        if expression.meta_get("quoted_column"):
             # If a column reference is of the form `dataset.table`.name, we need
             # to preserve the quoted table path, otherwise the reference breaks
             table_parts = ".".join(p.name for p in expression.parts[:-1])
@@ -583,7 +583,7 @@ class BigQueryGenerator(generator.Generator):
         #
         # - WITH x AS (SELECT [1, 2] AS y) SELECT * FROM x, `x.y`   -> cross join
         # - WITH x AS (SELECT [1, 2] AS y) SELECT * FROM x, `x`.`y` -> implicit unnest
-        if expression.meta.get("quoted_table"):
+        if expression.meta_get("quoted_table"):
             table_parts = ".".join(p.name for p in expression.parts)
             return self.sql(exp.Identifier(this=table_parts, quoted=True))
 

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/sqlglot/generators/databricks.py

@@ -10,14 +10,6 @@ from sqlglot.dialects.dialect import (
 from sqlglot.generators.spark import SparkGenerator
 
 
-def _jsonextract_sql(
-    self: DatabricksGenerator, expression: exp.JSONExtract | exp.JSONExtractScalar
-) -> str:
-    this = self.sql(expression, "this")
-    expr = self.sql(expression, "expression")
-    return f"{this}:{expr}"
-
-
 class DatabricksGenerator(SparkGenerator):
     TABLESAMPLE_SEED_KEYWORD = "REPEATABLE"
     COPY_PARAMS_ARE_WRAPPED = False
@@ -52,9 +44,10 @@ class DatabricksGenerator(SparkGenerator):
                     transforms.any_to_exists,
                 ]
             ),
-            exp.JSONExtract: _jsonextract_sql,
-            exp.JSONExtractScalar: _jsonextract_sql,
-            exp.JSONPathRoot: lambda *_: "",
+            exp.JSONExtract: lambda self, e: f"{self.sql(e, 'this')}:{self.sql(e, 'expression')}",
+            exp.JSONPathRoot: lambda self, e: (
+                "$" if isinstance(e.parent and e.parent.parent, exp.JSONExtractScalar) else ""
+            ),
             exp.ToChar: lambda self, e: (
                 self.cast_sql(exp.Cast(this=e.this, to=exp.DataType(this="STRING")))
                 if e.args.get("is_numeric")
@@ -98,7 +91,12 @@ class DatabricksGenerator(SparkGenerator):
 
     def jsonpath_sql(self, expression: exp.JSONPath) -> str:
         expression.set("escape", None)
-        return super().jsonpath_sql(expression)
+        path = super().jsonpath_sql(expression)
+
+        if isinstance(expression.parent, exp.JSONExtractScalar):
+            return f"{self.dialect.QUOTE_START}{path}{self.dialect.QUOTE_END}"
+
+        return path
 
     def uniform_sql(self, expression: exp.Uniform) -> str:
         gen = expression.args.get("gen")

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/sqlglot/generators/tsql.py

@@ -417,6 +417,15 @@ class TSQLGenerator(generator.Generator):
                 # but CREATE VIEW actually requires the WITH clause to come after it so we need
                 # to amend the AST by moving the CTEs to the CREATE VIEW statement's query.
                 ctas_expression.set("with_", with_.pop())
+        elif (
+            kind == "FUNCTION"
+            and isinstance(ctas_expression, exp.Return)
+            and isinstance(body := ctas_expression.this.unnest(), exp.Query)
+            and (with_ := expression.args.get("with_"))
+        ):
+            # Similar to the VIEW branch, the table-valued functions require the WITH clause
+            # to stay inside the RETURN body, so we move back any CTEs that were bubbled up.
+            body.set("with_", with_.pop())
 
         table = expression.find(exp.Table)
 

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/sqlglot/lineage.py

@@ -9,6 +9,7 @@ from sqlglot import Schema, exp, maybe_parse
 from sqlglot.errors import SqlglotError
 from sqlglot.optimizer import Scope, build_scope, find_all_in_scope, normalize_identifiers, qualify
 from sqlglot.optimizer.scope import ScopeType
+from sqlglot.schema import ensure_schema
 
 if t.TYPE_CHECKING:
     from sqlglot.dialects.dialect import DialectType
@@ -133,6 +134,8 @@ def lineage(
             copy=copy,
         )
 
+    schema = ensure_schema(schema, dialect=dialect)
+
     if not scope:
         expression = qualify.qualify(
             expression,
@@ -162,6 +165,7 @@ def lineage(
             scope,
             dialect,
             trim_selects=trim_selects,
+            schema=schema,
             _cache=cache,
             _scope_meta=scope_meta,
             on_node=on_node,
@@ -180,6 +184,7 @@ def lineage(
             scope,
             dialect,
             trim_selects=trim_selects,
+            schema=schema,
             _cache=cache,
             _scope_meta=scope_meta,
             on_node=on_node,
@@ -197,6 +202,7 @@ def to_node(
     source_name: str | None = None,
     reference_node_name: str | None = None,
     trim_selects: bool = True,
+    schema: Schema | None = None,
     _cache: dict[tuple, Node] | None = None,
     _scope_meta: dict[int, tuple[bool, dict[str, exp.Expr]]] | None = None,
     on_node: t.Callable[[Node], None] | None = None,
@@ -248,6 +254,7 @@ def to_node(
                 source_name=source_name,
                 reference_node_name=reference_node_name,
                 trim_selects=trim_selects,
+                schema=schema,
                 _cache=_cache,
                 _scope_meta=_scope_meta,
                 on_node=on_node,
@@ -288,6 +295,7 @@ def to_node(
                 source_name=source_name,
                 reference_node_name=reference_node_name,
                 trim_selects=trim_selects,
+                schema=schema,
                 _cache=_cache,
                 _scope_meta=_scope_meta,
                 on_node=on_node,
@@ -337,6 +345,7 @@ def to_node(
                 dialect=dialect,
                 upstream=node,
                 trim_selects=trim_selects,
+                schema=schema,
                 _cache=_cache,
                 _scope_meta=_scope_meta,
                 on_node=on_node,
@@ -372,25 +381,19 @@ def to_node(
     }
 
     pivots = scope.pivots
-    pivot = pivots[0] if len(pivots) == 1 and not pivots[0].unpivot else None
+    pivot = pivots[0] if len(pivots) == 1 else None
+    pivot_renames: dict[str, str] = {}
+    pivot_column_mapping: dict[str, list[exp.Column]] = {}
+
     if pivot:
-        # For each aggregation function, the pivot creates a new column for each field in category
-        # combined with the aggfunc. So the columns parsed have this order: cat_a_value_sum, cat_a,
-        # b_value_sum, b. Because of this step wise manner the aggfunc 'sum(value) as value_sum'
-        # belongs to the column indices 0, 2, and the aggfunc 'max(price)' without an alias belongs
-        # to the column indices 1, 3. Here, only the columns used in the aggregations are of interest
-        # in the lineage, so lookup the pivot column name by index and map that with the columns used
-        # in the aggregation.
-        #
-        # Example: PIVOT (SUM(value) AS value_sum, MAX(price)) FOR category IN ('a' AS cat_a, 'b')
-        pivot_columns = pivot.args["columns"]
-        pivot_aggs_count = len(pivot.expressions)
-
-        pivot_column_mapping = {}
-        for i, agg in enumerate(pivot.expressions):
-            agg_cols = list(agg.find_all(exp.Column))
-            for col_index in range(i, len(pivot_columns), pivot_aggs_count):
-                pivot_column_mapping[pivot_columns[col_index].name] = agg_cols
+        pivot_renames = _pivot_output_renames(pivot, scope, schema)
+        pivot_column_mapping = _pivot_column_mapping(pivot)
+        if pivot_renames:
+            pivot_column_mapping = {
+                post: pivot_column_mapping[pre]
+                for post, pre in pivot_renames.items()
+                if pre in pivot_column_mapping
+            }
 
     for c in source_columns:
         table = c.table
@@ -414,6 +417,7 @@ def to_node(
                 source_name=source_names.get(table) or source_name,
                 reference_node_name=reference_node_name,
                 trim_selects=trim_selects,
+                schema=schema,
                 _cache=_cache,
                 _scope_meta=_scope_meta,
                 on_node=on_node,
@@ -422,19 +426,35 @@ def to_node(
             downstream_columns = []
 
             column_name = c.name
-            if any(column_name == pivot_column.name for pivot_column in pivot_columns):
+            if column_name in pivot_column_mapping:
                 downstream_columns.extend(pivot_column_mapping[column_name])
             else:
                 # The column is not in the pivot, so it must be an implicit column of the
                 # pivoted source -- adapt column to be from the implicit pivoted source.
                 pivot_parent = pivot.parent
                 downstream_columns.append(
-                    exp.column(c.this, table=pivot_parent.alias_or_name if pivot_parent else "")
+                    exp.column(
+                        pivot_renames.get(c.name, c.this),
+                        table=pivot_parent.alias_or_name if pivot_parent else None,
+                    )
                 )
 
             for downstream_column in downstream_columns:
+                if not downstream_column.table:
+                    # Some dialects (e.g. bigquery) don't qualify the IN-list columns,
+                    # but they can only come from the pivoted source
+                    pivot_parent = pivot.parent
+                    downstream_column = exp.column(
+                        downstream_column.this,
+                        table=pivot_parent.alias_or_name if pivot_parent else None,
+                    )
+
                 table = downstream_column.table
                 col_source = scope.sources.get(table)
+                if isinstance(col_source, exp.Table) and not col_source.db:
+                    # A pivoted CTE reference maps to the raw table in `scope.sources`,
+                    # so recover the CTE's scope to keep tracing through it
+                    col_source = scope.cte_sources.get(col_source.name, col_source)
                 if isinstance(col_source, Scope):
                     to_node(
                         downstream_column.name,
@@ -445,6 +465,7 @@ def to_node(
                         source_name=source_names.get(table) or source_name,
                         reference_node_name=reference_node_name,
                         trim_selects=trim_selects,
+                        schema=schema,
                         _cache=_cache,
                         _scope_meta=_scope_meta,
                         on_node=on_node,
@@ -479,6 +500,89 @@ def to_node(
     return node
 
 
+def _pivot_output_renames(
+    pivot: exp.Pivot, scope: Scope, schema: Schema | None = None
+) -> dict[str, str]:
+    """
+    Map each (UN)PIVOT output column name to its pre-rename name, when an alias column
+    list (`... AS t(c1, c2, ...)`) renames the outputs. The renames are positional over
+    the operator's full output, so they can only be aligned when the pre-pivot columns
+    are known: from the projections of a derived table or CTE source, or from the
+    schema for a physical table.
+    """
+    if not pivot.alias_column_names:
+        return {}
+
+    parent = pivot.parent
+    pre_pivot_columns: list[str] = []
+    if isinstance(parent, exp.DerivedTable) and isinstance(parent.this, exp.Query):
+        pre_pivot_columns = parent.this.named_selects
+    elif isinstance(parent, exp.Table):
+        cte_source = scope.cte_sources.get(parent.name) if not parent.db else None
+        if isinstance(cte_source, Scope) and isinstance(cte_source.expression, exp.Query):
+            pre_pivot_columns = cte_source.expression.named_selects
+        elif schema is not None:
+            pre_pivot_columns = list(schema.column_names(parent, only_visible=True))
+
+    # The alignment is also unknowable when the source's projections aren't fully
+    # expanded (e.g. an unresolved star), since the renames would silently shift
+    if not pre_pivot_columns or "*" in pre_pivot_columns:
+        return {}
+
+    return pivot.output_columns(pre_pivot_columns)
+
+
+def _pivot_column_mapping(pivot: exp.Pivot) -> dict[str, list[exp.Column]]:
+    """Map each (UN)PIVOT output column name to the source columns it's derived from."""
+    mapping: dict[str, list[exp.Column]] = {}
+
+    if pivot.unpivot:
+        # UNPIVOT((v1, v2) FOR name IN ((a1, a2), (b1, b2))): each value column is derived
+        # positionally from the IN-list entries, and the name column from all of them
+        value_columns = [
+            identifier for e in pivot.expressions for identifier in e.find_all(exp.Identifier)
+        ]
+        for value_column in value_columns:
+            mapping[value_column.name] = []
+
+        for field in pivot.fields:
+            if not isinstance(field, exp.In):
+                continue
+
+            name_columns = mapping.setdefault(field.this.name, [])
+            for entry in field.expressions:
+                entry_columns = list(entry.find_all(exp.Column))
+                name_columns.extend(entry_columns)
+
+                if len(entry_columns) == len(value_columns):
+                    for value_column, column in zip(value_columns, entry_columns):
+                        mapping[value_column.name].append(column)
+                else:
+                    for value_column in value_columns:
+                        mapping[value_column.name].extend(entry_columns)
+
+        return mapping
+
+    # For each aggregation function, the pivot creates a new column for each field in category
+    # combined with the aggfunc. So the columns parsed have this order: cat_a_value_sum, cat_a,
+    # b_value_sum, b. Because of this step wise manner the aggfunc 'sum(value) as value_sum'
+    # belongs to the column indices 0, 2, and the aggfunc 'max(price)' without an alias belongs
+    # to the column indices 1, 3. Here, only the columns used in the aggregations are of interest
+    # in the lineage, so lookup the pivot column name by index and map that with the columns used
+    # in the aggregation.
+    #
+    # Example: PIVOT (SUM(value) AS value_sum, MAX(price)) FOR category IN ('a' AS cat_a, 'b')
+    pivot_columns = pivot.args["columns"]
+    pivot_aggs_count = len(pivot.expressions)
+
+    mapping = {}
+    for i, agg in enumerate(pivot.expressions):
+        agg_cols = list(agg.find_all(exp.Column))
+        for col_index in range(i, len(pivot_columns), pivot_aggs_count):
+            mapping[pivot_columns[col_index].name] = agg_cols
+    return mapping
+
+
 class GraphHTML:
     """Node to HTML generator using vis.js.
 

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/sqlglot/optimizer/annotate_types.py

@@ -400,7 +400,7 @@ class TypeAnnotator:
                     isinstance(source, Scope)
                     and isinstance(source.expression, exp.Query)
                     and (
-                        source.expression.meta.get("query_type") or exp.DType.UNKNOWN.into_expr()
+                        source.expression.meta_get("query_type") or exp.DType.UNKNOWN.into_expr()
                     ).is_type(exp.DType.STRUCT)
                 ):
                     self._set_type(table_column, source.expression.meta["query_type"])
@@ -497,7 +497,7 @@ class TypeAnnotator:
                 else:
                     self._set_type(expr, exp.DType.UNKNOWN)
 
-                if expr.is_type(exp.DType.JSON) and (dot_parts := expr.meta.get("dot_parts")):
+                if expr.is_type(exp.DType.JSON) and (dot_parts := expr.meta_get("dot_parts")):
                     # JSON dot access is case sensitive across all dialects, so we need to undo the normalization.
                     i = iter(dot_parts)
                     parent = expr.parent
@@ -740,7 +740,7 @@ class TypeAnnotator:
             self._annotate_by_args(expression, left, right)
 
         if isinstance(expression, exp.Is) or (
-            left.meta.get("nonnull") is True and right.meta.get("nonnull") is True
+            left.meta_get("nonnull") is True and right.meta_get("nonnull") is True
         ):
             expression.meta["nonnull"] = True
 
@@ -752,7 +752,7 @@ class TypeAnnotator:
         else:
             self._set_type(expression, expression.this.type)
 
-        if expression.this.meta.get("nonnull") is True:
+        if expression.this.meta_get("nonnull") is True:
             expression.meta["nonnull"] = True
 
         return expression

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/sqlglot/optimizer/normalize_identifiers.py

@@ -63,8 +63,8 @@ def normalize_identifiers(expression, dialect=None, store_original_column_identi
     if isinstance(expression, str):
         expression = exp.parse_identifier(expression, dialect=dialect)
 
-    for node in expression.walk(prune=lambda n: bool(n.meta.get("case_sensitive"))):
-        if not node.meta.get("case_sensitive"):
+    for node in expression.walk(prune=lambda n: bool(n.meta_get("case_sensitive"))):
+        if not node.meta_get("case_sensitive"):
             if store_original_column_identifiers and isinstance(node, exp.Column):
                 # TODO: This does not handle non-column cases, e.g PARSE_JSON(...).key
                 parent = node
@@ -73,6 +73,7 @@ def normalize_identifiers(expression, dialect=None, store_original_column_identi
 
                 node.meta["dot_parts"] = [p.name for p in parent.parts]
 
-            dialect.normalize_identifier(node)
+            if isinstance(node, exp.Identifier):
+                dialect.normalize_identifier(node)
 
     return expression

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/sqlglot/optimizer/qualify_columns.py

@@ -124,10 +124,10 @@ def validate_qualify_columns(expression: E, sql: str | None = None) -> E:
             if scope.external_columns and not scope.is_correlated_subquery and not scope.pivots:
                 column = scope.external_columns[0]
                 for_table = f" for table: '{column.table}'" if column.table else ""
-                line = column.this.meta.get("line")
-                col = column.this.meta.get("col")
-                start = column.this.meta.get("start")
-                end = column.this.meta.get("end")
+                line = column.this.meta_get("line")
+                col = column.this.meta_get("col")
+                start = column.this.meta_get("start")
+                end = column.this.meta_get("end")
 
                 error_msg = f"Column '{column.name}' could not be resolved{for_table}."
                 if line and col:
@@ -142,10 +142,10 @@ def validate_qualify_columns(expression: E, sql: str | None = None) -> E:
 
     if all_unqualified_columns:
         first_column = all_unqualified_columns[0]
-        line = first_column.this.meta.get("line")
-        col = first_column.this.meta.get("col")
-        start = first_column.this.meta.get("start")
-        end = first_column.this.meta.get("end")
+        line = first_column.this.meta_get("line")
+        col = first_column.this.meta_get("col")
+        start = first_column.this.meta_get("start")
+        end = first_column.this.meta_get("end")
 
         error_msg = f"Ambiguous column '{first_column.name}'"
         if line and col:
@@ -204,6 +204,9 @@ def _expand_using(scope: Scope, resolver: Resolver) -> dict[str, t.Any]:
                 columns[column_name] = source_name
 
     joins = list(scope.find_all(exp.Join))
+    if not joins:
+        return {}
+
     names = {join.alias_or_name for join in joins}
     ordered = [key for key in scope.selected_sources if key not in names]
 
@@ -213,6 +216,9 @@ def _expand_using(scope: Scope, resolver: Resolver) -> dict[str, t.Any]:
     # Mapping of automatically joined column names to an ordered set of source names (dict).
     column_tables: dict[str, dict[str, t.Any]] = {}
 
+    if not any(join.args.get("using") for join in joins):
+        return column_tables
+
     for source_name in ordered:
         _update_source_columns(source_name)
 
@@ -954,9 +960,15 @@ def qualify_outputs(scope_or_expression: Scope | exp.Expr) -> None:
 
 def quote_identifiers(expression: E, dialect: DialectType = None, identify: bool = True) -> E:
     """Makes sure all identifiers that need to be quoted are quoted."""
-    return expression.transform(
-        Dialect.get_or_raise(dialect).quote_identifier, identify=identify, copy=False
-    )
+    dialect = Dialect.get_or_raise(dialect)
+
+    # `quote_identifier` only mutates identifiers in place, so we avoid `transform` here
+    # because its node replacement machinery is wasteful for this case.
+    for node in expression.walk():
+        if isinstance(node, exp.Identifier):
+            dialect.quote_identifier(node, identify=identify)
+
+    return expression
 
 
 def pushdown_cte_alias_columns(scope: Scope) -> None:

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/sqlglot/optimizer/resolver.py

@@ -157,9 +157,8 @@ class Resolver:
             ):
                 columns = source_expr.named_selects
 
-                # in bigquery, unnest structs are automatically scoped as tables, so you can
-                # directly select a struct field in a query.
-                # this handles the case where the unnest is statically defined.
+                # in bigquery, unnest structs are automatically scoped as tables, so you can directly select
+                # a struct field in a query. This handles the case where the unnest is statically defined.
                 if self.dialect.UNNEST_COLUMN_ONLY and isinstance(source_expr, exp.Unnest):
                     if not source_expr.type or source_expr.type.is_type(exp.DType.UNKNOWN):
                         unnest_expr = seq_get(source_expr.expressions, 0)
@@ -178,7 +177,10 @@ class Resolver:
                 ):
                     explode_col = source_expr.this.this
 
-                    if isinstance(explode_col, exp.Column) and source.parent:
+                    # If the column is unqualified at this point, it couldn't be resolved when
+                    # this scope's children were qualified; disambiguating it here would require
+                    # enumerating this very source's columns, i.e recurse without bound
+                    if isinstance(explode_col, exp.Column) and explode_col.table and source.parent:
                         col_type = self._get_unnest_column_type(explode_col, source.parent)
                         columns.extend(self._struct_field_names(col_type))
             elif isinstance(source, Scope) and isinstance(source.expression, exp.SetOperation):

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/sqlglot/optimizer/scope.py

@@ -21,6 +21,20 @@ TRAVERSABLES = (exp.Query, exp.DDL, exp.DML)
 
 ROW_LEVEL_AGG_FUNCS = (exp.Count,)
 
+# The node types `Scope._collect` classifies, roughly ordered by frequency. `exp.Query`
+# covers subqueries, and `exp.UDTF` covers laterals.
+COLLECTIBLE_TYPES = (
+    exp.Column,
+    exp.Dot,
+    exp.Table,
+    exp.Query,
+    exp.UDTF,
+    exp.CTE,
+    exp.Star,
+    exp.TableColumn,
+    exp.JoinHint,
+)
+
 
 class ScopeType(Enum):
     ROOT = auto()
@@ -170,7 +184,9 @@ class Scope:
         self._column_index = set()
 
         for node in self.walk():
-            if node is self.expression:
+            # Most nodes (identifiers, literals, operators etc.) aren't collectible, so a
+            # single isinstance gate lets them skip the classification chain below.
+            if node is self.expression or not isinstance(node, COLLECTIBLE_TYPES):
                 continue
 
             if isinstance(node, exp.Dot) and node.is_star:
@@ -460,8 +476,10 @@ class Scope:
             list[exp.Column]: Column instances that reference sources in the current scope.
         """
         if self._local_columns is None:
-            external_columns = set(self.external_columns)
-            self._local_columns = [c for c in self.columns if c not in external_columns]
+            # Compare nodes by identity: structural equality would conflate distinct
+            # column nodes that happen to look the same, and is much more expensive.
+            external_column_ids = {id(c) for c in self.external_columns}
+            self._local_columns = [c for c in self.columns if id(c) not in external_column_ids]
 
         return self._local_columns
 
@@ -950,11 +968,17 @@ def walk_in_scope(
 
         yield node
 
-        if node is not expression and (
-            isinstance(node, exp.CTE)
-            or (isinstance(node.parent, (exp.From, exp.Join)) and _is_derived_table(node))
-            or (isinstance(node.parent, exp.UDTF) and isinstance(node, exp.Query))
-            or isinstance(node, exp.UNWRAPPED_QUERIES)
+        # Only CTEs and Queries can start child scopes; checking that first lets all
+        # other nodes (the vast majority) skip the rest of the boundary checks.
+        if (
+            node is not expression
+            and isinstance(node, (exp.CTE, exp.Query))
+            and (
+                isinstance(node, exp.CTE)
+                or (isinstance(node.parent, (exp.From, exp.Join)) and _is_derived_table(node))
+                or isinstance(node.parent, exp.UDTF)
+                or isinstance(node, exp.UNWRAPPED_QUERIES)
+            )
         ):
             if isinstance(node, (exp.Subquery, exp.UDTF)):
                 for key in ("joins", "laterals", "pivots"):

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/sqlglot/optimizer/simplify.py

@@ -596,9 +596,9 @@ class Simplifier:
         joins: list[exp.Join] = []
 
         for node in expression.walk(
-            prune=lambda n: bool(isinstance(n, exp.Condition) or n.meta.get(FINAL))
+            prune=lambda n: bool(isinstance(n, exp.Condition) or n.meta_get(FINAL))
         ):
-            if node.meta.get(FINAL):
+            if node.meta_get(FINAL):
                 continue
 
             # group by expressions cannot be simplified, for example
@@ -687,10 +687,10 @@ class Simplifier:
                 original.replace(node)
 
             for n in node.iter_expressions(reverse=True):
-                if n.meta.get(FINAL):
+                if n.meta_get(FINAL):
                     raise
             pre_transformation_stack.extend(
-                n for n in node.iter_expressions(reverse=True) if not n.meta.get(FINAL)
+                n for n in node.iter_expressions(reverse=True) if not n.meta_get(FINAL)
             )
             post_transformation_stack.append((node, parent))
 
@@ -699,9 +699,16 @@ class Simplifier:
             root = original is expression
 
             # Resets parent, arg_key, index pointers– this is needed because some of the
-            # previous transformations mutate the AST, leading to an inconsistent state
+            # previous transformations mutate the AST, leading to an inconsistent state.
+            # We only fix pointers instead of calling `set` because the values are unchanged:
+            # actual mutations go through `set`/`replace`, which already invalidate cached
+            # hashes, so clearing them again here would force `while_changing` to rehash
+            # entire subtrees after every (mostly no-op) pass.
             for k, v in tuple(original.args.items()):
-                original.set(k, v)
+                if v is None:
+                    original.args.pop(k)
+                else:
+                    original._set_parent(k, v)
 
             # Post-order transformations
             node = self.simplify_not(original)
@@ -937,7 +944,7 @@ class Simplifier:
             ops = set(expression.flatten())
             for op in ops:
                 if isinstance(op, exp.Not) and op.this in ops:
-                    if expression.meta.get("nonnull") is True:
+                    if expression.meta_get("nonnull") is True:
                         return exp.false() if isinstance(expression, exp.And) else exp.true()
 
         return expression
@@ -1289,15 +1296,15 @@ class Simplifier:
             sep_expr, *expressions = expression.expressions
             sep = sep_expr.name
             concat_type = exp.ConcatWs
-            args = {}
         else:
             expressions = expression.expressions
             sep = ""
             concat_type = exp.Concat
-            args = {
-                "safe": expression.args.get("safe"),
-                "coalesce": expression.args.get("coalesce"),
-            }
+
+        args = {
+            "safe": expression.args.get("safe"),
+            "coalesce": expression.args.get("coalesce"),
+        }
 
         new_args = []
         for is_string_group, group in itertools.groupby(

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/sqlglot/parsers/bigquery.py

@@ -480,10 +480,10 @@ class BigQueryParser(parser.Parser):
 
             info_schema_view = f"{table_parts[-2].name}.{table_parts[-1].name}"
             new_this = exp.Identifier(this=info_schema_view, quoted=True).update_positions(
-                line=table_parts[-2].meta.get("line"),
-                col=table_parts[-1].meta.get("col"),
-                start=table_parts[-2].meta.get("start"),
-                end=table_parts[-1].meta.get("end"),
+                line=table_parts[-2].meta_get("line"),
+                col=table_parts[-1].meta_get("col"),
+                start=table_parts[-2].meta_get("start"),
+                end=table_parts[-1].meta_get("end"),
             )
             table.set("this", new_this)
             table.set("db", seq_get(table_parts, -3))

{sqlglotc-30.10.0 → sqlglotc-30.11.0/sqlglotc.egg-info}/PKG-INFO

@@ -1,13 +1,15 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.10.0
+Version: 30.11.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.11.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"
 Requires-Dist: sqlglot-mypy>=2.1.0.post2; extra == "dev"
+Dynamic: requires-dist

{sqlglotc-30.10.0 → sqlglotc-30.11.0}/sqlglotc.egg-info/requires.txt

@@ -1,3 +1,4 @@
+sqlglot==30.11.0
 
 [dev]
 setuptools>=61.0