Struct LogicalMultiJoin 

pub struct LogicalMultiJoin {
    pub base: PlanBase<Logical>,
    inputs: Vec<LogicalPlanRef>,
    on: Condition,
    output_indices: Vec<usize>,
    inner2output: ColIndexMapping,
    inner_o2i_mapping: Vec<(usize, usize)>,
    inner_i2o_mappings: Vec<ColIndexMapping>,
}

LogicalMultiJoin combines two or more relations according to some condition.

Each output row has fields from one the inputs. The set of output rows is a subset of the cartesian product of all the inputs; The LogicalMultiInnerJoin is only supported for inner joins as it implicitly assumes commutativity. Non-inner joins should be expressed as 2-way LogicalJoins.

Fields

base: PlanBase<Logical>

inputs: Vec<LogicalPlanRef>

on: Condition

output_indices: Vec<usize>

inner2output: ColIndexMapping

inner_o2i_mapping: Vec<(usize, usize)>

the mapping output_col_idx -> (input_idx, input_col_idx), “output_col_idx” is internal, not consider output_indices

inner_i2o_mappings: Vec<ColIndexMapping>

Implementations

impl LogicalMultiJoin

pub(crate) fn new( inputs: Vec<PlanRef>, on: Condition, output_indices: Vec<usize>, ) -> Self

fn derive_stream_key( inputs: &[PlanRef], inner_i2o_mappings: &[ColIndexMapping], inner2output: &ColIndexMapping, ) -> Option<Vec<usize>>

pub fn on(&self) -> &Condition

Get a reference to the logical join’s on.

pub fn clone_with_cond(&self, cond: Condition) -> Self

Clone with new on condition

impl LogicalMultiJoin

pub fn as_reordered_left_deep_join(&self, join_ordering: &[usize]) -> PlanRef

pub(crate) fn heuristic_ordering(&self) -> Result<Vec<usize>>

Our heuristic join reordering algorithm will try to perform a left-deep join. It will try to do the following:

1. First, split the join graph, with eq join conditions as graph edges, into their connected components. Repeat the procedure in 2. with the largest connected components down to the smallest.

2. For each connected component, add joins to the chain, prioritizing adding those joins to the bottom of the chain if their join conditions have:

   a. eq joins between primary keys on both sides b. eq joins with primary keys on one side c. more equijoin conditions

   in that order. This forms our selectivity heuristic.

3. Thirdly, we will emit a left-deep cross-join of each of the left-deep joins of the connected components. Depending on the type of plan, this may result in a planner failure (e.g. for streaming). No cross-join will be emitted for a single connected component.

4. Finally, we will emit, above the left-deep join tree: a. a filter with the non eq conditions b. a projection which reorders the output column ordering to agree with the original ordering of the joins. The filter will then be pushed down by another filter pushdown pass.

pub fn as_bushy_tree_join(&self) -> Result<PlanRef>

transform multijoin into bushy tree join.

1. First, use equivalent condition derivation to get derive join relation.
2. Second, for every isolated node will create connection to every other nodes.
3. Third, select and merge one node for a iteration, and use a bfs policy for which node the selected node merged with. i. The select node mentioned above is the node with least number of relations and the lowest join tree. ii. nodes with a join tree higher than the temporal optimal join tree will be pruned.

pub(crate) fn input_col_nums(&self) -> Vec<usize>

fn get_join_graph(&self) -> Result<(BTreeMap<usize, GraphNode>, Condition)>

get join graph from self.on, return the join graph and the new join condition.

fn eq_condition_derivation(&self, condition: Condition) -> Result<Condition>

equivalent condition derivation by a = b && a = c ==> b = c

fn create_logical_join( &self, join_tree: JoinTreeNode, join_ordering: &mut Vec<usize>, ) -> Result<PlanRef>

create logical plan by recursively travase JoinTreeNode

Methods from Deref<Target = PlanBase<Logical>>

pub fn clone_with_new_plan_id(&self) -> Self

pub fn clone_with_new_distribution(&self, dist: Distribution) -> Self

Clone the plan node with a new distribution.

Panics if the plan node is not physical.

Trait Implementations

impl Clone for LogicalMultiJoin

fn clone(&self) -> LogicalMultiJoin

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ColPrunable for LogicalMultiJoin

fn prune_col( &self, _required_cols: &[usize], _ctx: &mut ColumnPruningContext, ) -> PlanRef

Transform the plan node to only output the required columns ordered by index number.

impl Debug for LogicalMultiJoin

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

Formats the value using the given formatter.

impl Deref for LogicalMultiJoin

type Target = PlanBase<Logical>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Distill for LogicalMultiJoin

fn distill<'a>(&self) -> XmlNode<'a>

fn distill_to_string(&self) -> String

impl ExprRewritable<Logical> for LogicalMultiJoin

fn rewrite_exprs(&self, _r: &mut dyn ExprRewriter) -> PlanRef

fn has_rewritable_expr(&self) -> bool

impl ExprVisitable for LogicalMultiJoin

fn visit_exprs(&self, _v: &mut dyn ExprVisitor)

impl Hash for LogicalMultiJoin

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for LogicalMultiJoin

fn eq(&self, other: &LogicalMultiJoin) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PlanNodeMeta for LogicalMultiJoin

const NODE_TYPE: LogicalPlanNodeType = LogicalPlanNodeType::LogicalMultiJoin

type Convention = Logical

fn plan_base(&self) -> &PlanBase<Logical>

Get the reference to the PlanBase with corresponding convention.

impl PlanTreeNode<Logical> for LogicalMultiJoin

fn inputs(&self) -> SmallVec<[PlanRef; 2]>

Get input nodes of the plan.

fn clone_with_inputs(&self, inputs: &[PlanRef]) -> PlanRef

Clone the node with a list of new inputs.

impl PredicatePushdown for LogicalMultiJoin

fn predicate_pushdown( &self, _predicate: Condition, _ctx: &mut PredicatePushdownContext, ) -> PlanRef

Push predicate down for every logical plan node.

impl ToBatch for LogicalMultiJoin

fn to_batch(&self) -> Result<BatchPlanRef>

to_batch is equivalent to to_batch_with_order_required(&Order::any())

fn to_batch_with_order_required( &self, required_order: &Order, ) -> Result<BatchPlanRef>

convert the plan to batch physical plan and satisfy the required Order

impl ToStream for LogicalMultiJoin

fn logical_rewrite_for_stream( &self, _ctx: &mut RewriteStreamContext, ) -> Result<(PlanRef, ColIndexMapping)>

logical_rewrite_for_stream will rewrite the logical node, and return (new_plan_node, col_mapping), the col_mapping is for original columns have been changed into some other position.

fn to_stream(&self, _ctx: &mut ToStreamContext) -> Result<StreamPlanRef>

to_stream is equivalent to to_stream_with_dist_required(RequiredDist::Any)

fn to_stream_with_dist_required( &self, required_dist: &RequiredDist, ctx: &mut ToStreamContext, ) -> Result<StreamPlanRef>

convert the plan to streaming physical plan and satisfy the required distribution

fn try_better_locality(&self, _columns: &[usize]) -> Option<LogicalPlanRef>

impl Eq for LogicalMultiJoin

impl LogicalPlanNode for LogicalMultiJoin

impl StructuralPartialEq for LogicalMultiJoin