polyglot-sql 0.10.0__tar.gz → 0.11.0__tar.gz

{polyglot_sql-0.10.0 → polyglot_sql-0.11.0}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.10.0"
+version = "0.11.0"
 dependencies = [
  "criterion",
  "once_cell",
@@ -623,7 +623,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ast-derive"
-version = "0.10.0"
+version = "0.11.0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -632,7 +632,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.10.0"
+version = "0.11.0"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -642,11 +642,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.10.0"
+version = "0.11.0"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.10.0"
+version = "0.11.0"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -657,7 +657,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.10.0"
+version = "0.11.0"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.10.0 → polyglot_sql-0.11.0}/Cargo.toml

@@ -6,7 +6,7 @@ exclude = [
 ]
 
 [workspace.package]
-version = "0.10.0"
+version = "0.11.0"
 edition = "2021"
 license = "MIT"
 authors = ["polyglot contributors"]

{polyglot_sql-0.10.0 → polyglot_sql-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.10.0
+Version: 0.11.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -110,6 +110,26 @@ polyglot_sql.generate(ast)
 # ["SELECT id FROM a UNION ALL SELECT id FROM b ORDER BY id LIMIT 100 OFFSET 10"]
 ```
 
+### Complexity Guard Options
+
+`transpile` also accepts `complexity_guard`, a `ComplexityGuardOptions` typed dictionary
+using the shared camelCase keys: `maxParserDepth`, `maxInputBytes`, `maxTokens`,
+`maxAstNodes`, `maxAstDepth`, `maxParenthesisDepth`, and `maxFunctionCallDepth`.
+Omit the argument, pass `None`, or omit a key to use its default. A field-level `None`
+disables that check; a nonnegative integer overrides it. For example:
+
+```python
+polyglot_sql.transpile(sql, complexity_guard={"maxParserDepth": 128})
+```
+
+Parser depth defaults to 1024 logical levels on native targets (32 on WASM) and is
+checked during parsing, before an AST exists. Zero rejects parsing descents.
+Other checks remain independent.
+Raising or disabling limits can permit stack exhaustion and process termination,
+even for trusted generated SQL. Increasing a limit does not increase stack space;
+these limits are not general time/memory budgets. Application owners should control
+overrides. Parsing APIs without guard options inherit the default protection.
+
 ### Format Guard Behavior
 
 `format_sql` uses Rust core formatting guards with default limits:

{polyglot_sql-0.10.0/crates/polyglot-sql-python → polyglot_sql-0.11.0}/README.md

@@ -83,6 +83,26 @@ polyglot_sql.generate(ast)
 # ["SELECT id FROM a UNION ALL SELECT id FROM b ORDER BY id LIMIT 100 OFFSET 10"]
 ```
 
+### Complexity Guard Options
+
+`transpile` also accepts `complexity_guard`, a `ComplexityGuardOptions` typed dictionary
+using the shared camelCase keys: `maxParserDepth`, `maxInputBytes`, `maxTokens`,
+`maxAstNodes`, `maxAstDepth`, `maxParenthesisDepth`, and `maxFunctionCallDepth`.
+Omit the argument, pass `None`, or omit a key to use its default. A field-level `None`
+disables that check; a nonnegative integer overrides it. For example:
+
+```python
+polyglot_sql.transpile(sql, complexity_guard={"maxParserDepth": 128})
+```
+
+Parser depth defaults to 1024 logical levels on native targets (32 on WASM) and is
+checked during parsing, before an AST exists. Zero rejects parsing descents.
+Other checks remain independent.
+Raising or disabling limits can permit stack exhaustion and process termination,
+even for trusted generated SQL. Increasing a limit does not increase stack space;
+these limits are not general time/memory budgets. Application owners should control
+overrides. Parsing APIs without guard options inherit the default protection.
+
 ### Format Guard Behavior
 
 `format_sql` uses Rust core formatting guards with default limits:

{polyglot_sql-0.10.0 → polyglot_sql-0.11.0}/crates/polyglot-sql/Cargo.toml

@@ -100,14 +100,14 @@ function-catalog-all-dialects = [
 ]
 
 [dependencies]
-polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.10.0" }
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.11.0" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 unicode-segmentation = { workspace = true }
 stacker = { version = "0.1", optional = true }
 ts-rs = { version = "12.0", features = ["serde-compat"], optional = true }
-polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.10.0", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.11.0", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.10.0 → polyglot_sql-0.11.0}/crates/polyglot-sql/README.md

