Implement Graph evaluation for matches without alternatives (#547)

Author: jpschorr

extension/partiql-extension-ddl/Cargo.toml

@@ -27,7 +27,7 @@ thiserror = "1.0"
 miette = { version = "7", features = ["fancy"] }
 time = { version = "0.3", features = ["formatting", "parsing", "serde"] }
 
-indexmap = "2.5"
+indexmap = "2"
 
 [dev-dependencies]
 

extension/partiql-extension-ion/tests/test.rs

@@ -180,6 +180,9 @@ fn flatten_dump_owned(prefix: &str, value: Value, indent: usize) -> String {
             assert_eq!(datum_lowered_value_stats, datum_owned_value_stats);
             result += &datum_owned_value_stats;
         }
+        _ => {
+            unreachable!("unhandled category")
+        }
     }
     result
 }
@@ -279,6 +282,9 @@ fn flatten_dump_ref(prefix: &str, value: Value, indent: usize) -> String {
             assert_eq!(datum_lowered_value_stats, datum_owned_value_stats);
             result += &datum_owned_value_stats;
         }
+        _ => {
+            unreachable!("unhandled category")
+        }
     }
     result
 }

partiql-ast-passes/Cargo.toml

@@ -26,7 +26,7 @@ partiql-common = { path = "../partiql-common", version = "0.11.*" }
 partiql-types = { path = "../partiql-types", version = "0.11.*" }
 
 fnv = "1"
-indexmap = "2.5"
+indexmap = "2"
 thiserror = "1.0"
 
 [dev-dependencies]

partiql-ast/Cargo.toml

@@ -21,7 +21,7 @@ bench = false
 
 [dependencies]
 partiql-common = { path = "../partiql-common", version = "0.11.*" }
-indexmap = "2.5"
+indexmap = "2"
 rust_decimal = { version = "1.36.0", default-features = false, features = ["std"] }
 serde = { version = "1", features = ["derive"], optional = true }
 pretty = "0.12"

partiql-common/Cargo.toml

@@ -20,7 +20,7 @@ path = "src/lib.rs"
 bench = false
 
 [dependencies]
-indexmap = "2.5"
+indexmap = "2"
 pretty = "0.12"
 serde = { version = "1", features = ["derive"], optional = true }
 rust_decimal = { version = "1.36", default-features = false, features = ["std"] }

partiql-conformance-tests/src/bin/generate_comparison_report.rs

@@ -20,7 +20,7 @@ struct CTSReport {
 /// - number of tests passing in both reports
 /// - number of tests failing in both reports
 /// - number of tests passing in the first report but now fail in the second report (i.e. tests with
-/// regressed behavior)
+///   regressed behavior)
 ///   - also lists out these tests and gives a warning
 /// - number of tests failing in the first report but now pass in the second report
 ///   - also lists out these tests

partiql-eval/Cargo.toml

@@ -27,7 +27,11 @@ partiql-value = { path = "../partiql-value", version = "0.11.*" }
 partiql-catalog = { path = "../partiql-catalog", version = "0.11.*" }
 partiql-types = { path = "../partiql-types", version = "0.11.*" }
 partiql-extension-ion = { path = "../extension/partiql-extension-ion", version = "0.11.*" }
+ion-rs_old = { version = "0.18", package = "ion-rs" }
+lasso = "0.7"
 petgraph = "0.7"
+fxhash = "0.2"
+indexmap = "2"
 ordered-float = "4"
 itertools = "0.13"
 unicase = "2"
@@ -44,6 +48,8 @@ serde = { version = "1", features = ["derive"], optional = true }
 
 [dev-dependencies]
 criterion = "0.5"
+partiql-parser = { path = "../partiql-parser", version = "0.11.*" }
+partiql-logical-planner = { path = "../partiql-logical-planner", version = "0.11.*" }
 
 
 [features]

partiql-eval/src/eval/eval_expr_wrapper.rs

@@ -62,6 +62,9 @@ impl TypeSatisfier for Static {
             (StaticCategory::Tuple(), DatumCategoryRef::Tuple(_)) => {
                 true // TODO when Static typing knows how to type a tuple
             }
+            (StaticCategory::Graph(), DatumCategoryRef::Graph(_)) => {
+                true // TODO when Static typing knows how to type a graph
+            }
             _ => false,
         }
     }

partiql-eval/src/eval/evaluable.rs

