sqlglotc 30.25.0__tar.gz → 30.26.0__tar.gz

{sqlglotc-30.25.0/sqlglotc.egg-info → sqlglotc-30.26.0}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.25.0
+Version: 30.26.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.25.0
+Requires-Dist: sqlglot==30.26.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
-Requires-Dist: setuptools_scm; extra == "dev"
+Requires-Dist: setuptools_scm>=10.2; extra == "dev"
 Requires-Dist: mypy>=2.4.0; extra == "dev"
 Dynamic: requires-dist

{sqlglotc-30.25.0 → sqlglotc-30.26.0}/pyproject.toml

@@ -7,7 +7,7 @@ license = "MIT"
 requires-python = ">= 3.10"
 
 [project.optional-dependencies]
-dev = ["setuptools >= 61.0", "setuptools_scm", "mypy >= 2.4.0"]
+dev = ["setuptools >= 61.0", "setuptools_scm >= 10.2", "mypy >= 2.4.0"]
 
 [project.urls]
 Homepage = "https://sqlglot.com/"
@@ -16,7 +16,7 @@ Repository = "https://github.com/tobymao/sqlglot"
 [build-system]
 requires = [
     "setuptools >= 61.0",
-    "setuptools_scm",
+    "setuptools_scm >= 10.2",
     "mypy >= 2.4.0",
     "types-python-dateutil",
     "sqlglot",

{sqlglotc-30.25.0 → sqlglotc-30.26.0}/sqlglot/expressions/core.py

@@ -2108,6 +2108,10 @@ class Filter(Expression):
     arg_types = {"this": True, "expression": True}
 
 
+class Per(Expression):
+    arg_types = {"this": True, "expressions": True}
+
+
 class Check(Expression):
     pass
 

{sqlglotc-30.25.0 → sqlglotc-30.26.0}/sqlglot/expressions/properties.py

@@ -107,6 +107,10 @@ class CopyGrantsProperty(Property):
     arg_types = {}
 
 
+class CopyTagsProperty(Property):
+    arg_types = {}
+
+
 class DataBlocksizeProperty(Property):
     arg_types = {
         "size": False,

{sqlglotc-30.25.0 → sqlglotc-30.26.0}/sqlglot/generator.py

@@ -169,6 +169,7 @@ class Generator:
             "CONVERT", e.this, e.args["dest"], e.args.get("source")
         ),
         exp.CopyGrantsProperty: lambda *_: "COPY GRANTS",
+        exp.CopyTagsProperty: lambda *_: "COPY TAGS",
         exp.CredentialsProperty: lambda self, e: (
             f"CREDENTIALS=({self.expressions(e, 'expressions', sep=' ')})"
         ),
@@ -731,6 +732,7 @@ class Generator:
         exp.CollateProperty: exp.Properties.Location.POST_SCHEMA,
         exp.ComputeProperty: exp.Properties.Location.POST_CREATE,
         exp.CopyGrantsProperty: exp.Properties.Location.POST_SCHEMA,
+        exp.CopyTagsProperty: exp.Properties.Location.POST_SCHEMA,
         exp.Cluster: exp.Properties.Location.POST_SCHEMA,
         exp.ClusteredByProperty: exp.Properties.Location.POST_SCHEMA,
         exp.ClusterProperty: exp.Properties.Location.POST_SCHEMA,
@@ -1964,19 +1966,63 @@ class Generator:
                 return self.sql(select)
 
         sqls: list[str] = []
-        stack: list[str | exp.Expr] = [expression]
+        stack: list[str | exp.Expr | int | None] = [expression]
+        depth = 0
+        open_parens = ""
 
         while stack:
             node = stack.pop()
 
-            if isinstance(node, exp.SetOperation):
+            if isinstance(node, int):
+                # Closes a plain grouping opened below, restoring its depth
+                depth = node
+                sqls[-1] += self.sep("") + self.indent(")", level=depth, pad=0)
+            elif isinstance(node, exp.SetOperation):
                 stack.append(node.expression)
                 stack.append(
                     self.maybe_comment(
                         self.set_operation(node), comments=node.comments, separated=True
                     )
                 )
-                stack.append(node.this)
+                left = node.this
+                if (
+                    not self.SET_OP_PARENTHESIZED_OPERANDS
+                    and not self.dialect.INTERSECT_BINDS_TIGHTER_THAN_UNION_AND_EXCEPT
+                ):
+                    # Left grouping is implicit, so skip the `SELECT * FROM (...)` wrapper:
+                    # it renames duplicate columns and deepens recursion. Inner CTEs and
+                    # modifiers still need the wrapper.
+                    wrappers: list[exp.Subquery] = []
+                    inner = left
+                    while isinstance(inner, exp.Subquery) and inner.is_wrapper:
+                        wrappers.append(inner)
+                        inner = inner.this
+
+                    if (
+                        isinstance(inner, exp.SetOperation)
+                        and not inner.args.get("with_")
+                        and not any(inner.args.get(key) for key in exp.QUERY_MODIFIERS)
+                    ):
+                        for wrapper in wrappers:
+                            inner.add_comments(wrapper.pop_comments())
+                        left = inner
+                elif (
+                    self.SET_OP_PARENTHESIZED_OPERANDS
+                    and isinstance(left, exp.Subquery)
+                    and left.is_wrapper
+                    and not left.comments
+                    and isinstance(left.this, exp.SetOperation)
+                    and not left.this.args.get("with_")
+                    and not any(left.this.args.get(key) for key in exp.QUERY_MODIFIERS)
+                ):
+                    # Write a plain grouping's parentheses here rather than recursing through
+                    # subquery_sql: left-to-right chains nest one grouping per INTERSECT, and
+                    # long ones would exhaust the stack. The depth pushed here marks the close.
+                    open_parens += self.indent("(", level=depth, pad=0) + self.sep("")
+                    stack.append(depth)
+                    depth += 1
+                    left = left.this
+                stack.append(left)
             else:
                 if (
                     not self.SET_OP_LIMITS
@@ -1986,7 +2032,14 @@ class Generator:
                     node = node.subquery(copy=False)
                     if not self.SET_OP_PARENTHESIZED_OPERANDS:
                         node = exp.select("*").from_(node, copy=False)
-                sqls.append(self.sql(node))
+                elif (
+                    not self.SET_OP_PARENTHESIZED_OPERANDS
+                    and isinstance(node, exp.Subquery)
+                    and isinstance(node.unnest(), exp.SetOperation)
+                ):
+                    node = exp.select("*").from_(node, copy=False)
+                sqls.append(open_parens + self.indent(self.sql(node), level=depth, pad=0))
+                open_parens = ""
 
         this = self.sep().join(sqls)
         this = self.query_modifiers(expression, this)
@@ -2014,6 +2067,9 @@ class Generator:
         where = self.sql(expression, "expression").strip()
         return f"{this} FILTER({where})"
 
+    def per_sql(self, expression: exp.Per) -> str:
+        return f"{self.sql(expression, 'this')} PER ({self.expressions(expression, flat=True)})"
+
     def hint_sql(self, expression: exp.Hint) -> str:
         if not self.QUERY_HINTS:
             self.unsupported("Hints are not supported")

{sqlglotc-30.25.0 → sqlglotc-30.26.0}/sqlglot/generators/duckdb.py

@@ -1978,6 +1978,42 @@ class DuckDBGenerator(generator.Generator):
         "show",
         "summarize",
         "unpivot",
+        "anti",
+        "asof",
+        "at",
+        "authorization",
+        "binary",
+        "by",
+        "collation",
+        "columns",
+        "concurrently",
+        "cross",
+        "freeze",
+        "full",
+        "generated",
+        "glob",
+        "ilike",
+        "inner",
+        "is",
+        "isnull",
+        "join",
+        "left",
+        "like",
+        "map",
+        "natural",
+        "notnull",
+        "outer",
+        "overlaps",
+        "positional",
+        "right",
+        "semi",
+        "similar",
+        "struct",
+        "tablesample",
+        "try_cast",
+        "tuple",
+        "unpack",
+        "verbose",
     }
 
     UNWRAPPED_INTERVAL_VALUES = (exp.Literal, exp.Paren)
@@ -4568,10 +4604,8 @@ class DuckDBGenerator(generator.Generator):
         else:
             result = self.func("DATE_TRUNC", unit, date)
 
-        if (
-            expression.args.get("input_type_preserved")
-            and date.is_type(*exp.DataType.TEMPORAL_TYPES)
-            and not (is_date_unit(unit) and date.is_type(exp.DType.DATE))
+        if expression.args.get("input_type_preserved") and date.is_type(
+            *exp.DataType.TEMPORAL_TYPES
         ):
             return self.sql(exp.Cast(this=result, to=date.type))
 
@@ -4628,9 +4662,7 @@ class DuckDBGenerator(generator.Generator):
                 result = self.func("DATE_TRUNC", unit, date_time)
                 return self.sql(exp.Cast(this=result, to=timestamp.type))
 
-            if timestamp.is_type(*exp.DataType.TEMPORAL_TYPES) and not (
-                date_unit and timestamp.is_type(exp.DType.DATE)
-            ):
+            if timestamp.is_type(*exp.DataType.TEMPORAL_TYPES):
                 return self.sql(exp.Cast(this=result, to=timestamp.type))
 
         return result

{sqlglotc-30.25.0 → sqlglotc-30.26.0}/sqlglot/generators/postgres.py

@@ -12,6 +12,7 @@ from sqlglot.dialects.dialect import (
     array_concat_sql,
     bool_xor_sql,
     count_if_to_sum,
+    date_delta_to_binary_sql,
     datestrtodate_sql,
     filter_array_using_unnest,
     generate_series_sql,
@@ -52,28 +53,39 @@ DATE_DIFF_FACTOR = {
     "DAY": " / 86400",
 }
 
+DATE_DIFF_BOUNDARY_UNITS = {
+    "MICROSECOND",
+    "MILLISECOND",
+    "SECOND",
+    "MINUTE",
+    "HOUR",
+    "MONTH",
+    "QUARTER",
+    "YEAR",
+}
+
 
 def _date_add_sql(kind: str) -> t.Callable[[PostgresGenerator, DATE_ADD_OR_SUB], str]:
     def func(self: PostgresGenerator, expression: DATE_ADD_OR_SUB) -> str:
         if isinstance(expression, exp.TsOrDsAdd):
             expression = ts_or_ds_add_cast(expression)
 
-        this = self.sql(expression, "this")
+        this = expression.this
         unit = expression.args.get("unit")
 
         e = self._simplify_unless_literal(expression.expression)
+        interval: exp.Expr
         if isinstance(e, exp.Interval):
-            return f"{this} {kind} {self.sql(e)}"
-        elif isinstance(e, exp.Literal):
-            e.set("is_string", True)
-        elif e.is_number:
-            e = exp.Literal.string(e.to_py())
+            interval = e
+        elif e.is_number or e.is_string:
+            interval = exp.Interval(this=exp.Literal.string(e.to_py()), unit=unit)
         else:
             one = exp.Literal.number(1)
-            interval_times_value = exp.Interval(this=one, unit=unit) * e
-            return f"{this} {kind} {self.sql(interval_times_value)}"
+            interval = exp.Interval(this=one, unit=unit) * e
 
-        return f"{this} {kind} {self.sql(exp.Interval(this=e, unit=unit))}"
+        return date_delta_to_binary_sql(
+            self, expression, this + interval if kind == "+" else this - interval
+        )
 
     return func
 
@@ -104,6 +116,13 @@ def _date_diff_sql(self: PostgresGenerator, expression: exp.DateDiff | exp.TsOrD
     end = f"CAST({self.sql(expression, 'this')} AS TIMESTAMP)"
     start = f"CAST({self.sql(expression, 'expression')} AS TIMESTAMP)"
 
+    # The arithmetic below counts complete units between the operands, whereas dialects that set
+    # date_part_boundary count unit boundary crossings, so the operands are truncated down to the
+    # unit to make the two coincide. WEEK is left out: its start day differs across dialects
+    if expression.args.get("date_part_boundary") and unit in DATE_DIFF_BOUNDARY_UNITS:
+        end = self.func("DATE_TRUNC", exp.Literal.string(unit), end)
+        start = self.func("DATE_TRUNC", exp.Literal.string(unit), start)
+
     if factor is not None:
         return f"CAST(EXTRACT(epoch FROM {end} - {start}){factor} AS BIGINT)"
 
@@ -336,6 +355,8 @@ class PostgresGenerator(generator.Generator):
         exp.DateDiff: _date_diff_sql,
         exp.DateStrToDate: datestrtodate_sql,
         exp.DateSub: _date_add_sql("-"),
+        exp.DatetimeAdd: _date_add_sql("+"),
+        exp.DatetimeSub: _date_add_sql("-"),
         exp.Day: _day_month_year_sql,
         exp.Explode: rename_func("UNNEST"),
         exp.ExplodingGenerateSeries: rename_func("GENERATE_SERIES"),
@@ -400,6 +421,8 @@ class PostgresGenerator(generator.Generator):
         exp.TimeFromParts: rename_func("MAKE_TIME"),
         exp.TimestampFromParts: rename_func("MAKE_TIMESTAMP"),
         exp.TimestampTrunc: timestamptrunc_sql(zone=True),
+        exp.TimestampAdd: _date_add_sql("+"),
+        exp.TimestampSub: _date_add_sql("-"),
         exp.TimeStrToTime: timestrtotime_sql,
         exp.TimeToStr: lambda self, e: self.func("TO_CHAR", e.this, self.format_time(e)),
         exp.ToChar: lambda self, e: (

{sqlglotc-30.25.0 → sqlglotc-30.26.0}/sqlglot/generators/tsql.py

@@ -78,6 +78,7 @@ def qualify_derived_table_outputs(expression: exp.Expr) -> exp.Expr:
         isinstance(expression, (exp.CTE, exp.Subquery))
         and isinstance(alias, exp.TableAlias)
         and not alias.columns
+        and isinstance(expression.this, exp.Query)
     ):
         from sqlglot.dialects.tsql import TSQL
         from sqlglot.optimizer.qualify_columns import qualify_outputs

{sqlglotc-30.25.0 → sqlglotc-30.26.0}/sqlglot/optimizer/annotate_types.py

@@ -217,12 +217,9 @@ class TypeAnnotator:
         # Databricks and Spark ≥v3 actually support NULL (i.e., VOID) as a type
         self._supports_null_type = dialect.SUPPORTS_NULL_TYPE
 
-        # Maps a SetOperation's id to itself and its projection types, keeping the node alive.
-        # Selecting from the same source multiple times would otherwise reprocess its subtree
-        # to coerce the types of its operands' projections
-        self._setop_column_types: dict[
-            int, tuple[exp.SetOperation, dict[str, exp.DataType | exp.DType]]
-        ] = {}
+        # Keep ordered output columns until a parent set operation consumes them. Source
+        # queries retain their results for subsequent column lookups.
+        self._setop_column_types: dict[int, list[tuple[str, exp.DataType | exp.DType]]] = {}
         self._table_column_aliases: dict[int, tuple[exp.Table, dict[str, str]]] = {}
 
         # When set to False, this enables partial annotation by skipping already-annotated nodes
@@ -346,6 +343,16 @@ class TypeAnnotator:
 
     def _get_source_scope_selects(self, source: Scope) -> dict[str, exp.DataType | exp.DType]:
         expression = source.expression
+
+        if source.is_cte:
+            # Recursive references can point to an unfinished UNION. Use its nearest resolved
+            # anchor prefix until the recursive branches have been annotated.
+            while (
+                isinstance(expression, exp.SetOperation)
+                and id(expression) not in self._setop_column_types
+            ):
+                expression = expression.this.unnest()
+
         if isinstance(expression, exp.UDTF):
             values = []
 
@@ -391,11 +398,8 @@ class TypeAnnotator:
 
             return {alias: column.type for alias, column in zip(alias_column_names, values)}
 
-        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)
+        if isinstance(expression, exp.SetOperation):
+            return dict(self._get_setop_column_types(expression))
 
         if isinstance(expression, exp.Selectable):
             return {s.alias_or_name: s.type for s in expression.selects if s.type}
@@ -410,7 +414,7 @@ class TypeAnnotator:
         if self.dialect.QUERY_RESULTS_ARE_STRUCTS and isinstance(scope.expression, exp.Query):
             scope.expression.meta.pop("query_type", None)
             column_types = (
-                self._get_setop_column_types(scope.expression).items()
+                self._get_setop_column_types(scope.expression)
                 if isinstance(scope.expression, exp.SetOperation)
                 else ((select.output_name, select.type) for select in scope.expression.selects)
             )
@@ -426,7 +430,7 @@ class TypeAnnotator:
                 nested=True,
             )
 
-            if not any(
+            if struct_type.expressions and not any(
                 not cd.kind or cd.kind.is_type(exp.DType.UNKNOWN) for cd in struct_type.expressions
             ):
                 # We don't use `_set_type` on purpose here. If we annotated the query directly, then
@@ -527,6 +531,9 @@ class TypeAnnotator:
                     expr.meta["nonnull"] = True
                 continue
 
+            if isinstance(expr, exp.SetOperation):
+                self._annotate_set_operation(expr)
+
             spec = self.expression_metadata.get(expr.__class__)
 
             if spec and (annotator := spec.get("annotator")):
@@ -682,75 +689,55 @@ class TypeAnnotator:
         return type2_value if type2_value in self.coerces_to.get(type1_value, {}) else type1_value
 
     def _get_setop_column_types(
-        self, setop: exp.SetOperation
-    ) -> dict[str, exp.DataType | exp.DType]:
-        """
-        Computes and returns the coerced column types for a SetOperation.
-
-        This handles UNION, INTERSECT, EXCEPT, etc., coercing types across
-        left and right operands for all projections/columns.
-
-        Args:
-            setop: The SetOperation expression to analyze
-
-        Returns:
-            Dictionary mapping column names to their coerced types
-        """
-        setop_id = id(setop)
-        if cached := self._setop_column_types.get(setop_id):
-            return cached[1]
-
-        col_types: dict[str, exp.DataType | exp.DType] = {}
-
-        # 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 (
-                setop.args.get("by_name")
-                or len(setop.this.selects) == len(setop.expression.selects)
-            )
-        ):
-            return col_types
-
-        # Process a chain / sub-tree of set operations
-        for set_op in setop.walk(
-            prune=lambda n: not isinstance(n, (exp.SetOperation, exp.Subquery))
-        ):
-            if not isinstance(set_op, exp.SetOperation):
-                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(
-                        s.type 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
+        self, expression: exp.SetOperation
+    ) -> list[tuple[str, exp.DataType | exp.DType]]:
+        return self._setop_column_types.get(id(expression), [])
+
+    def _annotate_set_operation(self, expression: exp.SetOperation) -> None:
+        # The expression annotation pass visits children first, including when a scope is
+        # annotated independently. Preserve duplicate names until positional matching is done.
+        operands: list[list[tuple[str, exp.DataType | exp.DType]]] = []
+        for operand in (expression.this.unnest(), expression.expression.unnest()):
+            if isinstance(operand, exp.SetOperation):
+                operands.append(self._setop_column_types.pop(id(operand), []))
             else:
-                setop_cols = {
-                    ls.alias_or_name: self._maybe_coerce(
-                        ls.type or exp.DType.UNKNOWN, rs.type or exp.DType.UNKNOWN
-                    )
-                    for ls, rs in zip(set_op.this.selects, set_op.expression.selects)
-                }
-
-            # Coerce intermediate results with the previously registered types, if they exist
-            for col_name, col_type in setop_cols.items():
-                col_types[col_name] = self._maybe_coerce(
-                    col_type, col_types.get(col_name, exp.DType.NULL)
+                operands.append(
+                    [(s.alias_or_name, s.type or exp.DType.UNKNOWN) for s in operand.selects]
                 )
+        left, right = operands
+
+        columns: list[tuple[str, exp.DataType | exp.DType]] = []
+        if left and right:
+            if expression.args.get("by_name"):
+                left_types = dict(left)
+                right_types = dict(right)
+                if on := expression.args.get("on"):
+                    names = [column.name for column in on]
+                elif expression.kind == "INNER":
+                    names = [name for name in left_types if name in right_types]
+                elif expression.side == "LEFT":
+                    names = list(left_types)
+                else:
+                    names = list({**left_types, **right_types})
+
+                # Missing columns are NULL-filled, preserving the other operand's type.
+                columns = [
+                    (
+                        name,
+                        self._maybe_coerce(
+                            left_types.get(name, exp.DType.NULL),
+                            right_types.get(name, exp.DType.NULL),
+                        ),
+                    )
+                    for name in names
+                ]
+            elif len(left) == len(right):
+                columns = [
+                    (name, self._maybe_coerce(left_type, right_type))
+                    for (name, left_type), (_, right_type) in zip(left, right)
+                ]
 
-        self._setop_column_types[setop_id] = (setop, col_types)
-        return col_types
+        self._setop_column_types[id(expression)] = columns
 
     def _get_unpivot_column_types(
         self, pivot: exp.Pivot, src_types: dict[str, exp.DataType | exp.DType]
@@ -911,9 +898,18 @@ class TypeAnnotator:
                     return expression
 
                 if nested_type:
+                    # Only resolve ARRAY<NULL>; preserve existing coercion for other nested types.
+                    if (
+                        nested_type.is_type(exp.DType.ARRAY)
+                        and nested_type.expressions
+                        and nested_type.expressions[0].is_type(exp.DType.NULL)
+                        and expr_type.is_type(exp.DType.ARRAY)
+                        and expr_type.expressions
+                    ):
+                        nested_type = expr_type
                     continue
 
-                # Stop coercing at the first nested data type found
+                # Prefer the first nested data type, resolving ARRAY<NULL> from later arrays.
                 if expr_type.args.get("nested"):
                     nested_type = expr_type
                 elif isinstance(expr, exp.Literal):
@@ -947,7 +943,9 @@ class TypeAnnotator:
             if result_type is None:
                 result_type = self._maybe_coerce(non_literal_type, literal_type)
         else:
-            result_type = literal_type or non_literal_type or exp.DType.UNKNOWN
+            result_type = (
+                literal_type or non_literal_type or (exp.DType.NULL if array else exp.DType.UNKNOWN)
+            )
 
         self._set_type(expression, result_type)
 
@@ -958,7 +956,7 @@ class TypeAnnotator:
             elif this_type in exp.DataType.FLOAT_TYPES:
                 self._set_type(expression, exp.DType.DOUBLE)
 
-        if array:
+        if array and not expression.is_type(exp.DType.UNKNOWN):
             self._set_type(
                 expression,
                 exp.DataType(this=exp.DType.ARRAY, expressions=[expression.type], nested=True),
@@ -1121,12 +1119,20 @@ class TypeAnnotator:
 
         map_type = exp.DataType(this=exp.DType.MAP)
         if isinstance(keys, exp.Array) and isinstance(values, exp.Array):
-            key_type = seq_get(keys.type.expressions, 0) or exp.DType.UNKNOWN
-            value_type = seq_get(values.type.expressions, 0) or exp.DType.UNKNOWN
+            key_type = seq_get(keys.type.expressions, 0)
+            value_type = seq_get(values.type.expressions, 0)
+
+            if (
+                not key_type
+                or key_type.is_type(exp.DType.UNKNOWN)
+                or not value_type
+                or value_type.is_type(exp.DType.UNKNOWN)
+            ):
+                self._set_type(expression, exp.DType.UNKNOWN)
+                return expression
 
-            if key_type != exp.DType.UNKNOWN and value_type != exp.DType.UNKNOWN:
-                map_type.set("expressions", [key_type, value_type])
-                map_type.set("nested", True)
+            map_type.set("expressions", [key_type, value_type])
+            map_type.set("nested", True)
 
         self._set_type(expression, map_type)
         return expression

{sqlglotc-30.25.0 → sqlglotc-30.26.0}/sqlglot/optimizer/resolver.py

@@ -361,7 +361,9 @@ class Resolver:
         available_sources = {from_name: self.get_source_columns(from_name)}
 
         for join in args["joins"][: t.cast(int, join_ancestor.index) + 1]:
-            available_sources[join.alias_or_name] = self.get_source_columns(join.alias_or_name)
+            # An earlier SEMI/ANTI join's table is only visible within its own ON clause
+            if join is join_ancestor or not join.is_semi_or_anti_join:
+                available_sources[join.alias_or_name] = self.get_source_columns(join.alias_or_name)
 
         return available_sources
 

{sqlglotc-30.25.0 → sqlglotc-30.26.0}/sqlglot/optimizer/scope.py

@@ -819,11 +819,16 @@ def _traverse_set_operation(scope: Scope) -> Iterator[Scope]:
             scope_type=ScopeType.SET_OPERATION,
         )
 
-        if isinstance(expression, exp.SetOperation):
+        # Use the scope's unwrapped expression rather than the operand itself so parenthesized
+        # left operands are descended into iteratively. Only descend while prev_scope is None,
+        # i.e. until the chain's leftmost query has been scoped; later scopes are paired as
+        # right operands.
+        inner = new_scope.expression
+        if prev_scope is None and isinstance(inner, exp.SetOperation):
             yield from _traverse_ctes(new_scope)
 
             set_op_scope_stack.append(new_scope)
-            expression_stack.extend([expression.expression, expression.this])
+            expression_stack.extend([inner.expression, inner.this])
             continue
 
         branch_scope: Scope | None = None