Struct DefaultPhysicalPlanner 

pub struct DefaultPhysicalPlanner {
    extension_planners: Vec<Arc<dyn ExtensionPlanner + Send + Sync>>,
}

Default single node physical query planner that converts a LogicalPlan to an ExecutionPlan suitable for execution.

This planner will first flatten the LogicalPlan tree via a depth first approach, which allows it to identify the leaves of the tree.

Tasks are spawned from these leaves and traverse back up the tree towards the root, converting each LogicalPlan node it reaches into their equivalent ExecutionPlan node. When these tasks reach a common node, they will terminate until the last task reaches the node which will then continue building up the tree.

Up to planning_concurrency tasks are buffered at once to execute concurrently.

Fields

extension_planners: Vec<Arc<dyn ExtensionPlanner + Send + Sync>>

Implementations

impl DefaultPhysicalPlanner

pub fn with_extension_planners( extension_planners: Vec<Arc<dyn ExtensionPlanner + Send + Sync>>, ) -> Self

Create a physical planner that uses extension_planners to plan user-defined logical nodes LogicalPlan::Extension. The planner uses the first ExtensionPlanner to return a non-None plan.

async fn create_initial_plan( &self, logical_plan: &LogicalPlan, session_state: &SessionState, ) -> Result<Arc<dyn ExecutionPlan>>

Create a physical plan from a logical plan

async fn task_helper<'a>( &'a self, leaf_starter_index: usize, flat_tree: Arc<Vec<LogicalNode<'a>>>, session_state: &'a SessionState, ) -> Result<Option<Arc<dyn ExecutionPlan>>>

These tasks start at a leaf and traverse up the tree towards the root, building an ExecutionPlan as they go. When they reach a node with two or more children, they append their current result (a child of the parent node) to the children vector, and if this is sufficient to create the parent then continues traversing the tree to create nodes. Otherwise, the task terminates.

async fn map_logical_node_to_physical( &self, node: &LogicalPlan, session_state: &SessionState, children: ChildrenContainer, ) -> Result<Arc<dyn ExecutionPlan>>

Given a single LogicalPlan node, map it to its physical ExecutionPlan counterpart.

fn create_grouping_physical_expr( &self, group_expr: &[Expr], input_dfschema: &DFSchema, input_schema: &Schema, session_state: &SessionState, ) -> Result<PhysicalGroupBy>

impl DefaultPhysicalPlanner

async fn handle_explain_or_analyze( &self, logical_plan: &LogicalPlan, session_state: &SessionState, ) -> Result<Option<Arc<dyn ExecutionPlan>>>

Handles capturing the various plans for EXPLAIN queries

Returns Some(plan) if optimized, and None if logical_plan was not an explain (and thus needs to be optimized as normal)

async fn handle_explain( &self, e: &Explain, session_state: &SessionState, ) -> Result<Arc<dyn ExecutionPlan>>

Planner for LogicalPlan::Explain

async fn handle_analyze( &self, a: &Analyze, session_state: &SessionState, ) -> Result<Arc<dyn ExecutionPlan>>

pub fn optimize_physical_plan<F>( &self, plan: Arc<dyn ExecutionPlan>, session_state: &SessionState, observer: F, ) -> Result<Arc<dyn ExecutionPlan>>

where F: FnMut(&dyn ExecutionPlan, &dyn PhysicalOptimizerRule),

Optimize a physical plan by applying each physical optimizer, calling observer(plan, optimizer after each one)

fn plan_describe( &self, table_schema: Arc<Schema>, output_schema: Arc<Schema>, ) -> Result<Arc<dyn ExecutionPlan>>

fn create_project_physical_exec( &self, session_state: &SessionState, input_exec: Arc<dyn ExecutionPlan>, input: &Arc<LogicalPlan>, expr: &[Expr], ) -> Result<Arc<dyn ExecutionPlan>>

fn try_plan_async_exprs( &self, num_input_columns: usize, physical_expr: PlannedExprResult, schema: &Schema, ) -> Result<PlanAsyncExpr>

Trait Implementations

impl Default for DefaultPhysicalPlanner

fn default() -> DefaultPhysicalPlanner

Returns the “default value” for a type.

impl PhysicalPlanner for DefaultPhysicalPlanner

fn create_physical_plan<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, logical_plan: &'life1 LogicalPlan, session_state: &'life2 SessionState, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn ExecutionPlan>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Create a physical plan from a logical plan

fn create_physical_expr( &self, expr: &Expr, input_dfschema: &DFSchema, session_state: &SessionState, ) -> Result<Arc<dyn PhysicalExpr>>

Create a physical expression from a logical expression suitable for evaluation

e: the expression to convert

input_dfschema: the logical plan schema for evaluating e