Enum Expr 

pub enum Expr {
    Literal(Literal),
    Column {
        table: Option<String>,
        name: String,
        span: Span,
    },
    Binary {
        left: Box<Expr>,
        op: BinaryOp,
        right: Box<Expr>,
    },
    Unary {
        op: UnaryOp,
        operand: Box<Expr>,
    },
    Function(FunctionCall),
    Subquery(Box<SelectStatement>),
    IsNull {
        expr: Box<Expr>,
        negated: bool,
    },
    In {
        expr: Box<Expr>,
        list: Vec<Expr>,
        negated: bool,
    },
    Between {
        expr: Box<Expr>,
        low: Box<Expr>,
        high: Box<Expr>,
        negated: bool,
    },
    Case {
        operand: Option<Box<Expr>>,
        when_clauses: Vec<(Expr, Expr)>,
        else_clause: Option<Box<Expr>>,
    },
    Cast {
        expr: Box<Expr>,
        data_type: DataType,
    },
    Paren(Box<Expr>),
    Parameter {
        name: Option<String>,
        position: usize,
    },
    Wildcard {
        table: Option<String>,
    },
}

An SQL expression.

Variants

Literal(Literal)

A literal value.

Column

A column reference (optionally qualified with table name).

Fields

table: Option<String>

Table name or alias (optional).

name: String

Column name.

span: Span

Source span.

Binary

A binary expression.

Fields

left: Box<Expr>

Left operand.

op: BinaryOp

Operator.

right: Box<Expr>

Right operand.

Unary

A unary expression.

Fields

op: UnaryOp

Operator.

operand: Box<Expr>

Operand.

Function(FunctionCall)

A function call.

Subquery(Box<SelectStatement>)

A subquery.

IsNull

IS NULL expression.

Fields

expr: Box<Expr>

The expression to check.

negated: bool

Whether this is IS NOT NULL.

In

IN expression.

Fields

expr: Box<Expr>

The expression to check.

list: Vec<Expr>

The list of values or subquery.

negated: bool

Whether this is NOT IN.

Between

BETWEEN expression.

Fields

expr: Box<Expr>

The expression to check.

low: Box<Expr>

Lower bound.

high: Box<Expr>

Upper bound.

negated: bool

Whether this is NOT BETWEEN.

Case

CASE expression.

Fields

operand: Option<Box<Expr>>

The operand (if any).

when_clauses: Vec<(Expr, Expr)>

WHEN/THEN clauses.

else_clause: Option<Box<Expr>>

ELSE clause.

Cast

CAST expression.

Fields

expr: Box<Expr>

Expression to cast.

data_type: DataType

Target type.

Paren(Box<Expr>)

Parenthesized expression.

Parameter

A parameter placeholder (? or :name).

Fields

name: Option<String>

The parameter index or name.

position: usize

Position in the query (1-based for ? placeholders).

Wildcard

Wildcard (*) in SELECT.

Fields

table: Option<String>

Table qualifier (optional).

Implementations

impl Expr

pub fn column(name: impl Into<String>) -> Self

Creates a new column reference.

pub fn qualified_column( table: impl Into<String>, name: impl Into<String>, ) -> Self

Creates a new qualified column reference.

pub const fn integer(value: i64) -> Self

Creates a new integer literal.

pub const fn float(value: f64) -> Self

Creates a new float literal.

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

Creates a new string literal.

pub const fn boolean(value: bool) -> Self

Creates a new boolean literal.

pub const fn null() -> Self

Creates a NULL literal.

pub fn binary(self, op: BinaryOp, right: Self) -> Self

Creates a binary expression.

pub fn eq(self, right: Self) -> Self

Creates an equality expression.

pub fn not_eq(self, right: Self) -> Self

Creates an inequality expression.

pub fn lt(self, right: Self) -> Self

Creates a less-than expression.

pub fn lt_eq(self, right: Self) -> Self

Creates a less-than-or-equal expression.

pub fn gt(self, right: Self) -> Self

Creates a greater-than expression.

pub fn gt_eq(self, right: Self) -> Self

Creates a greater-than-or-equal expression.

pub fn and(self, right: Self) -> Self

Creates an AND expression.

pub fn or(self, right: Self) -> Self

Creates an OR expression.

pub fn is_null(self) -> Self

Creates an IS NULL expression.

pub fn is_not_null(self) -> Self

Creates an IS NOT NULL expression.

pub fn between(self, low: Self, high: Self) -> Self

Creates a BETWEEN expression.

pub fn not_between(self, low: Self, high: Self) -> Self

Creates a NOT BETWEEN expression.

pub fn in_list(self, list: Vec<Self>) -> Self

Creates an IN expression.

pub fn not_in_list(self, list: Vec<Self>) -> Self

Creates a NOT IN expression.

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 Display 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 StructuralPartialEq for Expr