Enum LogicalExpression 

pub enum LogicalExpression {
    Literal(Value),
    Variable(String),
    Property {
        variable: String,
        property: String,
    },
    Binary {
        left: Box<LogicalExpression>,
        op: BinaryOp,
        right: Box<LogicalExpression>,
    },
    Unary {
        op: UnaryOp,
        operand: Box<LogicalExpression>,
    },
    FunctionCall {
        name: String,
        args: Vec<LogicalExpression>,
        distinct: bool,
    },
    List(Vec<LogicalExpression>),
    Map(Vec<(String, LogicalExpression)>),
    IndexAccess {
        base: Box<LogicalExpression>,
        index: Box<LogicalExpression>,
    },
    SliceAccess {
        base: Box<LogicalExpression>,
        start: Option<Box<LogicalExpression>>,
        end: Option<Box<LogicalExpression>>,
    },
    Case {
        operand: Option<Box<LogicalExpression>>,
        when_clauses: Vec<(LogicalExpression, LogicalExpression)>,
        else_clause: Option<Box<LogicalExpression>>,
    },
    Parameter(String),
    Labels(String),
    Type(String),
    Id(String),
    ListComprehension {
        variable: String,
        list_expr: Box<LogicalExpression>,
        filter_expr: Option<Box<LogicalExpression>>,
        map_expr: Box<LogicalExpression>,
    },
    ListPredicate {
        kind: ListPredicateKind,
        variable: String,
        list_expr: Box<LogicalExpression>,
        predicate: Box<LogicalExpression>,
    },
    ExistsSubquery(Box<LogicalOperator>),
    CountSubquery(Box<LogicalOperator>),
    ValueSubquery(Box<LogicalOperator>),
    MapProjection {
        base: String,
        entries: Vec<MapProjectionEntry>,
    },
    Reduce {
        accumulator: String,
        initial: Box<LogicalExpression>,
        variable: String,
        list: Box<LogicalExpression>,
        expression: Box<LogicalExpression>,
    },
    PatternComprehension {
        subplan: Box<LogicalOperator>,
        projection: Box<LogicalExpression>,
    },
}

A logical expression.

Variants

Literal(Value)

A literal value.

Variable(String)

A variable reference.

Property

Property access (e.g., n.name).

Fields

variable: String

The variable to access.

property: String

The property name.

Binary

Binary operation.

Fields

left: Box<LogicalExpression>

Left operand.

op: BinaryOp

Operator.

right: Box<LogicalExpression>

Right operand.

Unary

Unary operation.

Fields

op: UnaryOp

Operator.

operand: Box<LogicalExpression>

Operand.

FunctionCall

Function call.

Fields

name: String

Function name.

args: Vec<LogicalExpression>

Arguments.

distinct: bool

Whether DISTINCT is applied (e.g., COUNT(DISTINCT x)).

List(Vec<LogicalExpression>)

List literal.

Map(Vec<(String, LogicalExpression)>)

Map literal (e.g., {name: ‘Alix’, age: 30}).

IndexAccess

Index access (e.g., list[0]).

Fields

base: Box<LogicalExpression>

The base expression (typically a list or string).

index: Box<LogicalExpression>

The index expression.

SliceAccess

Slice access (e.g., list[1..3]).

Fields

base: Box<LogicalExpression>

The base expression (typically a list or string).

start: Option<Box<LogicalExpression>>

Start index (None means from beginning).

end: Option<Box<LogicalExpression>>

End index (None means to end).

Case

CASE expression.

Fields

operand: Option<Box<LogicalExpression>>

Test expression (for simple CASE).

when_clauses: Vec<(LogicalExpression, LogicalExpression)>

WHEN clauses.

else_clause: Option<Box<LogicalExpression>>

ELSE clause.

Parameter(String)

Parameter reference.

Labels(String)

Labels of a node.

Type(String)

Type of an edge.

Id(String)

ID of a node or edge.

ListComprehension

List comprehension: [x IN list WHERE predicate | expression]

Fields

variable: String

Variable name for each element.

list_expr: Box<LogicalExpression>

The source list expression.

filter_expr: Option<Box<LogicalExpression>>

Optional filter predicate.

map_expr: Box<LogicalExpression>

The mapping expression for each element.

ListPredicate

List predicate: all/any/none/single(x IN list WHERE pred).

Fields

kind: ListPredicateKind

The kind of list predicate.

variable: String

The iteration variable name.

list_expr: Box<LogicalExpression>

The source list expression.

predicate: Box<LogicalExpression>

The predicate to test for each element.

ExistsSubquery(Box<LogicalOperator>)

EXISTS subquery.

CountSubquery(Box<LogicalOperator>)

COUNT subquery.

ValueSubquery(Box<LogicalOperator>)

VALUE subquery: returns scalar value from first row of inner query.

MapProjection

Map projection: node { .prop1, .prop2, key: expr, .* }.

Fields

base: String

The base variable name.

entries: Vec<MapProjectionEntry>

Projection entries (property selectors, literal entries, all-properties).

Reduce

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

Fields

accumulator: String

Accumulator variable name.

initial: Box<LogicalExpression>

Initial value for the accumulator.

variable: String

Iteration variable name.

list: Box<LogicalExpression>

List to iterate over.

expression: Box<LogicalExpression>

Body expression evaluated per iteration (references both accumulator and variable).

PatternComprehension

Pattern comprehension: [(pattern) WHERE pred | expr].

Executes the inner subplan, evaluates the projection for each row, and collects the results into a list.

Fields

subplan: Box<LogicalOperator>

The subplan produced by translating the pattern (+optional WHERE).

projection: Box<LogicalExpression>

The projection expression evaluated for each match.

Trait Implementations

impl Clone for LogicalExpression

fn clone(&self) -> LogicalExpression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LogicalExpression

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

Formats the value using the given formatter.