Support LogicalExpr for op in FilterValueAst

Author: utkarshgupta137

engine/src/ast/logical_expr.rs

@@ -206,7 +206,7 @@ impl LogicalExpr {
         }
     }
 
-    fn lex_quantifier_expr<'i>(
+    pub(crate) fn lex_quantifier_expr<'i>(
         input: &'i str,
         parser: &FilterParser<'_>,
     ) -> Option<LexResult<'i, Self>> {

engine/src/ast/mod.rs

@@ -13,7 +13,7 @@ use crate::compiler::{Compiler, DefaultCompiler};
 use crate::filter::{CompiledExpr, CompiledValueExpr, Filter, FilterValue};
 use crate::lex::{LexErrorKind, LexResult, LexWith};
 use crate::scheme::{Scheme, UnknownFieldError};
-use crate::types::{GetType, Type, TypeMismatchError};
+use crate::types::{GetType, LhsValue, Type, TypeMismatchError};
 use serde::Serialize;
 use std::fmt::{self, Debug};
 
@@ -164,6 +164,75 @@ impl FilterAst {
     }
 }
 
+/// The root expression of a parsed value AST.
+#[derive(PartialEq, Eq, Serialize, Clone, Hash)]
+#[serde(untagged)]
+pub enum FilterValueExpr {
+    /// An indexed field or function-call expression.
+    Index(IndexExpr),
+    /// A logical expression that evaluates to a scalar boolean value.
+    Logical(LogicalExpr),
+}
+
+impl Debug for FilterValueExpr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Index(expr) => expr.fmt(f),
+            Self::Logical(expr) => expr.fmt(f),
+        }
+    }
+}
+
+impl<'i, 's> LexWith<'i, &FilterParser<'s>> for FilterValueExpr {
+    fn lex_with(input: &'i str, parser: &FilterParser<'s>) -> LexResult<'i, Self> {
+        if let Some(result) = LogicalExpr::lex_quantifier_expr(input, parser) {
+            result.map(|(expr, rest)| (FilterValueExpr::Logical(expr), rest))
+        } else {
+            IndexExpr::lex_with(input, parser)
+                .map(|(expr, rest)| (FilterValueExpr::Index(expr), rest))
+        }
+    }
+}
+
+impl ValueExpr for FilterValueExpr {
+    fn walk<'a, V: Visitor<'a>>(&'a self, visitor: &mut V) {
+        match self {
+            Self::Index(expr) => visitor.visit_index_expr(expr),
+            Self::Logical(expr) => visitor.visit_logical_expr(expr),
+        }
+    }
+
+    fn walk_mut<'a, V: VisitorMut<'a>>(&'a mut self, visitor: &mut V) {
+        match self {
+            Self::Index(expr) => visitor.visit_index_expr(expr),
+            Self::Logical(expr) => visitor.visit_logical_expr(expr),
+        }
+    }
+
+    fn compile_with_compiler<C: Compiler>(self, compiler: &mut C) -> CompiledValueExpr<C::U> {
+        match self {
+            Self::Index(expr) => compiler.compile_index_expr(expr),
+            Self::Logical(expr) => match compiler.compile_logical_expr(expr) {
+                CompiledExpr::One(expr) => {
+                    CompiledValueExpr::new(move |ctx| LhsValue::from(expr.execute(ctx)).into())
+                }
+                CompiledExpr::Vec(expr) => CompiledValueExpr::new(move |ctx| {
+                    LhsValue::Array(expr.execute(ctx).into()).into()
+                }),
+            },
+        }
+    }
+}
+
+impl GetType for FilterValueExpr {
+    fn get_type(&self) -> Type {
+        match self {
+            Self::Index(expr) => expr.get_type(),
+            Self::Logical(expr) => expr.get_type(),
+        }
+    }
+}
+
 /// A parsed value AST.
 ///
 /// It's attached to its corresponding [`Scheme`](struct@Scheme) because all
