polyglot-sql 0.5.4__tar.gz → 0.5.5__tar.gz

{polyglot_sql-0.5.4 → polyglot_sql-0.5.5}/Cargo.lock

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

{polyglot_sql-0.5.4 → polyglot_sql-0.5.5}/Cargo.toml

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

{polyglot_sql-0.5.4 → polyglot_sql-0.5.5}/PKG-INFO

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

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

{polyglot_sql-0.5.4 → polyglot_sql-0.5.5}/crates/polyglot-sql/src/dialects/tsql.rs

@@ -36,6 +36,8 @@ impl DialectImpl for TSQLDialect {
         config.identifiers.insert('[', ']');
         // SQL Server also supports double quotes (when QUOTED_IDENTIFIER is ON)
         config.identifiers.insert('"', '"');
+        // SQL Server uses 0x-prefixed binary/varbinary hex literals.
+        config.hex_number_strings = true;
         config
     }
 

{polyglot_sql-0.5.4 → polyglot_sql-0.5.5}/crates/polyglot-sql/src/generator.rs

@@ -14733,8 +14733,13 @@ impl Generator {
                 }
             }
             Literal::HexString(h) => {
-                // Most dialects use lowercase x'...' for hex literals; Spark/Databricks/Teradata use uppercase X'...'
+                // Most dialects use lowercase x'...' for hex literals.
                 match self.config.dialect {
+                    Some(DialectType::TSQL) | Some(DialectType::Fabric) => {
+                        self.write("0x");
+                        self.write(h);
+                        return Ok(());
+                    }
                     Some(DialectType::Spark)
                     | Some(DialectType::Databricks)
                     | Some(DialectType::Teradata) => self.write("X'"),

{polyglot_sql-0.5.4 → polyglot_sql-0.5.5}/crates/polyglot-sql/src/query_analysis.rs

@@ -775,6 +775,23 @@ fn transform_function_fact(
     expression: &Expression,
     scope: &Scope,
     dialect: DialectType,
+) -> Option<TransformFunctionFact> {
+    let mut matches = expression
+        .find_all(|candidate| transform_function_fact_for_node(candidate, scope, dialect).is_some())
+        .into_iter();
+
+    let first = matches.next()?;
+    if matches.next().is_some() {
+        return None;
+    }
+
+    transform_function_fact_for_node(first, scope, dialect)
+}
+
+fn transform_function_fact_for_node(
+    expression: &Expression,
+    scope: &Scope,
+    dialect: DialectType,
 ) -> Option<TransformFunctionFact> {
     match expression {
         Expression::Function(function) => Some(transform_function_from_args(
@@ -789,9 +806,6 @@ fn transform_function_fact(
             scope,
             dialect,
         )),
-        Expression::WindowFunction(function) => {
-            transform_function_fact(&function.this, scope, dialect)
-        }
         Expression::DateTrunc(function) => Some(transform_function_from_parts(
             "DATE_TRUNC",
             vec![datetime_field_name(&function.unit)],

polyglot_sql-0.5.5/crates/polyglot-sql/tests/query_analysis_regression.rs

@@ -0,0 +1,79 @@
+use polyglot_sql::{analyze_query, AnalyzeQueryOptions, DialectType, TransformKind};
+
+fn first_projection(sql: &str) -> polyglot_sql::ProjectionFact {
+    let analysis = analyze_query(
+        sql,
+        AnalyzeQueryOptions {
+            dialect: DialectType::DuckDB,
+            ..Default::default()
+        },
+    )
+    .unwrap_or_else(|error| panic!("analyze_query failed for {sql:?}: {error}"));
+
+    analysis
+        .projections
+        .into_iter()
+        .next()
+        .expect("expected one projection")
+}
+
+#[test]
+fn analyze_query_reports_top_level_transform_function() {
+    let projection = first_projection("SELECT DATE_TRUNC('month', created_at) AS m FROM orders");
+
+    let transform = projection
+        .transform_function
+        .expect("DATE_TRUNC should be reported");
+    assert_eq!(projection.transform_kind, TransformKind::Expression);
+    assert_eq!(transform.name, "DATE_TRUNC");
+    assert_eq!(transform.literal_args, vec!["month"]);
+    assert_eq!(transform.column_args.len(), 1);
+    assert_eq!(transform.column_args[0].table.as_deref(), Some("orders"));
+    assert_eq!(transform.column_args[0].column, "created_at");
+}
+
+#[test]
+fn analyze_query_reports_transform_function_wrapped_in_coalesce() {
+    let projection = first_projection(
+        "SELECT COALESCE(DATE_TRUNC('month', created_at), DATE '1970-01-01') AS m FROM orders",
+    );
+
+    let transform = projection
+        .transform_function
+        .expect("nested DATE_TRUNC should be reported");
+    assert_eq!(projection.transform_kind, TransformKind::Expression);
+    assert_eq!(transform.name, "DATE_TRUNC");
+    assert_eq!(transform.literal_args, vec!["month"]);
+    assert_eq!(transform.column_args.len(), 1);
+    assert_eq!(transform.column_args[0].table.as_deref(), Some("orders"));
+    assert_eq!(transform.column_args[0].column, "created_at");
+}
+
+#[test]
+fn analyze_query_reports_transform_function_wrapped_in_cast() {
+    let projection =
+        first_projection("SELECT CAST(DATE_TRUNC('day', created_at) AS DATE) AS d FROM orders");
+
+    let transform = projection
+        .transform_function
+        .expect("nested DATE_TRUNC should be reported");
+    assert_eq!(projection.transform_kind, TransformKind::Cast);
+    assert_eq!(projection.cast_type.as_deref(), Some("DATE"));
+    assert_eq!(transform.name, "DATE_TRUNC");
+    assert_eq!(transform.literal_args, vec!["day"]);
+    assert_eq!(transform.column_args.len(), 1);
+    assert_eq!(transform.column_args[0].table.as_deref(), Some("orders"));
+    assert_eq!(transform.column_args[0].column, "created_at");
+}
+
+#[test]
+fn analyze_query_omits_ambiguous_nested_transform_functions() {
+    let projection = first_projection(
+        "SELECT COALESCE(DATE_TRUNC('month', created_at), DATE_TRUNC('day', updated_at)) AS m FROM orders",
+    );
+
+    assert!(
+        projection.transform_function.is_none(),
+        "multiple transform function candidates should remain ambiguous"
+    );
+}

{polyglot_sql-0.5.4 → polyglot_sql-0.5.5}/crates/polyglot-sql/tests/tsql_regression.rs

@@ -2,7 +2,8 @@
 
 use polyglot_sql::generator::{Generator, GeneratorConfig};
 use polyglot_sql::{
-    get_all_tables, parse, transpile, validate, DialectType, Expression, ExpressionWalk, Parser,
+    get_all_tables, parse, transpile, validate, Dialect, DialectType, Expression, ExpressionWalk,
+    Parser, TokenType,
 };
 
 fn pg_to_tsql(sql: &str) -> String {
@@ -32,6 +33,45 @@ BEGIN CATCH
     INSERT INTO error_log (msg) VALUES (ERROR_MESSAGE());
 END CATCH"#;
 
+// ---------------------------------------------------------------------------
+// T-SQL hex literals
+// ---------------------------------------------------------------------------
+
+#[test]
+fn tsql_hex_literals_tokenize_as_hex_strings() {
+    let dialect = Dialect::get(DialectType::TSQL);
+    let tokens = dialect
+        .tokenize("SELECT * FROM Employees WHERE EmployeeId = 0x1")
+        .expect("T-SQL hex literal should tokenize");
+
+    let hex = tokens
+        .iter()
+        .find(|token| token.token_type == TokenType::HexString)
+        .expect("expected a HexString token for 0x1");
+
+    assert_eq!(hex.text, "1");
+}
+
+#[test]
+fn tsql_hex_literals_parse_and_roundtrip() {
+    for sql in [
+        "SELECT * FROM Employees WHERE EmployeeId = 0x1",
+        "INSERT INTO t (bin) VALUES (0xFF)",
+        "SELECT 0xCAFE + 1",
+    ] {
+        let ast = parse(sql, DialectType::TSQL)
+            .unwrap_or_else(|error| panic!("T-SQL hex literal should parse for {sql:?}: {error}"));
+        assert_eq!(ast.len(), 1);
+        assert_eq!(generate_tsql(&ast[0]), sql);
+
+        let roundtrip =
+            transpile(sql, DialectType::TSQL, DialectType::TSQL).unwrap_or_else(|error| {
+                panic!("T-SQL hex literal should transpile for {sql:?}: {error}")
+            });
+        assert_eq!(roundtrip, vec![sql.to_string()]);
+    }
+}
+
 // ---------------------------------------------------------------------------
 // T-SQL SET options
 // ---------------------------------------------------------------------------