polyglot-sql 0.3.10__tar.gz → 0.3.11__tar.gz

{polyglot_sql-0.3.10 → polyglot_sql-0.3.11}/Cargo.lock

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

{polyglot_sql-0.3.10 → polyglot_sql-0.3.11}/Cargo.toml

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

{polyglot_sql-0.3.10 → polyglot_sql-0.3.11}/PKG-INFO

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

{polyglot_sql-0.3.10 → polyglot_sql-0.3.11}/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.10", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.3.11", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.3.10 → polyglot_sql-0.3.11}/crates/polyglot-sql/src/dialects/fabric.rs

@@ -371,6 +371,7 @@ impl FabricDialect {
                 // Parse out precision and scale if present: "TYPENAME(n)" or "TYPENAME(n, m)"
                 let (base_name, precision, scale) =
                     TSQLDialect::parse_type_precision_and_scale(&upper);
+                let has_max_length = upper.contains("(MAX)");
 
                 match base_name.as_str() {
                     // DATETIME -> DATETIME2(6)
@@ -445,7 +446,11 @@ impl FabricDialect {
 
                     // NCHAR -> CHAR (with length preserved)
                     "NCHAR" => {
-                        if let Some(len) = precision {
+                        if has_max_length {
+                            DataType::Custom {
+                                name: "CHAR(MAX)".to_string(),
+                            }
+                        } else if let Some(len) = precision {
                             DataType::Custom {
                                 name: format!("CHAR({})", len),
                             }
@@ -458,7 +463,11 @@ impl FabricDialect {
 
                     // NVARCHAR -> VARCHAR (with length preserved)
                     "NVARCHAR" => {
-                        if let Some(len) = precision {
+                        if has_max_length {
+                            DataType::Custom {
+                                name: "VARCHAR(MAX)".to_string(),
+                            }
+                        } else if let Some(len) = precision {
                             DataType::Custom {
                                 name: format!("VARCHAR({})", len),
                             }

{polyglot_sql-0.3.10 → polyglot_sql-0.3.11}/crates/polyglot-sql/src/generator.rs

@@ -24029,6 +24029,12 @@ impl Generator {
             } => {
                 // Dialect-specific timestamp type mappings
                 match self.config.dialect {
+                    Some(DialectType::Snowflake) if *timezone => {
+                        self.write_keyword("TIMESTAMPTZ");
+                        if let Some(p) = precision {
+                            self.write(&format!("({})", p));
+                        }
+                    }
                     Some(DialectType::ClickHouse) => {
                         self.write("DateTime");
                         if let Some(p) = precision {
@@ -24597,6 +24603,52 @@ impl Generator {
                         // MySQL doesn't support TIMESTAMPTZ/TIMESTAMPLTZ, use TIMESTAMP
                         self.write_keyword("TIMESTAMP");
                     }
+                    Some(DialectType::Snowflake) => {
+                        let (base_upper, suffix) = if let Some(idx) = name.find('(') {
+                            (name_upper[..idx].to_string(), &name[idx..])
+                        } else {
+                            (name_upper.clone(), "")
+                        };
+
+                        match base_upper.as_str() {
+                            "TIMESTAMPNTZ" | "TIMESTAMP_NTZ" => {
+                                self.write_keyword("TIMESTAMPNTZ");
+                                self.write(suffix);
+                            }
+                            "TIMESTAMPLTZ" | "TIMESTAMP_LTZ" => {
+                                self.write_keyword("TIMESTAMPLTZ");
+                                self.write(suffix);
+                            }
+                            "TIMESTAMPTZ" | "TIMESTAMP_TZ" => {
+                                self.write_keyword("TIMESTAMPTZ");
+                                self.write(suffix);
+                            }
+                            _ => self.write(name),
+                        }
+                    }
+                    Some(DialectType::Fabric) => {
+                        let (base_upper, args_str) = if let Some(idx) = name.find('(') {
+                            (name_upper[..idx].to_string(), Some(&name[idx..]))
+                        } else {
+                            (name_upper.clone(), None)
+                        };
+
+                        match base_upper.as_str() {
+                            "NVARCHAR" => {
+                                self.write_keyword("VARCHAR");
+                                if let Some(args) = args_str {
+                                    self.write(args);
+                                }
+                            }
+                            "NCHAR" => {
+                                self.write_keyword("CHAR");
+                                if let Some(args) = args_str {
+                                    self.write(args);
+                                }
+                            }
+                            _ => self.write(name),
+                        }
+                    }
                     Some(DialectType::TSQL) if name_upper == "VARIANT" => {
                         self.write_keyword("SQL_VARIANT");
                     }

{polyglot_sql-0.3.10 → polyglot_sql-0.3.11}/crates/polyglot-sql/src/parser.rs

@@ -40661,6 +40661,7 @@ impl Parser {
                 DataType::Double { precision, scale }
             }
             "BPCHAR" | "CHARACTER" | "CHAR" | "NCHAR" => {
+                let is_nchar = name == "NCHAR";
                 // Handle CHARACTER VARYING / CHAR VARYING
                 if self.match_identifier("VARYING") {
                     let length = if self.match_token(TokenType::LParen) {
@@ -40670,9 +40671,18 @@ impl Parser {
                     } else {
                         None
                     };
-                    DataType::VarChar {
-                        length,
-                        parenthesized_length: false,
+                    if is_nchar {
+                        let name = if let Some(len) = length {
+                            format!("NVARCHAR({})", len)
+                        } else {
+                            "NVARCHAR".to_string()
+                        };
+                        DataType::Custom { name }
+                    } else {
+                        DataType::VarChar {
+                            length,
+                            parenthesized_length: false,
+                        }
                     }
                 } else {
                     let length = if self.match_token(TokenType::LParen) {
@@ -40690,7 +40700,16 @@ impl Parser {
                         let charset = self.expect_identifier_or_keyword()?;
                         return Ok(DataType::CharacterSet { name: charset });
                     }
-                    DataType::Char { length }
+                    if is_nchar {
+                        let name = if let Some(len) = length {
+                            format!("NCHAR({})", len)
+                        } else {
+                            "NCHAR".to_string()
+                        };
+                        DataType::Custom { name }
+                    } else {
+                        DataType::Char { length }
+                    }
                 }
             }
             "TIME" => {
@@ -40852,9 +40871,15 @@ impl Parser {
                 if self.match_token(TokenType::LParen) {
                     if self.check(TokenType::RParen) {
                         self.skip();
-                        DataType::VarChar {
-                            length: None,
-                            parenthesized_length: false,
+                        if is_nvarchar {
+                            DataType::Custom {
+                                name: "NVARCHAR".to_string(),
+                            }
+                        } else {
+                            DataType::VarChar {
+                                length: None,
+                                parenthesized_length: false,
+                            }
                         }
                     } else if self.check_identifier("MAX") {
                         self.skip();
@@ -40870,15 +40895,27 @@ impl Parser {
                     } else {
                         let n = self.expect_number()? as u32;
                         self.expect(TokenType::RParen)?;
-                        DataType::VarChar {
-                            length: Some(n),
-                            parenthesized_length: false,
+                        if is_nvarchar {
+                            DataType::Custom {
+                                name: format!("NVARCHAR({})", n),
+                            }
+                        } else {
+                            DataType::VarChar {
+                                length: Some(n),
+                                parenthesized_length: false,
+                            }
                         }
                     }
                 } else {
-                    DataType::VarChar {
-                        length: None,
-                        parenthesized_length: false,
+                    if is_nvarchar {
+                        DataType::Custom {
+                            name: "NVARCHAR".to_string(),
+                        }
+                    } else {
+                        DataType::VarChar {
+                            length: None,
+                            parenthesized_length: false,
+                        }
                     }
                 }
             }

{polyglot_sql-0.3.10 → polyglot_sql-0.3.11}/crates/polyglot-sql/tests/common/known_failures.rs

@@ -203,13 +203,12 @@ pub fn identity_known_failures() -> HashSet<String> {
     HashSet::new()
 }
 
-/// Load dialect identity test known failures
+/// Load dialect identity tests that should be skipped for now.
 pub fn dialect_identity_known_failures(_dialect: &str) -> HashSet<String> {
-    // Start with an empty set - failures will be added per dialect
     HashSet::new()
 }
 
-/// Load transpilation test known failures
+/// Load transpilation tests that should be skipped for now.
 pub fn transpilation_known_failures(_source: &str, _target: &str) -> HashSet<String> {
     HashSet::new()
 }

polyglot_sql-0.3.11/crates/polyglot-sql/tests/issue201_regression_test.rs

@@ -0,0 +1,38 @@
+use polyglot_sql::builder::{cast, col};
+use polyglot_sql::dialects::{Dialect, DialectType};
+use polyglot_sql::transpile;
+
+#[test]
+fn test_tsql_and_fabric_nvarchar_generation_differ_by_target() {
+    let expr = cast(col("x"), "NVARCHAR(MAX)").into_inner();
+
+    let tsql = Dialect::get(DialectType::TSQL).generate(&expr).unwrap();
+    assert_eq!(tsql, "CAST(x AS NVARCHAR(MAX))");
+
+    let fabric = Dialect::get(DialectType::Fabric).generate(&expr).unwrap();
+    assert_eq!(fabric, "CAST(x AS VARCHAR(MAX))");
+}
+
+#[test]
+fn test_tsql_preserves_nvarchar_in_cast_parsing() {
+    let result = transpile(
+        "SELECT CAST(x AS NVARCHAR(100))",
+        DialectType::TSQL,
+        DialectType::TSQL,
+    )
+    .unwrap();
+
+    assert_eq!(result[0], "SELECT CAST(x AS NVARCHAR(100))");
+}
+
+#[test]
+fn test_fabric_maps_nvarchar_to_supported_varchar() {
+    let result = transpile(
+        "SELECT CAST(x AS NVARCHAR(MAX))",
+        DialectType::Fabric,
+        DialectType::Fabric,
+    )
+    .unwrap();
+
+    assert_eq!(result[0], "SELECT CAST(x AS VARCHAR(MAX))");
+}

{polyglot_sql-0.3.10 → polyglot_sql-0.3.11}/crates/polyglot-sql/tests/snowflake_regression_test.rs

@@ -98,6 +98,32 @@ fn test_snowflake_timestamp_cast_roundtrip() {
     );
 }
 
+#[test]
+fn test_snowflake_timestamp_variant_casts_generate_sqlglot_aliases() {
+    let cases = [
+        (
+            "SELECT CAST(CURRENT_TIMESTAMP() AS TIMESTAMP_NTZ)",
+            "SELECT CAST(CURRENT_TIMESTAMP() AS TIMESTAMPNTZ)",
+        ),
+        (
+            "SELECT CAST(CURRENT_TIMESTAMP() AS TIMESTAMP_LTZ)",
+            "SELECT CAST(CURRENT_TIMESTAMP() AS TIMESTAMPLTZ)",
+        ),
+        (
+            "SELECT CAST(CURRENT_TIMESTAMP() AS TIMESTAMP_TZ)",
+            "SELECT CAST(CURRENT_TIMESTAMP() AS TIMESTAMPTZ)",
+        ),
+        (
+            "SELECT CURRENT_TIMESTAMP()::TIMESTAMP_NTZ",
+            "SELECT CAST(CURRENT_TIMESTAMP() AS TIMESTAMPNTZ)",
+        ),
+    ];
+
+    for (sql, expected) in cases {
+        assert_eq!(parse_and_generate(sql), expected);
+    }
+}
+
 // =====================================================================
 // Category 2: PUT file upload commands
 // =====================================================================

{polyglot_sql-0.3.10 → polyglot_sql-0.3.11}/crates/polyglot-sql/tests/sqlglot_dialect_identity.rs

@@ -109,6 +109,10 @@ fn run_dialect_identity_tests_impl(dialect_name: &str) -> TestResults {
 
     for (i, test) in fixture.identity.iter().enumerate() {
         let test_id = format!("{}:identity:{}", dialect_name, i);
+        if known.contains(&test_id) {
+            results.known_failures += 1;
+            continue;
+        }
         let result = dialect_identity_test(&test.sql, test.expected.as_deref(), dialect_type);
         results.record_with_sql(&test_id, &test.sql, i, result);
     }

{polyglot_sql-0.3.10 → polyglot_sql-0.3.11}/crates/polyglot-sql/tests/sqlglot_transpilation.rs

@@ -100,7 +100,6 @@ fn run_dialect_transpilation_tests(source_dialect: &str) -> TestResults {
 
             if known.contains(&test_id) {
                 results.known_failures += 1;
-                results.failed += 1;
                 continue;
             }
 

{polyglot_sql-0.3.10 → polyglot_sql-0.3.11}/crates/polyglot-sql-python/tests/test_transpile.py

@@ -33,6 +33,33 @@ def test_postgres_to_snowflake_cast_text():
     assert out == ["SELECT CAST(x AS VARCHAR) FROM t"]
 
 
+def test_tsql_identity_preserves_nvarchar():
+    out = polyglot_sql.transpile(
+        "SELECT CAST(x AS NVARCHAR(MAX))",
+        read="tsql",
+        write="tsql",
+    )
+    assert out == ["SELECT CAST(x AS NVARCHAR(MAX))"]
+
+
+def test_tsql_to_fabric_maps_nvarchar_to_varchar():
+    out = polyglot_sql.transpile(
+        "SELECT CAST(x AS NVARCHAR(MAX))",
+        read="tsql",
+        write="fabric",
+    )
+    assert out == ["SELECT CAST(x AS VARCHAR(MAX))"]
+
+
+def test_snowflake_timestamp_variant_names_match_sqlglot_aliases():
+    out = polyglot_sql.transpile(
+        "SELECT CURRENT_TIMESTAMP()::TIMESTAMPNTZ",
+        read="snowflake",
+        write="snowflake",
+    )
+    assert out == ["SELECT CAST(CURRENT_TIMESTAMP() AS TIMESTAMPNTZ)"]
+
+
 def test_multi_statement_transpile_returns_multiple_entries():
     out = polyglot_sql.transpile(
         "SELECT 1; SELECT 2",