Enum LogicalOperator 

pub enum LogicalOperator {
    ScanByLabel {
        variable: String,
        label: String,
        properties: HashMap<String, PropertyValue>,
    },
    Unwind {
        input: Option<Box<LogicalOperator>>,
        expression: ValueExpression,
        alias: 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,
        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,
    },
}

A logical plan operator - describes what operation to perform

Variants

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

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) This is implemented by unrolling into multiple fixed-length paths and unioning them

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)

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

Trait Implementations

impl Clone for LogicalOperator

fn clone(&self) -> LogicalOperator

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: &LogicalOperator) -> 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 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