fix(generator): wrap bare boolean in T-SQL condition position as = 1 (CR-018)

SQL Server has no native boolean type, so a bare boolean expression in a
search-condition position (WHERE/HAVING/QUALIFY, JOIN ON, searched CASE
WHEN, UPDATE/DELETE WHERE, MERGE AND, and AND/OR/NOT operands) is rejected
with error 4145. Add a recursive gen_condition helper that, for the T-SQL
family only, wraps a bare boolean as '<expr> = 1', lowers bare TRUE/FALSE
to '1 = 1'/'1 = 0', recurses through logical connectives, and leaves
existing predicates untouched. Simple CASE (CASE <operand> WHEN <value>)
WHEN values are not conditions and are left alone. Non-T-SQL output is
unchanged.

Author: yigalrozenberg

src/generator/sql_generator.rs

@@ -331,11 +331,11 @@ impl Generator {
             if self.pretty {
                 self.indent_up();
                 self.newline();
-                self.gen_expr(wh);
+                self.gen_condition(wh);
                 self.indent_down();
             } else {
                 self.write(" ");
-                self.gen_expr(wh);
+                self.gen_condition(wh);
             }
         }
 
@@ -359,11 +359,11 @@ impl Generator {
             if self.pretty {
                 self.indent_up();
                 self.newline();
-                self.gen_expr(having);
+                self.gen_condition(having);
                 self.indent_down();
             } else {
                 self.write(" ");
-                self.gen_expr(having);
+                self.gen_condition(having);
             }
         }
 
@@ -373,11 +373,11 @@ impl Generator {
             if self.pretty {
                 self.indent_up();
                 self.newline();
-                self.gen_expr(qualify);
+                self.gen_condition(qualify);
                 self.indent_down();
             } else {
                 self.write(" ");
-                self.gen_expr(qualify);
+                self.gen_condition(qualify);
             }
         }
 
@@ -682,7 +682,7 @@ impl Generator {
                 self.write(" ");
             }
             self.write_keyword("ON ");
