polyglot-sql 0.3.1__tar.gz → 0.3.2__tar.gz

{polyglot_sql-0.3.1 → polyglot_sql-0.3.2}/Cargo.lock

@@ -587,7 +587,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.3.1"
+version = "0.3.2"
 dependencies = [
  "criterion",
  "once_cell",
@@ -602,7 +602,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.3.1"
+version = "0.3.2"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -612,11 +612,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.3.1"
+version = "0.3.2"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.3.1"
+version = "0.3.2"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -627,7 +627,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.3.1"
+version = "0.3.2"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.3.1 → polyglot_sql-0.3.2}/Cargo.toml

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

{polyglot_sql-0.3.1 → polyglot_sql-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.3.1
+Version: 0.3.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyglot_sql-0.3.1 → polyglot_sql-0.3.2}/crates/polyglot-sql/Cargo.toml

@@ -78,7 +78,7 @@ serde_json = { workspace = true }
 thiserror = { workspace = true }
 unicode-segmentation = { workspace = true }
 ts-rs = { version = "12.0", features = ["serde-compat"], optional = true }
-polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.3.1", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.3.2", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.3.1 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/ast_transforms.rs

@@ -422,6 +422,18 @@ pub fn get_table_names(expr: &Expression) -> Vec<String> {
                     }
                 }
             }
+            Expression::Cache(cache) => {
+                let name = cache.table.name.clone();
+                if !name.is_empty() && !cte_aliases.contains(&name) {
+                    names.push(name);
+                }
+            }
+            Expression::Uncache(uncache) => {
+                let name = uncache.table.name.clone();
+                if !name.is_empty() && !cte_aliases.contains(&name) {
+                    names.push(name);
+                }
+            }
             _ => {}
         }
     }

