Fix issues with the initial draft of the quad pattern node

Cargo.toml

@@ -58,9 +58,12 @@ uuid = "1.14.0"
 zip-extract = "0.3.0"
 
 # Upstream Oxigraph dependencies
-oxttl = "0.1.7"
-oxrdfio = "0.1.7"
-sparesults = "0.2.4"
+oxttl = "0.1.8"
+oxiri = "0.2.11"
+oxrdf = "0.2.4"
+oxrdfio = "0.1.8"
+oxsdatatypes = "0.2.2"
+sparesults = "0.2.5"
 spargebra = "0.3.5"
 
 # Internal dependencies

lib/common/src/blank_node_mode.rs

@@ -0,0 +1,9 @@
+/// TODO
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
+pub enum BlankNodeMatchingMode {
+    /// A blank node is interpreted as a variable.
+    #[default]
+    Variable,
+    /// A blank node is interpreted as a constant filter.
+    Filter,
+}

lib/common/src/lib.rs

@@ -1,8 +1,10 @@
 extern crate core;
 
+mod blank_node_mode;
 pub mod error;
 mod quad_storage;
 
+pub use blank_node_mode::BlankNodeMatchingMode;
 pub use quad_storage::QuadPatternEvaluator;
 pub use quad_storage::QuadStorage;
 

lib/common/src/quad_storage.rs

@@ -1,12 +1,12 @@
 use crate::error::StorageError;
-use crate::DFResult;
+use crate::{BlankNodeMatchingMode, DFResult};
 use async_trait::async_trait;
 use datafusion::datasource::TableProvider;
 use datafusion::execution::SendableRecordBatchStream;
 use datafusion::physical_planner::ExtensionPlanner;
 use rdf_fusion_model::{
-    GraphNameRef, NamedNodeRef, NamedOrBlankNode, NamedOrBlankNodeRef, Quad, QuadRef, SubjectRef,
-    TermRef,
+    GraphName, GraphNameRef, NamedOrBlankNode, NamedOrBlankNodeRef, Quad, QuadRef, TriplePattern,
+    Variable,
 };
 use std::fmt::Debug;
 use std::sync::Arc;
@@ -72,17 +72,14 @@ pub trait QuadStorage: Send + Sync {
 pub trait QuadPatternEvaluator: Debug + Send + Sync {
     /// Returns a stream of quads that match the given pattern.
     ///
-    /// The resulting stream must have a schema that is compatible with the default schema for
-    /// quads. Each emitted batch should have `batch_size` elements.
-    ///
-    /// While currently we can only filter for constant patterns, in the future this method
-    /// should be able to evaluate arbitrary patterns (i.e., including variables).
-    fn quads_for_pattern(
+    /// The resulting stream must have a schema that projects to the variables provided in the
+    /// arguments. Each emitted batch should have `batch_size` elements.
+    fn evaluate_pattern(
         &self,
-        graph: GraphNameRef<'_>,
-        subject: Option<SubjectRef<'_>>,
-        predicate: Option<NamedNodeRef<'_>>,
-        object: Option<TermRef<'_>>,
+        graph: GraphName,
+        graph_variable: Option<Variable>,
+        pattern: TriplePattern,
+        blank_node_mode: BlankNodeMatchingMode,
         batch_size: usize,
     ) -> DFResult<SendableRecordBatchStream>;
 }

lib/engine/src/engine.rs

@@ -80,7 +80,7 @@ impl RdfFusionInstance {
     /// Checks whether `quad` is contained in the instance.
     pub async fn contains(&self, quad: &QuadRef<'_>) -> DFResult<bool> {
         let active_graph_info = graph_name_to_active_graph(Some(quad.graph_name));
-        let pattern_plan = RdfFusionLogicalPlanBuilder::new_from_quads(
+        let pattern_plan = RdfFusionLogicalPlanBuilder::new_from_matching_quads(
             Arc::clone(&self.functions),
             active_graph_info,
             Some(quad.subject.into_owned()),
@@ -109,7 +109,7 @@ impl RdfFusionInstance {
         object: Option<TermRef<'_>>,
     ) -> DFResult<SendableRecordBatchStream> {
         let active_graph_info = graph_name_to_active_graph(graph_name);
-        let pattern_plan = RdfFusionLogicalPlanBuilder::new_from_quads(
+        let pattern_plan = RdfFusionLogicalPlanBuilder::new_from_matching_quads(
             Arc::clone(&self.functions),
             active_graph_info,
             subject.map(SubjectRef::into_owned),

lib/engine/src/sparql/rewriting/graph_pattern_rewriter.rs

@@ -186,14 +186,14 @@ impl GraphPatternRewriter {
                 object,
             } => {
                 let state = self.state.borrow();
-                RdfFusionLogicalPlanBuilder::new_from_property_path(
+                Ok(RdfFusionLogicalPlanBuilder::new_from_property_path(
                     Arc::clone(&self.registry),
                     state.active_graph.clone(),
                     state.graph_name_var.clone(),
                     path.clone(),
                     subject.clone(),
                     object.clone(),
-                )
+                ))
             }
             GraphPattern::Minus { left, right } => {
                 let left = self.rewrite_graph_pattern(left)?;

lib/logical/Cargo.toml

@@ -12,7 +12,6 @@ rdf-fusion-encoding.workspace = true
 rdf-fusion-functions.workspace = true
 datafusion.workspace = true
 rdf-fusion-model.workspace = true
-spargebra.workspace = true
 
 [lints]
 workspace = true

lib/logical/src/lib.rs

@@ -9,7 +9,7 @@ mod logical_plan_builder;
 pub mod minus;
 pub mod paths;
 pub mod patterns;
-pub mod quads;
+pub mod quad_pattern;
 
 pub use active_graph::{ActiveGraph, EnumeratedActiveGraph};
 use datafusion::common::{plan_err, DFSchema};