Enum FilterExpr 

pub enum FilterExpr {
    And(Box<FilterExpr>, Box<FilterExpr>),
    Or(Box<FilterExpr>, Box<FilterExpr>),
    Not(Box<FilterExpr>),
    Compare {
        field: String,
        op: FilterOp,
        value: Value,
    },
    Exists(String),
    All,
    None,
}

Filter expression for metadata-based filtering

Supports composable boolean logic (AND, OR, NOT) and various comparison operators for flexible query filtering.

Example

use embedvec::FilterExpr;

let filter = FilterExpr::eq("category", "finance")
    .and(FilterExpr::gt("timestamp", 1730000000))
    .and(FilterExpr::not(FilterExpr::eq("status", "archived")));

Variants

And(Box<FilterExpr>, Box<FilterExpr>)

Logical AND of two expressions

Or(Box<FilterExpr>, Box<FilterExpr>)

Logical OR of two expressions

Not(Box<FilterExpr>)

Logical NOT of an expression

Compare

Comparison operation on a field

Fields

field: String

Field name to compare

op: FilterOp

Comparison operator

value: Value

Value to compare against

Exists(String)

Check if field exists

All

Always true (no filter)

None

Always false (match nothing)

Implementations

impl FilterExpr

pub fn eq(field: impl Into<String>, value: impl Into<Value>) -> Self

Create an equality filter: field == value

pub fn neq(field: impl Into<String>, value: impl Into<Value>) -> Self

Create a not-equal filter: field != value

pub fn gt(field: impl Into<String>, value: impl Into<Value>) -> Self

Create a greater-than filter: field > value

pub fn gte(field: impl Into<String>, value: impl Into<Value>) -> Self

Create a greater-than-or-equal filter: field >= value

pub fn lt(field: impl Into<String>, value: impl Into<Value>) -> Self

Create a less-than filter: field < value

pub fn lte(field: impl Into<String>, value: impl Into<Value>) -> Self

Create a less-than-or-equal filter: field <= value

pub fn in_values(field: impl Into<String>, values: Vec<Value>) -> Self

Create an “in” filter: field in [values…]

pub fn contains(field: impl Into<String>, substring: impl Into<String>) -> Self

Create a contains filter: field contains substring

pub fn starts_with(field: impl Into<String>, prefix: impl Into<String>) -> Self

Create a starts-with filter

pub fn ends_with(field: impl Into<String>, suffix: impl Into<String>) -> Self

Create an ends-with filter

pub fn exists(field: impl Into<String>) -> Self

Create an exists filter: field exists

pub fn not(expr: FilterExpr) -> Self

Create a NOT expression

pub fn and(self, other: FilterExpr) -> Self

Combine with AND

pub fn or(self, other: FilterExpr) -> Self

Combine with OR

pub fn matches(&self, metadata: &Metadata) -> bool

Evaluate filter against metadata

Arguments

• metadata - The metadata to evaluate against

Returns

true if metadata matches the filter

Trait Implementations

impl Clone for FilterExpr

fn clone(&self) -> FilterExpr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FilterExpr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FilterExpr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for FilterExpr

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.