Lower & evaluate graph match label negation,conjunction disjunction (#568)

jpschorr · web-flow · commit a07da04e0ca0 · 2025-04-30T16:35:33.000-07:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - *BREAKING* partiql-ast: Removes disused `Sexp` AST node
 
 ### Added
+- Added lowering and evaluation of graph `MATCH` label negation, conjunction, and disjunction
 
 ### Removed
 
diff --git a/partiql-eval/src/eval/graph/plan.rs b/partiql-eval/src/eval/graph/plan.rs
@@ -25,6 +25,9 @@ pub enum LabelFilter<GT: GraphTypes> {
     #[default]
     Always,
     Named(GT::Label),
+    Negated(Box<LabelFilter<GT>>),
+    Disjunction(Vec<LabelFilter<GT>>),
+    Conjunction(Vec<LabelFilter<GT>>),
     Never,
 }
 
diff --git a/partiql-eval/src/eval/graph/simple_graph/engine.rs b/partiql-eval/src/eval/graph/simple_graph/engine.rs
@@ -81,6 +81,17 @@ impl GraphPlanConvert<StringGraphTypes, SimpleGraphTypes> for SimpleGraphEngine
                     LabelFilter::Never
                 }
             }
+            LabelFilter::Negated(inner) => {
+                LabelFilter::Negated(Box::new(self.convert_label_filter(inner)))
+            }
+            LabelFilter::Conjunction(inner) => {
+                let inner = inner.iter().map(|l| self.convert_label_filter(l));
+                LabelFilter::Conjunction(inner.collect())
+            }
+            LabelFilter::Disjunction(inner) => {
+                let inner = inner.iter().map(|l| self.convert_label_filter(l));
+                LabelFilter::Disjunction(inner.collect())
+            }
         }
     }
 
@@ -100,6 +111,17 @@ impl GraphPlanConvert<SimpleGraphTypes, StringGraphTypes> for SimpleGraphEngine
             LabelFilter::Named(l) => {
                 LabelFilter::Named(self.graph.labels.resolve(&l.0).to_string())
             }
+            LabelFilter::Negated(inner) => {
+                LabelFilter::Negated(Box::new(self.convert_label_filter(inner)))
+            }
+            LabelFilter::Conjunction(inner) => {
+                let inner = inner.iter().map(|l| self.convert_label_filter(l));
+                LabelFilter::Conjunction(inner.collect())
+            }
+            LabelFilter::Disjunction(inner) => {
+                let inner = inner.iter().map(|l| self.convert_label_filter(l));
+                LabelFilter::Disjunction(inner.collect())
+            }
         }
     }
 
