Enum Expr 

pub enum Expr {
    Literal(Literal),
    Idiom(Idiom),
    Param(String),
    Table(Spanned<String>),
    RecordId {
        table: Spanned<String>,
        id: ByteRange,
        range: bool,
    },
    Binary {
        lhs: Box<Spanned<Expr>>,
        op: Spanned<BinaryOp>,
        rhs: Box<Spanned<Expr>>,
    },
    Prefix {
        op: Spanned<PrefixOp>,
        expr: Box<Spanned<Expr>>,
    },
    Call(Call),
    Object(Vec<(Spanned<String>, Spanned<Expr>)>),
    Array(Vec<Spanned<Expr>>),
    Subquery(Box<Spanned<Statement>>),
    Block(Block),
    Cast {
        ty: Spanned<TypeExpr>,
        expr: Box<Spanned<Expr>>,
    },
    Closure(Closure),
    Partial(PartialNode),
}

A value-producing expression.

Variants

Literal(Literal)

A literal value.

Idiom(Idiom)

A field path / graph traversal, rooted in the current row context or in a leading value (see IdiomPart::Start).

Param(String)

A bare $name — parameter or LET binding reference (without $). $name.field chains lower as Idiom with a Start part instead.

Table(Spanned<String>)

A table reference. Only produced in source/target positions (FROM person, CREATE person): a bare identifier in expression position is a field path, not a table.

RecordId

A record id literal: person:one. The id’s internal structure is kept opaque (ids can be composite; nothing consumes their shape).

Fields

table: Spanned<String>

The table portion (person in person:one).

id: ByteRange

The id portion, kept as an opaque span.

range: bool

Whether the id portion is a range (person:a..z) rather than a single id. A range denotes many records, so it carries none of the single-row guarantee a plain record id does.

Binary

A binary operation: a + b, a AND b.

Fields

lhs: Box<Spanned<Expr>>

Left operand.

op: Spanned<BinaryOp>

The operator.

rhs: Box<Spanned<Expr>>

Right operand.

Prefix

A prefix operation: !x, -x.

Fields

op: Spanned<PrefixOp>

The operator.

expr: Box<Spanned<Expr>>

The operand.

Call(Call)

A function call.

Object(Vec<(Spanned<String>, Spanned<Expr>)>)

An object literal: { a: 1, b: 2 }.

Array(Vec<Spanned<Expr>>)

An array literal: [1, 2, 3].

Subquery(Box<Spanned<Statement>>)

A parenthesized statement used as a value: (SELECT ...).

Block(Block)

A { ...; ... } block used as a value.

Cast

A type cast: <int> $x.

Fields

ty: Spanned<TypeExpr>

The target type.

expr: Box<Spanned<Expr>>

The expression being cast.

Closure(Closure)

A closure value.

Partial(PartialNode)

An expression that failed to lower.

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Expr