data-flow-control 0.2.0__tar.gz → 0.2.1__tar.gz

{data_flow_control-0.2.0 → data_flow_control-0.2.1}/Cargo.lock

@@ -1593,7 +1593,7 @@ dependencies = [
 
 [[package]]
 name = "passant-cli"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1605,7 +1605,7 @@ dependencies = [
 
 [[package]]
 name = "passant-core"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "anyhow",
  "criterion",
@@ -1623,7 +1623,7 @@ dependencies = [
 
 [[package]]
 name = "passant-py"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "passant-core",
  "pyo3",

{data_flow_control-0.2.0 → data_flow_control-0.2.1}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["passant-core", "passant-py"]
 resolver = "2"
 
 [workspace.package]
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 license = "MIT"
 authors = ["Charlie Summers"]

{data_flow_control-0.2.0 → data_flow_control-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: data-flow-control
-Version: 0.2.0
+Version: 0.2.1
 Requires-Dist: duckdb>=1.3.0
 Requires-Dist: numpy>=1.24.4
 Requires-Dist: sqlglot==28.3.0

{data_flow_control-0.2.0 → data_flow_control-0.2.1}/passant-core/src/rewriter/columns.rs

@@ -39,6 +39,14 @@ pub(crate) fn replace_source_alias_qualifiers(
             op,
             expr: Box::new(replace_source_alias_qualifiers(*expr, source_aliases)),
         },
+        Expr::IsNull(expr) => Expr::IsNull(Box::new(replace_source_alias_qualifiers(
+            *expr,
+            source_aliases,
+        ))),
+        Expr::IsNotNull(expr) => Expr::IsNotNull(Box::new(replace_source_alias_qualifiers(
+            *expr,
+            source_aliases,
+        ))),
         Expr::Case {
             operand,
             conditions,
@@ -144,6 +152,16 @@ pub(crate) fn replace_sink_columns(
             op,
             expr: Box::new(replace_sink_columns(*expr, sink, sink_expr_by_column)),
         },
+        Expr::IsNull(expr) => Expr::IsNull(Box::new(replace_sink_columns(
+            *expr,
+            sink,
+            sink_expr_by_column,
+        ))),
+        Expr::IsNotNull(expr) => Expr::IsNotNull(Box::new(replace_sink_columns(
+            *expr,
+            sink,
+            sink_expr_by_column,
+        ))),
         Expr::Case {
             operand,
             conditions,
@@ -238,6 +256,18 @@ fn replace_sink_columns_strict(
                 ambiguous_output_columns,
             )?),
         }),
+        Expr::IsNull(expr) => Ok(Expr::IsNull(Box::new(replace_sink_columns_strict(
+            *expr,
+            sink,
+            sink_expr_by_column,
+            ambiguous_output_columns,
+        )?))),
+        Expr::IsNotNull(expr) => Ok(Expr::IsNotNull(Box::new(replace_sink_columns_strict(
+            *expr,
+            sink,
+            sink_expr_by_column,
+            ambiguous_output_columns,
+        )?))),
         Expr::Case {
             operand,
             conditions,
@@ -676,4 +706,122 @@ mod tests {
         );
         assert_eq!(expr.to_string(), "mt.\"OrderID\" > 1");
     }
+
+    #[test]
+    fn source_alias_replacement_descends_through_nested_null_tests() {
+        let aliases = HashMap::from([("src".to_string(), "receipts".to_string())]);
+        for (input, expected) in [
+            ("src.amount IS NULL", "receipts.amount IS NULL"),
+            ("src.amount IS NOT NULL", "receipts.amount IS NOT NULL"),
+            (
+                "NOT ((src.amount IS NULL) IS NOT NULL)",
+                "NOT ((receipts.amount IS NULL) IS NOT NULL)",
+            ),
+            (
+                "CASE WHEN src.amount IS NULL THEN src.id IS NOT NULL ELSE false END",
+                "CASE WHEN receipts.amount IS NULL THEN receipts.id IS NOT NULL ELSE false END",
+            ),
+            (
+                "coalesce(src.amount IS NOT NULL, false)",
+                "coalesce(receipts.amount IS NOT NULL, false)",
+            ),
+        ] {
+            assert_eq!(
+                replace_source_alias_qualifiers(parse_expr(input), &aliases),
+                parse_expr(expected),
+                "{input}"
+            );
+        }
+    }
+
+    #[test]
+    fn sink_replacement_descends_through_nested_null_tests() {
+        let columns = HashMap::from([("amount".to_string(), parse_expr("input.cost"))]);
+        for (input, expected) in [
+            ("reports.amount IS NULL", "input.cost IS NULL"),
+            ("reports.amount IS NOT NULL", "input.cost IS NOT NULL"),
+            (
+                "NOT ((reports.amount IS NOT NULL) IS NULL)",
+                "NOT ((input.cost IS NOT NULL) IS NULL)",
+            ),
+            (
+                "coalesce(reports.amount IS NULL, false)",
+                "coalesce(input.cost IS NULL, false)",
+            ),
+        ] {
+            assert_eq!(
+                replace_sink_columns(parse_expr(input), "reports", &columns),
+                parse_expr(expected),
+                "{input}"
+            );
+        }
+    }
+
+    #[test]
+    fn output_marker_replacement_descends_through_nested_null_tests() {
+        let columns = HashMap::from([("amount".to_string(), parse_expr("input.cost"))]);
+        for (input, expected) in [
+            ("_OUTPUT_.amount IS NULL", "input.cost IS NULL"),
+            ("_OUTPUT_.amount IS NOT NULL", "input.cost IS NOT NULL"),
+            (
+                "NOT ((_OUTPUT_.amount IS NULL) IS NOT NULL)",
+                "NOT ((input.cost IS NULL) IS NOT NULL)",
+            ),
+            (
+                "CASE WHEN _OUTPUT_.amount IS NULL THEN false ELSE _OUTPUT_.amount IS NOT NULL END",
+                "CASE WHEN input.cost IS NULL THEN false ELSE input.cost IS NOT NULL END",
+            ),
+        ] {
+            assert_eq!(
+                apply_output_marker_replacements(parse_expr(input), &columns, &HashSet::new())
+                    .expect("valid output mapping"),
+                parse_expr(expected),
+                "{input}"
+            );
+        }
+    }
+
+    #[test]
+    fn nested_null_output_references_still_reject_ambiguity_and_missing_columns() {
+        let columns = HashMap::from([("amount".to_string(), parse_expr("input.cost"))]);
+        let ambiguous = HashSet::from(["amount".to_string()]);
+        for predicate in [
+            "_OUTPUT_.amount IS NULL",
+            "NOT ((_OUTPUT_.amount IS NOT NULL) IS NULL)",
+        ] {
+            let error =
+                apply_output_marker_replacements(parse_expr(predicate), &columns, &ambiguous)
+                    .expect_err("ambiguous output must fail closed");
+            assert!(
+                error.to_string().contains("ambiguous _OUTPUT_ column"),
+                "{error}"
+            );
+        }
+        for predicate in [
+            "_OUTPUT_.missing IS NULL",
+            "NOT ((_OUTPUT_.missing IS NOT NULL) IS NULL)",
+        ] {
+            let error =
+                apply_output_marker_replacements(parse_expr(predicate), &columns, &HashSet::new())
+                    .expect_err("missing output must fail closed");
+            assert!(
+                error.to_string().contains("not a projected output column"),
+                "{error}"
+            );
+        }
+    }
+
+    #[test]
+    fn null_replacements_preserve_unrelated_qualifiers() {
+        let columns = HashMap::from([("amount".to_string(), parse_expr("input.cost"))]);
+        let original = parse_expr("other.amount IS NULL OR other.amount IS NOT NULL");
+        assert_eq!(
+            replace_sink_columns(original.clone(), "reports", &columns),
+            original
+        );
+        assert_eq!(
+            apply_output_marker_replacements(original.clone(), &columns, &HashSet::new()).unwrap(),
+            original
+        );
+    }
 }

{data_flow_control-0.2.0 → data_flow_control-0.2.1}/passant-core/src/sql/builders.rs

@@ -385,7 +385,7 @@ pub fn passant_kill_pass_filter(pass_expr: Expr) -> Expr {
     }
 }
 
-/// Tuple-resolution KILL filter: relation-level abort guard plus per-row pass filter.
+/// Tuple-resolution KILL filter: relation-level abort guard plus legacy NULL filtering.
 ///
 /// DuckDB may invoke `passant_kill()` from the legacy per-row `pass OR CASE …` pattern even
 /// when every row passes; aggregating violations first avoids that.
@@ -413,7 +413,11 @@ pub fn passant_kill_tuple_filter(relation: &str, pass_column: &str) -> Expr {
         ),
         relation,
     );