@@ -148,17 +170,13 @@ impl TripleScan<SimpleGraphTypes> for SimpleGraph {
         // scan directed triples left to right and right to left
         self.g_dir
             .iter()
-            .filter(move |(_, e, _)| EdgeMatcher::matches(self, &spec.e, e))
+            .filter(move |(_, e, _)| self.edge_matches(&spec.e, e))
             .flat_map(move |(l, e, r)| {
                 let mut res = Vec::with_capacity(2);
-                if NodeMatcher::matches(self, &spec.lhs, l)
-                    && NodeMatcher::matches(self, &spec.rhs, r)
-                {
+                if self.node_matches(&spec.lhs, l) && self.node_matches(&spec.rhs, r) {
                     res.push(build_triple(&(*l, *e, *r)))
                 }
-                if NodeMatcher::matches(self, &spec.rhs, l)
-                    && NodeMatcher::matches(self, &spec.lhs, r)
-                {
+                if self.node_matches(&spec.rhs, l) && self.node_matches(&spec.lhs, r) {
                     res.push(reverse_triple(&(*l, *e, *r)))
                 }
 
@@ -173,17 +191,13 @@ impl TripleScan<SimpleGraphTypes> for SimpleGraph {
         // scan undirected triples
         self.g_undir
             .iter()
-            .filter(move |(_, e, _)| EdgeMatcher::matches(self, &spec.e, e))
+            .filter(move |(_, e, _)| self.edge_matches(&spec.e, e))
             .flat_map(move |(l, e, r)| {
                 let mut res = Vec::with_capacity(2);
-                if NodeMatcher::matches(self, &spec.lhs, l)
-                    && NodeMatcher::matches(self, &spec.rhs, r)
-                {
+                if self.node_matches(&spec.lhs, l) && self.node_matches(&spec.rhs, r) {
                     res.push(build_triple(&(*l, *e, *r)))
                 }
-                if NodeMatcher::matches(self, &spec.rhs, l)
-                    && NodeMatcher::matches(self, &spec.lhs, r)
-                {
+                if self.node_matches(&spec.rhs, l) && self.node_matches(&spec.lhs, r) {
                     res.push(reverse_triple(&(*l, *e, *r)))
                 }
 
@@ -194,7 +208,7 @@ impl TripleScan<SimpleGraphTypes> for SimpleGraph {
     fn get(&self, spec: &NodeFilter<SimpleGraphTypes>) -> Vec<GNodeId> {
         (0..self.nodes.len())
             .map(GNodeId)
-            .filter(|node| NodeMatcher::matches(self, spec, node))
+            .filter(|node| self.node_matches(spec, node))
             .collect()
     }
 }
@@ -222,11 +236,17 @@ trait TripleMatcher<GT: GraphTypes> {
 }
 
 trait NodeMatcher<GT: GraphTypes> {
-    fn matches(&self, spec: &NodeFilter<GT>, node: &GT::NodeId) -> bool;
+    fn node_matches(&self, spec: &NodeFilter<GT>, node: &GT::NodeId) -> bool;
+    fn node_label_matches(&self, spec: &LabelFilter<GT>, node: &GT::NodeId) -> bool;
+    #[allow(dead_code)] // TODO implement value filters for `where`
+    fn node_value_matches(&self, spec: &ValueFilter, node: &GT::NodeId) -> bool;
 }
 
 trait EdgeMatcher<GT: GraphTypes> {
-    fn matches(&self, spec: &EdgeFilter<GT>, edge: &GT::EdgeId) -> bool;
+    fn edge_matches(&self, spec: &EdgeFilter<GT>, edge: &GT::EdgeId) -> bool;
+    fn edge_label_matches(&self, spec: &LabelFilter<GT>, edge: &GT::EdgeId) -> bool;
+    #[allow(dead_code)] // TODO implement value filters for `where`
+    fn edge_value_matches(&self, spec: &ValueFilter, edge: &GT::EdgeId) -> bool;
 }
 
 impl TripleMatcher<SimpleGraphTypes> for SimpleGraph {
@@ -236,32 +256,82 @@ impl TripleMatcher<SimpleGraphTypes> for SimpleGraph {
         spec: &TripleFilter<SimpleGraphTypes>,
         triple: &Triple<SimpleGraphTypes>,
     ) -> bool {
-        NodeMatcher::matches(self, &spec.lhs, &triple.lhs)
-            && EdgeMatcher::matches(self, &spec.e, &triple.e)
-            && NodeMatcher::matches(self, &spec.rhs, &triple.rhs)
+        self.node_matches(&spec.lhs, &triple.lhs)
+            && self.edge_matches(&spec.e, &triple.e)
+            && self.node_matches(&spec.rhs, &triple.rhs)
     }
 }
 
 impl NodeMatcher<SimpleGraphTypes> for SimpleGraph {
     #[inline]
-    fn matches(&self, spec: &NodeFilter<SimpleGraphTypes>, node: &GNodeId) -> bool {
+    fn node_matches(&self, spec: &NodeFilter<SimpleGraphTypes>, node: &GNodeId) -> bool {
         let NodeFilter { label, filter } = spec;
         match (label, filter) {
             (LabelFilter::Never, _) => false,
             (LabelFilter::Always, ValueFilter::Always) => true,
-            (LabelFilter::Named(l), ValueFilter::Always) => self.nodes[node.0].labels.0.contains(l),
+            //TODO when ValueFilter has other variants:
+            // (LabelFilter::Always, v) => self.node_value_matches(v, node),
+            (l, ValueFilter::Always) => self.node_label_matches(l, node),
+            //TODO when ValueFilter has other variants:
+            // (l, v) => self.node_label_matches(l, node) && self.node_value_matches(v, node),
+        }
+    }
+
+    fn node_label_matches(&self, spec: &LabelFilter<SimpleGraphTypes>, node: &GNodeId) -> bool {
+        match spec {
+            LabelFilter::Never => false,
+            LabelFilter::Always => true,
+            LabelFilter::Named(l) => self.nodes[node.0].labels.0.contains(l),
+            LabelFilter::Negated(inner) => !self.node_label_matches(inner.as_ref(), node),
+            LabelFilter::Disjunction(inner) => {
+                inner.iter().any(|l| self.node_label_matches(l, node))
+            }
+            LabelFilter::Conjunction(inner) => {
+                inner.iter().all(|l| self.node_label_matches(l, node))
+            }
+        }
+    }
+
+    fn node_value_matches(&self, spec: &ValueFilter, _: &GNodeId) -> bool {
+        match spec {
+            ValueFilter::Always => true,
         }
     }
 }
 
 impl EdgeMatcher<SimpleGraphTypes> for SimpleGraph {
     #[inline]
-    fn matches(&self, spec: &EdgeFilter<SimpleGraphTypes>, edge: &GEdgeId) -> bool {
+    fn edge_matches(&self, spec: &EdgeFilter<SimpleGraphTypes>, edge: &GEdgeId) -> bool {
         let EdgeFilter { label, filter } = spec;
         match (label, filter) {
             (LabelFilter::Never, _) => false,
             (LabelFilter::Always, ValueFilter::Always) => true,
-            (LabelFilter::Named(l), ValueFilter::Always) => self.edges[edge.0].labels.0.contains(l),
+            //TODO when ValueFilter has other variants:
+            // (LabelFilter::Always, v) => self.edge_value_matches(v, edge),
+            (l, ValueFilter::Always) => self.edge_label_matches(l, edge),
+            //TODO when ValueFilter has other variants:
+            // (l, v) => self.edge_label_matches(l, edge) && self.edge_value_matches(v, edge),
+        }
+    }
+
+    fn edge_label_matches(&self, spec: &LabelFilter<SimpleGraphTypes>, edge: &GEdgeId) -> bool {
+        match spec {
+            LabelFilter::Never => false,
+            LabelFilter::Always => true,
+            LabelFilter::Named(l) => self.edges[edge.0].labels.0.contains(l),
+            LabelFilter::Negated(inner) => !self.edge_label_matches(inner.as_ref(), edge),
+            LabelFilter::Disjunction(inner) => {
+                inner.iter().any(|l| self.edge_label_matches(l, edge))
+            }
+            LabelFilter::Conjunction(inner) => {
+                inner.iter().all(|l| self.edge_label_matches(l, edge))
+            }
+        }
+    }
+
+    fn edge_value_matches(&self, spec: &ValueFilter, _: &GEdgeId) -> bool {
+        match spec {
+            ValueFilter::Always => true,
         }
     }
 }
diff --git a/partiql-eval/src/plan.rs b/partiql-eval/src/plan.rs
@@ -813,6 +813,17 @@ fn plan_graph_plan(
             logical::graph::LabelFilter::Always => physical::LabelFilter::Always,
             logical::graph::LabelFilter::Never => physical::LabelFilter::Never,
             logical::graph::LabelFilter::Named(n) => physical::LabelFilter::Named(n.clone()),
+            logical::graph::LabelFilter::Negated(inner) => {
+                physical::LabelFilter::Negated(Box::new(plan_label_filter(inner)?))
+            }
+            logical::graph::LabelFilter::Conjunction(inner) => {
+                let inner: Result<Vec<_>, _> = inner.iter().map(plan_label_filter).collect();
+                physical::LabelFilter::Conjunction(inner?)
+            }
+            logical::graph::LabelFilter::Disjunction(inner) => {
+                let inner: Result<Vec<_>, _> = inner.iter().map(plan_label_filter).collect();
+                physical::LabelFilter::Disjunction(inner?)
+            }
         })
     }
 
diff --git a/partiql-logical-planner/src/graph.rs b/partiql-logical-planner/src/graph.rs
@@ -270,35 +270,6 @@ impl GraphToLogical {
         }
     }
 
-    fn plan_graph_pattern_label(
-        &self,
-        label: Option<&ast::GraphMatchLabel>,
-    ) -> Result<LabelFilter, String> {
-        if let Some(label) = label {
-            match label {
-                ast::GraphMatchLabel::Name(n) => Ok(LabelFilter::Named(n.value.clone())),
-                ast::GraphMatchLabel::Wildcard => Ok(LabelFilter::Always),
-                ast::GraphMatchLabel::Negated(_) => {
-                    not_yet_implemented_result!(
-                        "MATCH expression label negation is not yet supported."
-                    );
-                }
-                ast::GraphMatchLabel::Conjunction(_) => {
-                    not_yet_implemented_result!(
-                        "MATCH expression label conjunction is not yet supported."
-                    );
-                }
-                ast::GraphMatchLabel::Disjunction(_) => {
-                    not_yet_implemented_result!(
-                        "MATCH expression label disjunction is not yet supported."
-                    );
-                }
-            }
-        } else {
-            Ok(LabelFilter::Always)
-        }
-    }
-
     fn plan_graph_pattern_part_node(
         &self,
         node: &ast::GraphMatchNode,
@@ -310,7 +281,7 @@ impl GraphToLogical {
             None => self.graph_id.node(),
             Some(v) => v.value.clone(),
         };
-        let label = self.plan_graph_pattern_label(node.label.as_deref())?;
+        let label = plan_graph_pattern_label(node.label.as_deref())?;
         let node_match = NodeMatch {
             binder: BindSpec(binder),
             spec: NodeFilter {
@@ -341,7 +312,7 @@ impl GraphToLogical {
             None => self.graph_id.node(),
             Some(v) => v.value.clone(),
         };
-        let label = self.plan_graph_pattern_label(edge.label.as_deref())?;
+        let label = plan_graph_pattern_label(edge.label.as_deref())?;
         let edge_match = EdgeMatch {
             binder: BindSpec(binder),
             spec: EdgeFilter {
@@ -352,3 +323,32 @@ impl GraphToLogical {
         Ok(vec![MatchElement::Edge(direction, edge_match)])
     }
 }
+
+fn plan_graph_pattern_label(label: Option<&ast::GraphMatchLabel>) -> Result<LabelFilter, String> {
+    if let Some(label) = label {
+        match label {
+            ast::GraphMatchLabel::Name(n) => Ok(LabelFilter::Named(n.value.clone())),
+            ast::GraphMatchLabel::Wildcard => Ok(LabelFilter::Always),
+            ast::GraphMatchLabel::Negated(l) => {
+                let inner = plan_graph_pattern_label(Some(l.as_ref()))?;
+                Ok(LabelFilter::Negated(Box::new(inner)))
+            }
+            ast::GraphMatchLabel::Conjunction(inner) => {
+                let inner: Result<Vec<_>, _> = inner
+                    .iter()
+                    .map(|l| plan_graph_pattern_label(Some(l)))
+                    .collect();
+                Ok(LabelFilter::Conjunction(inner?))
+            }
+            ast::GraphMatchLabel::Disjunction(inner) => {
+                let inner: Result<Vec<_>, _> = inner
+                    .iter()
+                    .map(|l| plan_graph_pattern_label(Some(l)))
+                    .collect();
+                Ok(LabelFilter::Disjunction(inner?))
+            }
+        }
+    } else {
+        Ok(LabelFilter::Always)
+    }
+}
diff --git a/partiql-logical/src/graph/mod.rs b/partiql-logical/src/graph/mod.rs
@@ -30,6 +30,9 @@ pub enum LabelFilter {
     #[default]
     Always,
     Named(String),
+    Negated(Box<LabelFilter>),
+    Conjunction(Vec<LabelFilter>),
+    Disjunction(Vec<LabelFilter>),
     Never,
 }
 

Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,9 @@ pub enum LabelFilter<GT: GraphTypes> {`
`25`	`25`	`#[default]`
`26`	`26`	`Always,`
`27`	`27`	`Named(GT::Label),`
	`28`	`+ Negated(Box<LabelFilter<GT>>),`
	`29`	`+ Disjunction(Vec<LabelFilter<GT>>),`
	`30`	`+ Conjunction(Vec<LabelFilter<GT>>),`
`28`	`31`	`Never,`
`29`	`32`	`}`
`30`	`33`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,9 @@ pub enum LabelFilter {`
`30`	`30`	`#[default]`
`31`	`31`	`Always,`
`32`	`32`	`Named(String),`
	`33`	`+ Negated(Box<LabelFilter>),`
	`34`	`+ Conjunction(Vec<LabelFilter>),`
	`35`	`+ Disjunction(Vec<LabelFilter>),`
`33`	`36`	`Never,`
`34`	`37`	`}`
`35`	`38`