Enum IrExpr 

pub enum IrExpr {
    Literal(IrLiteral),
    VarRef(VarId),
    PropertyAccess {
        base: ExprId,
        prop: PropId,
    },
    BinaryOp {
        op: BinaryOpKind,
        left: ExprId,
        right: ExprId,
    },
    UnaryOp {
        op: UnaryOpKind,
        expr: ExprId,
    },
    FunctionCall {
        name: String,
        args: Vec<ExprId>,
    },
    Parameter(String),
    Case {
        operand: Option<ExprId>,
        arms: Vec<CaseArm>,
        else_expr: Option<ExprId>,
    },
    ListLiteral(Vec<ExprId>),
    MapLiteral(Vec<(String, ExprId)>),
    Quantifier {
        kind: QuantifierKind,
        loop_var: VarId,
        list: ExprId,
        predicate: ExprId,
    },
    ListComprehension {
        loop_var: VarId,
        list: ExprId,
        filter: Option<ExprId>,
        projection: Option<ExprId>,
    },
}

A single node in the ExprArena.

Every ExprId child is an index into the same arena; the arena owns all nodes and is the authoritative source of truth for expression structure.

Variants

Literal(IrLiteral)

A scalar constant.

VarRef(VarId)

A reference to a pattern variable (e.g. n in MATCH (n:Person)).

PropertyAccess

A property read: base.prop.

Fields

base: ExprId

The expression whose property is read.

prop: PropId

The property type ID (resolved by the binder).

BinaryOp

A binary infix expression.

Fields

op: BinaryOpKind

The operator.

left: ExprId

Left-hand operand.

right: ExprId

Right-hand operand.

UnaryOp

A unary prefix expression.

Fields

op: UnaryOpKind

The operator.

expr: ExprId

The operand.

FunctionCall

A built-in or user-defined function call.

Fields

name: String

Fully-qualified function name (e.g. "toUpper", "apoc.text.join").

args: Vec<ExprId>

Argument expressions.

Parameter(String)

A named query parameter (e.g. $name).

Case

A CASE expression.

Fields

operand: Option<ExprId>

Simple-CASE operand; None for searched CASE.

arms: Vec<CaseArm>

The WHEN/THEN arms.

else_expr: Option<ExprId>

The ELSE expression, if present.

ListLiteral(Vec<ExprId>)

A list literal: [e0, e1, …].

MapLiteral(Vec<(String, ExprId)>)

A map literal: {k0: e0, k1: e1, …}.

Keys are plain strings; values are ExprId references.

Quantifier

A quantifier predicate all/any/none/single(loop_var IN list WHERE pred). loop_var is bound (only) within predicate. (#955)

Fields

kind: QuantifierKind

Which quantifier (all/any/none/single).

loop_var: VarId

The loop variable bound per element while evaluating predicate.

list: ExprId

The list expression iterated over.

predicate: ExprId

The per-element predicate.

ListComprehension

A list comprehension [loop_var IN list WHERE filter | projection]. loop_var is bound (only) within filter and projection. Either of filter/projection may be absent (a bare [x IN list] is the list itself; [x IN list WHERE p] filters; [x IN list | e] maps). (#955)

Fields

loop_var: VarId

The loop variable bound per element while evaluating the clauses.

list: ExprId

The list expression iterated over.

filter: Option<ExprId>

Optional per-element filter; only elements where it is true are kept.

projection: Option<ExprId>

Optional per-element projection; absent ⇒ the element itself.

Trait Implementations

impl Clone for IrExpr

fn clone(&self) -> IrExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IrExpr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IrExpr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for IrExpr

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for IrExpr

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for IrExpr