Enum Predicate 

pub enum Predicate {
    Eq(ColumnName, PredicateValue),
    Lt(ColumnName, PredicateValue),
    Le(ColumnName, PredicateValue),
    Gt(ColumnName, PredicateValue),
    Ge(ColumnName, PredicateValue),
    In(ColumnName, Vec<PredicateValue>),
    NotIn(ColumnName, Vec<PredicateValue>),
    NotBetween(ColumnName, PredicateValue, PredicateValue),
    Like(ColumnName, String),
    NotLike(ColumnName, String),
    ILike(ColumnName, String),
    NotILike(ColumnName, String),
    IsNull(ColumnName),
    IsNotNull(ColumnName),
    JsonExtractEq {
        column: ColumnName,
        path: String,
        as_text: bool,
        value: PredicateValue,
    },
    JsonContains {
        column: ColumnName,
        value: PredicateValue,
    },
    InSubquery {
        column: ColumnName,
        subquery: Box<ParsedSelect>,
        negated: bool,
    },
    Exists {
        subquery: Box<ParsedSelect>,
        negated: bool,
    },
    Always(bool),
    Or(Vec<Predicate>, Vec<Predicate>),
    ScalarCmp {
        lhs: ScalarExpr,
        op: ScalarCmpOp,
        rhs: ScalarExpr,
    },
}

A comparison predicate from the WHERE clause.

Variants

Eq(ColumnName, PredicateValue)

column = value or column = $N

Lt(ColumnName, PredicateValue)

column < value

Le(ColumnName, PredicateValue)

column <= value

Gt(ColumnName, PredicateValue)

column > value

Ge(ColumnName, PredicateValue)

column >= value

In(ColumnName, Vec<PredicateValue>)

column IN (value, value, …)

NotIn(ColumnName, Vec<PredicateValue>)

column NOT IN (value, value, …)

NotBetween(ColumnName, PredicateValue, PredicateValue)

column NOT BETWEEN low AND high

Like(ColumnName, String)

column LIKE ‘pattern’

NotLike(ColumnName, String)

column NOT LIKE ‘pattern’

ILike(ColumnName, String)

column ILIKE ‘pattern’ (case-insensitive LIKE)

NotILike(ColumnName, String)

column NOT ILIKE ‘pattern’

IsNull(ColumnName)

column IS NULL

IsNotNull(ColumnName)

column IS NOT NULL

JsonExtractEq

JSON path extraction with comparison.

data->'key' = value → as_text=false (compare as JSON value) data->>'key' = value → as_text=true (compare as text)

Fields

column: ColumnName

The JSON column being extracted from.

path: String

The key path (single-level for now).

as_text: bool

true for ->> (text result), false for -> (JSON result).

value: PredicateValue

Value to compare extracted result against.

JsonContains

JSON containment: column @> value — column (a JSON value) contains value.

Fields

column: ColumnName

value: PredicateValue

InSubquery

column IN (SELECT ...) / column NOT IN (SELECT ...).

• Uncorrelated form: pre-executed in pre_execute_subqueries and rewritten to Predicate::In / Predicate::NotIn before planning.
• Correlated form: detected in the same pass, left in place, and handled by the correlated-loop executor (v0.6.0).

See docs/reference/sql/correlated-subqueries.md.

Fields

column: ColumnName

subquery: Box<ParsedSelect>

negated: bool

true for NOT IN (SELECT ...).

Exists

EXISTS (SELECT ...) and NOT EXISTS (...).

• Uncorrelated form: pre-executed and rewritten to Always(bool).
• Correlated form: left in place for the correlated-loop executor.

Fields

subquery: Box<ParsedSelect>

negated: bool

Always(bool)

Constant truth value: matches every row (true) or no rows (false).

Produced by the subquery pre-execution pass: an EXISTS whose inner query returns rows becomes Always(true), an empty EXISTS becomes Always(false). Decoupling these from regular column predicates means the rest of the planner doesn’t need to invent sentinel columns.

Or(Vec<Predicate>, Vec<Predicate>)

OR of multiple predicates

ScalarCmp

Comparison between two arbitrary scalar expressions.

Used for any WHERE predicate where one or both sides is a function call, CAST, or || operator — e.g. UPPER(name) = 'ALICE', COALESCE(x, 0) > 10, CAST(s AS INTEGER) = $1. The bare column/literal predicates above stay on the hot path; this variant is the fallback when the bare shape doesn’t match.

Fields

lhs: ScalarExpr

op: ScalarCmpOp

rhs: ScalarExpr

Implementations

impl Predicate

pub fn column(&self) -> Option<&ColumnName>

Returns the column name this predicate operates on.

Returns None for OR predicates which may reference multiple columns.

Trait Implementations

impl Clone for Predicate

fn clone(&self) -> Predicate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Predicate

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

Formats the value using the given formatter.