feat(cognitarium): add expression filtering in where clause

amimart · amimart · commit 945bc3a6c89e · 2024-08-22T10:40:27.000+02:00
diff --git a/contracts/axone-cognitarium/src/msg.rs b/contracts/axone-cognitarium/src/msg.rs
@@ -464,7 +464,7 @@ pub enum SelectItem {
 }
 
 /// # WhereClause
-/// Represents a WHERE clause in a [SelectQuery], i.e. a set of conditions to filter the results.
+/// Represents a WHERE clause, i.e. a set of conditions to filter the results.
 #[cw_serde]
 pub enum WhereClause {
     /// # Bgp
@@ -474,6 +474,42 @@ pub enum WhereClause {
     /// # LateralJoin
     /// Evaluates right for all result row of left
     LateralJoin { left: Box<Self>, right: Box<Self> },
+
+    /// # Filter
+    /// Filters the inner clause matching the expression.
+    /// The solutions coming from the inner clause that do not match the expression are discarded.
+    /// The variables provided in the inner clause are available in the filter expression.
+    Filter { expr: Expression, inner: Box<Self> },
+}
+
+/// # Expression
+/// Represents a logical combination of operations whose evaluation results in a term.
+#[cw_serde]
+pub enum Expression {
+    /// A named node constant.
+    NamedNode(IRI),
+    /// A literal constant.
+    Literal(Literal),
+    /// A variable that must be bound for evaluation.
+    Variable(String),
+    /// Logical conjunction of expressions.
+    /// All expressions must evaluate to true for the conjunction to be true.
+    /// If the conjunction is empty, it is considered true.
+    And(Vec<Self>),
+    /// Logical disjunction of expressions.
+    /// At least one expression must evaluate to true for the disjunction to be true.
+    /// If the disjunction is empty, it is considered false.
+    Or(Vec<Self>),
+    /// Equality comparison.
+    Equal(Box<Self>, Box<Self>),
+    /// Greater than comparison.
+    Greater(Box<Self>, Box<Self>),
+    /// Greater or equal comparison.
+    GreaterOrEqual(Box<Self>, Box<Self>),
+    /// Less than comparison.
+    Less(Box<Self>, Box<Self>),
+    /// Less or equal comparison.
+    LessOrEqual(Box<Self>, Box<Self>),
 }
 
 /// # TripleDeleteTemplate
diff --git a/contracts/axone-cognitarium/src/querier/engine.rs b/contracts/axone-cognitarium/src/querier/engine.rs
@@ -1,6 +1,7 @@
 use crate::msg::{
     Node, SelectItem, VarOrNamedNode, VarOrNamedNodeOrLiteral, VarOrNode, VarOrNodeOrLiteral,
 };
+use crate::querier::expression::Expression;
 use crate::querier::mapper::{iri_as_node, literal_as_object};
 use crate::querier::plan::{PatternValue, QueryNode, QueryPlan};
 use crate::querier::variable::{ResolvedVariable, ResolvedVariables};
@@ -159,6 +160,17 @@ impl<'a> QueryEngine<'a> {
                     Box::new(ForLoopJoinIterator::new(left(vars), right))
                 })
             }
