Enum ExecutionPlan 

#[non_exhaustive]
pub enum ExecutionPlan {
    Sequence(Vec<ExecutionPlan>),
    Parallel(Vec<ExecutionPlan>),
    Execute {
        node_id: NodeId,
    },
    Cached {
        node_id: NodeId,
        key: CacheKey,
    },
    Loop {
        node_id: NodeId,
        body: Box<ExecutionPlan>,
        max_iterations: Option<usize>,
    },
    Branch {
        node_id: NodeId,
        arms: Vec<(String, ExecutionPlan)>,
    },
    Remote {
        node_id: NodeId,
        target: RemoteTarget,
        plan: Box<ExecutionPlan>,
    },
    Empty,
}

A compiled execution plan produced by the compiler.

This is a recursive tree that the runtime walks to execute a pipeline. The compiler resolves caching, parallelism, and distribution before the runtime sees the plan.

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.

Sequence(Vec<ExecutionPlan>)

Execute steps sequentially, one after another.

Parallel(Vec<ExecutionPlan>)

Execute branches concurrently (fork-join).

Execute

Execute a single filter node.

Fields

node_id: NodeId

Cached

Load result from cache (resolved at compile time).

Fields

node_id: NodeId

key: CacheKey

Loop

Iterate: execute body for each item in a collection.

Fields

node_id: NodeId

body: Box<ExecutionPlan>

max_iterations: Option<usize>

Branch

Conditional branching: evaluate condition, pick an arm.

Fields

node_id: NodeId

arms: Vec<(String, ExecutionPlan)>

Remote

Execute a sub-plan on a remote worker.

Fields

node_id: NodeId

target: RemoteTarget

plan: Box<ExecutionPlan>

Empty

No-op: nothing to execute (e.g. empty graph).

Implementations

impl ExecutionPlan

pub fn node_count(&self) -> usize

Count total nodes in the plan (Execute + Cached).

pub fn cached_count(&self) -> usize

Count cached nodes in the plan.

pub fn parallel_branch_count(&self) -> usize

Count parallel branches at the top level of the plan.

pub fn node_ids(&self) -> Vec<&str>

Collect all node IDs referenced in the plan.

pub fn summary(&self) -> PlanSummary

Create a PlanSummary for event payloads.

pub fn simplify(self) -> Self

Flatten unnecessary nesting (e.g. Sequence of one element).

impl ExecutionPlan

pub fn to_mermaid(&self) -> String

Render the execution plan as a Mermaid flowchart.

Trait Implementations

impl Clone for ExecutionPlan

fn clone(&self) -> ExecutionPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExecutionPlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExecutionPlan

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ExecutionPlan

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

Formats the value using the given formatter.

impl Serialize for ExecutionPlan

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

where __S: Serializer,

Serialize this value into the given Serde serializer.