Struct Planner

pub struct Planner {
    ctx: OptimizerContextRef,
    share_cache: HashMap<usize, PlanRef>,
}

Planner converts a bound statement to a crate::optimizer::plan_node::PlanNode tree

Fields

ctx: OptimizerContextRef

share_cache: HashMap<usize, PlanRef>

Mapping of ShareId to its share plan. The share plan can be a CTE, a source, a view and so on.

Implementations

impl Planner

pub(super) fn plan_changelog( &mut self, relation: Relation, ) -> Result<PlanRef, RwError>

impl Planner

pub(super) fn plan_delete( &mut self, delete: BoundDelete, ) -> Result<PlanRoot, RwError>

impl Planner

pub(super) fn plan_insert( &mut self, insert: BoundInsert, ) -> Result<PlanRoot, RwError>

impl Planner

pub fn plan_query(&mut self, query: BoundQuery) -> Result<PlanRoot, RwError>

Plan a BoundQuery. Need to bind before planning.

Works for both batch query and streaming query (CREATE MATERIALIZED VIEW).

impl Planner

pub(super) fn plan_recursive_union( &mut self, base: BoundSetExpr, recursive: BoundSetExpr, id: usize, ) -> Result<PlanRef, RwError>

impl Planner

pub fn plan_relation(&mut self, relation: Relation) -> Result<PlanRef, RwError>

pub(crate) fn plan_sys_table( &mut self, sys_table: BoundSystemTable, ) -> Result<PlanRef, RwError>

pub(super) fn plan_base_table( &mut self, base_table: &BoundBaseTable, ) -> Result<PlanRef, RwError>

pub(super) fn plan_source( &mut self, source: BoundSource, ) -> Result<PlanRef, RwError>

pub(super) fn plan_join(&mut self, join: BoundJoin) -> Result<PlanRef, RwError>

pub(super) fn plan_apply(&mut self, join: BoundJoin) -> Result<PlanRef, RwError>

pub(super) fn plan_window_table_function( &mut self, table_function: BoundWindowTableFunction, ) -> Result<PlanRef, RwError>

pub(super) fn plan_table_function( &mut self, table_function: ExprImpl, with_ordinality: bool, ) -> Result<PlanRef, RwError>

pub(super) fn plan_share( &mut self, share: BoundShare, ) -> Result<PlanRef, RwError>

pub(super) fn plan_watermark( &mut self, _watermark: BoundWatermark, ) -> Result<PlanRef, RwError>

pub(super) fn plan_cte_ref( &mut self, cte_ref: BoundBackCteRef, ) -> Result<PlanRef, RwError>

fn collect_col_data_types_for_tumble_window( relation: &Relation, ) -> Result<Vec<DataType>, RwError>

fn plan_tumble_window( &mut self, input: Relation, time_col: InputRef, args: Vec<ExprImpl>, ) -> Result<PlanRef, RwError>

fn plan_hop_window( &mut self, input: Relation, time_col: InputRef, args: Vec<ExprImpl>, ) -> Result<PlanRef, RwError>

impl Planner

pub(super) fn plan_select( &mut self, _: BoundSelect, extra_order_exprs: Vec<ExprImpl>, order: &[ColumnOrder], ) -> Result<PlanRef, RwError>

fn create_dummy_values(&self) -> PlanRef

Helper to create a dummy node as child of LogicalProject. For example, select 1+2, 3*4 will be Project([1+2, 3+4]) - Values([[]]).

fn create_exists(&self, input: PlanRef) -> Result<PlanRef, RwError>

Helper to create an EXISTS boolean operator with the given input. It is represented by Project([$0 >= 1]) -> Agg(count(*)) -> input

pub(super) fn plan_where( &mut self, input: PlanRef, where_clause: ExprImpl, ) -> Result<PlanRef, RwError>

For (NOT) EXISTS subquery or (NOT) IN subquery, we can plan it as LeftSemi/LeftAnti LogicalApply For other subqueries, we plan it as LeftOuter LogicalApply using Self::substitute_subqueries.

fn handle_exists_and_in( &mut self, expr: ExprImpl, negated: bool, input: &mut PlanRef, ) -> Result<(), RwError>

Handle (NOT) EXISTS and (NOT) IN in WHERE clause.

We will use a = b to replace a in (select b from ….) for (NOT) IN thus avoiding adding a LogicalFilter on LogicalApply.

pub(super) fn substitute_subqueries( &mut self, root: PlanRef, exprs: Vec<ExprImpl>, ) -> Result<(PlanRef, Vec<ExprImpl>), RwError>

Substitutes all Subquery in exprs.

Each time a Subquery is found, it is replaced by a new InputRef. And root is replaced by a new LeftOuter LogicalApply whose left side is root and right side is the planned subquery.

The InputRefs’ indexes start from root.schema().len(), which means they are additional columns beyond the original root.

fn create_apply( correlated_id: CorrelatedId, correlated_indices: Vec<usize>, left: PlanRef, right: PlanRef, on: ExprImpl, join_type: JoinType, max_one_row: bool, ) -> PlanRef

impl Planner

pub(super) fn plan_set_expr( &mut self, set_expr: BoundSetExpr, extra_order_exprs: Vec<ExprImpl>, order: &[ColumnOrder], ) -> Result<PlanRef, RwError>

impl Planner

pub(super) fn plan_set_operation( &mut self, op: BoundSetOperation, all: bool, corresponding_col_indices: Option<(ColIndexMapping, ColIndexMapping)>, left: BoundSetExpr, right: BoundSetExpr, ) -> Result<PlanRef, RwError>

impl Planner

pub(super) fn plan_statement( &mut self, stmt: BoundStatement, ) -> Result<PlanRoot, RwError>

impl Planner

pub(super) fn plan_update( &mut self, update: BoundUpdate, ) -> Result<PlanRoot, RwError>

impl Planner

pub(super) fn plan_values( &mut self, values: BoundValues, ) -> Result<PlanRef, RwError>

impl Planner

pub fn new(ctx: OptimizerContextRef) -> Planner

pub fn plan(&mut self, stmt: BoundStatement) -> Result<PlanRoot, RwError>

Plan a BoundStatement. Need to bind a statement before plan.

pub fn ctx(&self) -> OptimizerContextRef