Enum Expr 

pub enum Expr {
    Literal(Literal, Span),
    Column(ColumnRef, Span),
    BinaryOp {
        left: Box<Self>,
        op: BinaryOp,
        right: Box<Self>,
        span: Span,
    },
    UnaryOp {
        op: UnaryOp,
        expr: Box<Self>,
        span: Span,
    },
    Between {
        expr: Box<Self>,
        low: Box<Self>,
        high: Box<Self>,
        not: bool,
        span: Span,
    },
    In {
        expr: Box<Self>,
        set: InSet,
        not: bool,
        span: Span,
    },
    Like {
        expr: Box<Self>,
        pattern: Box<Self>,
        escape: Option<Box<Self>>,
        op: LikeOp,
        not: bool,
        span: Span,
    },
    Case {
        operand: Option<Box<Self>>,
        whens: Vec<(Self, Self)>,
        else_expr: Option<Box<Self>>,
        span: Span,
    },
    Cast {
        expr: Box<Self>,
        type_name: TypeName,
        span: Span,
    },
    Exists {
        subquery: Box<SelectStatement>,
        not: bool,
        span: Span,
    },
    Subquery(Box<SelectStatement>, Span),
    FunctionCall {
        name: String,
        args: FunctionArgs,
        distinct: bool,
        order_by: Vec<OrderingTerm>,
        filter: Option<Box<Self>>,
        over: Option<WindowSpec>,
        span: Span,
    },
    Collate {
        expr: Box<Self>,
        collation: String,
        span: Span,
    },
    IsNull {
        expr: Box<Self>,
        not: bool,
        span: Span,
    },
    Raise {
        action: RaiseAction,
        message: Option<String>,
        span: Span,
    },
    JsonAccess {
        expr: Box<Self>,
        path: Box<Self>,
        arrow: JsonArrow,
        span: Span,
    },
    RowValue(Vec<Self>, Span),
    Placeholder(PlaceholderType, Span),
    // some variants omitted
}

An expression node in the AST.

Every variant carries a Span for source-location tracking. The Expr enum covers all expression forms in the SQLite SQL dialect.

Variants

Literal(Literal, Span)

A literal constant.

Column(ColumnRef, Span)

A column reference (possibly table-qualified).

BinaryOp

A binary operation: left op right.

Fields

left: Box<Self>

op: BinaryOp

right: Box<Self>

span: Span

UnaryOp

A unary operation: op expr.

Fields

op: UnaryOp

expr: Box<Self>

span: Span

Between

expr [NOT] BETWEEN low AND high.

Fields

expr: Box<Self>

low: Box<Self>

high: Box<Self>

not: bool

span: Span

In

expr [NOT] IN (...).

Fields

expr: Box<Self>

set: InSet

not: bool

span: Span

Like

expr [NOT] LIKE/GLOB/MATCH/REGEXP pattern [ESCAPE escape].

Fields

expr: Box<Self>

pattern: Box<Self>

escape: Option<Box<Self>>

op: LikeOp

not: bool

span: Span

Case

CASE [operand] WHEN ... THEN ... [ELSE ...] END.

Fields

operand: Option<Box<Self>>

whens: Vec<(Self, Self)>

else_expr: Option<Box<Self>>

span: Span

Cast

CAST(expr AS type_name).

Fields

expr: Box<Self>

type_name: TypeName

span: Span

Exists

[NOT] EXISTS (subquery).

Fields

subquery: Box<SelectStatement>

not: bool

span: Span

Subquery(Box<SelectStatement>, Span)

A scalar subquery: (SELECT ...).

FunctionCall

A function call, optionally with DISTINCT, FILTER, and window spec.

Fields

name: String

args: FunctionArgs

distinct: bool

order_by: Vec<OrderingTerm>

In-aggregate ORDER BY (SQLite 3.44+), e.g. group_concat(x ORDER BY y).

filter: Option<Box<Self>>

over: Option<WindowSpec>

span: Span

Collate

expr COLLATE collation_name.

Fields

expr: Box<Self>

collation: String

span: Span

IsNull

expr IS [NOT] NULL / expr ISNULL / expr NOTNULL.

Fields

expr: Box<Self>

not: bool

span: Span

Raise

RAISE(action, message) — used inside trigger bodies.

Fields

action: RaiseAction

message: Option<String>

span: Span

JsonAccess

expr -> path or expr ->> path (JSON access).

Fields

expr: Box<Self>

path: Box<Self>

arrow: JsonArrow

span: Span

RowValue(Vec<Self>, Span)

A row value (a, b, c) for multi-column comparisons (SQLite 3.15+).

Placeholder(PlaceholderType, Span)

A bind parameter (?, ?NNN, :name, @name, $name).

Implementations

impl Expr

pub const fn span(&self) -> Span

Return the span of this expression node.

impl Expr

pub fn as_sql_function_call(&self) -> Option<SqlFunctionCallRef<'_>>

View this expression as a semantic SQL function call, when applicable.

JSON access operators are exposed as two-argument calls named -> or ->>. This does not alter their parser AST representation or display.

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

Span-ignoring, SQL-semantics-aware structural equality for expressions.

Two expressions are equal if they have the same structure and all semantic fields match, regardless of their source-location Span values. This is essential for partial-index predicate matching and expression-index lookup, where the same logical expression is parsed from different source texts.

SQL identifiers and function names are case-insensitive, so comparisons of FunctionCall::name and Collate::collation use eq_ignore_ascii_case rather than byte-exact equality. Column and table names in ColumnRef are compared via the derived PartialEq on that struct, which is currently case-sensitive — this is a known limitation but a safe default because mixed-case column references are rare in practice and would only cause a missed optimisation (silent scan fallback), never a wrong result.

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.