wirerust 0.1.0

A modular, embeddable filter engine for structured data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! Filter module: wraps compiled filters and provides the main execution API.
//!
//! This module provides the CompiledFilter type.

use crate::compiler::IrCompiledFilter;

/// A compiled filter, ready for execution.
pub struct CompiledFilter {
    ir: IrCompiledFilter,
}

impl CompiledFilter {
    /// Create a new compiled filter from an expression, schema, and function registry.
    pub fn new(
        expr: crate::expr::FilterExpr,
        schema: std::sync::Arc<crate::schema::FilterSchema>,
        functions: std::sync::Arc<crate::functions::FunctionRegistry>,
    ) -> Self {
        let ir = crate::compiler::DefaultCompiler::compile(expr, schema, functions);
        Self { ir }
    }
    /// Execute the filter against a context.
    pub fn execute(
        &self,
        context: &crate::context::FilterContext,
    ) -> Result<bool, crate::WirerustError> {
        self.ir.execute(context)
    }
    /// Get a reference to the schema used by this filter.
    pub fn schema(&self) -> &crate::schema::FilterSchema {
        &self.ir.schema
    }
    /// Get a reference to the function registry used by this filter.
    pub fn functions(&self) -> &crate::functions::FunctionRegistry {
        &self.ir.functions
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::context::FilterContext;
    use crate::expr::{ComparisonOp, FilterExpr};
    use crate::functions::FunctionRegistry;
    use crate::schema::FilterSchema;
    use crate::schema::FilterSchemaBuilder;
    use crate::types::{FieldType, LiteralValue};
    use std::sync::Arc;

    fn schema() -> FilterSchema {
        FilterSchemaBuilder::new()
            .field("foo", FieldType::Int)
            .field("bar", FieldType::Bytes)
            .build()
    }

    fn context() -> FilterContext {
        let mut ctx = FilterContext::new();
        let sch = schema();
        ctx.set("foo", LiteralValue::Int(42), &sch).unwrap();
        ctx.set("bar", LiteralValue::Bytes(Arc::new(b"baz".to_vec())), &sch)
            .unwrap();
        ctx
    }

    #[test]
    fn test_compiled_filter_execute_true() {
        let expr = FilterExpr::Comparison {
            left: Box::new(FilterExpr::Value(LiteralValue::Bytes(Arc::new(
                b"foo".to_vec(),
            )))),
            op: ComparisonOp::Eq,
            right: Box::new(FilterExpr::Value(LiteralValue::Int(42))),
        };
        let filter =
            CompiledFilter::new(expr, Arc::new(schema()), Arc::new(FunctionRegistry::new()));
        assert!(filter.execute(&context()).unwrap());
    }

    #[test]
    fn test_compiled_filter_execute_false() {
        let expr = FilterExpr::Comparison {
            left: Box::new(FilterExpr::Value(LiteralValue::Bytes(Arc::new(
                b"foo".to_vec(),
            )))),
            op: ComparisonOp::Eq,
            right: Box::new(FilterExpr::Value(LiteralValue::Int(0))),
        };
        let filter =
            CompiledFilter::new(expr, Arc::new(schema()), Arc::new(FunctionRegistry::new()));
        assert!(!filter.execute(&context()).unwrap());
    }

    #[test]
    fn test_compiled_filter_schema_access() {
        let expr = FilterExpr::Comparison {
            left: Box::new(FilterExpr::Value(LiteralValue::Bytes(Arc::new(
                b"foo".to_vec(),
            )))),
            op: ComparisonOp::Eq,
            right: Box::new(FilterExpr::Value(LiteralValue::Int(42))),
        };
        let filter =
            CompiledFilter::new(expr, Arc::new(schema()), Arc::new(FunctionRegistry::new()));
        let sch = filter.schema();
        assert_eq!(sch.get_field_type("foo"), Some(&FieldType::Int));
    }
}