Struct SubPlan 

pub struct SubPlan {
    pub root: Option<PlanNodeEnum>,
    pub tail: Option<PlanNodeEnum>,
    pub logical_root: Option<LogicalNodeEnum>,
}

SubPlan structure Represents a sub-part of the execution plan, which contains the root node and the tail node. Segmented planning for complex queries

Fields

root: Option<PlanNodeEnum>

The root node of the sub-plan

tail: Option<PlanNodeEnum>

The end node of the sub-plan Used to connect multiple sub-plans

logical_root: Option<LogicalNodeEnum>

Native logical tree, when the planner produced one directly.

Migrated planners build the pure [LogicalNodeEnum] tree first and convert it to the physical root exactly once at the plan exit; the logical tree is attached here so the compiler can build the crate::planning::plan::logical_plan::LogicalPlan natively instead of stripping it back out of the physical tree.

Implementations

impl SubPlan

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

Create a new SubPlan without a logical mirror.

Reserved for planners whose operators stay physical-only by design (data modifications, administrative statements, search operators) where no LogicalNodeEnum counterpart exists. DQL planners build a native logical tree instead and attach it via the SubPlan struct literal or the plan_combiner mirror helpers.

pub fn from_logical_root(logical_root: LogicalNodeEnum) -> Self

Create a SubPlan from a native logical tree.

Converts the logical root to the physical root exactly once (via convert_logical_to_physical) and retains the logical tree for the compiler.

pub fn logical_root(&self) -> Option<&LogicalNodeEnum>

Obtain the native logical tree, if the planner produced one.

pub fn from_root(root: PlanNodeEnum) -> Self

Create a SubPlan that contains only the root node.

Like SubPlan::new, the plan carries no logical mirror and is reserved for physical-only operators and transient physical wiring seeds.

pub fn from_single_node(node: PlanNodeEnum) -> Self

Create a SubPlan that contains only a single node.

Like SubPlan::new, the plan carries no logical mirror and is reserved for physical-only operators and transient physical wiring seeds.

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

Obtain a reference to the root node.

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

Obtain the reference to the tail node.

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

Setting the root node

pub fn set_tail(&mut self, tail: PlanNodeEnum)

Setting the tail node

pub fn is_empty(&self) -> bool

Check whether SubPlan is empty.

pub fn collect_nodes(&self) -> Vec<PlanNodeEnum>

Retrieve all nodes from the SubPlan.

pub fn connect_upstream( downstream: SubPlan, upstream: SubPlan, ) -> Result<SubPlan, PlannerError>

Connect upstream as the input of downstream, returning a structurally closed plan.

The upstream root is attached as the downstream root’s input, so the resulting SubPlan is a complete tree that planners and executors observe identically. This replaces the previous pattern of creating the downstream node first and manually injecting its input, which left the connection outside the SubPlan structure.

The returned plan’s tail is the upstream tail (the data flows from upstream into downstream).

Trait Implementations

impl Clone for SubPlan

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 SubPlan

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

Formats the value using the given formatter.