Enum Expression 

pub enum Expression {
    Property {
        variable: String,
        property: String,
    },
    Literal(PropertyValue),
    Binary {
        left: Box<Expression>,
        op: BinaryOp,
        right: Box<Expression>,
    },
    Unary {
        op: UnaryOp,
        expr: Box<Expression>,
    },
    Function {
        name: String,
        args: Vec<Expression>,
        distinct: bool,
    },
    Variable(String),
    Case {
        operand: Option<Box<Expression>>,
        when_clauses: Vec<(Expression, Expression)>,
        else_result: Option<Box<Expression>>,
    },
    Index {
        expr: Box<Expression>,
        index: Box<Expression>,
    },
    ListSlice {
        expr: Box<Expression>,
        start: Option<Box<Expression>>,
        end: Option<Box<Expression>>,
    },
    ExistsSubquery {
        pattern: Pattern,
        where_clause: Option<Box<WhereClause>>,
    },
    ListComprehension {
        variable: String,
        list_expr: Box<Expression>,
        filter: Option<Box<Expression>>,
        map_expr: Box<Expression>,
    },
    PredicateFunction {
        name: String,
        variable: String,
        list_expr: Box<Expression>,
        predicate: Box<Expression>,
    },
    Reduce {
        accumulator: String,
        init: Box<Expression>,
        variable: String,
        list_expr: Box<Expression>,
        expression: Box<Expression>,
    },
    PatternComprehension {
        pattern: Pattern,
        filter: Option<Box<Expression>>,
        projection: Box<Expression>,
    },
    PathVariable(String),
    Parameter(String),
}

Expression in WHERE or RETURN

Variants

Property

Property access: n.name

Fields

variable: String

Variable name (e.g., “n”)

property: String

Property name (e.g., “name”)

Literal(PropertyValue)

Literal value

Binary

Binary operation

Fields

left: Box<Expression>

Left operand

op: BinaryOp

Binary operator

right: Box<Expression>

Right operand

Unary

Unary operation

Fields

op: UnaryOp

Unary operator

expr: Box<Expression>

Operand expression

Function

Function call

Fields

name: String

Function name

args: Vec<Expression>

Function arguments

distinct: bool

Whether DISTINCT modifier is present (e.g., count(DISTINCT x))

Variable(String)

Variable reference

Case

CASE expression

Fields

operand: Option<Box<Expression>>

Optional operand for simple CASE

when_clauses: Vec<(Expression, Expression)>

WHEN condition THEN result pairs

else_result: Option<Box<Expression>>

ELSE default

Index

List/map indexing: expr[index]

Fields

expr: Box<Expression>

Expression being indexed

index: Box<Expression>

Index expression

ListSlice

List slicing: expr[start..end]

Fields

expr: Box<Expression>

Expression being sliced

start: Option<Box<Expression>>

Optional start index (inclusive)

end: Option<Box<Expression>>

Optional end index (exclusive)

ExistsSubquery

EXISTS { MATCH pattern WHERE condition }

Fields

pattern: Pattern

Pattern to match

where_clause: Option<Box<WhereClause>>

Optional WHERE predicate

ListComprehension

List comprehension: [x IN list WHERE cond | expr]

Fields

variable: String

Variable name

list_expr: Box<Expression>

List expression

filter: Option<Box<Expression>>

Optional filter predicate

map_expr: Box<Expression>

Mapping expression

PredicateFunction

Predicate function: all(x IN list WHERE pred), any(…), none(…), single(…)

Fields

name: String

Function name (all, any, none, single)

variable: String

Iterator variable

list_expr: Box<Expression>

List expression

predicate: Box<Expression>

Predicate expression

Reduce

reduce(acc = init, x IN list | expr)

Fields

accumulator: String

Accumulator variable name

init: Box<Expression>

Initial value expression

variable: String

Iterator variable name

list_expr: Box<Expression>

List expression

expression: Box<Expression>

Body expression

PatternComprehension

Pattern comprehension: [(a)-[:REL]->(b) WHERE cond | expr]

Fields

pattern: Pattern

Pattern to match

filter: Option<Box<Expression>>

Optional filter predicate

projection: Box<Expression>

Projection expression

PathVariable(String)

Named path reference (for Value::Path)

Parameter(String)

Query parameter reference ($name)

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl PartialEq for Expression

fn eq(&self, other: &Expression) -> 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 Expression