Enum Predicate 

pub enum Predicate<D: Dialect> {
    Binary {
        col: String,
        op: &'static str,
        val: Value,
    },
    In {
        col: String,
        neg: bool,
        vals: Vec<Value>,
    },
    Null {
        col: String,
        neg: bool,
    },
    Between {
        col: String,
        lo: Value,
        hi: Value,
    },
    ILike {
        col: String,
        val: Value,
    },
    JsonContains {
        col: String,
        val: Value,
    },
    Raw {
        sql: String,
        binds: Vec<Value>,
    },
    Group {
        outer_conj: Conj,
        preds: Vec<Predicate<D>>,
    },
    Column {
        lhs: String,
        op: &'static str,
        rhs: String,
    },
    Exists {
        neg: bool,
        sub: Box<QueryBuilder<D>>,
    },
    InSubquery {
        col: String,
        neg: bool,
        sub: Box<QueryBuilder<D>>,
    },
}

A single WHERE-clause predicate.

Generic over the Dialect marker D because subquery-bearing variants (Predicate::Exists / Predicate::InSubquery) embed a QueryBuilder<D>; the recursion is broken with a Box.

Variants

Binary

col op value, e.g. "age" > $1.

Fields

col: String

Raw identifier; escaped in compile.rs.

op: &'static str

SQL operator token (=, !=, LIKE, …).

val: Value

Bound value.

In

col [NOT ]IN (...).

Fields

col: String

Raw identifier; escaped in compile.rs.

neg: bool

Whether this is a NOT IN.

vals: Vec<Value>

Bound values; empty yields a constant true/false predicate.

Null

col IS [NOT ]NULL.

Fields

col: String

Raw identifier; escaped in compile.rs.

neg: bool

Whether this is IS NOT NULL.

Between

col BETWEEN lo AND hi.

Fields

col: String

Raw identifier; escaped in compile.rs.

lo: Value

Lower bound.

hi: Value

Upper bound.

ILike

col ILIKE val — dialect-aware case-insensitive match.

Postgres emits native {col} ILIKE {ph}; MySQL/SQLite emit LOWER({col}) LIKE LOWER({ph}). Dispatched in compile::write_pred.

Fields

col: String

Raw identifier; escaped in compile.rs.

val: Value

Bound value.

JsonContains

col @> val — JSONB containment (Postgres-oriented; @> emitted verbatim for all dialects).

Fields

col: String

Raw identifier; escaped in compile.rs.

val: Value

Bound value (JSON text or Value::Json).

Raw

Raw SQL fragment with its own binds, emitted verbatim.

Fields

sql: String

Verbatim SQL.

binds: Vec<Value>

Bound values appended in order.

Group

A parenthesized group of predicates.

outer_conj controls how the group attaches to the preceding clause (AND (...) vs OR (...)). Inner predicates are joined with AND, except that a nested Group carries its own outer_conj (so or_where inside a group emits OR (...)) — groups nest arbitrarily.

Fields

outer_conj: Conj

How this group attaches to the preceding clause (outer separator).

preds: Vec<Predicate<D>>

Inner predicates; rendered like the top level, so nested groups with outer_conj: Or introduce OR within this group.

Column

lhs op rhs — both sides are column identifiers (escaped at compile time), no bind. Backs where_column.

Fields

lhs: String

Raw left identifier; escaped in compile.rs.

op: &'static str

SQL operator token (=, !=, …).

rhs: String

Raw right identifier; escaped in compile.rs.

Exists

[NOT ]EXISTS (subquery).

Fields

neg: bool

Whether this is NOT EXISTS.

sub: Box<QueryBuilder<D>>

The embedded sub-query, compiled with placeholder continuity.

InSubquery

col [NOT ]IN (subquery).

Fields

col: String

Raw identifier; escaped in compile.rs.

neg: bool

Whether this is NOT IN.

sub: Box<QueryBuilder<D>>

The embedded sub-query, compiled with placeholder continuity.

Trait Implementations

impl<D: Clone + Dialect> Clone for Predicate<D>

fn clone(&self) -> Predicate<D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D: Debug + Dialect> Debug for Predicate<D>

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

Formats the value using the given formatter.

impl<D: PartialEq + Dialect> PartialEq for Predicate<D>

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