Enum Expr 

pub enum Expr {
    Param(ParamName),
    Column(ColumnRef),
    String(String),
    Int(i64),
    Bool(bool),
    Null,
    Now,
    Default,
    BinOp {
        left: Box<Expr>,
        op: BinOp,
        right: Box<Expr>,
    },
    IsNull {
        expr: Box<Expr>,
        negated: bool,
    },
    Like {
        expr: Box<Expr>,
        pattern: Box<Expr>,
    },
    ILike {
        expr: Box<Expr>,
        pattern: Box<Expr>,
    },
    Any {
        expr: Box<Expr>,
        array: Box<Expr>,
    },
    JsonGet {
        expr: Box<Expr>,
        key: Box<Expr>,
    },
    JsonGetText {
        expr: Box<Expr>,
        key: Box<Expr>,
    },
    Contains {
        expr: Box<Expr>,
        value: Box<Expr>,
    },
    KeyExists {
        expr: Box<Expr>,
        key: Box<Expr>,
    },
    Cast {
        expr: Box<Expr>,
        pg_type: PgType,
    },
    Excluded(ColumnName),
    FnCall {
        name: String,
        args: Vec<Expr>,
    },
    Count {
        table: TableName,
    },
    Raw(String),
}

A SQL expression.

Variants

Param(ParamName)

A parameter placeholder (e.g., $handle -> $1)

Column(ColumnRef)

A column reference

String(String)

A string literal

Int(i64)

An integer literal

Bool(bool)

A boolean literal

Null

NULL

Now

NOW() function

Default

DEFAULT keyword

BinOp

Binary operation (e.g., a = b, a AND b)

Fields

left: Box<Expr>

op: BinOp

right: Box<Expr>

IsNull

IS NULL / IS NOT NULL

Fields

expr: Box<Expr>

negated: bool

Like

LIKE pattern match (case-sensitive)

Fields

expr: Box<Expr>

pattern: Box<Expr>

ILike

ILIKE pattern match (case-insensitive)

Fields

expr: Box<Expr>

pattern: Box<Expr>

Any

= ANY(array) for IN checks with array parameter

Fields

expr: Box<Expr>

array: Box<Expr>

JsonGet

JSONB -> operator (get object field, returns JSONB)

Fields

expr: Box<Expr>

key: Box<Expr>

JsonGetText

JSONB ->> operator (get object field as text)

Fields

expr: Box<Expr>

key: Box<Expr>

Contains

@> operator (contains, typically for JSONB)

Fields

expr: Box<Expr>

value: Box<Expr>

KeyExists

? operator (key exists, typically for JSONB)

Fields

expr: Box<Expr>

key: Box<Expr>

Cast

Type cast (e.g., $1::text[], value::integer)

Fields

expr: Box<Expr>

pg_type: PgType

Excluded(ColumnName)

EXCLUDED.column reference for ON CONFLICT DO UPDATE

FnCall

Function call

Fields

name: String

args: Vec<Expr>

Count

COUNT(table.*) for counting related rows

Fields

table: TableName

Raw(String)

Raw SQL (escape hatch)

Implementations

impl Expr

pub fn param(name: ParamName) -> Self

pub fn column(name: ColumnName) -> Self

pub fn qualified_column(table: TableName, column: ColumnName) -> Self

pub fn string(s: impl Into<String>) -> Self

pub fn int(n: i64) -> Self

pub fn bool(b: bool) -> Self

pub fn eq(self, other: Expr) -> Self

Create an equality expression: self = other

pub fn and(self, other: Expr) -> Self

Create an AND expression: self AND other

pub fn or(self, other: Expr) -> Self

Create an OR expression: self OR other

pub fn is_null(self) -> Self

Create IS NULL expression

pub fn is_not_null(self) -> Self

Create IS NOT NULL expression

pub fn like(self, pattern: Expr) -> Self

Create LIKE expression (case-sensitive pattern match)

pub fn ilike(self, pattern: Expr) -> Self

Create ILIKE expression (case-insensitive pattern match)

pub fn any(self, array: Expr) -> Self

Create = ANY(array) expression for IN checks

pub fn json_get(self, key: Expr) -> Self

Create JSONB -> expression (get object field, returns JSONB)

pub fn json_get_text(self, key: Expr) -> Self

Create JSONB ->> expression (get object field as text)

pub fn contains(self, value: Expr) -> Self

Create @> expression (contains, typically for JSONB)

pub fn key_exists(self, key: Expr) -> Self

Create ? expression (key exists, typically for JSONB)

pub fn cast(self, pg_type: PgType) -> Self

Create a type cast expression (e.g., $1::text[])

pub fn excluded(column: ColumnName) -> Self

Create an EXCLUDED.column reference for ON CONFLICT DO UPDATE

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl PartialEq for Expr

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

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

impl StructuralPartialEq for Expr