Enum LogicalOperator 

pub enum LogicalOperator {
    SingleRow,
    QueryUnion {
        left: Box<LogicalOperator>,
        right: Box<LogicalOperator>,
        all: bool,
    },
    ScanByLabel {
        variable: String,
        label: String,
        properties: HashMap<String, PropertyValue>,
    },
    Unwind {
        input: Option<Box<LogicalOperator>>,
        expression: ValueExpression,
        alias: String,
        label: Option<String>,
    },
    Filter {
        input: Box<LogicalOperator>,
        predicate: BooleanExpression,
    },
    Expand {
        input: Box<LogicalOperator>,
        source_variable: String,
        target_variable: String,
        target_label: String,
        relationship_types: Vec<String>,
        direction: RelationshipDirection,
        relationship_variable: Option<String>,
        properties: HashMap<String, PropertyValue>,
        target_properties: HashMap<String, PropertyValue>,
    },
    VariableLengthExpand {
        input: Box<LogicalOperator>,
        source_variable: String,
        target_variable: String,
        target_label: String,
        relationship_types: Vec<String>,
        direction: RelationshipDirection,
        relationship_variable: Option<String>,
        min_length: Option<u32>,
        max_length: Option<u32>,
        target_properties: HashMap<String, PropertyValue>,
    },
    Project {
        input: Box<LogicalOperator>,
        projections: Vec<ProjectionItem>,
    },
    Join {
        left: Box<LogicalOperator>,
        right: Box<LogicalOperator>,
        join_type: JoinType,
    },
    Distinct {
        input: Box<LogicalOperator>,
    },
    Sort {
        input: Box<LogicalOperator>,
        sort_items: Vec<SortItem>,
    },
    Offset {
        input: Box<LogicalOperator>,
        offset: u64,
    },
    Limit {
        input: Box<LogicalOperator>,
        count: u64,
    },
    Union {
        inputs: Vec<LogicalOperator>,
    },
    PathMatch {
        input: Box<LogicalOperator>,
        path: PathPattern,
    },
    ShortestPath {
        input: Box<LogicalOperator>,
        source_variable: String,
        target_variable: String,
        relationship_type: String,
        direction: RelationshipDirection,
        min_hops: u32,
        max_hops: u32,
        all: bool,
        path_variable: String,
    },
    OptionalMatch {
        input: Box<LogicalOperator>,
        optional: Box<LogicalOperator>,
        keys: Vec<String>,
    },
    ListComprehension {
        input: Box<LogicalOperator>,
        list: ValueExpression,
        variable: String,
        label: Option<String>,
        element: Box<LogicalOperator>,
        keep: Option<BooleanExpression>,
        map: ValueExpression,
        output: String,
        count_only: bool,
    },
    Apply {
        input: Box<LogicalOperator>,
        inner: Box<LogicalOperator>,
        imports: Vec<String>,
        labels: HashMap<String, String>,
        id: usize,
    },
    CallInput {
        labels: HashMap<String, String>,
    },
    ComprehensionElement,
}

A logical plan operator - describes what operation to perform

Variants

SingleRow

One row with no bound variables, for queries without reading clauses.

QueryUnion

Language-level UNION; unlike pattern alternation, branches must share output schema.

Fields

left: Box<LogicalOperator>

right: Box<LogicalOperator>

all: bool

ScanByLabel

Scan all nodes with a specific label

Fields

variable: String

label: String

properties: HashMap<String, PropertyValue>

Unwind

Unwind a list into a sequence of rows

Fields

input: Option<Box<LogicalOperator>>

The input operator

expression: ValueExpression

The expression to unwind (must yield a list)

alias: String

The alias for the unwound element

label: Option<String>

Set when the list holds node ids of this label (collect(node)): each unwound id is joined back to its node table, so alias is a node again.

Filter

Apply a filter predicate (WHERE clause)

Fields

input: Box<LogicalOperator>

predicate: BooleanExpression

Expand

Traverse relationships (the core graph operation)

Represents a single-hop relationship traversal: (source)-[rel]->(target)

Fields

input: Box<LogicalOperator>

The input operator (typically a node scan or previous expand)

source_variable: String

Variable name for the source node (e.g., “a” in (a)-[]->(b))

target_variable: String

Variable name for the target node (e.g., “b” in (a)-[]->(b))

target_label: String

