Enum ReadOp 

#[non_exhaustive]
pub enum ReadOp {
    Source {
        label: Option<LabelSet>,
        bind: VarId,
    },
    Expand {
        input: OpId,
        from: VarId,
        rel: RelSpec,
        to: NodeSpec,
        bind_rel: VarId,
        bind_to: VarId,
    },
    Filter {
        input: OpId,
        predicate: Expr,
    },
    Project {
        input: OpId,
        items: Vec<Projection>,
    },
    Aggregate {
        input: OpId,
        keys: Vec<Expr>,
        aggs: Vec<AggExpr>,
    },
    OrderBy {
        input: OpId,
        keys: Vec<OrderKey>,
    },
    Skip {
        input: OpId,
        count: Expr,
    },
    Limit {
        input: OpId,
        count: Expr,
    },
    Distinct {
        input: OpId,
    },
    Unwind {
        input: OpId,
        list: Expr,
        bind: VarId,
    },
    Union {
        left: OpId,
        right: OpId,
        kind: UnionKind,
    },
    With {
        input: OpId,
        items: Vec<Projection>,
        filter: Option<Expr>,
    },
    OptionalJoin {
        input: OpId,
        pattern: Box<ReadOp>,
    },
}

Logical read-plan operator tree. Spec §12.1.

Operators form a DAG — each variant that has an input field references its source by OpId. The OptionalJoin variant embeds a sub-tree directly via Box<ReadOp> because its inner pattern is always a fresh tree introduced by OPTIONAL MATCH.

Consumers iterate the tree in whatever order suits their executor. This crate imposes no evaluation semantics.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Source

Scan all nodes, optionally filtered to those carrying a set of labels.

When label is None this is an all-node scan; when Some it is a label-index scan (or filtered full scan, depending on the consumer’s storage). Spec §12.1 N1.

Fields

label: Option<LabelSet>

Labels to filter on, or None for every node.

bind: VarId

Variable that receives each scanned node.

Expand

Expand a node into its adjacent relationships and neighbour nodes.

Starting from from (already bound in input), traverse relationships matching rel to reach a node matching to. Spec §12.1 N2.

Fields

input: OpId

Source operator that provides the from variable.

from: VarId

Variable holding the start node.

rel: RelSpec

Relationship type / direction / length specification.

to: NodeSpec

Target node specification (labels + optional property predicate).

bind_rel: VarId

Variable that receives the traversed relationship.

bind_to: VarId

Variable that receives the reached node.

Filter

Predicate filter — keeps only rows where predicate is truthy.

Implements WHERE and inline pattern predicates. Spec §12.1 N3.

Fields

input: OpId

Source operator.

predicate: Expr

Boolean expression; rows where it evaluates to false or null are dropped.

Project

Column projection — renames / computes output columns.

Implements the output column list of RETURN and WITH. Spec §12.1 N4.

Fields

input: OpId

Source operator.

items: Vec<Projection>

Ordered list of output columns.

Aggregate

Aggregation — groups rows and applies aggregate functions.

keys are the grouping expressions; aggs are the aggregate calls. An empty keys vec aggregates the entire input into a single row. Spec §12.1 N5.

Fields

input: OpId

Source operator.

keys: Vec<Expr>

Grouping expressions (the non-aggregate columns in the output).

aggs: Vec<AggExpr>

Aggregate function calls.

OrderBy

Sort — orders rows by a list of sort keys. Spec §12.1 N6.

Fields

input: OpId

Source operator.

keys: Vec<OrderKey>

Ordered list of sort keys (primary first).

Skip

Skip — discards the first count rows. Spec §12.1 N7.

Fields

input: OpId

Source operator.

count: Expr

Number of rows to skip; must evaluate to a non-negative integer.

Limit

Limit — keeps only the first count rows. Spec §12.1 N8.

Fields

input: OpId

Source operator.

count: Expr

Maximum number of rows to pass through.

Distinct

Distinct — removes duplicate rows. Spec §12.1 N9.

Row equality is Cypher value equality (null != null).

Fields

input: OpId

Source operator.

Unwind

Unwind — flattens a list expression into one row per element.

Implements UNWIND list AS var. Spec §12.1 N10.

Fields

input: OpId

Source operator.

list: Expr

List expression to iterate.

bind: VarId

Variable that receives each list element.

Union

Union — concatenates rows from two sub-plans. Spec §12.1 N11.

Fields

left: OpId

Left source operator.

right: OpId

Right source operator.

kind: UnionKind

Whether to deduplicate the combined output.

With

With — projects columns and optionally filters, resetting scope.

Implements the WITH clause. Differs from ReadOp::Project in that WITH starts a new variable scope. Spec §12.1 N12.

Fields

input: OpId

Source operator.

items: Vec<Projection>

Output columns.

filter: Option<Expr>

Optional WHERE predicate applied after projection.

OptionalJoin

Optional join — left-outer-join a sub-plan. Spec §12.1 N13.

Implements OPTIONAL MATCH. Rows from input that have no match in pattern are kept with null-bound variables.

Fields

input: OpId

Outer source operator.

pattern: Box<ReadOp>

Inner pattern (embedded tree, not an OpId, because it is always a fresh sub-tree introduced by OPTIONAL MATCH).

Trait Implementations

impl Clone for ReadOp

fn clone(&self) -> ReadOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReadOp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReadOp

fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl PartialEq for ReadOp

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

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for ReadOp

impl StructuralPartialEq for ReadOp