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>,
    },
    ExistsSubquery(Box<LogicalOperator>),
    CountSubquery(Box<LogicalOperator>),
}

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: ‘Alice’, 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.

ExistsSubquery(Box<LogicalOperator>)

EXISTS subquery.

CountSubquery(Box<LogicalOperator>)

COUNT subquery.

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.