Label of the target node (e.g., “Person”, “Book”) This is essential for looking up the correct schema during planning

relationship_types: Vec<String>

Types of relationships to traverse (e.g., [“KNOWS”, “FRIEND_OF”])

direction: RelationshipDirection

Direction of traversal (Outgoing, Incoming, or Undirected)

relationship_variable: Option<String>

Optional variable name for the relationship itself (e.g., “r” in -[r]->)

properties: HashMap<String, PropertyValue>

Property filters to apply on the relationship

target_properties: HashMap<String, PropertyValue>

Property filters to apply on the target node

VariableLengthExpand

Variable-length path expansion (*1..2 syntax)

Represents multi-hop relationship traversals: (source)-[rel*min..max]->(target) Uses iterative CSR traversal when indexed, otherwise fixed-length branches and a union.

Fields

input: Box<LogicalOperator>

The input operator (typically a node scan)

source_variable: String

Variable name for the source node

target_variable: String

Variable name for the target node (reachable in min..max hops)

target_label: String

The label of the final node, which may differ from intermediate nodes.

relationship_types: Vec<String>

Types of relationships to traverse in each hop

direction: RelationshipDirection

Direction of traversal for each hop

relationship_variable: Option<String>

Optional variable name for the relationship pattern

min_length: Option<u32>

Minimum number of hops (defaults to 1 if None)

max_length: Option<u32>

Maximum number of hops (defaults to system max if None)

target_properties: HashMap<String, PropertyValue>

Property filters to apply on target nodes

Project

Project specific columns (RETURN clause)

Fields

input: Box<LogicalOperator>

projections: Vec<ProjectionItem>

Join

Join multiple disconnected patterns

Fields

left: Box<LogicalOperator>

right: Box<LogicalOperator>

join_type: JoinType

Distinct

Apply DISTINCT

Fields

input: Box<LogicalOperator>

Sort

Apply ORDER BY

Fields

input: Box<LogicalOperator>

sort_items: Vec<SortItem>

Offset

Apply SKIP/OFFSET

Fields

input: Box<LogicalOperator>

offset: u64

Limit

Apply LIMIT

Fields

input: Box<LogicalOperator>

count: u64

Union

UNION ALL of the branches of one MATCH clause that uses relationship-type alternation or multi-label nodes (see pattern_alternatives). Branches bind the same variables, possibly with different labels; columns a branch lacks are null.

Fields

inputs: Vec<LogicalOperator>

PathMatch

A named path retaining actual relationship occurrences and typed node records.

Fields

input: Box<LogicalOperator>

path: PathPattern

ShortestPath

shortestPath / allShortestPaths between two variables bound in input; adds <path_variable>__length and <path_variable>__nodes (node ids, source first).

Fields

input: Box<LogicalOperator>

source_variable: String

target_variable: String

relationship_type: String

direction: RelationshipDirection

min_hops: u32

max_hops: u32

all: bool

path_variable: String

OptionalMatch

OPTIONAL MATCH: LEFT JOIN of input with optional (which is planned on top of input‘s distinct shared variables) on the shared variables’ id columns keys.

Fields

input: Box<LogicalOperator>

optional: Box<LogicalOperator>

keys: Vec<String>

ListComprehension

[variable IN list WHERE keep | map] for each row of input, into the column output. The list is unnested with element positions (an empty or null list keeps its row), element is planned over those element rows (its leaf is LogicalOperator::ComprehensionElement; EXISTS marks of keep join onto it), and the kept values are collected back per row in position order. With label, the list holds node ids and each element is joined to its node.

Fields

input: Box<LogicalOperator>

list: ValueExpression

variable: String

label: Option<String>

element: Box<LogicalOperator>

keep: Option<BooleanExpression>

map: ValueExpression

output: String

count_only: bool

Count retained elements without building an ordered list.

Apply

Evaluate a read-only subquery once per input row, extending it by each result.

Fields

input: Box<LogicalOperator>

inner: Box<LogicalOperator>

imports: Vec<String>

labels: HashMap<String, String>

id: usize

CallInput

The single imported row of a CALL body; its values are bound at execution.

Fields

labels: HashMap<String, String>

ComprehensionElement

The element rows of the enclosing LogicalOperator::ListComprehension.

Trait Implementations

impl Clone for LogicalOperator

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LogicalOperator

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LogicalOperator

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for LogicalOperator

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for LogicalOperator

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 LogicalOperator