polyglot-sql 0.5.10__tar.gz → 0.5.11__tar.gz

{polyglot_sql-0.5.10 → polyglot_sql-0.5.11}/Cargo.lock

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

{polyglot_sql-0.5.10 → polyglot_sql-0.5.11}/Cargo.toml

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

{polyglot_sql-0.5.10 → polyglot_sql-0.5.11}/PKG-INFO

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

{polyglot_sql-0.5.10 → polyglot_sql-0.5.11}/crates/polyglot-sql/Cargo.toml

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

{polyglot_sql-0.5.10 → polyglot_sql-0.5.11}/crates/polyglot-sql/src/dialects/mod.rs

@@ -4879,6 +4879,15 @@ impl Dialect {
                 Self::push_unsupported_diagnostic(&mut diagnostics, "ARRAY_AGG");
             }
 
+            if matches!(target, DialectType::TSQL | DialectType::Fabric)
+                && Self::node_is_regex_predicate(node)
+            {
+                Self::push_unsupported_diagnostic(
+                    &mut diagnostics,
+                    "regular expression predicates",
+                );
+            }
+
             if matches!(source, DialectType::PostgreSQL | DialectType::CockroachDB)
                 && !matches!(target, DialectType::PostgreSQL | DialectType::CockroachDB)
             {
@@ -5018,6 +5027,15 @@ impl Dialect {
         matches!(expr, Expression::ArrayAgg(_)) || Self::node_is_function_named(expr, "ARRAY_AGG")
     }
 
+    fn node_is_regex_predicate(expr: &Expression) -> bool {
+        matches!(
+            expr,
+            Expression::SimilarTo(_) | Expression::RegexpLike(_) | Expression::RegexpILike(_)
+        ) || Self::node_is_function_named(expr, "REGEXP_LIKE")
+            || Self::node_is_function_named(expr, "REGEXP_I_LIKE")
+            || Self::node_is_function_named(expr, "REGEXP_ILIKE")
+    }
+
     fn node_is_function_named(expr: &Expression, name: &str) -> bool {
         match expr {
             Expression::Function(function) => function.name.eq_ignore_ascii_case(name),

{polyglot_sql-0.5.10 → polyglot_sql-0.5.11}/crates/polyglot-sql/src/generator.rs

@@ -17924,7 +17924,7 @@ impl Generator {
         {
             self.write_keyword("DATEPART");
             self.write("(");
-            self.generate_expression(&func.args[0])?;
+            self.write_tsql_date_part(&func.args[0])?;
             self.write(", ");
             self.generate_expression(&func.args[1])?;
             self.write(")");
@@ -18888,6 +18888,22 @@ impl Generator {
         }
     }
 
+    fn write_tsql_date_part(&mut self, expr: &Expression) -> Result<()> {
+        if let Some(part) = self.extract_date_part_string(expr) {
+            let upper = part.to_ascii_uppercase();
+            let unmapped = match upper.as_str() {
+                "DAYOFWEEK" => "WEEKDAY",
+                "WEEKISO" => "ISO_WEEK",
+                "TIMEZONE_MINUTE" => "TZOFFSET",
+                _ => part.as_str(),
+            };
+            self.write_keyword(unmapped);
+        } else {
+            self.generate_expression(expr)?;
+        }
+        Ok(())
+    }
+
     /// Extract date part string from expression (handles string literals and identifiers)
     fn extract_date_part_string(&self, expr: &Expression) -> Option<String> {
         match expr {

{polyglot_sql-0.5.10 → polyglot_sql-0.5.11}/crates/polyglot-sql/tests/issue227_strict_unsupported.rs

@@ -138,6 +138,31 @@ fn strict_transpile_rejects_array_agg_for_lossy_targets() {
     assert!(err.to_string().contains("ARRAY_AGG"));
 }
 
+#[test]
+fn strict_transpile_rejects_regex_predicates_for_tsql_targets() {
+    let sqls = [
+        "SELECT 1 FROM t WHERE p_brand SIMILAR TO 'Brand#[1-3][0-9]'",
+        "SELECT 1 FROM t WHERE c_phone ~ '^1[0-9]'",
+        "SELECT 1 FROM t WHERE c_phone !~ '^1[0-9]'",
+        "SELECT 1 FROM t WHERE c_phone ~* '^1[0-9]'",
+        "SELECT 1 FROM t WHERE c_phone !~* '^1[0-9]'",
+        "SELECT 1 FROM t WHERE REGEXP_LIKE(c_phone, '^1[0-9]')",
+    ];
+
+    for sql in sqls {
+        for write in [DialectType::Fabric, DialectType::TSQL] {
+            let err =
+                transpile_with_level(sql, DialectType::PostgreSQL, write, UnsupportedLevel::Raise)
+                    .expect_err("strict TSQL/Fabric transpile should reject regex predicates");
+
+            assert!(
+                err.to_string().contains("regular expression predicates"),
+                "unexpected error for PostgreSQL -> {write:?}: {err}"
+            );
+        }
+    }
+}
+
 #[test]
 fn strict_transpile_rejects_postgres_only_functions() {
     let err = transpile_with_level(

{polyglot_sql-0.5.10 → polyglot_sql-0.5.11}/crates/polyglot-sql/tests/tsql_regression.rs

@@ -2,8 +2,8 @@
 
 use polyglot_sql::generator::{Generator, GeneratorConfig};
 use polyglot_sql::{
-    get_all_tables, parse, transpile, validate, Dialect, DialectType, Expression, ExpressionWalk,
-    Parser, TokenType,
+    generate, get_all_tables, parse, transpile, validate, Dialect, DialectType, Expression,
+    ExpressionWalk, Parser, TokenType,
 };
 
 fn pg_to_tsql(sql: &str) -> String {
@@ -72,6 +72,51 @@ fn tsql_hex_literals_parse_and_roundtrip() {
     }
 }
 
+#[test]
+fn tsql_datepart_dayofweek_generates_valid_tsql_datepart() {
+    let cases = [
+        ("WEEKDAY", "WEEKDAY"),
+        ("dw", "WEEKDAY"),
+        ("DAYOFWEEK", "WEEKDAY"),
+        ("isowk", "ISO_WEEK"),
+        ("WEEKISO", "ISO_WEEK"),
+        ("tz", "TZOFFSET"),
+        ("TIMEZONE_MINUTE", "TZOFFSET"),
+    ];
+
+    for dialect in [DialectType::TSQL, DialectType::Fabric] {
+        for (input, expected) in cases {
+            let sql = format!("SELECT DATEPART({input}, o.order_date) AS dow FROM orders o");
+            let ast = parse(&sql, dialect)
+                .unwrap_or_else(|error| panic!("{dialect:?} DATEPART should parse: {error}"));
+            assert_eq!(ast.len(), 1);
+
+            let generated = generate(&ast[0], dialect)
+                .unwrap_or_else(|error| panic!("{dialect:?} DATEPART should generate: {error}"));
+
+            assert_eq!(
+                generated,
+                format!("SELECT DATEPART({expected}, o.order_date) AS dow FROM orders AS o"),
+                "failed for {dialect:?} DATEPART({input}, ...)"
+            );
+        }
+    }
+}
+
+#[test]
+fn tsql_datepart_dayofweek_transpiles_to_valid_tsql_datepart() {
+    let sql = "SELECT DATEPART(WEEKDAY, o.order_date) AS dow FROM orders o";
+
+    assert_eq!(
+        transpile(sql, DialectType::TSQL, DialectType::TSQL).expect("TSQL identity transpile"),
+        vec!["SELECT DATEPART(WEEKDAY, o.order_date) AS dow FROM orders AS o"]
+    );
+    assert_eq!(
+        transpile(sql, DialectType::TSQL, DialectType::Fabric).expect("TSQL to Fabric transpile"),
+        vec!["SELECT DATEPART(WEEKDAY, o.order_date) AS dow FROM orders AS o"]
+    );
+}
+
 // ---------------------------------------------------------------------------
 // T-SQL SET options
 // ---------------------------------------------------------------------------