Enum PlanNode 

pub enum PlanNode {
    NodeScan {
        kind: Option<NodeKind>,
        visibility: Option<Visibility>,
        name_pattern: Option<StringPattern>,
    },
    EdgeTraversal {
        direction: Direction,
        edge_kind: Option<EdgeKind>,
        max_depth: u32,
    },
    Filter {
        predicate: Predicate,
    },
    SetOp {
        op: SetOperation,
        left: Box<PlanNode>,
        right: Box<PlanNode>,
    },
    Chain {
        steps: Vec<PlanNode>,
    },
}

Operator tree for a structural query.

Every variant produces a node-set. Consumers treat the resulting Vec<NodeId> as a sorted, deduplicated sequence.

Variant semantics

• PlanNode::NodeScan scans the graph and emits every node matching the supplied filters. This is the only variant without an input set.
• PlanNode::EdgeTraversal requires an input set (supplied by the enclosing PlanNode::Chain) and follows edges from those nodes.
• PlanNode::Filter narrows its input set by evaluating the predicate.
• PlanNode::SetOp evaluates two sub-plans independently and combines the results. Neither side inherits an input set from an enclosing chain.
• PlanNode::Chain threads the output of each step into the next step’s input. The first step must be context-free (a NodeScan or SetOp).

Variants

NodeScan

Scan all nodes matching the given filters.

Each filter is an optional narrowing condition; None means “accept any value”. kind = None, visibility = None, name_pattern = None yields a full node scan.

Fields

kind: Option<NodeKind>

Optional kind filter (Function, Method, Class, …).

visibility: Option<Visibility>

Optional visibility filter (Public, Private).

name_pattern: Option<StringPattern>

Optional symbol-name pattern filter.

EdgeTraversal

Follow edges outward from the input set.

edge_kind = None matches any edge kind. max_depth = 1 performs a single hop; values greater than one perform a bounded BFS.

Fields

direction: Direction

Direction in which to follow edges.

edge_kind: Option<EdgeKind>

Optional edge-kind filter. See module docs for how the executor compares variants by discriminant.

max_depth: u32

Maximum hops to follow. Must be >= 1 to produce any output.

Filter

Narrow the input set with a predicate.

Fields

predicate: Predicate

The predicate to evaluate for each input node.

SetOp

Combine two independently-evaluated sub-plans with a set operation.

Fields

op: SetOperation

The set operation: Union, Intersect, or Difference.

left: Box<PlanNode>

Left-hand operand sub-plan.

right: Box<PlanNode>

Right-hand operand sub-plan.

Chain

Pipeline a sequence of steps, threading each step’s output into the next step’s input.

The first step must be context-free (a PlanNode::NodeScan or PlanNode::SetOp); subsequent steps are applied to the running set.

Fields

steps: Vec<PlanNode>

Steps to evaluate in order. An empty vec yields the empty set.

Implementations

impl PlanNode

pub fn operator_count(&self) -> usize

Returns the total number of operators in this subtree.

Counts this node plus all descendants through PlanNode::SetOp::left, PlanNode::SetOp::right, and PlanNode::Chain::steps. PlanNode::Filter’s predicate tree is not counted here — predicate trees have their own complexity.

pub fn is_context_free(&self) -> bool

Returns true if this node has no input dependency (can be evaluated in isolation).

Used by the compiler to validate PlanNode::Chain::steps — the first step must be context-free.

Trait Implementations

impl Clone for PlanNode

fn clone(&self) -> PlanNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PlanNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PlanNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for PlanNode

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for PlanNode

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for PlanNode

impl StructuralPartialEq for PlanNode