{polyglot_sql-0.3.1 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/dialects/bigquery.rs

@@ -1142,9 +1142,7 @@ impl BigQueryDialect {
                 let unit_name = match &unit_expr {
                     Expression::Identifier(id) => id.name.to_uppercase(),
                     Expression::Var(v) => v.this.to_uppercase(),
-                    Expression::Column(col) if col.table.is_none() => {
-                        col.name.name.to_uppercase()
-                    }
+                    Expression::Column(col) if col.table.is_none() => col.name.name.to_uppercase(),
                     _ => "DAY".to_string(),
                 };
                 let unit = match unit_name.as_str() {

{polyglot_sql-0.3.1 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/dialects/duckdb.rs

@@ -13,9 +13,9 @@ use super::{DialectImpl, DialectType};
 use crate::error::Result;
 use crate::expressions::{
     AggFunc, Alias, BinaryOp, Case, Cast, CeilFunc, Column, DataType, Expression, Function,
-    Identifier, Interval, IntervalUnit, IntervalUnitSpec, IsNull, JSONPath,
-    JSONPathKey, JSONPathRoot, JSONPathSubscript, JsonExtractFunc, Literal, Null, Paren, Struct,
-    Subquery, SubstringFunc, UnaryFunc, UnaryOp, VarArgFunc, WindowFunction,
+    Identifier, Interval, IntervalUnit, IntervalUnitSpec, IsNull, JSONPath, JSONPathKey,
+    JSONPathRoot, JSONPathSubscript, JsonExtractFunc, Literal, Null, Paren, Struct, Subquery,
+    SubstringFunc, UnaryFunc, UnaryOp, VarArgFunc, WindowFunction,
 };
 use crate::generator::GeneratorConfig;
 use crate::tokens::TokenizerConfig;

{polyglot_sql-0.3.1 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/dialects/mod.rs

@@ -4109,7 +4109,7 @@ impl Dialect {
             DuckDBTryCastJsonToTryJsonParse, // DuckDB TRY_CAST(x AS JSON) -> TRY(JSON_PARSE(x)) for Trino/Presto/Athena
             DuckDBJsonFuncToJsonParse, // DuckDB json(x) -> JSON_PARSE(x) for Trino/Presto/Athena
             DuckDBJsonValidToIsJson,   // DuckDB json_valid(x) -> x IS JSON for Trino/Presto/Athena
-            ArraySyntaxConvert,     // ARRAY[x] -> ARRAY(x) for Spark, [x] for BigQuery/DuckDB
+            ArraySyntaxConvert,        // ARRAY[x] -> ARRAY(x) for Spark, [x] for BigQuery/DuckDB
             AtTimeZoneConvert, // AT TIME ZONE -> AT_TIMEZONE (Presto) / FROM_UTC_TIMESTAMP (Spark)
             DayOfWeekConvert,  // DAY_OF_WEEK -> dialect-specific
             MaxByMinByConvert, // MAX_BY/MIN_BY -> argMax/argMin for ClickHouse
@@ -20066,20 +20066,27 @@ impl Dialect {
                                         // DuckDB supports TRUNC(x, decimals) — preserve both args
                                         let mut args = f.args;
                                         // Snowflake fractions_supported: wrap non-INT decimals in CAST(... AS INT)
-                                        if args.len() == 2 && matches!(source, DialectType::Snowflake) {
+                                        if args.len() == 2
+                                            && matches!(source, DialectType::Snowflake)
+                                        {
                                             let decimals = args.remove(1);
                                             let is_int = matches!(&decimals, Expression::Literal(lit) if matches!(lit.as_ref(), Literal::Number(_)))
                                                 || matches!(&decimals, Expression::Cast(c) if matches!(c.to, DataType::Int { .. } | DataType::SmallInt { .. } | DataType::BigInt { .. } | DataType::TinyInt { .. }));
                                             let wrapped = if !is_int {
-                                                Expression::Cast(Box::new(crate::expressions::Cast {
-                                                    this: decimals,
-                                                    to: DataType::Int { length: None, integer_spelling: false },
-                                                    double_colon_syntax: false,
-                                                    trailing_comments: Vec::new(),
-                                                    format: None,
-                                                    default: None,
-                                                    inferred_type: None,
-                                                }))
+                                                Expression::Cast(Box::new(
+                                                    crate::expressions::Cast {
+                                                        this: decimals,
+                                                        to: DataType::Int {
+                                                            length: None,
+                                                            integer_spelling: false,
+                                                        },
+                                                        double_colon_syntax: false,
+                                                        trailing_comments: Vec::new(),
+                                                        format: None,
+                                                        default: None,
+                                                        inferred_type: None,
+                                                    },
+                                                ))
                                             } else {
                                                 decimals
                                             };
@@ -22230,14 +22237,12 @@ impl Dialect {
                     // DuckDB json_valid(x) -> x IS JSON (SQL:2016 predicate) for Trino/Presto/Athena
                     if let Expression::Function(mut f) = e {
                         let arg = f.args.remove(0);
-                        Ok(Expression::IsJson(Box::new(
-                            crate::expressions::IsJson {
-                                this: arg,
-                                json_type: None,
-                                unique_keys: None,
-                                negated: false,
-                            },
-                        )))
+                        Ok(Expression::IsJson(Box::new(crate::expressions::IsJson {
+                            this: arg,
+                            json_type: None,
+                            unique_keys: None,
+                            negated: false,
+                        })))
                     } else {
                         Ok(e)
                     }
@@ -35998,9 +36003,7 @@ mod tests {
     #[test]
     fn test_pg_hash_bitwise_xor() {
         let dialect = Dialect::get(DialectType::PostgreSQL);
-        let result = dialect
-            .transpile("x # y", DialectType::PostgreSQL)
-            .unwrap();
+        let result = dialect.transpile("x # y", DialectType::PostgreSQL).unwrap();
         assert_eq!(result[0], "x # y");
     }
 

{polyglot_sql-0.3.1 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/dialects/sqlite.rs

@@ -355,9 +355,7 @@ impl SQLiteDialect {
                     }
                     Expression::Identifier(id) => id.name.to_lowercase(),
                     Expression::Var(v) => v.this.to_lowercase(),
-                    Expression::Column(col) if col.table.is_none() => {
-                        col.name.name.to_lowercase()
-                    }
+                    Expression::Column(col) if col.table.is_none() => col.name.name.to_lowercase(),
                     _ => "day".to_string(),
                 };
 

{polyglot_sql-0.3.1 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/expressions.rs

@@ -10603,6 +10603,9 @@ pub struct MultitableInserts {
     /// Leading comments before the statement
     #[serde(default)]
     pub leading_comments: Vec<String>,
+    /// OVERWRITE modifier (Snowflake: INSERT OVERWRITE ALL)
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub overwrite: bool,
 }
 
 /// OnConflict

{polyglot_sql-0.3.1 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/generator.rs

@@ -31138,8 +31138,12 @@ impl Generator {
                 self.write_space();
             }
         }
-        // Python: INSERT kind expressions source
+        // Python: INSERT [OVERWRITE] kind expressions source
         self.write_keyword("INSERT");
+        if e.overwrite {
+            self.write_space();
+            self.write_keyword("OVERWRITE");
+        }
         self.write_space();
         self.write(&e.kind);
         if self.config.pretty {

{polyglot_sql-0.3.1 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/lib.rs

@@ -846,17 +846,48 @@ mod format_tests {
     #[test]
     fn transpile_matches_dialect_method() {
         let cases: &[(DialectType, DialectType, &str, &str, &str)] = &[
-            (DialectType::DuckDB, DialectType::Trino, "duckdb", "trino",
-             "SELECT to_timestamp(col) FROM t"),
-            (DialectType::DuckDB, DialectType::Trino, "duckdb", "trino",
-             "SELECT CAST(col AS JSON) FROM t"),
-            (DialectType::DuckDB, DialectType::Trino, "duckdb", "trino",
-             "SELECT json_valid(col) FROM t"),
-            (DialectType::Snowflake, DialectType::DuckDB, "snowflake", "duckdb",
-             "SELECT DATEDIFF(day, a, b) FROM t"),
-            (DialectType::BigQuery, DialectType::DuckDB, "bigquery", "duckdb",
-             "SELECT DATE_DIFF(a, b, DAY) FROM t"),
-            (DialectType::Generic, DialectType::Generic, "generic", "generic", "SELECT 1"),
+            (
+                DialectType::DuckDB,
+                DialectType::Trino,
+                "duckdb",
+                "trino",
+                "SELECT to_timestamp(col) FROM t",
+            ),
+            (
+                DialectType::DuckDB,
+                DialectType::Trino,
+                "duckdb",
+                "trino",
+                "SELECT CAST(col AS JSON) FROM t",
+            ),
+            (
+                DialectType::DuckDB,
+                DialectType::Trino,
+                "duckdb",
+                "trino",
+                "SELECT json_valid(col) FROM t",
+            ),
+            (
+                DialectType::Snowflake,
+                DialectType::DuckDB,
+                "snowflake",
+                "duckdb",
+                "SELECT DATEDIFF(day, a, b) FROM t",
+            ),
+            (
+                DialectType::BigQuery,
+                DialectType::DuckDB,
+                "bigquery",
+                "duckdb",
+                "SELECT DATE_DIFF(a, b, DAY) FROM t",
+            ),
+            (
+                DialectType::Generic,
+                DialectType::Generic,
+                "generic",
+                "generic",
+                "SELECT 1",
+            ),
         ];
         for (read, write, read_name, write_name, sql) in cases {
             let via_lib = transpile(sql, *read, *write).expect("lib::transpile failed");

{polyglot_sql-0.3.1 → polyglot_sql-0.3.2}/crates/polyglot-sql/src/lineage.rs

@@ -250,12 +250,13 @@ pub fn expand_cte_stars(expr: &mut Expression, schema: Option<&dyn Schema>) {
         // a source in its own body, skip it. Non-recursive CTEs in a recursive WITH
         // block are still expanded.
         if with.recursive {
-            let is_self_referencing = if let Some(body_select) = get_leftmost_select_mut(&mut cte.this) {
-                let body_sources = get_select_sources(body_select);
-                body_sources.iter().any(|s| s.normalized == cte_name)
-            } else {
-                false
-            };
+            let is_self_referencing =
+                if let Some(body_select) = get_leftmost_select_mut(&mut cte.this) {
+                    let body_sources = get_select_sources(body_select);
+                    body_sources.iter().any(|s| s.normalized == cte_name)
+                } else {
+                    false
+                };
             if is_self_referencing {
                 continue;
             }
@@ -332,12 +333,9 @@ fn rewrite_stars_in_select(
         match expr {
             Expression::Star(star) => {
                 let qual = star.table.as_ref();
-                if let Some(expanded) = expand_star_from_sources(
-                    qual,
-                    &sources,
-                    resolved_ctes,
-                    schema,
-                ) {
+                if let Some(expanded) =
+                    expand_star_from_sources(qual, &sources, resolved_ctes, schema)
+                {
                     for (src_alias, col_name) in &expanded {
                         let table_id = Identifier::new(src_alias);
                         new_expressions.push(make_column_expr(col_name, Some(&table_id)));
@@ -350,12 +348,9 @@ fn rewrite_stars_in_select(
             }
             Expression::Column(c) if c.name.name == "*" => {
                 let qual = c.table.as_ref();
-                if let Some(expanded) = expand_star_from_sources(
-                    qual,
-                    &sources,
-                    resolved_ctes,
-                    schema,
-                ) {
+                if let Some(expanded) =
+                    expand_star_from_sources(qual, &sources, resolved_ctes, schema)
+                {
                     for (_src_alias, col_name) in &expanded {
                         // Keep the original table qualifier for qualified stars (table.*)
                         new_expressions.push(make_column_expr(col_name, c.table.as_ref()));
@@ -441,7 +436,10 @@ fn lookup_schema_columns(schema: Option<&dyn Schema>, fq_name: &str) -> Option<V
     if fq_name.is_empty() {
         return None;
     }
-    schema.column_names(fq_name).ok().filter(|cols| !cols.is_empty() && !cols.contains(&"*".to_string()))
+    schema
+        .column_names(fq_name)
+        .ok()
+        .filter(|cols| !cols.is_empty() && !cols.contains(&"*".to_string()))
 }
 
 /// Create a Column expression with the given name and optional table qualifier.
@@ -499,13 +497,21 @@ fn get_select_sources(select: &Select) -> Vec<SourceInfo> {
                 }
                 parts.push(t.name.name.clone());
                 let fq_name = parts.join(".");
-                Some(SourceInfo { alias, normalized, fq_name })
+                Some(SourceInfo {
+                    alias,
+                    normalized,
+                    fq_name,
+                })
             }
             Expression::Subquery(s) => {
                 let alias = s.alias.as_ref()?.name.clone();
                 let normalized = alias.to_lowercase();
                 let fq_name = alias.clone();
-                Some(SourceInfo { alias, normalized, fq_name })
+                Some(SourceInfo {
+                    alias,
+                    normalized,
+                    fq_name,
+                })
             }
             Expression::Paren(p) => extract_source(&p.this),
             _ => None,
@@ -816,9 +822,9 @@ fn resolve_qualified_column(
     // Check if table is a CTE reference — check both the current scope's cte_sources
     // and ancestor CTE scopes (for sibling CTEs in parent WITH clauses).
     let is_cte = scope.cte_sources.contains_key(effective_table)
-        || all_cte_scopes.iter().any(|s| {
-            matches!(&s.expression, Expression::Cte(cte) if cte.alias.name == effective_table)
-        });
+        || all_cte_scopes.iter().any(
+            |s| matches!(&s.expression, Expression::Cte(cte) if cte.alias.name == effective_table),
+        );
     if is_cte {
         if let Some(child_scope) = find_child_scope_in(all_cte_scopes, scope, effective_table) {
             // Build ancestor CTE scopes from all_cte_scopes for the recursive call
@@ -3261,14 +3267,9 @@ SELECT * FROM orders"#;
         ];
         schema.add_table("stg_orders", &cols, None).unwrap();
 
-        let node = lineage_with_schema(
-            "order_id",
-            &expr,
-            Some(&schema as &dyn Schema),
-            None,
-            false,
-        )
-        .unwrap();
+        let node =
+            lineage_with_schema("order_id", &expr, Some(&schema as &dyn Schema), None, false)
+                .unwrap();
         assert_eq!(node.name, "order_id");
     }
 
@@ -3284,7 +3285,9 @@ SELECT * FROM orders"#;
             ("order_id".to_string(), DataType::Unknown),
             ("customer_id".to_string(), DataType::Unknown),
         ];
-        schema.add_table("db.schema.stg_orders", &cols, None).unwrap();
+        schema
+            .add_table("db.schema.stg_orders", &cols, None)
+            .unwrap();
 
         let node = lineage_with_schema(
             "customer_id",
@@ -3314,14 +3317,8 @@ SELECT * FROM orders"#;
         ];
         schema.add_table("external_table", &cols, None).unwrap();
 
-        let node = lineage_with_schema(
-            "name",
-            &expr,
-            Some(&schema as &dyn Schema),
-            None,
-            false,
-        )
-        .unwrap();
+        let node =
+            lineage_with_schema("name", &expr, Some(&schema as &dyn Schema), None, false).unwrap();
         assert_eq!(node.name, "name");
     }
 
@@ -3345,25 +3342,14 @@ SELECT * FROM orders"#;
         ];
         schema.add_table("stg_orders", &cols, None).unwrap();
 
-        let node = lineage_with_schema(
-            "order_id",
-            &expr,
-            Some(&schema as &dyn Schema),
-            None,
-            false,
-        )
-        .unwrap();
+        let node =
+            lineage_with_schema("order_id", &expr, Some(&schema as &dyn Schema), None, false)
+                .unwrap();
         assert_eq!(node.name, "order_id");
 
         // Also verify the extra column works
-        let extra = lineage_with_schema(
-            "extra",
-            &expr,
-            Some(&schema as &dyn Schema),
-            None,
-            false,
-        )
-        .unwrap();
+        let extra =
+            lineage_with_schema("extra", &expr, Some(&schema as &dyn Schema), None, false).unwrap();
         assert_eq!(extra.name, "extra");
     }
 
@@ -3404,38 +3390,59 @@ SELECT * FROM final_cte"#;
 
         let mut schema = MappingSchema::new();
         let order_cols = vec![
-            ("order_id".to_string(), crate::expressions::DataType::Unknown),
-            ("customer_id".to_string(), crate::expressions::DataType::Unknown),
+            (
+                "order_id".to_string(),
+                crate::expressions::DataType::Unknown,
+            ),
+            (
+                "customer_id".to_string(),
+                crate::expressions::DataType::Unknown,
+            ),
             ("status".to_string(), crate::expressions::DataType::Unknown),
         ];
         let pay_cols = vec![
-            ("payment_id".to_string(), crate::expressions::DataType::Unknown),
-            ("order_id".to_string(), crate::expressions::DataType::Unknown),
+            (
+                "payment_id".to_string(),
+                crate::expressions::DataType::Unknown,
+            ),
+            (
+                "order_id".to_string(),
+                crate::expressions::DataType::Unknown,
+            ),
             ("amount".to_string(), crate::expressions::DataType::Unknown),
         ];
         schema.add_table("stg_orders", &order_cols, None).unwrap();
         schema.add_table("stg_payments", &pay_cols, None).unwrap();
 
         // order_id should trace back to stg_orders
-        let node = lineage_with_schema(
-            "order_id", &expr, Some(&schema as &dyn Schema), None, false,
-        ).unwrap();
+        let node =
+            lineage_with_schema("order_id", &expr, Some(&schema as &dyn Schema), None, false)
+                .unwrap();
         let all_names: Vec<_> = node.walk().map(|n| n.name.clone()).collect();
 
         // The leaf should be "stg_orders.order_id" (not just "order_id")
-        let has_table_qualified = all_names.iter().any(|n| n.contains('.') && n.contains("order_id"));
-        assert!(has_table_qualified,
-            "Expected table-qualified leaf like 'stg_orders.order_id', got: {:?}", all_names);
+        let has_table_qualified = all_names
+            .iter()
+            .any(|n| n.contains('.') && n.contains("order_id"));
+        assert!(
+            has_table_qualified,
+            "Expected table-qualified leaf like 'stg_orders.order_id', got: {:?}",
+            all_names
+        );
 
         // amount should trace back to stg_payments
-        let node = lineage_with_schema(
-            "amount", &expr, Some(&schema as &dyn Schema), None, false,
-        ).unwrap();
+        let node = lineage_with_schema("amount", &expr, Some(&schema as &dyn Schema), None, false)
+            .unwrap();
         let all_names: Vec<_> = node.walk().map(|n| n.name.clone()).collect();
 
-        let has_table_qualified = all_names.iter().any(|n| n.contains('.') && n.contains("amount"));
-        assert!(has_table_qualified,
-            "Expected table-qualified leaf like 'stg_payments.amount', got: {:?}", all_names);
+        let has_table_qualified = all_names
+            .iter()
+            .any(|n| n.contains('.') && n.contains("amount"));
+        assert!(
+            has_table_qualified,
+            "Expected table-qualified leaf like 'stg_payments.amount', got: {:?}",
+            all_names
+        );
     }
 
     #[test]
@@ -3481,14 +3488,8 @@ FROM import_stg AS base"#;
             )
             .unwrap();
 
-        let node = lineage_with_schema(
-            "item_id",
-            &expr,
-            Some(&schema as &dyn Schema),
-            None,
-            false,
-        )
-        .unwrap();
+        let node = lineage_with_schema("item_id", &expr, Some(&schema as &dyn Schema), None, false)
+            .unwrap();
         let all_names: Vec<_> = node.walk().map(|n| n.name.clone()).collect();
         assert!(
             all_names.iter().any(|n| n == "stg_items.item_id"),
@@ -3533,9 +3534,7 @@ LEFT JOIN import_orders AS o ON u.id = o.user_id"#;
     fn test_lineage_unquoted_cte_case_insensitive() {
         // Unquoted CTE names are case-insensitive (both normalized to lowercase).
         // MyCte and MYCTE should match.
-        let expr = parse(
-            "WITH MyCte AS (SELECT id AS col FROM source) SELECT * FROM MYCTE",
-        );
+        let expr = parse("WITH MyCte AS (SELECT id AS col FROM source) SELECT * FROM MYCTE");
         let node = lineage("col", &expr, None, false).unwrap();
         assert_eq!(node.name, "col");
         assert!(
@@ -3547,9 +3546,7 @@ LEFT JOIN import_orders AS o ON u.id = o.user_id"#;
     #[test]
     fn test_lineage_quoted_cte_case_preserved() {
         // Quoted CTE name preserves case. "MyCte" referenced as "MyCte" should match.
-        let expr = parse(
-            r#"WITH "MyCte" AS (SELECT id AS col FROM source) SELECT * FROM "MyCte""#,
-        );
+        let expr = parse(r#"WITH "MyCte" AS (SELECT id AS col FROM source) SELECT * FROM "MyCte""#);
         let node = lineage("col", &expr, None, false).unwrap();
         assert_eq!(node.name, "col");
         assert!(
@@ -3563,9 +3560,7 @@ LEFT JOIN import_orders AS o ON u.id = o.user_id"#;
         // Quoted CTE "MyCte" referenced as "mycte" — case mismatch.
         // sqlglot treats this as a table reference, not a CTE match.
         // Star expansion should NOT resolve through the CTE.
-        let expr = parse(
-            r#"WITH "MyCte" AS (SELECT id AS col FROM source) SELECT * FROM "mycte""#,
-        );
+        let expr = parse(r#"WITH "MyCte" AS (SELECT id AS col FROM source) SELECT * FROM "mycte""#);
         // lineage("col", ...) should fail because "mycte" is treated as an external
         // table (not matching CTE "MyCte"), and SELECT * cannot be expanded.
         let result = lineage("col", &expr, None, false);
@@ -3617,9 +3612,7 @@ LEFT JOIN import_orders AS o ON u.id = o.user_id"#;
         // This test asserts the CURRENT BUGGY behavior. When the bug is fixed,
         // this test should fail — update the assertion to match correct behavior:
         //   child.source_name should be "" (table ref), not "MyCte" (CTE ref).
-        let expr = parse(
-            r#"WITH "MyCte" AS (SELECT 1 AS col) SELECT col FROM "mycte""#,
-        );
+        let expr = parse(r#"WITH "MyCte" AS (SELECT 1 AS col) SELECT col FROM "mycte""#);
         let node = lineage("col", &expr, None, false).unwrap();
         assert!(!node.downstream.is_empty());
         let child = &node.downstream[0];
@@ -3639,9 +3632,7 @@ LEFT JOIN import_orders AS o ON u.id = o.user_id"#;
         //
         // This test asserts the CURRENT BUGGY behavior. When the bug is fixed,
         // this test should fail — update to assert source_name != "MyCte".
-        let expr = parse(
-            r#"WITH "MyCte" AS (SELECT 1 AS col) SELECT "mycte".col FROM "mycte""#,
-        );
+        let expr = parse(r#"WITH "MyCte" AS (SELECT 1 AS col) SELECT "mycte".col FROM "mycte""#);
         let node = lineage("col", &expr, None, false).unwrap();
         assert!(!node.downstream.is_empty());
         let child = &node.downstream[0];