Enum Expr 

pub enum Expr {
    Literal {
        value: Value,
        span: Span,
    },
    Column {
        field: FieldRef,
        span: Span,
    },
    Parameter {
        index: usize,
        span: Span,
    },
    BinaryOp {
        op: BinOp,
        lhs: Box<Expr>,
        rhs: Box<Expr>,
        span: Span,
    },
    UnaryOp {
        op: UnaryOp,
        operand: Box<Expr>,
        span: Span,
    },
    Cast {
        inner: Box<Expr>,
        target: DataType,
        span: Span,
    },
    FunctionCall {
        name: String,
        args: Vec<Expr>,
        span: Span,
    },
    Case {
        branches: Vec<(Expr, Expr)>,
        else_: Option<Box<Expr>>,
        span: Span,
    },
    IsNull {
        operand: Box<Expr>,
        negated: bool,
        span: Span,
    },
    InList {
        target: Box<Expr>,
        values: Vec<Expr>,
        negated: bool,
        span: Span,
    },
    Between {
        target: Box<Expr>,
        low: Box<Expr>,
        high: Box<Expr>,
        negated: bool,
        span: Span,
    },
    Subquery {
        query: ExprSubquery,
        span: Span,
    },
}

The syntactic expression tree. Every node carries a Span so semantic errors from the analyze pass can point back at the exact token range. Created by the Fase 2 parser, consumed by the analyzer and (eventually) the planner.

Variants

Literal

A literal value (number, string, boolean, null).

Fields

value: Value

span: Span

Column

Reference to a column (possibly qualified by table / alias).

Fields

field: FieldRef

span: Span

Parameter

Query parameter placeholder (? or $n). Used by prepared statements in Fase 4 — the plan cache strips these so repeated bindings reuse the same plan.

Fields

index: usize

span: Span

BinaryOp

Binary infix operator: lhs <op> rhs.

Fields

op: BinOp

lhs: Box<Expr>

rhs: Box<Expr>

span: Span

UnaryOp

Prefix unary operator.

Fields

op: UnaryOp

operand: Box<Expr>

span: Span

Cast

CAST(expr AS type) / expr::type.

Fields

inner: Box<Expr>

target: DataType

span: Span

FunctionCall

Function / aggregate call.

Fields

name: String

args: Vec<Expr>

span: Span

Case

CASE WHEN cond THEN val [...] [ELSE val] END.

Fields

branches: Vec<(Expr, Expr)>

else_: Option<Box<Expr>>

span: Span

IsNull

IS NULL / IS NOT NULL. Kept as a distinct variant because SQL treats them as unary postfix operators with special three-valued semantics.

Fields

operand: Box<Expr>

negated: bool

span: Span

InList

expr IN (v1, v2, …). The rhs list is Vec<Expr> — at Week 1 only literal lists survive analyze; correlated subquery lists land in Week 3 alongside the Subquery variant below.

Fields

target: Box<Expr>

values: Vec<Expr>

negated: bool

span: Span

Between

expr BETWEEN low AND high — first-class so pushdown can recognise range predicates without decomposing to >= and <=.

Fields

target: Box<Expr>

low: Box<Expr>

high: Box<Expr>

negated: bool

span: Span

Subquery

Parenthesized SELECT used in an expression context.

Fields

query: ExprSubquery

span: Span

Implementations

impl Expr

pub fn span(&self) -> Span

Extract the span of this expression. Synthetic nodes return Span::synthetic() — callers that need a real location should check span.is_synthetic() before rendering diagnostics.

pub fn lit(value: Value) -> Self

Constructor shortcut for the common Literal case.

pub fn col(field: FieldRef) -> Self

Constructor shortcut for the common Column case.

pub fn binop(op: BinOp, lhs: Expr, rhs: Expr) -> Self

Convenience: build a binary operation with a synthetic span. Used by unit tests and by the Projection → Expr shim while the migration is in flight.

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