-    and_exprs(vec![violation_guard, pass_col]).expect("kill tuple filter is non-empty")
+    // Do not filter FALSE rows here: a constant FALSE filter can let the optimizer
+    // discard the entire candidate relation without evaluating the abort guard.
+    // Keep NULL filtering to preserve KILL's existing three-valued behavior.
+    and_exprs(vec![violation_guard, Expr::IsNotNull(Box::new(pass_col))])
+        .expect("kill tuple filter is non-empty")
 }
 
 pub fn string_concat(left: Expr, right: Expr) -> Expr {

data_flow_control-0.2.1/passant-core/tests/kill_null_guard_regression.rs

@@ -0,0 +1,64 @@
+//! FALSE must reach the relation-level abort; NULL retains legacy filtering.
+#[path = "common/duckdb.rs"]
+mod fixture;
+
+use passant_core::sql::{passant_kill_tuple_filter, qualified_column};
+use sqlparser::ast::{BinaryOperator, Expr};
+
+#[test]
+fn kill_tuple_guard_filters_only_null_not_false_candidates() {
+    let guard = passant_kill_tuple_filter("candidates", "pass");
+    let Expr::BinaryOp {
+        left,
+        op: BinaryOperator::And,
+        right,
+    } = &guard
+    else {
+        panic!("expected aggregate abort guard AND null filter: {guard}");
+    };
+    assert!(matches!(left.as_ref(), Expr::Subquery(_)), "{guard}");
+    assert_eq!(
+        right.as_ref(),
+        &Expr::IsNotNull(Box::new(qualified_column("candidates", "pass")))
+    );
+    let abort = left.to_string();
+    assert!(
+        abort.contains("max(CASE WHEN NOT candidates.pass THEN 1 ELSE 0 END)"),
+        "{abort}"
+    );
+    assert_eq!(abort.matches("passant_kill()").count(), 1);
+}
+
+#[test]
+fn constant_false_kill_aborts_insert_without_changing_existing_rows() {
+    let db = fixture::TestDb::new();
+    db.exec("CREATE TABLE target(id INTEGER); INSERT INTO target VALUES (99)");
+    let guard = passant_kill_tuple_filter("candidates", "pass");
+    let sql = format!(
+        "INSERT INTO target WITH candidates AS (SELECT false AS pass) SELECT 7 FROM candidates WHERE {guard}"
+    );
+    let error = db
+        .conn
+        .execute_batch(&sql)
+        .expect_err("constant FALSE must not optimize away KILL");
+    assert!(
+        error
+            .to_string()
+            .contains("KILLing due to dfc policy violation"),
+        "{error}"
+    );
+    assert_eq!(db.fetchall_i64("SELECT id FROM target"), vec![99]);
+}
+
+#[test]
+fn kill_null_candidates_keep_legacy_null_filtering() {
+    let db = fixture::TestDb::new();
+    let guard = passant_kill_tuple_filter("candidates", "pass");
+    let sql = format!(
+        "WITH candidates AS (SELECT NULL::BOOLEAN AS pass) SELECT 7 FROM candidates WHERE {guard}"
+    );
+    assert!(db.fetchall_i64(&sql).is_empty());
+    let sql =
+        format!("WITH candidates AS (SELECT true AS pass) SELECT 7 FROM candidates WHERE {guard}");
+    assert_eq!(db.fetchall_i64(&sql), vec![7]);
+}

{data_flow_control-0.2.0 → data_flow_control-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "data-flow-control"
-version = "0.2.0"
+version = "0.2.1"
 description = "Rust-backed Data Flow Control rewrite engine"
 license = "MIT"
 license-files = ["LICENSE"]