data-flow-control 0.1.5__tar.gz → 0.1.7__tar.gz

{data_flow_control-0.1.5 → data_flow_control-0.1.7}/Cargo.lock

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

{data_flow_control-0.1.5 → data_flow_control-0.1.7}/Cargo.toml

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

{data_flow_control-0.1.5 → data_flow_control-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: data-flow-control
-Version: 0.1.5
+Version: 0.1.7
 Requires-Dist: boto3>=1.26.0
 Requires-Dist: duckdb>=1.3.0
 Requires-Dist: langchain>=1.3,<2

{data_flow_control-0.1.5 → data_flow_control-0.1.7}/passant-core/src/aggregate_registry.rs

@@ -167,6 +167,8 @@ impl AggregateRegistry {
             || lower.contains("countif")
             || lower.contains("approx_count_distinct")
             || lower.contains("approx_distinct")
+            || lower == "arbitrary"
+            || lower == "any_value"
             || is_count_like_name(&lower)
     }
 

{data_flow_control-0.1.5 → data_flow_control-0.1.7}/passant-core/src/full_push.rs

@@ -18,6 +18,10 @@ fn semiring_allows_full_push(rewriter: &PassantRewriter, semiring: &SemiringAnal
         .all(|aggregate| count_if_style_scan_aggregate(rewriter, aggregate))
 }
 
+fn aggregate_function_name(aggregate: &str) -> &str {
+    aggregate.split('(').next().unwrap_or(aggregate).trim()
+}
+
 fn count_if_style_scan_aggregate(rewriter: &PassantRewriter, aggregate: &str) -> bool {
     let lower = aggregate.to_ascii_lowercase();
     if lower.contains("array_agg")
@@ -27,7 +31,9 @@ fn count_if_style_scan_aggregate(rewriter: &PassantRewriter, aggregate: &str) ->
     {
         return false;
     }
-    rewriter.aggregate_registry.is_scan_transformable(aggregate)
+    rewriter
+        .aggregate_registry
+        .is_scan_transformable(aggregate_function_name(&lower))
 }
 
 /// Full-push engine — mutates the query in place, preserving its overall shape.

{data_flow_control-0.1.5 → data_flow_control-0.1.7}/passant-core/src/rewrite_strategy.rs

@@ -330,22 +330,6 @@ mod tests {
         }
     }
 
-    fn non_distributive_policy() -> PolicyIr {
-        PolicyIr::Pgn {
-            sources: vec!["foo".to_string()],
-            required_sources: Vec::new(),
-            dimension_tables: Vec::new(),
-            dimension_aliases: std::collections::HashMap::new(),
-            dimension_queries: std::collections::HashMap::new(),
-            sink: None,
-            sink_alias: None,
-            source_aliases: std::collections::HashMap::new(),
-            constraint: "string_agg(foo.name, ',') = 'x'".to_string(),
-            on_fail: Resolution::Remove,
-            description: None,
-        }
-    }
-
     #[test]
     fn full_push_runs_before_partial_push() {
         let full = FullPushEngine;
@@ -377,24 +361,71 @@ mod tests {
     }
 
     #[test]
-    fn non_distributive_policy_uses_partial_push() {
+    fn introspected_arbitrary_in_catalog_still_rewrites_kill_insert() {
+        use crate::aggregate_registry::AggregateFunctionSnapshot;
+        use crate::catalog::{CatalogSnapshot, CatalogTableInfo};
+        use std::collections::HashMap;
+
+        let policy_text = "SOURCE Receipts SINK Expenses CONSTRAINT ARBITRARY(Receipts.cat) != 'Meal' OR Expenses.biz_use <= 50.0 ON FAIL KILL";
+        let sql = "INSERT INTO Expenses SELECT 1, 100.0 FROM Receipts";
+
         let mut rewriter = PassantRewriter::new();
-        rewriter.register_policy(non_distributive_policy());
-        let statement = sqlparser::parser::Parser::parse_sql(
-            &sqlparser::dialect::GenericDialect {},
-            "SELECT id FROM foo",
-        )
-        .expect("parse")
-        .pop()
-        .expect("statement");
-        let request = RewriteRequest::analyze(
-            "SELECT id FROM foo",
-            &statement,
-            RewriteOptions::default(),
-            rewriter.policy_store(),
+        rewriter
+            .register_validated_policy(crate::parse_policy_text(policy_text).expect("parse"))
+            .expect("register without catalog");
+        let without_catalog = rewriter.rewrite(sql).expect("rewrite without catalog");
+        assert!(
+            without_catalog.contains("passant_kill"),
+            "baseline rewrite without catalog introspection: {without_catalog}"
+        );
+
+        let mut tables = HashMap::new();
+        tables.insert(
+            "Receipts".to_string(),
+            CatalogTableInfo {
+                columns: vec!["cat".into(), "biz_use".into()],
+                ..CatalogTableInfo::default()
+            },
+        );
+        tables.insert(
+            "Expenses".to_string(),
+            CatalogTableInfo {
+                columns: vec!["biz_use".into()],
+                ..CatalogTableInfo::default()
+            },
+        );
+        let mut rewriter = PassantRewriter::new();
+        rewriter.apply_catalog_snapshot(CatalogSnapshot {
+            dialect: Some("duckdb".to_string()),
+            tables,
+            aggregate_functions: vec![AggregateFunctionSnapshot {
+                name: "arbitrary".to_string(),
+                schema: None,
+                aliases: vec![],
+                classification: None,
+                source: Some("introspected".to_string()),
+            }],
+            ..CatalogSnapshot::default()
+        });
+        rewriter
+            .register_validated_policy(crate::parse_policy_text(policy_text).expect("parse"))
+            .expect("register validated policy");
+        assert!(
+            rewriter
+                .policy_store()
+                .has_enforcement_resolution_policies(),
+            "KILL policy should register as enforcement resolution"
+        );
+        assert_eq!(rewriter.policy_store().active_count(), 1);
+        let with_catalog = rewriter.rewrite(sql);
+        if let Err(err) = &with_catalog {
+            panic!("rewrite with catalog failed: {err}");
+        }
+        let with_catalog = with_catalog.expect("rewrite ok");
+        let summary = rewriter.last_statement_rewrite_summary();
+        assert!(
+            with_catalog.contains("passant_kill"),
+            "expected kill rewrite with introspected arbitrary aggregate, got: {with_catalog}; summary={summary:?}"
         );
-        assert!(!request.semiring.all_distributive);
-        assert!(!FullPushEngine.matches(&rewriter, &request));
-        assert!(PartialPushEngine.matches(&rewriter, &request));
     }
 }