polyglot-sql 0.3.3__tar.gz → 0.3.4__tar.gz

{polyglot_sql-0.3.3 → polyglot_sql-0.3.4}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.3.3"
+version = "0.3.4"
 dependencies = [
  "criterion",
  "once_cell",
@@ -621,7 +621,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.3.3"
+version = "0.3.4"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -631,11 +631,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.3.3"
+version = "0.3.4"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.3.3"
+version = "0.3.4"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -646,7 +646,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.3.3"
+version = "0.3.4"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.3.3 → polyglot_sql-0.3.4}/Cargo.toml

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

{polyglot_sql-0.3.3 → polyglot_sql-0.3.4}/PKG-INFO

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

{polyglot_sql-0.3.3 → polyglot_sql-0.3.4}/crates/polyglot-sql/Cargo.toml

@@ -83,7 +83,7 @@ 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.3.3", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.3.4", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.3.3 → polyglot_sql-0.3.4}/crates/polyglot-sql/src/builder.rs

@@ -1603,6 +1603,7 @@ impl SelectBuilder {
             clone_at_clause: None,
             is_copy: false,
             shallow_clone: false,
+            deep_clone: false,
             leading_comments: vec![],
             with_properties: vec![],
             teradata_post_name_options: vec![],

{polyglot_sql-0.3.3 → polyglot_sql-0.3.4}/crates/polyglot-sql/src/dialects/databricks.rs

@@ -37,6 +37,12 @@ impl DialectImpl for DatabricksDialect {
         config
             .keywords
             .insert("DIV".to_string(), crate::tokens::TokenType::Div);
+        config
+            .keywords
+            .insert("REPAIR".to_string(), crate::tokens::TokenType::Command);
+        config
+            .keywords
+            .insert("MSCK".to_string(), crate::tokens::TokenType::Command);
         // Databricks numeric literal suffixes (same as Hive/Spark)
         config
             .numeric_literals
@@ -1009,4 +1015,104 @@ mod tests {
             "FROM_UTC_TIMESTAMP with existing CAST failed"
         );
     }
+
+    #[test]
+    fn test_deep_clone_version_as_of() {
+        let sql = "CREATE TABLE events_clone DEEP CLONE events VERSION AS OF 5";
+        let d = Dialect::get(DialectType::Databricks);
+        let ast = d.parse(sql).expect("Parse failed");
+        let output = d.generate(&ast[0]).expect("Generate failed");
+
+        assert_eq!(output, sql);
+    }
+
+    #[test]
+    fn test_deep_clone_timestamp_as_of() {
+        let sql = "CREATE TABLE events_clone DEEP CLONE events TIMESTAMP AS OF '2024-01-01'";
+        let d = Dialect::get(DialectType::Databricks);
+        let ast = d.parse(sql).expect("Parse failed");
+        let output = d.generate(&ast[0]).expect("Generate failed");
+
+        assert_eq!(output, sql);
+    }
+
+    #[test]
+    fn test_shallow_clone_still_roundtrips() {
+        let sql = "CREATE TABLE events_clone SHALLOW CLONE events";
+        let d = Dialect::get(DialectType::Databricks);
+        let ast = d.parse(sql).expect("Parse failed");
+        let output = d.generate(&ast[0]).expect("Generate failed");
+
+        assert_eq!(output, sql);
+    }
+
+    #[test]
+    fn test_repair_table_commands_roundtrip() {
+        let d = Dialect::get(DialectType::Databricks);
+        let cases = [
+            "REPAIR TABLE events",
+            "MSCK REPAIR TABLE events",
+            "REPAIR TABLE events ADD PARTITIONS",
+            "REPAIR TABLE events DROP PARTITIONS",
+            "REPAIR TABLE events SYNC PARTITIONS",
+            "REPAIR TABLE events SYNC METADATA",
+        ];
+
+        for sql in cases {
+            let ast = d.parse(sql).expect("Parse failed");
+            let output = d.generate(&ast[0]).expect("Generate failed");
+            assert_eq!(output, sql);
+        }
+    }
+
+    #[test]
+    fn test_apply_changes_commands_roundtrip() {
+        let d = Dialect::get(DialectType::Databricks);
+        let cases = [
+            "APPLY CHANGES INTO silver.orders FROM STREAM(bronze.orders) KEYS (id) SEQUENCE BY ts",
+            "APPLY CHANGES INTO LIVE.silver_orders FROM STREAM(LIVE.bronze_orders) KEYS (id) IGNORE NULL UPDATES SEQUENCE BY ts",
+            "APPLY CHANGES INTO LIVE.silver_orders FROM STREAM(LIVE.bronze_orders) KEYS (id) APPLY AS DELETE WHEN operation = 'DELETE' SEQUENCE BY ts COLUMNS * EXCEPT (operation) STORED AS SCD TYPE 1",
+            "APPLY CHANGES INTO LIVE.silver_orders FROM STREAM(LIVE.bronze_orders) KEYS (id) SEQUENCE BY ts STORED AS SCD TYPE 2 TRACK HISTORY ON * EXCEPT (updated_at)",
+            "AUTO CDC INTO silver.orders FROM STREAM(bronze.orders) KEYS (id) SEQUENCE BY ts",
+            "CREATE FLOW apply_cdc AS AUTO CDC INTO silver.orders FROM STREAM(bronze.orders) KEYS (id) SEQUENCE BY ts",
+        ];
+
+        for sql in cases {
+            let ast = d.parse(sql).expect("Parse failed");
+            let output = d.generate(&ast[0]).expect("Generate failed");
+            assert_eq!(output, sql);
+        }
+    }
+
+    #[test]
+    fn test_generate_symlink_format_manifest_roundtrip() {
+        let d = Dialect::get(DialectType::Databricks);
+        let cases = [
+            "GENERATE symlink_format_manifest FOR TABLE events",
+            "GENERATE symlink_format_manifest FOR TABLE catalog.schema.events",
+        ];
+
+        for sql in cases {
+            let ast = d.parse(sql).expect("Parse failed");
+            let output = d.generate(&ast[0]).expect("Generate failed");
+            assert_eq!(output, sql);
+        }
+    }
+
+    #[test]
+    fn test_convert_to_delta_roundtrip() {
+        let d = Dialect::get(DialectType::Databricks);
+        let cases = [
+            "CONVERT TO DELTA parquet.`/mnt/data/events`",
+            "CONVERT TO DELTA database_name.table_name",
+            "CONVERT TO DELTA parquet.`s3://my-bucket/path/to/table` PARTITIONED BY (date DATE)",
+            "CONVERT TO DELTA database_name.table_name NO STATISTICS",
+        ];
+
+        for sql in cases {
+            let ast = d.parse(sql).expect("Parse failed");
+            let output = d.generate(&ast[0]).expect("Generate failed");
+            assert_eq!(output, sql);
+        }
+    }
 }