@@ -175,7 +244,7 @@ pub struct FilterValueAst {
     #[serde(skip)]
     scheme: Scheme,
 
-    op: IndexExpr,
+    op: FilterValueExpr,
 }
 
 impl Debug for FilterValueAst {
@@ -186,12 +255,14 @@ impl Debug for FilterValueAst {
 
 impl<'i, 's> LexWith<'i, &FilterParser<'s>> for FilterValueAst {
     fn lex_with(input: &'i str, parser: &FilterParser<'s>) -> LexResult<'i, Self> {
-        let (op, rest) = IndexExpr::lex_with(input.trim(), parser)?;
-        if op.map_each_count() > 0 {
+        let (op, rest) = FilterValueExpr::lex_with(input.trim(), parser)?;
+        if let FilterValueExpr::Index(expr) = &op
+            && expr.map_each_count() > 0
+        {
             Err((
                 LexErrorKind::TypeMismatch(TypeMismatchError {
-                    expected: op.get_type().into(),
-                    actual: Type::Array(op.get_type().into()),
+                    expected: expr.get_type().into(),
+                    actual: Type::Array(expr.get_type().into()),
                 }),
                 input,
             ))
@@ -216,20 +287,20 @@ impl FilterValueAst {
 
     /// Returns the associated expression.
     #[inline]
-    pub fn expression(&self) -> &IndexExpr {
+    pub fn expression(&self) -> &FilterValueExpr {
         &self.op
     }
 
     /// Recursively visit all nodes in the AST using a [`Visitor`].
     #[inline]
     pub fn walk<'a, V: Visitor<'a>>(&'a self, visitor: &mut V) {
-        visitor.visit_index_expr(&self.op)
+        visitor.visit_value_expr(&self.op)
     }
 
     /// Recursively visit all nodes in the AST using a [`VisitorMut`].
     #[inline]
     pub fn walk_mut<'a, V: VisitorMut<'a>>(&'a mut self, visitor: &mut V) {
-        visitor.visit_index_expr(&mut self.op)
+        visitor.visit_value_expr(&mut self.op)
     }
 
     /// Recursively checks whether a [`FilterAst`] uses a given field name.
@@ -254,7 +325,7 @@ impl FilterValueAst {
 
     /// Compiles a [`FilterValueAst`] into a [`FilterValue`] using a specific [`Compiler`].
     pub fn compile_with_compiler<C: Compiler>(self, compiler: &mut C) -> FilterValue<C::U> {
-        FilterValue::new(compiler.compile_index_expr(self.op), self.scheme)
+        FilterValue::new(compiler.compile_value_expr(self.op), self.scheme)
     }
 
     /// Compiles a [`FilterValueAst`] into a [`FilterValue`] using the [`DefaultCompiler`].

engine/src/lib.rs

@@ -89,7 +89,7 @@ pub use self::ast::logical_expr::{
 };
 pub use self::ast::parse::{FilterParser, ParseError, ParserSettings};
 pub use self::ast::visitor::{Visitor, VisitorMut};
-pub use self::ast::{Expr, FilterAst, FilterValueAst, ValueExpr};
+pub use self::ast::{Expr, FilterAst, FilterValueAst, FilterValueExpr, ValueExpr};
 pub use self::compiler::{Compiler, DefaultCompiler};
 pub use self::execution_context::{
     ExecutionContext, ExecutionContextGuard, InvalidListMatcherError, SetFieldValueError,

engine/src/scheme.rs

@@ -1260,6 +1260,71 @@ fn test_parse_error() {
     }
 }
 
+#[test]
+fn test_parse_quantifier_as_value() {
+    use crate::{Array, ExecutionContext, LhsValue};
+
+    let scheme = Scheme! {
+        values: Array(Bytes),
+    }
+    .build();
+    let ast = scheme
+        .parse_value(r#"any(values[*] in {"HIT" "UPDATE"})"#)
+        .unwrap();
+
+    assert_json!(scheme.parse_value("values").unwrap(), "values");
+    assert!(
+        scheme
+            .parse_value(r#"all(values[*] in {"HIT" "UPDATE"})"#)
+            .is_ok()
+    );
+
+    assert_eq!(ast.get_type(), Type::Bool);
+    assert_json!(
+        ast,
+        {
+            "op": "Any",
+            "arg": {
+                "kind": "SimpleExpr",
+                "value": {
+                    "lhs": ["values", { "kind": "MapEach" }],
+                    "op": "OneOf",
+                    "rhs": ["HIT", "UPDATE"]
+                }
+            }
+        }
+    );
+
+    let mut ctx = ExecutionContext::new(&scheme);
+    ctx.set_field_value(
+        scheme.get_field("values").unwrap(),
+        Array::from_iter(["MISS", "HIT"]),
+    )
+    .unwrap();
+    assert_eq!(ast.compile().execute(&ctx), Ok(Ok(LhsValue::Bool(true))));
+}
+
+#[test]
+fn test_parse_value_rejects_non_quantifier_logical_expressions() {
+    let scheme = Scheme! {
+        values: Array(Bytes),
+    }
+    .build();
+
+    for input in [
+        // LogicalExpr::Comparison
+        r#"values[0] == "HIT""#,
+        // LogicalExpr::Parenthesized
+        r#"(any(values[*] == "HIT"))"#,
+        // LogicalExpr::Unary
+        r#"not any(values[*] == "HIT")"#,
+        // LogicalExpr::Combining
+        r#"any(values[*] == "HIT") and any(values[*] == "UPDATE")"#,
+    ] {
+        assert!(scheme.parse_value(input).is_err(), "parsed {input:?}");
+    }
+}
+
 #[test]
 fn test_parse_error_in_op() {
     use cidr::errors::NetworkParseError;