-            self.gen_expr(on);
+            self.gen_condition(on);
         }
         if !join.using.is_empty() {
             if self.pretty {
@@ -934,11 +934,11 @@ impl Generator {
             if self.pretty {
                 self.indent_up();
                 self.newline();
-                self.gen_expr(wh);
+                self.gen_condition(wh);
                 self.indent_down();
             } else {
                 self.write(" ");
-                self.gen_expr(wh);
+                self.gen_condition(wh);
             }
         }
 
@@ -984,11 +984,11 @@ impl Generator {
             if self.pretty {
                 self.indent_up();
                 self.newline();
-                self.gen_expr(wh);
+                self.gen_condition(wh);
                 self.indent_down();
             } else {
                 self.write(" ");
-                self.gen_expr(wh);
+                self.gen_condition(wh);
             }
         }
 
@@ -1096,7 +1096,7 @@ impl Generator {
 
         if let Some(cond) = &clause.condition {
             self.write_keyword(" AND ");
-            self.gen_expr(cond);
+            self.gen_condition(cond);
         }
 
         self.write_keyword(" THEN");
@@ -1702,6 +1702,81 @@ impl Generator {
         }
     }
 
+    /// Emit `e` in a *condition* (search-condition) position.
+    ///
+    /// SQL Server has no native boolean type: a bare boolean expression (a
+    /// `bit` column, function result, or boolean literal) is not a valid
+    /// predicate and is rejected with error 4145 ("An expression of non-boolean
+    /// type specified in a context where a condition is expected"). For the
+    /// T-SQL family we wrap such a bare boolean as `<e> = 1`, recursing through
+    /// the logical connectives (`AND`/`OR`/`XOR`/`NOT`/parentheses) so each
+    /// nested operand is fixed, and lowering a bare boolean literal to `1 = 1`
+    /// / `1 = 0`. Expressions that are already predicates (comparisons,
+    /// `IS NULL`, `IN`, `LIKE`, `BETWEEN`, `EXISTS`, …) are emitted unchanged.
+    /// Every non-T-SQL dialect delegates straight to `gen_expr`, so their
+    /// output is byte-for-byte identical.
+    fn gen_condition(&mut self, e: &Expr) {
+        if !matches!(self.dialect, Some(d) if crate::dialects::is_tsql_family(d)) {
+            self.gen_expr(e);
+            return;
+        }
+        match e {
+            // Logical connectives: each operand is itself a condition position.
+            Expr::BinaryOp { left, op, right }
+                if matches!(
+                    op,
+                    BinaryOperator::And | BinaryOperator::Or | BinaryOperator::Xor
+                ) =>
+            {
+                self.gen_condition(left);
+                self.write(Self::binary_op_str(op));
+                self.gen_condition(right);
+            }
+            Expr::UnaryOp {
+                op: UnaryOperator::Not,
+                expr,
+            } => {
+                self.write("NOT ");
+                self.gen_condition(expr);
+            }
+            Expr::Nested(inner) => {
+                self.write("(");
+                self.gen_condition(inner);
+                self.write(")");
+            }
+            // Already boolean-typed predicates: emit unchanged.
+            Expr::BinaryOp {
+                op:
+                    BinaryOperator::Eq
+                    | BinaryOperator::Neq
+                    | BinaryOperator::Lt
+                    | BinaryOperator::Gt
+                    | BinaryOperator::LtEq
+                    | BinaryOperator::GtEq,
+                ..
+            }
+            | Expr::Between { .. }
+            | Expr::IsNull { .. }
+            | Expr::IsBool { .. }
+            | Expr::InList { .. }
+            | Expr::InSubquery { .. }
+            | Expr::Like { .. }
+            | Expr::ILike { .. }
+            | Expr::SimilarTo { .. }
+            | Expr::Exists { .. }
+            | Expr::AnyOp { .. }
+            | Expr::AllOp { .. } => self.gen_expr(e),
+            // Bare boolean literal in a condition position → `1 = 1` / `1 = 0`.
+            Expr::Boolean(b) => self.write(if *b { "1 = 1" } else { "1 = 0" }),
+            // Any other bare scalar (column, function, cast, scalar subquery,
+            // …) is a PostgreSQL boolean here; wrap it into a predicate.
+            _ => {
+                self.gen_expr(e);
+                self.write(" = 1");
+            }
+        }
+    }
+
     fn gen_expr(&mut self, expr: &Expr) {
         match expr {
             Expr::Column {
@@ -2011,7 +2086,15 @@ impl Generator {
                 for (cond, result) in when_clauses {
                     self.write(" ");
                     self.write_keyword("WHEN ");
-                    self.gen_expr(cond);
+                    // A simple CASE (`CASE <operand> WHEN <value>`) compares each
+                    // WHEN value against the operand, so it is NOT a condition
+                    // position. Only a searched CASE (`CASE WHEN <cond>`) puts a
+                    // boolean search condition here and needs T-SQL wrapping.
+                    if operand.is_some() {
+                        self.gen_expr(cond);
+                    } else {
+                        self.gen_condition(cond);
+                    }
                     self.write(" ");
                     self.write_keyword("THEN ");
                     self.gen_expr(result);

tests/test_transpile.rs

@@ -2654,3 +2654,158 @@ fn cr014_transpile_paren_setop_pg_identity() {
         );
     }
 }
+
+// ── CR-018: bare boolean in a condition position wrapped to `= 1` for T-SQL ──
+//
+// SQL Server has no native boolean type, so a bare boolean expression in a
+// search-condition position (WHERE / HAVING / QUALIFY / JOIN … ON / searched
+// CASE WHEN / AND / OR / NOT) is rejected with error 4145. The generator wraps
+// such a bare boolean as `<expr> = 1` for the T-SQL family only.
+
+#[test]
+fn cr018_where_bare_boolean_pg_to_tsql() {
+    validate_with_dialect(
+        "SELECT 1 FROM t WHERE b",
+        "SELECT 1 FROM t WHERE b = 1",
+        Dialect::Postgres,
+        Dialect::Tsql,
+    );
+}
+
+#[test]
+fn cr018_where_not_bare_boolean() {
+    // `NOT b` → `NOT b = 1`, which T-SQL parses as `NOT (b = 1)` (`=` binds
+    // tighter than `NOT`) — identical 3-valued logic to PostgreSQL `NOT b`.
+    validate_with_dialect(
+        "SELECT 1 FROM t WHERE NOT b",
+        "SELECT 1 FROM t WHERE NOT b = 1",
+        Dialect::Postgres,
+        Dialect::Tsql,
+    );
+}
+
+#[test]
+fn cr018_where_and_mixed_with_predicate() {
+    // Only the bare operand is wrapped; the existing IS NOT NULL predicate stays.
+    validate_with_dialect(
+        "SELECT 1 FROM t WHERE b AND x IS NOT NULL",
+        "SELECT 1 FROM t WHERE b = 1 AND x IS NOT NULL",
+        Dialect::Postgres,
+        Dialect::Tsql,
+    );
+}
+
+#[test]
+fn cr018_where_or_both_bare() {
+    validate_with_dialect(
+        "SELECT 1 FROM t WHERE b OR c",
+        "SELECT 1 FROM t WHERE b = 1 OR c = 1",
+        Dialect::Postgres,
+        Dialect::Tsql,
+    );
+}
+
+#[test]
+fn cr018_searched_case_when_bare_boolean() {
+    // The smoking-gun case from the ticket: bare boolean in a searched CASE WHEN.
+    let out = transpile(
+        "SELECT SUM(CASE WHEN b THEN 1 ELSE 0 END) FROM t",
+        Dialect::Postgres,
+        Dialect::Tsql,
+    )
+    .unwrap();
+    assert!(out.contains("WHEN b = 1 THEN"), "got: {out}");
+    assert!(!out.contains("WHEN b THEN"), "must not stay bare: {out}");
+}
+
+#[test]
+fn cr018_join_on_bare_boolean() {
+    let out = transpile(
+        "SELECT 1 FROM t1 JOIN t2 ON t2.b",
+        Dialect::Postgres,
+        Dialect::Tsql,
+    )
+    .unwrap();
+    assert!(out.contains("ON t2.b = 1"), "got: {out}");
+}
+
+#[test]
+fn cr018_where_boolean_literals() {
+    // Bare TRUE / FALSE in a condition position → `1 = 1` / `1 = 0`, not the
+    // invalid bare `1` / `0` produced by the value-context Boolean arm.
+    validate_with_dialect(
+        "SELECT 1 FROM t WHERE TRUE",
+        "SELECT 1 FROM t WHERE 1 = 1",
+        Dialect::Postgres,
+        Dialect::Tsql,
+    );
+    validate_with_dialect(
+        "SELECT 1 FROM t WHERE FALSE",
+        "SELECT 1 FROM t WHERE 1 = 0",
+        Dialect::Postgres,
+        Dialect::Tsql,
+    );
+}
+
+// ── CR-018 controls: predicates already valid must NOT be double-wrapped ──
+
+#[test]
+fn cr018_control_existing_predicate_not_double_wrapped() {
+    validate_with_dialect(
+        "SELECT 1 FROM t WHERE b = 1",
+        "SELECT 1 FROM t WHERE b = 1",
+        Dialect::Postgres,
+        Dialect::Tsql,
+    );
+    validate_with_dialect(
+        "SELECT 1 FROM t WHERE x IS NULL",
+        "SELECT 1 FROM t WHERE x IS NULL",
+        Dialect::Postgres,
+        Dialect::Tsql,
+    );
+    validate_with_dialect(
+        "SELECT 1 FROM t WHERE x BETWEEN 1 AND 9",
+        "SELECT 1 FROM t WHERE x BETWEEN 1 AND 9",
+        Dialect::Postgres,
+        Dialect::Tsql,
+    );
+}
+
+#[test]
+fn cr018_control_simple_case_when_value_not_wrapped() {
+    // A simple CASE (`CASE <operand> WHEN <value>`) compares each WHEN value
+    // against the operand — it is NOT a condition position and must be left
+    // alone (wrapping it would produce the broken `WHEN 1 = 1`).
+    let out = transpile(
+        "SELECT CASE status WHEN 1 THEN 'a' ELSE 'b' END FROM t",
+        Dialect::Postgres,
+        Dialect::Tsql,
+    )
+    .unwrap();
+    assert!(out.contains("WHEN 1 THEN"), "got: {out}");
+    assert!(!out.contains("1 = 1"), "simple CASE wrongly wrapped: {out}");
+}
+
+#[test]
+fn cr018_control_non_tsql_passthrough() {
+    // Non-T-SQL targets must be byte-for-byte unchanged (the helper delegates
+    // straight to gen_expr off the T-SQL family).
+    validate_with_dialect(
+        "SELECT 1 FROM t WHERE b",
+        "SELECT 1 FROM t WHERE b",
+        Dialect::Postgres,
+        Dialect::Postgres,
+    );
+    validate_with_dialect(
+        "SELECT 1 FROM t WHERE TRUE",
+        "SELECT 1 FROM t WHERE TRUE",
+        Dialect::Postgres,
+        Dialect::Postgres,
+    );
+    validate_with_dialect(
+        "SELECT SUM(CASE WHEN b THEN 1 ELSE 0 END) FROM t",
+        "SELECT SUM(CASE WHEN b THEN 1 ELSE 0 END) FROM t",
+        Dialect::Postgres,
+        Dialect::Postgres,
+    );
+}