polyglot-sql 0.5.13__tar.gz → 0.5.15__tar.gz

{polyglot_sql-0.5.13 → polyglot_sql-0.5.15}/Cargo.lock

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

{polyglot_sql-0.5.13 → polyglot_sql-0.5.15}/Cargo.toml

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

{polyglot_sql-0.5.13 → polyglot_sql-0.5.15}/PKG-INFO

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

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

{polyglot_sql-0.5.13 → polyglot_sql-0.5.15}/crates/polyglot-sql/src/dialects/fabric.rs

@@ -48,6 +48,8 @@ impl DialectImpl for FabricDialect {
             null_ordering_supported: false,
             aggregate_filter_supported: false,
             cte_recursive_keyword_required: false,
+            ensure_bools: true,
+            except_intersect_support_all_clause: false,
             ..Default::default()
         }
     }

{polyglot_sql-0.5.13 → polyglot_sql-0.5.15}/crates/polyglot-sql/src/dialects/mod.rs

@@ -4185,6 +4185,7 @@ impl Dialect {
             feature = "dialect-starrocks",
             feature = "dialect-oracle",
             feature = "dialect-clickhouse",
+            feature = "dialect-fabric",
         ))]
         use crate::transforms;
 
@@ -4258,6 +4259,16 @@ impl Dialect {
                 let expr = transforms::qualify_derived_table_outputs(expr)?;
                 Ok(expr)
             }
+            // Fabric shares T-SQL predicate rules: BIT values cannot be used as
+            // bare conditions in WHERE/HAVING/ON/CASE WHEN contexts. Keep this
+            // branch scoped to boolean coercion so Fabric-specific APPLY and
+            // derived-table output behavior does not inherit unrelated T-SQL
+            // preprocessing.
+            #[cfg(feature = "dialect-fabric")]
+            DialectType::Fabric => {
+                let expr = transforms::ensure_bools(expr)?;
+                Ok(expr)
+            }
             // Spark doesn't support QUALIFY (but Databricks does)
             // Spark doesn't support CTEs in subqueries (hoist to top level)
             #[cfg(feature = "dialect-spark")]