@@ -23,10 +23,10 @@ macro_rules! take_input {
     ($expr:expr, $ctx:expr) => {
         match $expr {
             None => {
-                $ctx.add_error(EvaluationError::IllegalState(
+                $ctx.add_error($crate::error::EvaluationError::IllegalState(
                     "Error in retrieving input value".to_string(),
                 ));
-                return Missing;
+                return partiql_value::Value::Missing;
             }
             Some(val) => val,
         }

partiql-eval/src/eval/graph/bind_name.rs

@@ -0,0 +1,45 @@
+use std::sync::atomic::AtomicU32;
+use std::sync::atomic::Ordering::Relaxed;
+
+/// A unicode non-character prefixed onto 'anonymous' bind names
+const ANON_PREFIX: char = '\u{FDD0}';
+
+pub trait BindNameExt {
+    fn is_anon(&self) -> bool;
+}
+
+impl<S: AsRef<str>> BindNameExt for S {
+    fn is_anon(&self) -> bool {
+        self.as_ref().starts_with(ANON_PREFIX)
+    }
+}
+
+/// Creates 'fresh' bind names
+pub struct FreshBinder {
+    #[allow(dead_code)] // TODO remove once graph planning is implemented
+    node: AtomicU32,
+
+    #[allow(dead_code)] // TODO remove once graph planning is implemented
+    edge: AtomicU32,
+}
+
+impl Default for FreshBinder {
+    fn default() -> Self {
+        Self {
+            node: AtomicU32::new(1),
+            edge: AtomicU32::new(1),
+        }
+    }
+}
+
+impl FreshBinder {
+    #[allow(dead_code)] // TODO remove once graph planning is implemented
+    pub fn node(&self) -> String {
+        format!("{ANON_PREFIX}🞎{}", self.node.fetch_add(1, Relaxed))
+    }
+
+    #[allow(dead_code)] // TODO remove once graph planning is implemented
+    pub fn edge(&self) -> String {
+        format!("{ANON_PREFIX}⁃{}", self.edge.fetch_add(1, Relaxed))
+    }
+}

partiql-eval/src/eval/graph/engine.rs

@@ -0,0 +1,82 @@
+use crate::eval::graph::plan::{
+    DirectionFilter, GraphPlanConvert, NodeFilter, StepFilter, TripleFilter,
+};
+use crate::eval::graph::result::Triple;
+use crate::eval::graph::string_graph::types::StringGraphTypes;
+use crate::eval::graph::types::GraphTypes;
+use partiql_value::Value;
+
+/// A graph 'engine'; Exposes scanning, node access, and plan conversion to a target graph.
+pub trait GraphEngine<GT: GraphTypes>:
+    GraphScan<GT>
+    + GraphPlanConvert<StringGraphTypes, GT>
+    + GraphPlanConvert<GT, StringGraphTypes>
+    + GraphAccess<GT>
+{
+}
+
+/// A trait to scan paths and nodes for a graph.
+pub trait GraphScan<GT: GraphTypes> {
+    fn scan(&self, spec: &StepFilter<GT>) -> Vec<Triple<GT>>;
+    fn get(&self, spec: &NodeFilter<GT>) -> Vec<GT::NodeId>;
+}
+
+/// A trait to retrieve named nodes and edges for a graph.
+pub trait GraphAccess<GT: GraphTypes> {
+    fn node(&self, id: &GT::NodeId) -> &Option<Value>;
+    fn edge(&self, id: &GT::EdgeId) -> &Option<Value>;
+}
+
+/// A train to scan paths and nodes for a triple-based graph.
+pub trait TripleScan<GT: GraphTypes> {
+    fn scan_directed_from_to(&self, spec: &TripleFilter<GT>) -> impl Iterator<Item = Triple<GT>>;
+
+    fn scan_directed_to_from(&self, spec: &TripleFilter<GT>) -> impl Iterator<Item = Triple<GT>>;
+
+    fn scan_directed_both(&self, spec: &TripleFilter<GT>) -> impl Iterator<Item = Triple<GT>>;
+
+    fn scan_undirected(&self, spec: &TripleFilter<GT>) -> impl Iterator<Item = Triple<GT>>;
+    fn get(&self, spec: &NodeFilter<GT>) -> Vec<GT::NodeId>;
+}
+
+impl<T, GT> GraphScan<GT> for T
+where
+    GT: GraphTypes,
+    T: TripleScan<GT>,
+{
+    fn scan(&self, spec: &StepFilter<GT>) -> Vec<Triple<GT>> {
+        let StepFilter { dir, triple } = spec;
+        let (to_from, undirected, from_to) = match dir {
+            DirectionFilter::L => (true, false, false),
+            DirectionFilter::U => (false, true, false),
+            DirectionFilter::R => (false, false, true),
+            DirectionFilter::LU => (true, true, false),
+            DirectionFilter::UR => (false, true, true),
+            DirectionFilter::LR => (true, false, true),
+            DirectionFilter::LUR => (true, true, true),
+        };
+
+        let mut result = vec![];
+        if undirected {
+            result.extend(self.scan_undirected(triple));
+        }
+        match (from_to, to_from) {
+            (true, true) => {
+                result.extend(self.scan_directed_both(triple));
+            }
+            (true, false) => {
+                result.extend(self.scan_directed_from_to(triple));
+            }
+            (false, true) => {
+                result.extend(self.scan_directed_to_from(triple));
+            }
+            (false, false) => {}
+        }
+
+        result
+    }
+
+    fn get(&self, spec: &NodeFilter<GT>) -> Vec<GT::NodeId> {
+        TripleScan::get(self, spec)
+    }
+}