Struct ExecutionPlan 

pub struct ExecutionPlan {
    pub root: Option<PlanNodeEnum>,
    pub id: i64,
    pub optimize_time_in_us: u64,
    pub format: String,
    pub partition_spec: Option<PartitionSpec>,
    pub max_workers: usize,
    pub max_buffered_chunks: usize,
    pub parallel_fallback_reason: String,
    pub cbo_notes: Vec<String>,
    pub row_estimates: HashMap<i64, u64>,
    pub join_algorithms: HashMap<i64, JoinAlgorithm>,
    pub logical_plan: Option<LogicalPlan>,
}

Execution plan structure Represents the complete executable plan, including the root node and the plan ID.

Fields

root: Option<PlanNodeEnum>

The root node of the planning tree

id: i64

The unique ID of the plan

optimize_time_in_us: u64

Optimized time (in microseconds)

format: String

Of course! Please provide the text you would like to have translated.

partition_spec: Option<PartitionSpec>

Optional physical partition layout. A layout is consumed only by a partition-safe streaming plan; unsupported plans fail explicitly.

max_workers: usize

Maximum worker threads for intra-query parallelism. 1 means fully serial. Propagated from PartitioningConfig.

max_buffered_chunks: usize

Per-partition output channel capacity for backpressure.

parallel_fallback_reason: String

Why parallel partitioning was not selected (empty = partitioning active or not requested). Surfaced in EXPLAIN / PROFILE diagnostics.

cbo_notes: Vec<String>

Cost-based decision notes produced during optimization (e.g. subquery unnesting and join-order rewrites). Surfaced in EXPLAIN diagnostics.

row_estimates: HashMap<i64, u64>

Per-logical-node output row estimates produced by the cost-based phase, keyed by logical node id. Written into physical operator specs (estimated_cardinality) by the estimated_rows metadata pass.

join_algorithms: HashMap<i64, JoinAlgorithm>

Cost-based join algorithm decisions keyed by planner node id.

Produced by the join-order rewriter when it reorders a join chain; consumed by the arena builder to pick HashJoin vs nested-loop execution for each InnerJoin/LeftJoin node. Absent keys fall back to the default heuristic (hash join for valid equi keys).

logical_plan: Option<LogicalPlan>

The pure logical plan (if conversion succeeded). Used by cost-based optimization to make physical decisions.

Implementations

impl ExecutionPlan

pub fn new(root: Option<PlanNodeEnum>) -> Self

Create a new execution plan.

pub fn set_root(&mut self, root: PlanNodeEnum)

Set the root node of the plan.

pub fn root(&self) -> &Option<PlanNodeEnum>

Obtain the reference to the root node of the plan.

pub fn root_mut(&mut self) -> &mut Option<PlanNodeEnum>

Obtain a reference to the variable root node.

pub fn set_id(&mut self, id: i64)

Set the ID for the plan.

pub fn set_optimize_time(&mut self, time_us: u64)

Set the optimization time

pub fn set_format(&mut self, format: String)

Set the output format

pub fn set_partition_spec(&mut self, partition_spec: PartitionSpec)

Attach the physical partition layout chosen by the optimizer.

pub fn clear_partition_spec(&mut self)

Remove partitioning and execute the plan as a single tree.

pub fn partition_spec(&self) -> Option<&PartitionSpec>

pub fn set_max_workers(&mut self, max_workers: usize)

pub fn set_max_buffered_chunks(&mut self, max_buffered_chunks: usize)

pub fn set_logical_plan(&mut self, logical_plan: LogicalPlan)

Attach a pure logical plan for cost-based optimization.

pub fn logical_plan(&self) -> Option<&LogicalPlan>

Access the logical plan, if available.

pub fn node_count(&self) -> usize

Calculate the number of nodes in the plan. Traverses the execution plan tree with an explicit stack instead of recursion so deeply nested plans cannot overflow the call stack.

Trait Implementations

impl Clone for ExecutionPlan

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 ExecutionPlan

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

Formats the value using the given formatter.