+            QueryNode::Filter { expr, inner } => {
+                let inner = self.eval_node(*inner);
+                Rc::new(move |vars| {
+                    Box::new(FilterIterator::new(
+                        self.storage,
+                        inner(vars),
+                        expr.clone(),
+                        self.ns_cache.clone(),
+                    ))
+                })
+            }
             QueryNode::Skip { child, first } => {
                 let upstream = self.eval_node(*child);
                 Rc::new(move |vars| Box::new(upstream(vars).skip(first)))
@@ -173,6 +185,27 @@ impl<'a> QueryEngine<'a> {
 
 type ResolvedVariablesIterator<'a> = Box<dyn Iterator<Item = StdResult<ResolvedVariables>> + 'a>;
 
+struct FilterIterator<'a> {
+    upstream: ResolvedVariablesIterator<'a>,
+    expr: Expression,
+    ns_resolver: NamespaceResolver<'a>,
+}
+
+impl<'a> FilterIterator<'a> {
+    fn new(
+        storage: &'a dyn Storage,
+        upstream: ResolvedVariablesIterator<'a>,
+        expr: Expression,
+        ns_cache: Vec<Namespace>,
+    ) -> Self {
+        Self {
+            upstream,
+            expr,
+            ns_resolver: NamespaceResolver::new(storage, ns_cache.into()),
+        }
+    }
+}
+
 impl<'a> Iterator for FilterIterator<'a> {
     type Item = StdResult<ResolvedVariables>;
 
diff --git a/contracts/axone-cognitarium/src/querier/mod.rs b/contracts/axone-cognitarium/src/querier/mod.rs
@@ -1,4 +1,5 @@
 mod engine;
+mod expression;
 mod mapper;
 mod plan;
 mod plan_builder;
diff --git a/contracts/axone-cognitarium/src/querier/plan.rs b/contracts/axone-cognitarium/src/querier/plan.rs
@@ -1,3 +1,4 @@
+use crate::querier::expression::Expression;
 use crate::state::{Object, Predicate, Subject};
 use std::collections::BTreeSet;
 
@@ -73,6 +74,9 @@ pub enum QueryNode {
     /// left node to use them as right node values.
     ForLoopJoin { left: Box<Self>, right: Box<Self> },
 
+    /// Filter the results of the inner node by applying the expression.
+    Filter { expr: Expression, inner: Box<Self> },
+
     /// Skip the specified first elements from the child node.
     Skip { child: Box<Self>, first: usize },
 
@@ -114,6 +118,10 @@ impl QueryNode {
                 left.lookup_bound_variables(callback);
                 right.lookup_bound_variables(callback);
             }
+            QueryNode::Filter { expr, inner } => {
+                expr.lookup_bound_variables(callback);
+                inner.lookup_bound_variables(callback);
+            }
             QueryNode::Skip { child, .. } | QueryNode::Limit { child, .. } => {
                 child.lookup_bound_variables(callback);
             }
diff --git a/contracts/axone-cognitarium/src/querier/plan_builder.rs b/contracts/axone-cognitarium/src/querier/plan_builder.rs
@@ -1,10 +1,12 @@
+use crate::msg;
 use crate::msg::{Node, TriplePattern, VarOrNamedNode, VarOrNode, VarOrNodeOrLiteral, WhereClause};
+use crate::querier::expression::{Expression, Term};
 use crate::querier::mapper::{iri_as_node, literal_as_object};
 use crate::querier::plan::{PatternValue, PlanVariable, QueryNode, QueryPlan};
 use crate::state::{
     HasCachedNamespaces, Namespace, NamespaceQuerier, NamespaceResolver, Object, Predicate, Subject,
 };
-use cosmwasm_std::{StdResult, Storage};
+use cosmwasm_std::{StdError, StdResult, Storage};
 use std::collections::HashMap;
 
 pub struct PlanBuilder<'a> {
@@ -69,6 +71,18 @@ impl<'a> PlanBuilder<'a> {
                 left: Box::new(self.build_node(left)?),
                 right: Box::new(self.build_node(right)?),
             }),
+            WhereClause::Filter { expr, inner } => {
+                let inner = Box::new(self.build_node(inner)?);
+                let expr = self.build_expression(expr)?;
+
+                if !expr.bound_variables().is_subset(&inner.bound_variables()) {
+                    return Err(StdError::generic_err(
+                        "Unbound variable in filter expression",
+                    ));
+                }
+
+                Ok(QueryNode::Filter { expr, inner })
+            }
         }
     }
 
@@ -101,6 +115,50 @@ impl<'a> PlanBuilder<'a> {
             .unwrap_or(Ok(QueryNode::noop()))
     }
 
+    fn build_expression(&mut self, expr: &msg::Expression) -> StdResult<Expression> {
+        match expr {
+            msg::Expression::NamedNode(iri) => {
+                Term::from_iri(iri.clone(), self.prefixes).map(Expression::Constant)
+            }
+            msg::Expression::Literal(literal) => {
+                Term::from_literal(literal.clone(), self.prefixes).map(Expression::Constant)
+            }
+            msg::Expression::Variable(v) => Ok(Expression::Variable(
+                self.resolve_basic_variable(v.to_string()),
+            )),
+            msg::Expression::And(exprs) => exprs
+                .iter()
+                .map(|e| self.build_expression(e))
+                .collect::<StdResult<Vec<Expression>>>()
+                .map(Expression::And),
+            msg::Expression::Or(exprs) => exprs
+                .iter()
+                .map(|e| self.build_expression(e))
+                .collect::<StdResult<Vec<Expression>>>()
+                .map(Expression::Or),
+            msg::Expression::Equal(left, right) => Ok(Expression::Equal(
+                Box::new(self.build_expression(left)?),
+                Box::new(self.build_expression(right)?),
+            )),
+            msg::Expression::Greater(left, right) => Ok(Expression::Greater(
+                Box::new(self.build_expression(left)?),
+                Box::new(self.build_expression(right)?),
+            )),
+            msg::Expression::GreaterOrEqual(left, right) => Ok(Expression::GreaterOrEqual(
+                Box::new(self.build_expression(left)?),
+                Box::new(self.build_expression(right)?),
+            )),
+            msg::Expression::Less(left, right) => Ok(Expression::Less(
+                Box::new(self.build_expression(left)?),
+                Box::new(self.build_expression(right)?),
+            )),
+            msg::Expression::LessOrEqual(left, right) => Ok(Expression::LessOrEqual(
+                Box::new(self.build_expression(left)?),
+                Box::new(self.build_expression(right)?),
+            )),
+        }
+    }
+
     fn build_triple_pattern(&mut self, pattern: &TriplePattern) -> StdResult<QueryNode> {
         let subject_res = self.build_subject_pattern(pattern.subject.clone());
         let predicate_res = self.build_predicate_pattern(pattern.predicate.clone());

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`mod engine;`
	`2`	`+mod expression;`
`2`	`3`	`mod mapper;`
`3`	`4`	`mod plan;`
`4`	`5`	`mod plan_builder;`