GRAPH_TABLE updates to logical plan lowering

Author: jpschorr

partiql-logical-planner/src/graph.rs

@@ -1,11 +1,12 @@
 use num::Integer;
 use partiql_ast::ast;
-use partiql_ast::ast::{GraphMatchDirection, GraphPathPatternPart};
+use partiql_ast::ast::{GraphMatchDirection, GraphMatchLabel, GraphMatchPathPattern};
 use partiql_logical::graph::bind_name::FreshBinder;
 use partiql_logical::graph::{
     BindSpec, DirectionFilter, EdgeFilter, EdgeMatch, LabelFilter, NodeFilter, NodeMatch,
     PathMatch, PathPattern, PathPatternMatch, StepFilter, TripleFilter, ValueFilter,
 };
+use petgraph::visit::Walker;
 use std::mem::take;
 
 #[macro_export]
@@ -165,94 +166,156 @@ impl GraphToLogical {
     }
     pub(crate) fn plan_graph_match(
         &self,
-        match_expr: &ast::GraphMatchExpr,
+        graph_match: &ast::GraphMatch,
     ) -> Result<PathPatternMatch, String> {
-        if match_expr.selector.is_some() {
-            not_yet_implemented_result!("MATCH expression selectors are not yet supported.");
+        if graph_match.shape.cols.is_some() {
+            not_yet_implemented_result!("MATCH expression COLUMNS are not yet supported.");
+        }
+        if graph_match.shape.export.is_some() {
+            not_yet_implemented_result!("MATCH expression EXPORT are not yet supported.");
+        }
+        if graph_match.shape.rows.is_some() {
+            not_yet_implemented_result!("MATCH expression ROWS are not yet supported.");
+        }
+
+        let pattern = self.plan_graph_pattern(&graph_match.pattern)?;
+        let normalized = self.normalize(pattern)?;
+        let expanded = self.expand(normalized)?;
+        self.plan(expanded)
+    }
+
+    fn plan_graph_pattern(&self, pattern: &ast::GraphPattern) -> Result<Vec<MatchElement>, String> {
+        if pattern.mode.is_some() {
+            not_yet_implemented_result!("MATCH expression MATCH MODE is not yet supported.");
+        }
+        if pattern.keep.is_some() {
+            not_yet_implemented_result!("MATCH expression KEEP is not yet supported.");
+        }
+        if pattern.where_clause.is_some() {
+            not_yet_implemented_result!("MATCH expression WHERE is not yet supported.");
         }
 
-        if match_expr.patterns.len() != 1 {
+        if pattern.patterns.len() != 1 {
             not_yet_implemented_result!(
                 "MATCH expression with multiple patterns are not yet supported."
             );
         }
 
-        let first_pattern = &match_expr.patterns[0].node;
-        let pattern = self.plan_graph_pattern(first_pattern)?;
-        let normalized = self.normalize(pattern)?;
-        let expanded = self.expand(normalized)?;
-        self.plan(expanded)
+        let first_pattern = &pattern.patterns[0];
+        self.plan_graph_path_pattern(first_pattern)
     }
 
-    fn plan_graph_pattern(
+    fn plan_graph_path_pattern(
         &self,
         pattern: &ast::GraphPathPattern,
     ) -> Result<Vec<MatchElement>, String> {
-        if pattern.restrictor.is_some() {
-            not_yet_implemented_result!("MATCH pattern restrictors are not yet supported.");
+        if pattern.prefix.is_some() {
+            not_yet_implemented_result!("MATCH pattern SEARCH/MODE prefix are not yet supported.");
         }
-        if pattern.quantifier.is_some() {
-            not_yet_implemented_result!("MATCH pattern quantifiers are not yet supported.");
+        if pattern.variable.is_some() {
+            not_yet_implemented_result!("MATCH pattern path variables are not yet supported.");
         }
-        if pattern.prefilter.is_some() {
-            not_yet_implemented_result!("MATCH pattern prefilters are not yet supported.");
+
+        self.plan_graph_match_path_pattern(&pattern.path)
+    }
+
+    fn plan_graph_subpath_pattern(
+        &self,
+        pattern: &ast::GraphPathSubPattern,
+    ) -> Result<Vec<MatchElement>, String> {
+        if pattern.mode.is_some() {
+            not_yet_implemented_result!("MATCH pattern MODE prefix are not yet supported.");
         }
         if pattern.variable.is_some() {
             not_yet_implemented_result!("MATCH pattern path variables are not yet supported.");
         }
+        if pattern.where_clause.is_some() {
+            not_yet_implemented_result!("MATCH expression WHERE is not yet supported.");
+        }
 
-        let parts = pattern
-            .parts
-            .iter()
-            .map(|p| self.plan_graph_pattern_part(p));
-        let result: Result<Vec<_>, _> = parts.collect();
-
-        result.map(|r| r.into_iter().flatten().collect())
+        self.plan_graph_match_path_pattern(&pattern.path)
     }
 
-    fn plan_graph_pattern_part(
+    fn plan_graph_match_path_pattern(
         &self,
-        part: &ast::GraphPathPatternPart,
+        pattern: &ast::GraphMatchPathPattern,
     ) -> Result<Vec<MatchElement>, String> {
-        match part {
-            GraphPathPatternPart::Node(n) => self.plan_graph_pattern_part_node(&n.node),
-            GraphPathPatternPart::Edge(e) => self.plan_graph_pattern_part_edge(&e.node),
-            GraphPathPatternPart::Pattern(pattern) => self.plan_graph_pattern(&pattern.node),
+        match pattern {
+            GraphMatchPathPattern::Path(path) => {
+                let path: Result<Vec<Vec<_>>, _> = path
+                    .iter()
+                    .map(|elt| self.plan_graph_match_path_pattern(elt))
+                    .collect();
+                Ok(path?.into_iter().flatten().collect())
+            }
+            GraphMatchPathPattern::Union(_) => {
+                not_yet_implemented_result!("MATCH expression UNION is not yet supported.")
+            }
+            GraphMatchPathPattern::Multiset(_) => {
+                not_yet_implemented_result!("MATCH expression MULTISET is not yet supported.")
+            }
+            GraphMatchPathPattern::Questioned(_) => {
+                not_yet_implemented_result!("MATCH expression QUESTIONED is not yet supported.")
+            }
+            GraphMatchPathPattern::Quantified(_, _) => {
+                not_yet_implemented_result!("MATCH expression QUANTIFIED is not yet supported.")
+            }
+            GraphMatchPathPattern::Sub(subpath) => self.plan_graph_subpath_pattern(subpath),
+            GraphMatchPathPattern::Node(n) => self.plan_graph_pattern_part_node(&n),
+            GraphMatchPathPattern::Edge(e) => self.plan_graph_pattern_part_edge(&e),
+            GraphMatchPathPattern::Simplified(_) => {
+                not_yet_implemented_result!(
+                    "MATCH expression Simplified Edge Expressions are not yet supported."
+                )
+            }
         }
     }
 
     fn plan_graph_pattern_label(
         &self,
-        label: &Option<Vec<ast::SymbolPrimitive>>,
+        label: Option<&GraphMatchLabel>,
     ) -> Result<LabelFilter, String> {
-        match label {
-            None => Ok(LabelFilter::Always),
-            Some(labels) => {
-                if labels.len() != 1 {
+        if let Some(label) = label {
+            match label {
+                GraphMatchLabel::Name(n) => Ok(LabelFilter::Named(n.value.clone())),
+                GraphMatchLabel::Wildcard => Ok(LabelFilter::Always),
+                GraphMatchLabel::Negated(_) => {
+                    not_yet_implemented_result!(
+                        "MATCH expression label negation is not yet supported."
+                    );
+                }
+                GraphMatchLabel::Conjunction(_) => {
                     not_yet_implemented_result!(
-                        "MATCH expression with multiple patterns are not yet supported."
+                        "MATCH expression label conjunction is not yet supported."
+                    );
+                }
+                GraphMatchLabel::Disjunction(_) => {
+                    not_yet_implemented_result!(
+                        "MATCH expression label disjunction is not yet supported."
                     );
                 }
-                Ok(LabelFilter::Named(labels[0].value.clone()))
             }
+        } else {
+            Ok(LabelFilter::Always)
         }
     }
 
     fn plan_graph_pattern_part_node(
         &self,
         node: &ast::GraphMatchNode,
     ) -> Result<Vec<MatchElement>, String> {
-        if node.prefilter.is_some() {
-            not_yet_implemented_result!("MATCH node prefilters are not yet supported.");
+        if node.where_clause.is_some() {
+            not_yet_implemented_result!("MATCH node where_clauses are not yet supported.");
         }
         let binder = match &node.variable {
             None => self.graph_id.node(),
             Some(v) => v.value.clone(),
         };
+        let label = self.plan_graph_pattern_label(node.label.as_deref())?;
         let node_match = NodeMatch {
             binder: BindSpec(binder),
             spec: NodeFilter {
-                label: self.plan_graph_pattern_label(&node.label)?,
+                label,
                 filter: ValueFilter::Always,
             },
         };
@@ -266,8 +329,8 @@ impl GraphToLogical {
         if edge.quantifier.is_some() {
             not_yet_implemented_result!("MATCH edge quantifiers are not yet supported.");
         }
-        if edge.prefilter.is_some() {
-            not_yet_implemented_result!("MATCH edge prefilters are not yet supported.");
+        if edge.where_clause.is_some() {
+            not_yet_implemented_result!("MATCH edge where_clauses are not yet supported.");
         }
         let direction = match &edge.direction {
             GraphMatchDirection::Left => DirectionFilter::L,
@@ -282,10 +345,11 @@ impl GraphToLogical {
             None => self.graph_id.node(),
             Some(v) => v.value.clone(),
         };
+        let label = self.plan_graph_pattern_label(edge.label.as_deref())?;
         let edge_match = EdgeMatch {
             binder: BindSpec(binder),
             spec: EdgeFilter {
-                label: self.plan_graph_pattern_label(&edge.label)?,
+                label,
                 filter: ValueFilter::Always,
             },
         };

partiql-logical-planner/src/lower.rs

@@ -1512,6 +1512,11 @@ impl<'ast> Visitor<'ast> for AstToLogical<'_> {
                 as_key,
                 at_key,
             }),
+            FromLetKind::GraphTable => logical::BindingsOp::Scan(logical::Scan {
+                expr,
+                as_key,
+                at_key,
+            }),
         };
         let id = self.plan.add_operator(bexpr);
         self.push_bexpr(id);
@@ -1899,16 +1904,19 @@ impl<'ast> Visitor<'ast> for AstToLogical<'_> {
         self.enter_env();
         Traverse::Continue
     }
-    fn exit_graph_match(&mut self, graph_pattern: &'ast GraphMatch) -> Traverse {
+    fn exit_graph_match(&mut self, graph_match: &'ast GraphMatch) -> Traverse {
         let mut env = self.exit_env();
         true_or_fault!(self, env.len() == 1, "env.len() is not 1");
 
-        let value = Box::new(env.pop().unwrap());
+        let graph_reference = Box::new(env.pop().unwrap());
         let graph_planner = crate::graph::GraphToLogical::default();
-        match graph_planner.plan_graph_match(&graph_pattern.graph_expr.node) {
-            Ok(pattern) => {
-                self.push_vexpr(ValueExpr::GraphMatch(GraphMatchExpr { value, pattern }));
 
+        match graph_planner.plan_graph_match(&graph_match) {
+            Ok(pattern) => {
+                self.push_vexpr(ValueExpr::GraphMatch(GraphMatchExpr {
+                    value: graph_reference,
+                    pattern,
+                }));
                 Traverse::Continue
             }
             Err(e) => {

partiql/tests/graph.rs

@@ -1,6 +1,16 @@
+use insta::assert_snapshot;
+use partiql_catalog::catalog::PartiqlCatalog;
+use partiql_catalog::context::SystemContext;
+use partiql_common::pretty::ToPretty;
+use partiql_eval::eval::graph::string_graph::StringGraphTypes;
+use partiql_eval::eval::BasicContext;
+use partiql_eval::plan::EvaluationMode;
 use partiql_extension_ion::decode::{IonDecodeResult, IonDecoderBuilder, IonDecoderConfig};
 
+use crate::common::{compile, evaluate, lower, parse};
 use partiql_extension_ion::Encoding;
+use partiql_value::{tuple, DateTime, Value};
+
 mod common;
 
 #[track_caller]
@@ -155,3 +165,34 @@ fn repeated_identifers() {
                                  {id:e1, ends: (n1 -- n1)} ] }"##,
     )
 }
+
+#[track_caller]
+fn snapshot_test_graph_eval(name: &'static str, contents: &'static str, query: &'static str) {
+    let graph = decode_ion_text(contents, Encoding::PartiqlEncodedAsIon).expect("graph decode");
+    let bindings = tuple![("g", graph)];
+
+    let parsed = parse(query).expect("parse");
+    let catalog = PartiqlCatalog::default();
+    let lowered = lower(&catalog, &parsed).expect("lower");
+    let plan = compile(EvaluationMode::Permissive, &catalog, lowered).expect("compile");
+    let res = evaluate(plan, bindings.into());
+    assert!(res.is_ok());
+    assert_snapshot!(name, res.unwrap().result);
+}
+
+#[test]
+fn select_star_rfc_0025() {
+    // The RFC 0025 graph has no payloads so these just return an appropriate number of `{}`
+    let contents = include_str!("resources/rfc0025-example.ion");
+    snapshot_test_graph_eval("RFC0025 Nodes", contents, "(g MATCH (x))");
+    snapshot_test_graph_eval("RFC0025 L Triples", contents, "(g MATCH (x) -> (y))");
+    snapshot_test_graph_eval("RFC0025 LUR Triples", contents, "(g MATCH (x) - (y))");
+}
+
+#[test]
+fn select_star_gpml_paper() {
+    let contents = include_str!("resources/gpml-paper-example.ion");
+    snapshot_test_graph_eval("GPML Nodes", contents, "(g MATCH (x))");
+    snapshot_test_graph_eval("GPML L Triples", contents, "(g MATCH (x) -[e]-> (y))");
+    snapshot_test_graph_eval("GPML LUR Triples", contents, "(g MATCH (x) -[e]- (y))");
+}

partiql/tests/snapshots/graph__GPML L Triples.snap

@@ -0,0 +1,57 @@
+---
+source: partiql/tests/graph.rs
+expression: res.unwrap().result
+---
+<<
+  { 'x': { 'owner': 'Scott', 'isBlocked': 'no' }, 'y': { 'name': 'Zembla' } },
+  {
+    'x': { 'owner': 'Aretha', 'isBlocked': 'no' },
+    'y': { 'name': 'Ankh-Morpork' }
+  },
+  { 'x': { 'owner': 'Mike', 'isBlocked': 'no' }, 'y': { 'name': 'Zembla' } },
+  {
+    'x': { 'owner': 'Jay', 'isBlocked': 'yes' },
+    'y': { 'name': 'Ankh-Morpork' }
+  },
+  { 'x': { 'owner': 'Charles', 'isBlocked': 'no' }, 'y': { 'name': 'Zembla' } },
+  {
+    'x': { 'owner': 'Scott', 'isBlocked': 'no' },
+    'e': { 'date': TIMESTAMP '2020-01-01 0:00:00.0', 'amount': 8000000.00 },
+    'y': { 'owner': 'Mike', 'isBlocked': 'no' }
+  },
+  {
+    'x': { 'owner': 'Mike', 'isBlocked': 'no' },
+    'e': { 'date': TIMESTAMP '2020-02-01 0:00:00.0', 'amount': 10000000.00 },
+    'y': { 'owner': 'Aretha', 'isBlocked': 'no' }
+  },
+  {
+    'x': { 'owner': 'Aretha', 'isBlocked': 'no' },
+    'e': { 'date': TIMESTAMP '2020-03-01 0:00:00.0', 'amount': 10000000.00 },
+    'y': { 'owner': 'Jay', 'isBlocked': 'yes' }
+  },
+  {
+    'x': { 'owner': 'Jay', 'isBlocked': 'yes' },
+    'e': { 'date': TIMESTAMP '2020-04-01 0:00:00.0', 'amount': 10000000.00 },
+    'y': { 'owner': 'Dave', 'isBlocked': 'no' }
+  },
+  {
+    'x': { 'owner': 'Dave', 'isBlocked': 'no' },
+    'e': { 'date': TIMESTAMP '2020-06-01 0:00:00.0', 'amount': 10000000.00 },
+    'y': { 'owner': 'Mike', 'isBlocked': 'no' }
+  },
+  {
+    'x': { 'owner': 'Dave', 'isBlocked': 'no' },
+    'e': { 'date': TIMESTAMP '2020-07-01 0:00:00.0', 'amount': 4000000.00 },
+    'y': { 'owner': 'Charles', 'isBlocked': 'no' }
+  },
+  {
+    'x': { 'owner': 'Mike', 'isBlocked': 'no' },
+    'e': { 'date': TIMESTAMP '2020-08-01 0:00:00.0', 'amount': 6000000.00 },
+    'y': { 'owner': 'Charles', 'isBlocked': 'no' }
+  },
+  {
+    'x': { 'owner': 'Charles', 'isBlocked': 'no' },
+    'e': { 'date': TIMESTAMP '2020-09-01 0:00:00.0', 'amount': 9000000.00 },
+    'y': { 'owner': 'Scott', 'isBlocked': 'no' }
+  }
+>>