Enum AstFilter 

pub enum AstFilter {
    Compare {
        field: FieldRef,
        op: CompareOp,
        value: Value,
    },
    CompareFields {
        left: FieldRef,
        op: CompareOp,
        right: FieldRef,
    },
    CompareExpr {
        lhs: Expr,
        op: CompareOp,
        rhs: Expr,
    },
    And(Box<Filter>, Box<Filter>),
    Or(Box<Filter>, Box<Filter>),
    Not(Box<Filter>),
    IsNull(FieldRef),
    IsNotNull(FieldRef),
    In {
        field: FieldRef,
        values: Vec<Value>,
    },
    Between {
        field: FieldRef,
        low: Value,
        high: Value,
    },
    Like {
        field: FieldRef,
        pattern: String,
    },
    StartsWith {
        field: FieldRef,
        prefix: String,
    },
    EndsWith {
        field: FieldRef,
        suffix: String,
    },
    Contains {
        field: FieldRef,
        substring: String,
    },
}

Filter condition

Variants

Compare

Comparison: field op value

Fields

field: FieldRef

op: CompareOp

value: Value

CompareFields

Field-to-field comparison: left.field op right.field. Used when WHERE / BETWEEN operands reference another column instead of a literal — the pre-Fase-2-parser-v2 shim for column-to-column predicates. Once the Expr-rewrite lands, this collapses into Compare { left: Expr, op, right: Expr }.

Fields

left: FieldRef

op: CompareOp

right: FieldRef

CompareExpr

Expression-to-expression comparison: lhs op rhs where either side may be an arbitrary Expr tree (function call, CAST, arithmetic, nested CASE). This is the most general compare variant — Compare and CompareFields stay as fast-path specialisations because the planner / cost model / index selector all pattern-match on the simpler shapes. The parser only emits this variant when a simpler one cannot express the predicate.

Fields

lhs: Expr

op: CompareOp

rhs: Expr

And(Box<Filter>, Box<Filter>)

Logical AND

Or(Box<Filter>, Box<Filter>)

Logical OR

Not(Box<Filter>)

Logical NOT

IsNull(FieldRef)

IS NULL

IsNotNull(FieldRef)

IS NOT NULL

In

IN (value1, value2, …)

Fields

field: FieldRef

values: Vec<Value>

Between

BETWEEN low AND high

Fields

field: FieldRef

low: Value

high: Value

Like

LIKE pattern

Fields

field: FieldRef

pattern: String

StartsWith

STARTS WITH prefix

Fields

field: FieldRef

prefix: String

EndsWith

ENDS WITH suffix

Fields

field: FieldRef

suffix: String

Contains

CONTAINS substring

Fields

field: FieldRef

substring: String

Implementations

impl Filter

pub fn compare(field: FieldRef, op: CompareOp, value: Value) -> Filter

Create a comparison filter

pub fn and(self, other: Filter) -> Filter

Combine with AND

pub fn or(self, other: Filter) -> Filter

Combine with OR

pub fn not(self) -> Filter

Negate

pub fn optimize(self) -> Filter

Bottom-up AST rewrites: OR-of-equalities → IN, AND/OR flatten. Inspired by MongoDB’s MatchExpression::optimize(). Call on the result of effective_table_filter() before evaluation.

Trait Implementations

impl Clone for Filter

fn clone(&self) -> Filter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Filter

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

Formats the value using the given formatter.

impl PartialEq for Filter

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