Enum Expr 

pub enum Expr<'a, F> {
    And(Vec<Expr<'a, F>>),
    Or(Vec<Expr<'a, F>>),
    Not(Box<Expr<'a, F>>),
    Pred(Filter<'a, F>),
    Compare {
        left: ScalarExpr<F>,
        op: CompareOp,
        right: ScalarExpr<F>,
    },
    InList {
        expr: ScalarExpr<F>,
        list: Vec<ScalarExpr<F>>,
        negated: bool,
    },
    IsNull {
        expr: ScalarExpr<F>,
        negated: bool,
    },
    Literal(bool),
    Exists(SubqueryExpr),
}

Logical expression over predicates.

Variants

And(Vec<Expr<'a, F>>)

Or(Vec<Expr<'a, F>>)

Not(Box<Expr<'a, F>>)

Pred(Filter<'a, F>)

Compare

Fields

left: ScalarExpr<F>

op: CompareOp

right: ScalarExpr<F>

InList

Fields

expr: ScalarExpr<F>

list: Vec<ScalarExpr<F>>

negated: bool

IsNull

Check if a scalar expression IS NULL or IS NOT NULL. For simple column references, prefer Pred(Filter { op: IsNull/IsNotNull }) for optimization. This variant handles complex expressions like (col1 + col2) IS NULL.

Fields

expr: ScalarExpr<F>

negated: bool

Literal(bool)

A literal boolean value (true/false). Used for conditions that are always true or always false (e.g., empty IN lists).

Exists(SubqueryExpr)

Correlated subquery evaluated in a boolean context.

Implementations

impl<'a, F> Expr<'a, F>

pub fn all_of(fs: Vec<Filter<'a, F>>) -> Expr<'a, F>

Build an AND of filters.

pub fn any_of(fs: Vec<Filter<'a, F>>) -> Expr<'a, F>

Build an OR of filters.

pub fn not(e: Expr<'a, F>) -> Expr<'a, F>

Wrap an expression in a logical NOT.

pub fn is_full_range_for(&self, expected_field: &F) -> bool

where F: PartialEq,

Returns true if this expression is a full range filter on the provided field id.

impl<'a, F> Expr<'a, F>

where F: Display + Copy,

pub fn format_display(&self) -> String

Render a predicate expression as a human-readable string.

Trait Implementations

impl<'a, F> Clone for Expr<'a, F>

where F: Clone,

fn clone(&self) -> Expr<'a, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, F> Debug for Expr<'a, F>

where F: Debug,

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

Formats the value using the given formatter.