@@ -25,12 +25,12 @@ By default, `polyglot-sql` enables the full public API. Parser-only consumers ca
 disable default features and opt into only the dialect parsers they need:
 
 ```toml
-polyglot-sql = { version = "0.10.0", default-features = false }
+polyglot-sql = { version = "0.11.0", default-features = false }
 ```
 
 ```toml
 polyglot-sql = {
-    version = "0.8.0",
+    version = "0.11.0",
     default-features = false,
     features = ["dialect-clickhouse"],
 }
@@ -44,14 +44,14 @@ Examples:
 ```toml
 # Parse and generate SQL for one dialect.
 polyglot-sql = {
-    version = "0.8.0",
+    version = "0.11.0",
     default-features = false,
     features = ["generate", "dialect-clickhouse"],
 }
 
 # Cross-dialect transpilation.
 polyglot-sql = {
-    version = "0.8.0",
+    version = "0.11.0",
     default-features = false,
     features = ["transpile", "dialect-clickhouse", "dialect-postgresql"],
 }

{polyglot_sql-0.10.0 → polyglot_sql-0.11.0}/crates/polyglot-sql/benches/performance_hotspots.rs

@@ -81,6 +81,7 @@ fn many_numbers() -> String {
 
 fn disabled_guards() -> ComplexityGuardOptions {
     ComplexityGuardOptions {
+        max_parser_depth: None,
         max_input_bytes: None,
         max_tokens: None,
         max_ast_nodes: None,

{polyglot_sql-0.10.0 → polyglot_sql-0.11.0}/crates/polyglot-sql/src/dialects/bigquery.rs

@@ -34,6 +34,7 @@ impl DialectImpl for BigQueryDialect {
         // Remove double quote from identifiers (it's in the default config)
         config.identifiers.remove(&'"');
         config.identifiers.insert('`', '`');
+        config.identifier_backslash_escapes = true;
         // BigQuery supports double quotes for strings (in addition to single quotes)
         config.quotes.insert("\"".to_string(), "\"".to_string());
         // BigQuery supports triple-quoted strings

{polyglot_sql-0.10.0 → polyglot_sql-0.11.0}/crates/polyglot-sql/src/dialects/clickhouse.rs

@@ -28,6 +28,7 @@ impl DialectImpl for ClickHouseDialect {
         // ClickHouse uses double quotes and backticks for identifiers
         config.identifiers.insert('"', '"');
         config.identifiers.insert('`', '`');
+        config.identifier_backslash_escapes = true;
         // ClickHouse supports nested comments
         config.nested_comments = true;
         // ClickHouse allows identifiers to start with digits

{polyglot_sql-0.10.0 → polyglot_sql-0.11.0}/crates/polyglot-sql/src/dialects/duckdb.rs

@@ -97,6 +97,8 @@ impl DialectImpl for DuckDBDialect {
         let mut config = TokenizerConfig::default();
         // DuckDB uses double quotes for identifiers
         config.identifiers.insert('"', '"');
+        // A leading escaped double quote belongs to the identifier, not a triple-quoted string.
+        config.quotes.remove("\"\"\"");
         // DuckDB supports nested comments
         config.nested_comments = true;
         // DuckDB allows underscores as digit separators in numeric literals

{polyglot_sql-0.10.0 → polyglot_sql-0.11.0}/crates/polyglot-sql/src/expressions.rs

@@ -3373,6 +3373,16 @@ impl Identifier {
         self.name.is_empty()
     }
 
+    /// Preserve quoting in the legacy string representation of named type fields.
+    /// Always use SQL-standard delimiters internally, independent of the source dialect.
+    pub(crate) fn to_type_field_name(&self) -> String {
+        if self.quoted {
+            format!("\"{}\"", self.name.replace('"', "\"\""))
+        } else {
+            self.name.clone()
+        }
+    }
+
     /// Set the source span on this identifier
     pub fn with_span(mut self, span: Span) -> Self {
         self.span = Some(span);
@@ -5740,6 +5750,9 @@ pub enum WindowFrameBound {
 #[derive(polyglot_sql_ast_derive::AstNode, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "bindings", derive(TS))]
 pub struct StructField {
+    /// A raw field name, or a delimited identifier for compatibility with parsed ASTs.
+    /// Parsed quoted names use double quotes with doubled internal quotes. An empty
+    /// string denotes an anonymous field. Generation selects the target dialect's quotes.
     pub name: String,
     pub data_type: DataType,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]

{polyglot_sql-0.10.0 → polyglot_sql-0.11.0}/crates/polyglot-sql/src/generator.rs

@@ -16621,22 +16621,7 @@ impl Generator {
             } else {
                 quote_style
             };
-            // Escape any quote characters within the identifier
-            let escaped_name = if quote_style.start == quote_style.end {
-                output_name.replace(
-                    quote_style.end,
-                    &format!("{}{}", quote_style.end, quote_style.end),
-                )
-            } else {
-                output_name.replace(
-                    quote_style.end,
-                    &format!("{}{}", quote_style.end, quote_style.end),
-                )
-            };
-            self.write(&format!(
-                "{}{}{}",
-                quote_style.start, escaped_name, quote_style.end
-            ));
+            self.write_quoted_identifier(&output_name, *quote_style);
         } else {
             self.write(&output_name);
         }
@@ -16746,24 +16731,8 @@ impl Generator {
         };
 
         if needs_quoting {
-            // Escape any quote characters within the identifier
-            let escaped_name = if quote_style.start == quote_style.end {
-                // Same start/end char (e.g., " or `) - double the quote char
-                output_name.replace(
-                    quote_style.end,
-                    &format!("{}{}", quote_style.end, quote_style.end),
-                )
-            } else {
-                // Different start/end (e.g., [ and ]) - escape only the end char
-                output_name.replace(
-                    quote_style.end,
-                    &format!("{}{}", quote_style.end, quote_style.end),
-                )
-            };
-            self.write(&format!(
-                "{}{}{}{}",
-                quote_style.start, escaped_name, quote_style.end, suffix
-            ));
+            self.write_quoted_identifier(&output_name, *quote_style);
+            self.write(&suffix);
         } else {
             self.write(&output_name);
         }
@@ -16776,6 +16745,78 @@ impl Generator {
         Ok(())
     }
 
+    /// Write an identifier using the target dialect's delimiters and escape rules.
+    fn write_quoted_identifier(&mut self, name: &str, quote_style: IdentifierQuoteStyle) {
+        let backslash_escapes = matches!(
+            self.config.dialect,
+            Some(DialectType::BigQuery | DialectType::ClickHouse)
+        );
+        self.output.push(quote_style.start);
+        for c in name.chars() {
+            if backslash_escapes {
+                let escape = match c {
+                    '\\' => Some("\\\\"),
+                    '\n' => Some("\\n"),
+                    '\r' => Some("\\r"),
+                    '\t' => Some("\\t"),
+                    '\0' => Some("\\x00"),
+                    _ => None,
+                };
+                if let Some(escape) = escape {
+                    self.write(escape);
+                    continue;
+                }
+                if c == quote_style.end && self.config.dialect == Some(DialectType::BigQuery) {
+                    self.output.push('\\');
+                    self.output.push(c);
+                    continue;
+                }
+            }
+            self.output.push(c);
+            if c == quote_style.end {
+                self.output.push(c);
+            }
+        }
+        self.output.push(quote_style.end);
+    }
+
+    /// Named type fields are single identifiers, never SQL fragments or index columns.
+    /// Keep the public string shape while accepting legacy delimited field names.
+    fn generate_type_field_name(&mut self, field_name: &str) {
+        let mut name = Cow::Borrowed(field_name);
+        let mut quoted = false;
+        for (start, end) in [('"', '"'), ('`', '`'), ('[', ']')] {
+            if let Some(inner) = field_name
+                .strip_prefix(start)
+                .and_then(|s| s.strip_suffix(end))
+            {
+                name = Cow::Owned(inner.replace(&format!("{end}{end}"), &end.to_string()));
+                quoted = true;
+                break;
+            }
+        }
+
+        let needs_quoting = quoted
+            || !Self::is_safe_unquoted_identifier(&name)
+            || self.is_reserved_keyword(&name)
+            || self.config.always_quote_identifiers;
+        if self.config.normalize_identifiers && !quoted {
+            name = Cow::Owned(name.to_ascii_lowercase());
+        }
+        if !needs_quoting {
+            self.write(&name);
+            return;
+        }
+
+        let quote_style =
+            if self.config.dialect == Some(DialectType::Athena) && self.athena_hive_context {
+                IdentifierQuoteStyle::BACKTICK
+            } else {
+                self.config.identifier_quote_style
+            };
+        self.write_quoted_identifier(&name, quote_style);
+    }
+
     fn generate_column(&mut self, col: &Column) -> Result<()> {
         use crate::dialects::DialectType;
 
@@ -26846,7 +26887,7 @@ impl Generator {
                     if i > 0 {
                         self.write(", ");
                     }
-                    self.write(name);
+                    self.generate_type_field_name(name);
                     self.write(" ");
                     self.generate_data_type(dt)?;
                     if *not_null {
@@ -26870,7 +26911,7 @@ impl Generator {
                                 self.write(", ");
                             }
                             if !field.name.is_empty() {
-                                self.write(&field.name);
+                                self.generate_type_field_name(&field.name);
                                 self.write(" ");
                             }
                             self.generate_data_type(&field.data_type)?;
@@ -26885,7 +26926,7 @@ impl Generator {
                                 self.write(", ");
                             }
                             if !field.name.is_empty() {
-                                self.write(&field.name);
+                                self.generate_type_field_name(&field.name);
                                 self.write(" ");
                             }
                             self.generate_data_type(&field.data_type)?;
@@ -26900,7 +26941,7 @@ impl Generator {
                                 self.write(", ");
                             }
                             if !field.name.is_empty() {
-                                self.write(&field.name);
+                                self.generate_type_field_name(&field.name);
                                 self.write(" ");
                             }
                             self.generate_data_type(&field.data_type)?;
@@ -26915,7 +26956,7 @@ impl Generator {
                                 self.write(", ");
                             }
                             if !field.name.is_empty() {
-                                self.write(&field.name);
+                                self.generate_type_field_name(&field.name);
                                 self.write(" ");
                             }
                             self.generate_data_type(&field.data_type)?;
@@ -26930,7 +26971,7 @@ impl Generator {
                                 self.write(", ");
                             }
                             if !field.name.is_empty() {
-                                self.write(&field.name);
+                                self.generate_type_field_name(&field.name);
                                 self.write(" ");
                             }
                             self.generate_data_type(&field.data_type)?;
@@ -26938,12 +26979,14 @@ impl Generator {
                         self.write(")");
                     }
                     _ => {
-                        // Hive/Spark always use angle bracket syntax: STRUCT<name: TYPE>
+                        // BigQuery and Hive/Spark use angle brackets even for types
+                        // parsed from a parenthesized source dialect.
                         let force_angle_brackets = matches!(
                             self.config.dialect,
                             Some(DialectType::Hive)
                                 | Some(DialectType::Spark)
                                 | Some(DialectType::Databricks)
+                                | Some(DialectType::BigQuery)
                         );
                         if *nested && !force_angle_brackets {
                             self.write_keyword("STRUCT(");
@@ -26952,7 +26995,7 @@ impl Generator {
                                     self.write(", ");
                                 }
                                 if !field.name.is_empty() {
-                                    self.write(&field.name);
+                                    self.generate_type_field_name(&field.name);
                                     self.write(" ");
                                 }
                                 self.generate_data_type(&field.data_type)?;
@@ -26966,7 +27009,7 @@ impl Generator {
                                 }
                                 if !field.name.is_empty() {
                                     // Named field: name TYPE (with configurable separator for Hive)
-                                    self.write(&field.name);
+                                    self.generate_type_field_name(&field.name);
                                     self.write(self.config.struct_field_sep);
                                 }
                                 // For anonymous fields, just output the type
@@ -27034,7 +27077,7 @@ impl Generator {
                         self.write(", ");
                     }
                     if !name.is_empty() {
-                        self.write(name);
+                        self.generate_type_field_name(name);
                         self.write(" ");
                     }
                     self.generate_data_type(dt)?;
@@ -33275,7 +33318,7 @@ impl Generator {
                 if key.is_empty() {
                     // Bracket notation at start of segment (e.g., already formatted)
                     self.write(segment);
-                } else if Self::is_safe_json_path_key(key) {
+                } else if Self::is_safe_unquoted_identifier(key) {
                     self.write(key);
                     self.write(subscript);
                 } else {
@@ -33284,7 +33327,7 @@ impl Generator {
                     self.write("\"]");
                     self.write(subscript);
                 }
-            } else if Self::is_safe_json_path_key(segment) {
+            } else if Self::is_safe_unquoted_identifier(segment) {
                 self.write(segment);
             } else {
                 self.write("[\"");
@@ -33294,9 +33337,9 @@ impl Generator {
         }
     }
 
-    /// Check if a JSON path key is a safe identifier that doesn't need bracket quoting.
+    /// Check if a name can be emitted as a conservative unquoted identifier.
     /// Matches Python sqlglot's SAFE_IDENTIFIER_RE: ^[_a-zA-Z]\w*$
-    fn is_safe_json_path_key(key: &str) -> bool {
+    fn is_safe_unquoted_identifier(key: &str) -> bool {
         if key.is_empty() {
             return false;
         }

{polyglot_sql-0.10.0 → polyglot_sql-0.11.0}/crates/polyglot-sql/src/guard.rs

@@ -11,6 +11,21 @@ const DEFAULT_MAX_AST_NODES: usize = 1_000_000;
 const DEFAULT_MAX_AST_DEPTH: usize = 512;
 const DEFAULT_MAX_PARENTHESES_DEPTH: usize = 512;
 const DEFAULT_MAX_FUNCTION_CALL_DEPTH: usize = 64;
+// WASM has no stacker support, and grammar frames differ substantially in size.
+// Keep its default conservative; an explicit option still replaces this value.
+#[cfg(target_arch = "wasm32")]
+const DEFAULT_MAX_PARSER_DEPTH: usize = 32;
+#[cfg(not(target_arch = "wasm32"))]
+const DEFAULT_MAX_PARSER_DEPTH: usize = 1_024;
+
+fn default_max_parser_depth() -> Option<usize> {
+    Some(DEFAULT_MAX_PARSER_DEPTH)
+}
+
+/// Resource exhaustion must not be treated as a speculative syntax mismatch.
+pub(crate) fn is_guard_error(error: &Error) -> bool {
+    matches!(error, Error::Parse { message, .. } if message.starts_with("E_GUARD_"))
+}
 
 fn default_max_input_bytes() -> Option<usize> {
     Some(DEFAULT_MAX_INPUT_BYTES)
@@ -43,6 +58,11 @@ fn default_max_function_call_depth() -> Option<usize> {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ComplexityGuardOptions {
+    /// Maximum logical nesting during parsing, before an AST exists.
+    /// Defaults to 32 on WASM and 1024 on native targets.
+    /// Raising this limit or disabling it with `None` can permit stack exhaustion.
+    #[serde(default = "default_max_parser_depth")]
+    pub max_parser_depth: Option<usize>,
     /// Maximum allowed SQL input size in bytes.
     /// `None` disables this check.
     #[serde(default = "default_max_input_bytes")]
@@ -120,6 +140,7 @@ impl TokenGuardStats {
 impl Default for ComplexityGuardOptions {
     fn default() -> Self {
         Self {
+            max_parser_depth: default_max_parser_depth(),
             max_input_bytes: default_max_input_bytes(),
             max_tokens: default_max_tokens(),
             max_ast_nodes: default_max_ast_nodes(),
@@ -372,6 +393,33 @@ mod token_guard_tests {
     use crate::tokens::Tokenizer;
     use std::sync::Arc;
 
+    #[test]
+    fn parser_depth_json_contract() {
+        let omitted: ComplexityGuardOptions = serde_json::from_str("{}").unwrap();
+        assert_eq!(omitted.max_parser_depth, Some(DEFAULT_MAX_PARSER_DEPTH));
+        assert_eq!(
+            omitted.max_parser_depth,
+            ComplexityGuardOptions::default().max_parser_depth
+        );
+        for limit in [Some(0), Some(1), Some(2048), None] {
+            let guard = ComplexityGuardOptions {
+                max_parser_depth: limit,
+                ..Default::default()
+            };
+            let json = serde_json::to_string(&guard).unwrap();
+            assert_eq!(
+                serde_json::from_str::<ComplexityGuardOptions>(&json).unwrap(),
+                guard
+            );
+        }
+        for value in ["-1", "1.5", "true", "\"10\""] {
+            assert!(serde_json::from_str::<ComplexityGuardOptions>(&format!(
+                "{{\"maxParserDepth\":{value}}}"
+            ))
+            .is_err());
+        }
+    }
+
     #[test]
     fn collected_parser_stats_match_full_token_guard_pass() {
         let sql: Arc<str> = Arc::from("SELECT outer(inner((value))), other(1, 2) FROM t");

{polyglot_sql-0.10.0 → polyglot_sql-0.11.0}/crates/polyglot-sql/src/lineage.rs

@@ -476,8 +476,8 @@ fn normalize_cte_name(ident: &Identifier) -> String {
 }
 
 /// Expand SELECT * in CTEs by walking CTE definitions in order and propagating
-/// resolved column lists. This handles nested CTEs (e.g., cte2 AS (SELECT * FROM cte1))
-/// which qualify_columns cannot resolve because it processes each SELECT independently.
+/// resolved column lists. This also handles chained CTEs in schema-free lineage
+/// and analysis paths, where full column qualification is not performed.
 ///
 /// When `schema` is provided, stars from external tables (not CTEs) are also resolved
 /// by looking up column names in the schema. This enables correct expansion of patterns
@@ -1211,14 +1211,26 @@ fn to_node_inner(
     // 0. Unwrap CTE scope — CTE scope expressions are Expression::Cte(...)
     //    but we need the inner query (SELECT/UNION) for column lookup.
     let effective_expr = effective_scope_expression(scope_expr);
+    // A CTE's explicit output names replace its projection names by ordinal.
+    // Resolve that boundary before unwrapping, including unnamed expressions.
+    let alias_ordinal = match (scope_expr, &column) {
+        (Expression::Cte(cte), ColumnRef::Name(name)) if !cte.columns.is_empty() => {
+            cte.columns.iter().position(|alias| {
+                normalize_column_name(&alias.name, dialect) == normalize_column_name(name, dialect)
+            })
+        }
+        _ => None,
+    };
+    let lookup_column = alias_ordinal.map(ColumnRef::Index);
+    let lookup_column = lookup_column.as_ref().unwrap_or(&column);
 
     // 1. Set operations (UNION / INTERSECT / EXCEPT)
     if matches!(
         effective_expr,
         Expression::Union(_) | Expression::Intersect(_) | Expression::Except(_)
     ) {
-        return handle_set_operation(
-            &column,
+        let mut node = handle_set_operation(
+            lookup_column,
             context,
             scope_id,
             effective_expr,
@@ -1230,11 +1242,17 @@ fn to_node_inner(
             trim_selects,
             &descendant_cte_scopes,
             depth,
-        );
+        )?;
+        if alias_ordinal.is_some() {
+            if let ColumnRef::Name(name) = &column {
+                node.name = (*name).to_string();
+            }
+        }
+        return Ok(node);
     }
 
     // 2. Find the select expression for this column
-    let select_expr = find_select_expr(effective_expr, &column, dialect)?;
+    let select_expr = find_select_expr(effective_expr, lookup_column, dialect)?;
     let column_name = resolve_column_name(&column, &select_expr);
 
     // 3. Trim source if requested