{polyglot_sql-0.3.3 → polyglot_sql-0.3.4}/crates/polyglot-sql/src/dialects/fabric.rs

@@ -42,6 +42,7 @@ impl DialectImpl for FabricDialect {
             identifier_quote: '[',
             identifier_quote_style: IdentifierQuoteStyle::BRACKET,
             dialect: Some(DialectType::Fabric),
+            null_ordering_supported: false,
             ..Default::default()
         }
     }
@@ -63,7 +64,14 @@ impl DialectImpl for FabricDialect {
                     }
                     _ => {}
                 }
-                // Also transform column data types through Fabric's type mappings
+                // Also transform column data types through Fabric's type mappings.
+                // Apply TSQL normalisation first (e.g. BPCHAR → Char), then Fabric-specific.
+                let tsql = TSQLDialect;
+                if let Ok(Expression::DataType(tsql_dt)) =
+                    tsql.transform_data_type(col.data_type.clone())
+                {
+                    col.data_type = tsql_dt;
+                }
                 if let Expression::DataType(new_dt) =
                     self.transform_fabric_data_type(col.data_type.clone())?
                 {
@@ -361,7 +369,8 @@ impl FabricDialect {
                 let upper = name.to_uppercase();
 
                 // Parse out precision and scale if present: "TYPENAME(n)" or "TYPENAME(n, m)"
-                let (base_name, precision, scale) = Self::parse_type_precision_and_scale(&upper);
+                let (base_name, precision, scale) =
+                    TSQLDialect::parse_type_precision_and_scale(&upper);
 
                 match base_name.as_str() {
                     // DATETIME -> DATETIME2(6)
@@ -518,24 +527,4 @@ impl FabricDialect {
             None => max, // Default to max if not specified
         }
     }
-
-    /// Parse type name and optional precision/scale from strings like "DATETIME2(7)" or "NUMERIC(10, 2)"
-    fn parse_type_precision_and_scale(name: &str) -> (String, Option<u32>, Option<u32>) {
-        if let Some(paren_pos) = name.find('(') {
-            let base = name[..paren_pos].to_string();
-            let rest = &name[paren_pos + 1..];
-            if let Some(close_pos) = rest.find(')') {
-                let args = &rest[..close_pos];
-                let parts: Vec<&str> = args.split(',').map(|s| s.trim()).collect();
-
-                let precision = parts.first().and_then(|s| s.parse::<u32>().ok());
-                let scale = parts.get(1).and_then(|s| s.parse::<u32>().ok());
-
-                return (base, precision, scale);
-            }
-            (base, None, None)
-        } else {
-            (name.to_string(), None, None)
-        }
-    }
 }

{polyglot_sql-0.3.3 → polyglot_sql-0.3.4}/crates/polyglot-sql/src/dialects/hive.rs

@@ -42,6 +42,12 @@ impl DialectImpl for HiveDialect {
         config
             .keywords
             .insert("DIV".to_string(), crate::tokens::TokenType::Div);
+        config
+            .keywords
+            .insert("REPAIR".to_string(), crate::tokens::TokenType::Command);
+        config
+            .keywords
+            .insert("MSCK".to_string(), crate::tokens::TokenType::Command);
         // Hive numeric literal suffixes: 1L -> BIGINT, 1S -> SMALLINT, etc.
         config
             .numeric_literals

{polyglot_sql-0.3.3 → polyglot_sql-0.3.4}/crates/polyglot-sql/src/dialects/mod.rs

@@ -158,7 +158,7 @@ pub use trino::TrinoDialect;
 pub use tsql::TSQLDialect;
 
 use crate::error::Result;
-use crate::expressions::{Expression, FunctionBody, Null};
+use crate::expressions::{Expression, Function, FunctionBody, Identifier, Null};
 use crate::generator::{Generator, GeneratorConfig};
 use crate::parser::Parser;
 use crate::tokens::{Token, Tokenizer, TokenizerConfig};
@@ -9067,6 +9067,11 @@ impl Dialect {
             match action {
                 Action::None => {
                     // Handle inline transforms that don't need a dedicated action
+                    if matches!(target, DialectType::TSQL | DialectType::Fabric) {
+                        if let Some(rewritten) = Self::rewrite_tsql_interval_arithmetic(&e) {
+                            return Ok(rewritten);
+                        }
+                    }
 
                     // BETWEEN SYMMETRIC/ASYMMETRIC expansion for non-PostgreSQL/Dremio targets
                     if let Expression::Between(ref b) = e {
@@ -31321,6 +31326,7 @@ impl Dialect {
                             clone_source: None,
                             clone_at_clause: None,
                             shallow_clone: false,
+                            deep_clone: false,
                             is_copy: false,
                             leading_comments: Vec::new(),
                             with_properties: Vec::new(),
@@ -31897,7 +31903,9 @@ impl Dialect {
                                 // Return just the numeric part as value and parsed unit
                                 return (
                                     Expression::Literal(Box::new(
-                                        crate::expressions::Literal::String(parts[0].to_string()),
+                                        crate::expressions::Literal::String(
+                                            parts[0].trim().to_string(),
+                                        ),
                                     )),
                                     parsed_unit,
                                 );
@@ -31919,6 +31927,88 @@ impl Dialect {
         }
     }
 
+    fn rewrite_tsql_interval_arithmetic(expr: &Expression) -> Option<Expression> {
+        match expr {
+            Expression::Add(op) => {
+                let Expression::Interval(_) = &op.right else {
+                    return None;
+                };
+                Some(Self::build_tsql_dateadd_from_interval(
+                    op.left.clone(),
+                    &op.right,
+                    false,
+                ))
+            }
+            Expression::Sub(op) => {
+                let Expression::Interval(_) = &op.right else {
+                    return None;
+                };
+                Some(Self::build_tsql_dateadd_from_interval(
+                    op.left.clone(),
+                    &op.right,
+                    true,
+                ))
+            }
+            _ => None,
+        }
+    }
+
+    fn build_tsql_dateadd_from_interval(
+        date: Expression,
+        interval: &Expression,
+        subtract: bool,
+    ) -> Expression {
+        let (value, unit) = Self::extract_interval_parts(interval);
+        let unit = Self::interval_unit_to_string(&unit);
+        let amount = Self::tsql_dateadd_amount(value, subtract);
+
+        Expression::Function(Box::new(Function::new(
+            "DATEADD".to_string(),
+            vec![Expression::Identifier(Identifier::new(unit)), amount, date],
+        )))
+    }
+
+    fn tsql_dateadd_amount(value: Expression, negate: bool) -> Expression {
+        use crate::expressions::UnaryOp;
+
+        fn numeric_literal_value(value: &Expression) -> Option<&str> {
+            match value {
+                Expression::Literal(lit) => match lit.as_ref() {
+                    crate::expressions::Literal::Number(n)
+                    | crate::expressions::Literal::String(n) => Some(n.as_str()),
+                    _ => None,
+                },
+                _ => None,
+            }
+        }
+
+        if let Some(n) = numeric_literal_value(&value) {
+            if let Ok(parsed) = n.parse::<f64>() {
+                let normalized = if negate { -parsed } else { parsed };
+                let rendered = if normalized.fract() == 0.0 {
+                    format!("{}", normalized as i64)
+                } else {
+                    normalized.to_string()
+                };
+                return Expression::Literal(Box::new(crate::expressions::Literal::Number(
+                    rendered,
+                )));
+            }
+        }
+
+        if !negate {
+            return value;
+        }
+
+        match value {
+            Expression::Neg(op) => op.this,
+            other => Expression::Neg(Box::new(UnaryOp {
+                this: other,
+                inferred_type: None,
+            })),
+        }
+    }
+
     /// Normalize BigQuery-specific functions to standard forms that target dialects can handle
     fn normalize_bigquery_function(
         e: Expression,
@@ -37962,7 +38052,11 @@ mod tests {
             "Expected IS NOT DISTINCT FROM: {}",
             result[0]
         );
-        assert!(result[0].contains("= 0"), "Expected = 0 filter: {}", result[0]);
+        assert!(
+            result[0].contains("= 0"),
+            "Expected = 0 filter: {}",
+            result[0]
+        );
     }
 
     #[test]

{polyglot_sql-0.3.3 → polyglot_sql-0.3.4}/crates/polyglot-sql/src/dialects/mysql.rs

@@ -1217,6 +1217,29 @@ mod tests {
         assert_eq!(config.identifier_quote, '`');
     }
 
+    #[test]
+    fn test_create_procedure_signal_sqlstate_regression() {
+        let sql = "CREATE PROCEDURE CheckSalary(IN p_salary DECIMAL(10,2))
+BEGIN
+  IF p_salary <= 0 THEN
+    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Salary must be positive';
+  END IF;
+  INSERT INTO employees (salary) VALUES (p_salary);
+END;";
+
+        let dialect = Dialect::get(DialectType::MySQL);
+        let ast = dialect.parse(sql).expect("Parse failed");
+        let output = dialect.generate(&ast[0]).expect("Generate failed");
+
+        assert!(output.contains("CREATE PROCEDURE CheckSalary"));
+        assert!(output.contains("IF p_salary <= 0 THEN"));
+        assert!(
+            output.contains("SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Salary must be positive'")
+        );
+        assert!(output.contains("END IF"));
+        assert!(output.contains("INSERT INTO employees (salary) VALUES (p_salary)"));
+    }
+
     fn mysql_identity(sql: &str, expected: &str) {
         let dialect = Dialect::get(DialectType::MySQL);
         let ast = dialect.parse(sql).expect("Parse failed");

{polyglot_sql-0.3.3 → polyglot_sql-0.3.4}/crates/polyglot-sql/src/dialects/snowflake.rs

@@ -3921,6 +3921,37 @@ mod tests {
         assert!(result.contains("FROM users"));
     }
 
+    #[test]
+    fn test_snowflake_scripting_cursor_declare_block_roundtrip() {
+        let sql = "DECLARE
+  emp CURSOR FOR SELECT salary FROM employees;
+BEGIN
+  RETURN 1;
+END";
+
+        let dialect = Dialect::get(DialectType::Snowflake);
+        let ast = dialect.parse(sql).expect("Parse failed");
+        let output = dialect.generate(&ast[0]).expect("Generate failed");
+
+        assert_eq!(output, sql);
+    }
+
+    #[test]
+    fn test_snowflake_scripting_cursor_return_table_roundtrip() {
+        let sql = "DECLARE
+  c1 CURSOR FOR SELECT * FROM invoices;
+BEGIN
+  OPEN c1;
+  RETURN TABLE(RESULTSET_FROM_CURSOR(c1));
+END";
+
+        let dialect = Dialect::get(DialectType::Snowflake);
+        let ast = dialect.parse(sql).expect("Parse failed");
+        let output = dialect.generate(&ast[0]).expect("Generate failed");
+
+        assert_eq!(output, sql);
+    }
+
     #[test]
     fn test_group_concat_to_listagg() {
         let result = transpile_to_snowflake("SELECT GROUP_CONCAT(name)");

{polyglot_sql-0.3.3 → polyglot_sql-0.3.4}/crates/polyglot-sql/src/dialects/spark.rs

@@ -41,6 +41,12 @@ impl DialectImpl for SparkDialect {
         config
             .keywords
             .insert("DIV".to_string(), crate::tokens::TokenType::Div);
+        config
+            .keywords
+            .insert("REPAIR".to_string(), crate::tokens::TokenType::Command);
+        config
+            .keywords
+            .insert("MSCK".to_string(), crate::tokens::TokenType::Command);
         // Spark numeric literal suffixes (same as Hive): 1L -> BIGINT, 1S -> SMALLINT, etc.
         config
             .numeric_literals

{polyglot_sql-0.3.3 → polyglot_sql-0.3.4}/crates/polyglot-sql/src/dialects/tsql.rs

@@ -13,8 +13,8 @@
 use super::{DialectImpl, DialectType};
 use crate::error::Result;
 use crate::expressions::{
-    Alias, Cast, Cte, DataType, Expression, Function, Identifier, Join, JoinKind, LikeOp, Literal,
-    Null, StringAggFunc, Subquery, UnaryFunc,
+    Alias, Cast, Cte, DataType, Expression, Function, Identifier, In, Join, JoinKind, LikeOp,
+    Literal, Null, QuantifiedOp, StringAggFunc, Subquery, UnaryFunc,
 };
 use crate::generator::GeneratorConfig;
 use crate::tokens::TokenizerConfig;
@@ -91,6 +91,18 @@ impl DialectImpl for TSQLDialect {
     }
 
     fn transform_expr(&self, expr: Expression) -> Result<Expression> {
+        // Transform column data types in DDL (transform_recursive skips them by design).
+        if let Expression::CreateTable(mut ct) = expr {
+            for col in &mut ct.columns {
+                if let Ok(Expression::DataType(new_dt)) =
+                    self.transform_data_type(col.data_type.clone())
+                {
+                    col.data_type = new_dt;
+                }
+            }
+            return Ok(Expression::CreateTable(ct));
+        }
+
         match expr {
             // ===== SELECT a = 1 → SELECT 1 AS a =====
             // In T-SQL, `SELECT a = expr` is equivalent to `SELECT expr AS a`
@@ -629,6 +641,36 @@ impl DialectImpl for TSQLDialect {
                 vec![f.this, f.path],
             )))),
 
+            // PostgreSQL pg_get_querydef can emit scalar array comparisons for
+            // literal arrays/tuples. T-SQL/Fabric require IN for this shape.
+            Expression::Any(ref q) if matches!(&q.op, Some(QuantifiedOp::Eq)) => {
+                let values: Option<Vec<Expression>> = match &q.subquery {
+                    Expression::ArrayFunc(a) => Some(a.expressions.clone()),
+                    Expression::Array(a) => Some(a.expressions.clone()),
+                    Expression::Tuple(t) => Some(t.expressions.clone()),
+                    _ => None,
+                };
+
+                match values {
+                    Some(expressions) if expressions.is_empty() => {
+                        Ok(Expression::Eq(Box::new(crate::expressions::BinaryOp::new(
+                            Expression::Literal(Box::new(Literal::Number("1".to_string()))),
+                            Expression::Literal(Box::new(Literal::Number("0".to_string()))),
+                        ))))
+                    }
+                    Some(expressions) => Ok(Expression::In(Box::new(In {
+                        this: q.this.clone(),
+                        expressions,
+                        query: None,
+                        not: false,
+                        global: false,
+                        unnest: None,
+                        is_field: false,
+                    }))),
+                    None => Ok(expr.clone()),
+                }
+            }
+
             // Pass through everything else
             _ => Ok(expr),
         }
@@ -637,7 +679,10 @@ impl DialectImpl for TSQLDialect {
 
 impl TSQLDialect {
     /// Transform data types according to T-SQL TYPE_MAPPING
-    fn transform_data_type(&self, dt: crate::expressions::DataType) -> Result<Expression> {
+    pub(super) fn transform_data_type(
+        &self,
+        dt: crate::expressions::DataType,
+    ) -> Result<Expression> {
         use crate::expressions::DataType;
         let transformed = match dt {
             // BOOLEAN -> BIT
@@ -669,12 +714,46 @@ impl TSQLDialect {
             DataType::Uuid => DataType::Custom {
                 name: "UNIQUEIDENTIFIER".to_string(),
             },
+            // Normalise custom type names that have PostgreSQL aliases
+            DataType::Custom { ref name } => {
+                let upper = name.trim().to_uppercase();
+                let (base_name, precision, _scale) = Self::parse_type_precision_and_scale(&upper);
+                match base_name.as_str() {
+                    // BPCHAR is PostgreSQL's blank-padded CHAR alias — map to CHAR
+                    "BPCHAR" => {
+                        if let Some(len) = precision {
+                            DataType::Char { length: Some(len) }
+                        } else {
+                            DataType::Char { length: None }
+                        }
+                    }
+                    _ => dt,
+                }
+            }
             // Keep all other types as-is
             other => other,
         };
         Ok(Expression::DataType(transformed))
     }
 
+    /// Parse a type name that may embed precision/scale: `"TYPENAME(n, m)"` → `("TYPENAME", Some(n), Some(m))`.
+    pub(super) fn parse_type_precision_and_scale(name: &str) -> (String, Option<u32>, Option<u32>) {
+        if let Some(paren_pos) = name.find('(') {
+            let base = name[..paren_pos].to_string();
+            let rest = &name[paren_pos + 1..];
+            if let Some(close_pos) = rest.find(')') {
+                let args = &rest[..close_pos];
+                let parts: Vec<&str> = args.split(',').map(|s| s.trim()).collect();
+                let precision = parts.first().and_then(|s| s.parse::<u32>().ok());
+                let scale = parts.get(1).and_then(|s| s.parse::<u32>().ok());
+                return (base, precision, scale);
+            }
+            (base, None, None)
+        } else {
+            (name.to_string(), None, None)
+        }
+    }
+
     fn transform_function(&self, f: Function) -> Result<Expression> {
         let name_upper = f.name.to_uppercase();
         match name_upper.as_str() {
@@ -1346,6 +1425,9 @@ mod tests {
             )
             .expect("transpile failed");
         let expected = r#"ISNULL(JSON_QUERY(REPLACE(REPLACE(x, '''', '"'), '""', '"'), '$'), JSON_VALUE(REPLACE(REPLACE(x, '''', '"'), '""', '"'), '$'))"#;
-        assert_eq!(result[0], expected, "JSON_QUERY should be wrapped with ISNULL");
+        assert_eq!(
+            result[0], expected,
+            "JSON_QUERY should be wrapped with ISNULL"
+        );
     }
 }

{polyglot_sql-0.3.3 → polyglot_sql-0.3.4}/crates/polyglot-sql/src/expressions.rs

@@ -7297,6 +7297,9 @@ pub struct CreateTable {
     /// Whether this is a SHALLOW CLONE (Databricks/Delta Lake)
     #[serde(default)]
     pub shallow_clone: bool,
+    /// Whether this is an explicit DEEP CLONE (Databricks/Delta Lake)
+    #[serde(default)]
+    pub deep_clone: bool,
     /// Leading comments before the statement
     #[serde(default)]
     pub leading_comments: Vec<String>,
@@ -7406,6 +7409,7 @@ impl CreateTable {
             clone_source: None,
             clone_at_clause: None,
             shallow_clone: false,
+            deep_clone: false,
             is_copy: false,
             leading_comments: Vec::new(),
             with_properties: Vec::new(),