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

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

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

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

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

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

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

{polyglot_sql-0.3.3 → polyglot_sql-0.3.5}/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.5", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.3.3 → polyglot_sql-0.3.5}/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.5}/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.5}/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.5}/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.5}/crates/polyglot-sql/src/dialects/mod.rs

@@ -158,10 +158,10 @@ 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};
+use crate::tokens::{Token, TokenType, Tokenizer, TokenizerConfig};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::{Arc, LazyLock, RwLock};
@@ -3750,6 +3750,11 @@ impl Dialect {
         pretty: bool,
     ) -> Result<Vec<String>> {
         let target = target_dialect.dialect_type;
+        if matches!(self.dialect_type, DialectType::PostgreSQL)
+            && matches!(target, DialectType::SQLite)
+        {
+            self.reject_pgvector_distance_operators_for_sqlite(sql)?;
+        }
         let expressions = self.parse(sql)?;
         let generic_identity =
             self.dialect_type == DialectType::Generic && target == DialectType::Generic;
@@ -4063,6 +4068,14 @@ impl Dialect {
                 let normalized =
                     Self::cross_dialect_normalize(normalized, self.dialect_type, target)?;
 
+                let normalized = if matches!(self.dialect_type, DialectType::PostgreSQL)
+                    && matches!(target, DialectType::SQLite)
+                {
+                    Self::normalize_postgres_to_sqlite_types(normalized)?
+                } else {
+                    normalized
+                };
+
                 // For DuckDB target from BigQuery source: wrap UNNEST of struct arrays in
                 // (SELECT UNNEST(..., max_depth => 2)) subquery
                 // Must run BEFORE unnest_alias_to_column_alias since it changes alias structure
@@ -4222,6 +4235,77 @@ impl Dialect {
 // Transpile-only methods: cross-dialect normalization and helpers
 #[cfg(feature = "transpile")]
 impl Dialect {
+    fn reject_pgvector_distance_operators_for_sqlite(&self, sql: &str) -> Result<()> {
+        let tokens = self.tokenize(sql)?;
+        for (i, token) in tokens.iter().enumerate() {
+            if token.token_type == TokenType::NullsafeEq {
+                return Err(crate::error::Error::unsupported(
+                    "PostgreSQL pgvector cosine distance operator <=>",
+                    "SQLite",
+                ));
+            }
+            if token.token_type == TokenType::Lt
+                && tokens
+                    .get(i + 1)
+                    .is_some_and(|token| token.token_type == TokenType::Tilde)
+                && tokens
+                    .get(i + 2)
+                    .is_some_and(|token| token.token_type == TokenType::Gt)
+            {
+                return Err(crate::error::Error::unsupported(
+                    "PostgreSQL pgvector Hamming distance operator <~>",
+                    "SQLite",
+                ));
+            }
+        }
+        Ok(())
+    }
+
+    fn normalize_postgres_to_sqlite_types(expr: Expression) -> Result<Expression> {
+        fn sqlite_type(dt: crate::expressions::DataType) -> crate::expressions::DataType {
+            use crate::expressions::DataType;
+
+            match dt {
+                DataType::Bit { .. } => DataType::Int {
+                    length: None,
+                    integer_spelling: true,
+                },
+                DataType::TextWithLength { .. } => DataType::Text,
+                DataType::VarChar { .. } => DataType::Text,
+                DataType::Char { .. } => DataType::Text,
+                DataType::Timestamp { timezone: true, .. } => DataType::Text,
+                DataType::Custom { name } => {
+                    let base = name
+                        .split_once('(')
+                        .map_or(name.as_str(), |(base, _)| base)
+                        .trim();
+                    if base.eq_ignore_ascii_case("TSVECTOR")
+                        || base.eq_ignore_ascii_case("TIMESTAMPTZ")
+                        || base.eq_ignore_ascii_case("TIMESTAMP WITH TIME ZONE")
+                        || base.eq_ignore_ascii_case("NVARCHAR")
+                        || base.eq_ignore_ascii_case("NCHAR")
+                    {
+                        DataType::Text
+                    } else {
+                        DataType::Custom { name }
+                    }
+                }
+                _ => dt,
+            }
+        }
+
+        transform_recursive(expr, &|e| match e {
+            Expression::DataType(dt) => Ok(Expression::DataType(sqlite_type(dt))),
+            Expression::CreateTable(mut ct) => {
+                for column in &mut ct.columns {
+                    column.data_type = sqlite_type(column.data_type.clone());
+                }
+                Ok(Expression::CreateTable(ct))
+            }
+            _ => Ok(e),
+        })
+    }
+
     /// For DuckDB target: when FROM clause contains RANGE(n), replace
     /// `(ROW_NUMBER() OVER (ORDER BY 1 NULLS FIRST) - 1)` with `range` in select expressions.
     /// This handles SEQ1/2/4/8 → RANGE transpilation from Snowflake.
@@ -9067,6 +9151,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 +31410,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 +31987,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 +32011,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 +38136,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.5}/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.5}/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.5}/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