Enum FilterAtom 

pub enum FilterAtom {
    Eq {
        field: String,
        value: FilterValue,
    },
    Ne {
        field: String,
        value: FilterValue,
    },
    In {
        field: String,
        values: Vec<FilterValue>,
    },
    NotIn {
        field: String,
        values: Vec<FilterValue>,
    },
    Range {
        field: String,
        min: Option<FilterValue>,
        max: Option<FilterValue>,
        min_inclusive: bool,
        max_inclusive: bool,
    },
    Prefix {
        field: String,
        prefix: String,
    },
    Contains {
        field: String,
        substring: String,
    },
    HasTag {
        tag: String,
    },
    True,
    False,
}

A single filter atom - the smallest unit of filtering

Variants

Eq

Equality: field = value

Fields

field: String

value: FilterValue

Ne

Not equal: field != value

Fields

field: String

value: FilterValue

In

Membership: field IN (v1, v2, …)

Fields

field: String

values: Vec<FilterValue>

NotIn

Not in set: field NOT IN (v1, v2, …)

Fields

field: String

values: Vec<FilterValue>

Range

Range: min <= field <= max (inclusive) Either bound can be None for open-ended ranges

Fields

field: String

min: Option<FilterValue>

max: Option<FilterValue>

min_inclusive: bool

max_inclusive: bool

Prefix

Prefix match: field STARTS WITH prefix

Fields

field: String

prefix: String

Contains

Contains substring: field CONTAINS substring

Fields

field: String

substring: String

HasTag

ACL tag presence (for row-level security)

Fields

tag: String

True

Always true (identity for conjunction)

False

Always false (identity for disjunction)

Implementations

impl FilterAtom

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

Create an equality atom

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

Create an IN atom

pub fn range( field: impl Into<String>, min: Option<FilterValue>, max: Option<FilterValue>, ) -> Self

Create a range atom

pub fn range_exclusive( field: impl Into<String>, min: Option<FilterValue>, max: Option<FilterValue>, ) -> Self

Create an open range (exclusive bounds)

pub fn field(&self) -> Option<&str>

Get the field name this atom filters on (if any)

pub fn is_trivially_true(&self) -> bool

Check if this atom is always true

pub fn is_trivially_false(&self) -> bool

Check if this atom is always false

pub fn negate(&self) -> FilterAtom

Negate this atom

Trait Implementations

impl Clone for FilterAtom

fn clone(&self) -> FilterAtom

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FilterAtom

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FilterAtom

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for FilterAtom

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

Formats the value using the given formatter.

impl PartialEq for FilterAtom

fn eq(&self, other: &FilterAtom) -> 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 FilterAtom

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FilterAtom