@@ -5003,6 +5014,15 @@ impl Dialect {
                 if Self::node_is_function_named(node, "TO_TSVECTOR") {
                     Self::push_unsupported_diagnostic(&mut diagnostics, "PostgreSQL TO_TSVECTOR");
                 }
+                if matches!(target, DialectType::TSQL | DialectType::Fabric) {
+                    if let Some(function_name) = Self::postgres_tsql_unsupported_function_name(node)
+                    {
+                        Self::push_unsupported_diagnostic(
+                            &mut diagnostics,
+                            &format!("PostgreSQL {function_name}"),
+                        );
+                    }
+                }
                 if matches!(target, DialectType::TSQL | DialectType::Fabric)
                     && Self::node_is_postgres_type_function_cast(node)
                 {
@@ -5183,6 +5203,46 @@ impl Dialect {
         }
     }
 
+    fn postgres_tsql_unsupported_function_name(expr: &Expression) -> Option<&'static str> {
+        match expr {
+            Expression::Lpad(_) => Some("LPAD"),
+            Expression::Rpad(_) => Some("RPAD"),
+            Expression::SplitPart(_) => Some("SPLIT_PART"),
+            Expression::Initcap(_) => Some("INITCAP"),
+            Expression::ToJson(_) => Some("TO_JSON"),
+            Expression::JSONBObjectAgg(_) => Some("JSONB_OBJECT_AGG"),
+            Expression::Function(function) => {
+                Self::postgres_tsql_unsupported_function_name_str(&function.name)
+            }
+            Expression::AggregateFunction(function) => {
+                Self::postgres_tsql_unsupported_function_name_str(&function.name)
+            }
+            _ => None,
+        }
+    }
+
+    fn postgres_tsql_unsupported_function_name_str(name: &str) -> Option<&'static str> {
+        if name.eq_ignore_ascii_case("LPAD") {
+            Some("LPAD")
+        } else if name.eq_ignore_ascii_case("RPAD") {
+            Some("RPAD")
+        } else if name.eq_ignore_ascii_case("SPLIT_PART") {
+            Some("SPLIT_PART")
+        } else if name.eq_ignore_ascii_case("INITCAP") {
+            Some("INITCAP")
+        } else if name.eq_ignore_ascii_case("TO_JSON") {
+            Some("TO_JSON")
+        } else if name.eq_ignore_ascii_case("TO_JSONB") {
+            Some("TO_JSONB")
+        } else if name.eq_ignore_ascii_case("JSONB_AGG") {
+            Some("JSONB_AGG")
+        } else if name.eq_ignore_ascii_case("JSONB_OBJECT_AGG") {
+            Some("JSONB_OBJECT_AGG")
+        } else {
+            None
+        }
+    }
+
     fn normalize_postgres_type_function_casts(expr: Expression) -> Result<Expression> {
         transform_recursive(expr, &|e| match e {
             Expression::Function(function) => {
@@ -5689,21 +5749,22 @@ impl Dialect {
     }
 
     fn tsql_boolean_value_case(predicate: Expression) -> Expression {
-        Expression::Case(Box::new(crate::expressions::Case {
+        let case = Expression::Case(Box::new(crate::expressions::Case {
             operand: None,
-            whens: vec![
-                (predicate.clone(), Expression::number(1)),
-                (
-                    Expression::Not(Box::new(crate::expressions::UnaryOp {
-                        this: predicate,
-                        inferred_type: None,
-                    })),
-                    Expression::number(0),
-                ),
-            ],
-            else_: None,
+            whens: vec![(predicate, Expression::number(1))],
+            else_: Some(Expression::number(0)),
             comments: Vec::new(),
             inferred_type: None,
+        }));
+
+        Expression::Cast(Box::new(Cast {
+            this: case,
+            to: DataType::Boolean,
+            trailing_comments: Vec::new(),
+            double_colon_syntax: false,
+            format: None,
+            default: None,
+            inferred_type: None,
         }))
     }
 

{polyglot_sql-0.5.13 → polyglot_sql-0.5.15}/crates/polyglot-sql/src/dialects/tsql.rs

@@ -194,66 +194,11 @@ impl DialectImpl for TSQLDialect {
             // ===== Data Type Mappings =====
             Expression::DataType(dt) => self.transform_data_type(dt),
 
-            // ===== Boolean IS TRUE/FALSE -> = 1/0 for TSQL =====
-            // TSQL doesn't have IS TRUE/IS FALSE syntax
-            Expression::IsTrue(it) => {
-                let one = Expression::Literal(Box::new(crate::expressions::Literal::Number(
-                    "1".to_string(),
-                )));
-                if it.not {
-                    // a IS NOT TRUE -> NOT a = 1
-                    Ok(Expression::Not(Box::new(crate::expressions::UnaryOp {
-                        this: Expression::Eq(Box::new(crate::expressions::BinaryOp {
-                            left: it.this,
-                            right: one,
-                            left_comments: vec![],
-                            operator_comments: vec![],
-                            trailing_comments: vec![],
-                            inferred_type: None,
-                        })),
-                        inferred_type: None,
-                    })))
-                } else {
-                    // a IS TRUE -> a = 1
-                    Ok(Expression::Eq(Box::new(crate::expressions::BinaryOp {
-                        left: it.this,
-                        right: one,
-                        left_comments: vec![],
-                        operator_comments: vec![],
-                        trailing_comments: vec![],
-                        inferred_type: None,
-                    })))
-                }
-            }
-            Expression::IsFalse(it) => {
-                let zero = Expression::Literal(Box::new(crate::expressions::Literal::Number(
-                    "0".to_string(),
-                )));
-                if it.not {
-                    // a IS NOT FALSE -> NOT a = 0
-                    Ok(Expression::Not(Box::new(crate::expressions::UnaryOp {
-                        this: Expression::Eq(Box::new(crate::expressions::BinaryOp {
-                            left: it.this,
-                            right: zero,
-                            left_comments: vec![],
-                            operator_comments: vec![],
-                            trailing_comments: vec![],
-                            inferred_type: None,
-                        })),
-                        inferred_type: None,
-                    })))
-                } else {
-                    // a IS FALSE -> a = 0
-                    Ok(Expression::Eq(Box::new(crate::expressions::BinaryOp {
-                        left: it.this,
-                        right: zero,
-                        left_comments: vec![],
-                        operator_comments: vec![],
-                        trailing_comments: vec![],
-                        inferred_type: None,
-                    })))
-                }
-            }
+            // ===== Boolean IS TRUE/FALSE -> T-SQL 3VL truth table =====
+            // T-SQL doesn't have IS TRUE/IS FALSE syntax. Negated forms must
+            // explicitly preserve UNKNOWN/NULL rows instead of using NOT (x = n).
+            Expression::IsTrue(it) => Ok(Self::boolean_test_predicate(it.this, true, it.not)),
+            Expression::IsFalse(it) => Ok(Self::boolean_test_predicate(it.this, false, it.not)),
 
             // Note: CASE WHEN boolean conditions are handled in ensure_bools preprocessing
 
@@ -684,6 +629,138 @@ impl DialectImpl for TSQLDialect {
 
 #[cfg(feature = "transpile")]
 impl TSQLDialect {
+    fn binary(
+        left: Expression,
+        right: Expression,
+        op: fn(Box<BinaryOp>) -> Expression,
+    ) -> Expression {
+        op(Box::new(BinaryOp {
+            left,
+            right,
+            left_comments: Vec::new(),
+            operator_comments: Vec::new(),
+            trailing_comments: Vec::new(),
+            inferred_type: None,
+        }))
+    }
+
+    fn eq(left: Expression, right: Expression) -> Expression {
+        Self::binary(left, right, Expression::Eq)
+    }
+
+    fn or(left: Expression, right: Expression) -> Expression {
+        Self::binary(left, right, Expression::Or)
+    }
+
+    fn not(this: Expression) -> Expression {
+        Expression::Not(Box::new(crate::expressions::UnaryOp {
+            this,
+            inferred_type: None,
+        }))
+    }
+
+    fn is_null(this: Expression) -> Expression {
+        Expression::IsNull(Box::new(crate::expressions::IsNull {
+            this,
+            not: false,
+            postfix_form: false,
+        }))
+    }
+
+    fn boolean_test_case_for_predicate(
+        predicate: Expression,
+        test_true: bool,
+        negated: bool,
+    ) -> Expression {
+        let condition = match (test_true, negated) {
+            (true, false) => predicate,
+            (false, false) => Self::not(predicate),
+            (true, true) => {
+                return Expression::Case(Box::new(crate::expressions::Case {
+                    operand: None,
+                    whens: vec![(predicate, Expression::number(0))],
+                    else_: Some(Expression::number(1)),
+                    comments: Vec::new(),
+                    inferred_type: None,
+                }))
+            }
+            (false, true) => {
+                return Expression::Case(Box::new(crate::expressions::Case {
+                    operand: None,
+                    whens: vec![(Self::not(predicate), Expression::number(0))],
+                    else_: Some(Expression::number(1)),
+                    comments: Vec::new(),
+                    inferred_type: None,
+                }))
+            }
+        };
+
+        Expression::Case(Box::new(crate::expressions::Case {
+            operand: None,
+            whens: vec![(condition, Expression::number(1))],
+            else_: Some(Expression::number(0)),
+            comments: Vec::new(),
+            inferred_type: None,
+        }))
+    }
+
+    fn boolean_test_predicate(operand: Expression, test_true: bool, negated: bool) -> Expression {
+        if Self::is_boolean_predicate_operand(&operand) {
+            return match (test_true, negated) {
+                (true, false) => operand,
+                (false, false) => Self::not(operand),
+                _ => Self::eq(
+                    Self::boolean_test_case_for_predicate(operand, test_true, negated),
+                    Expression::number(1),
+                ),
+            };
+        }
+
+        match (test_true, negated) {
+            (true, false) => Self::eq(operand, Expression::number(1)),
+            (false, false) => Self::eq(operand, Expression::number(0)),
+            (true, true) => Self::or(
+                Self::eq(operand.clone(), Expression::number(0)),
+                Self::is_null(operand),
+            ),
+            (false, true) => Self::or(
+                Self::eq(operand.clone(), Expression::number(1)),
+                Self::is_null(operand),
+            ),
+        }
+    }
+
+    fn is_boolean_predicate_operand(expr: &Expression) -> bool {
+        match expr {
+            Expression::Paren(paren) => Self::is_boolean_predicate_operand(&paren.this),
+            Expression::Eq(_)
+            | Expression::Neq(_)
+            | Expression::Lt(_)
+            | Expression::Lte(_)
+            | Expression::Gt(_)
+            | Expression::Gte(_)
+            | Expression::Is(_)
+            | Expression::IsNull(_)
+            | Expression::IsTrue(_)
+            | Expression::IsFalse(_)
+            | Expression::Like(_)
+            | Expression::ILike(_)
+            | Expression::SimilarTo(_)
+            | Expression::Glob(_)
+            | Expression::RegexpLike(_)
+            | Expression::In(_)
+            | Expression::Between(_)
+            | Expression::Exists(_)
+            | Expression::And(_)
+            | Expression::Or(_)
+            | Expression::Not(_)
+            | Expression::Any(_)
+            | Expression::All(_)
+            | Expression::EqualNull(_) => true,
+            _ => false,
+        }
+    }
+
     fn scalar_array_comparison_values(expr: &Expression) -> Option<Vec<Expression>> {
         let (mut values, element_type) = Self::scalar_array_comparison_values_inner(expr)?;
         if let Some(to) = element_type {