Enum FilterCondition

pub enum FilterCondition {
    Eq(String, MetadataValue),
    Ne(String, MetadataValue),
    Gt(String, MetadataValue),
    Gte(String, MetadataValue),
    Lt(String, MetadataValue),
    Lte(String, MetadataValue),
    In(String, Vec<MetadataValue>),
    NotIn(String, Vec<MetadataValue>),
    Exists(String),
    NotExists(String),
    Contains(String, String),
    StartsWith(String, String),
    EndsWith(String, String),
    Regex(String, String),
    And(Vec<FilterCondition>),
    Or(Vec<FilterCondition>),
    Not(Box<FilterCondition>),
}

Filter conditions for querying vectors

Variants

Eq(String, MetadataValue)

Equality filter: field == value

Ne(String, MetadataValue)

Not equal filter: field != value

Gt(String, MetadataValue)

Greater than filter: field > value

Gte(String, MetadataValue)

Greater than or equal filter: field >= value

Lt(String, MetadataValue)

Less than filter: field < value

Lte(String, MetadataValue)

Less than or equal filter: field <= value

In(String, Vec<MetadataValue>)

In filter: field in [values]

NotIn(String, Vec<MetadataValue>)

Not in filter: field not in [values]

Exists(String)

Exists filter: field exists

NotExists(String)

Not exists filter: field does not exist

Contains(String, String)

Text contains filter: field contains substring

StartsWith(String, String)

Text starts with filter: field starts with prefix

EndsWith(String, String)

Text ends with filter: field ends with suffix

Regex(String, String)

Regex match filter: field matches regex

And(Vec<FilterCondition>)

Logical AND: all conditions must be true

Or(Vec<FilterCondition>)

Logical OR: at least one condition must be true

Not(Box<FilterCondition>)

Logical NOT: condition must be false

Implementations

impl FilterCondition

pub fn eq( field: impl Into<String>, value: impl Into<MetadataValue>, ) -> FilterCondition

Create an equality filter

pub fn ne( field: impl Into<String>, value: impl Into<MetadataValue>, ) -> FilterCondition

Create a not equal filter

pub fn gt( field: impl Into<String>, value: impl Into<MetadataValue>, ) -> FilterCondition

Create a greater than filter

pub fn lt( field: impl Into<String>, value: impl Into<MetadataValue>, ) -> FilterCondition

Create a less than filter

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

Create an in filter

pub fn and(conditions: Vec<FilterCondition>) -> FilterCondition

Create an AND filter

pub fn or(conditions: Vec<FilterCondition>) -> FilterCondition

Create an OR filter

pub fn not(condition: FilterCondition) -> FilterCondition

Create a NOT filter

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

Create an exists filter

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

Create a contains filter

Trait Implementations

impl Clone for FilterCondition

fn clone(&self) -> FilterCondition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FilterCondition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FilterCondition

fn deserialize<__D>( __deserializer: __D, ) -> Result<FilterCondition, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for FilterCondition

fn eq(&self, other: &FilterCondition) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for FilterCondition

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FilterCondition