Struct LogicalJoin

pub struct LogicalJoin {
    pub base: PlanBase<Logical>,
    core: Join<PlanRef>,
}

LogicalJoin combines two relations according to some condition.

Each output row has fields from the left and right inputs. The set of output rows is a subset of the cartesian product of the two inputs; precisely which subset depends on the join condition. In addition, the output columns are a subset of the columns of the left and right columns, dependent on the output indices provided. A repeat output index is illegal.

Fields

base: PlanBase<Logical>

core: Join<PlanRef>

Implementations

impl LogicalJoin

pub(crate) fn new( left: PlanRef, right: PlanRef, join_type: JoinType, on: Condition, ) -> Self

pub(crate) fn with_output_indices( left: PlanRef, right: PlanRef, join_type: JoinType, on: Condition, output_indices: Vec<usize>, ) -> Self

pub fn with_core(core: Join<PlanRef>) -> Self

pub fn create( left: PlanRef, right: PlanRef, join_type: JoinType, on_clause: ExprImpl, ) -> PlanRef

pub fn internal_column_num(&self) -> usize

pub fn i2l_col_mapping_ignore_join_type(&self) -> ColIndexMapping

pub fn i2r_col_mapping_ignore_join_type(&self) -> ColIndexMapping

pub fn on(&self) -> &Condition

Get a reference to the logical join’s on.

pub fn input_idx_on_condition(&self) -> (Vec<usize>, Vec<usize>)

Collect all input ref in the on condition. And separate them into left and right.

pub fn join_type(&self) -> JoinType

Get the join type of the logical join.

pub fn eq_indexes(&self) -> Vec<(usize, usize)>

Get the eq join key of the logical join.

pub fn output_indices(&self) -> &Vec<usize>

Get the output indices of the logical join.

pub fn clone_with_output_indices(&self, output_indices: Vec<usize>) -> Self

Clone with new output indices

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

Clone with new on condition

pub fn is_left_join(&self) -> bool

pub fn is_right_join(&self) -> bool

pub fn is_full_out(&self) -> bool

pub fn output_indices_are_trivial(&self) -> bool

fn simplify_outer( predicate: &Condition, left_col_num: usize, join_type: JoinType, ) -> JoinType

Try to simplify the outer join with the predicate on the top of the join

now it is just a naive implementation for comparison expression, we can give a more general implementation with constant folding in future

fn to_batch_lookup_join_with_index_selection( &self, predicate: EqJoinPredicate, logical_join: Join<PlanRef>, ) -> Option<BatchLookupJoin>

Index Join: Try to convert logical join into batch lookup join and meanwhile it will do the index selection for the lookup table so that we can benefit from indexes.

fn to_batch_lookup_join( &self, predicate: EqJoinPredicate, logical_join: Join<PlanRef>, ) -> Option<BatchLookupJoin>

Try to convert logical join into batch lookup join.

pub fn decompose(self) -> (PlanRef, PlanRef, Condition, JoinType, Vec<usize>)

impl LogicalJoin

fn get_stream_input_for_hash_join( &self, predicate: &EqJoinPredicate, ctx: &mut ToStreamContext, ) -> Result<(PlanRef, PlanRef), RwError>

fn to_stream_hash_join( &self, predicate: EqJoinPredicate, ctx: &mut ToStreamContext, ) -> Result<PlanRef, RwError>

fn should_be_temporal_join(&self) -> bool

fn to_stream_temporal_join_with_index_selection( &self, predicate: EqJoinPredicate, ctx: &mut ToStreamContext, ) -> Result<StreamTemporalJoin, RwError>

fn check_temporal_rhs(right: &PlanRef) -> Result<&LogicalScan, RwError>

fn temporal_join_scan_predicate_pull_up( logical_scan: &LogicalScan, predicate: EqJoinPredicate, output_indices: &[usize], left_schema_len: usize, ) -> Result<(StreamTableScan, EqJoinPredicate, Condition, Vec<usize>), RwError>

fn to_stream_temporal_join( &self, predicate: EqJoinPredicate, ctx: &mut ToStreamContext, ) -> Result<StreamTemporalJoin, RwError>

fn to_stream_nested_loop_temporal_join( &self, predicate: EqJoinPredicate, ctx: &mut ToStreamContext, ) -> Result<StreamTemporalJoin, RwError>

fn to_stream_dynamic_filter( &self, predicate: Condition, ctx: &mut ToStreamContext, ) -> Result<Option<PlanRef>, RwError>

pub fn index_lookup_join_to_batch_lookup_join(&self) -> Result<PlanRef, RwError>

fn to_stream_asof_join( &self, predicate: EqJoinPredicate, ctx: &mut ToStreamContext, ) -> Result<StreamAsOfJoin, RwError>

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 LogicalJoin

fn clone(&self) -> LogicalJoin

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ColPrunable for LogicalJoin

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 LogicalJoin

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

Formats the value using the given formatter.

impl Deref for LogicalJoin

type Target = PlanBase<Logical>

The resulting type after dereferencing.

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

Dereferences the value.

impl Distill for LogicalJoin

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

fn distill_to_string(&self) -> String

impl ExprRewritable for LogicalJoin

fn has_rewritable_expr(&self) -> bool

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

impl ExprVisitable for LogicalJoin

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

impl Hash for LogicalJoin

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 LogicalJoin

fn eq(&self, other: &LogicalJoin) -> 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 LogicalJoin

const NODE_TYPE: PlanNodeType = PlanNodeType::LogicalJoin

type Convention = Logical

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

Get the reference to the PlanBase with corresponding convention.

fn plan_base_ref(&self) -> PlanBaseRef<'_>

Get the reference to the PlanBase with erased convention.

impl PlanTreeNode for LogicalJoin

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 PlanTreeNodeBinary for LogicalJoin

fn left(&self) -> PlanRef

fn right(&self) -> PlanRef

fn clone_with_left_right(&self, left: PlanRef, right: PlanRef) -> Self

fn rewrite_with_left_right( &self, left: PlanRef, left_col_change: ColIndexMapping, right: PlanRef, right_col_change: ColIndexMapping, ) -> (Self, ColIndexMapping)

Rewrites the plan node according to the schema change of its input nodes during rewriting.

impl PredicatePushdown for LogicalJoin

fn predicate_pushdown( &self, predicate: Condition, ctx: &mut PredicatePushdownContext, ) -> PlanRef

Pushes predicates above and within a join node into the join node and/or its children nodes.

Which predicates can be pushed

For inner join, we can do all kinds of pushdown.

For left/right semi join, we can push filter to left/right and on-clause, and push on-clause to left/right.

For left/right anti join, we can push filter to left/right, but on-clause can not be pushed

Outer Join

Preserved Row table : The table in an Outer Join that must return all rows.

Null Supplying table : This is the table that has nulls filled in for its columns in unmatched rows.

	Preserved Row table	Null Supplying table
Join predicate (on)	Not Pushed	Pushed
Where predicate (filter)	Pushed	Not Pushed

impl ToBatch for LogicalJoin

fn to_batch(&self) -> Result<PlanRef, RwError>

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

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

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

impl ToDistributedBatch for LogicalJoin

fn to_distributed(&self) -> Result<PlanRef, RwError>

to_distributed is equivalent to to_distributed_with_required(&Order::any(), &RequiredDist::Any)

fn to_distributed_with_required( &self, required_order: &Order, required_dist: &RequiredDist, ) -> Result<PlanRef, RwError>

insert the exchange in batch physical plan to satisfy the required Distribution and Order.

impl ToLocalBatch for LogicalJoin

fn to_local(&self) -> Result<PlanRef, RwError>

fn to_local_with_order_required( &self, required_order: &Order, ) -> Result<PlanRef, RwError>

Convert the plan to batch local physical plan and satisfy the required Order

impl ToStream for LogicalJoin

fn to_stream(&self, ctx: &mut ToStreamContext) -> Result<PlanRef, RwError>

to_stream is equivalent to to_stream_with_dist_required(RequiredDist::Any)

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

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_with_dist_required( &self, required_dist: &RequiredDist, ctx: &mut ToStreamContext, ) -> Result<PlanRef, RwError>

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

impl TryToBatchPb for LogicalJoin

fn try_to_batch_prost_body(&self) -> Result<NodeBody, SchedulerError>

impl TryToStreamPb for LogicalJoin

fn try_to_stream_prost_body( &self, _state: &mut BuildFragmentGraphState, ) -> Result<NodeBody, SchedulerError>

impl Eq for LogicalJoin

impl PlanNode for LogicalJoin

impl StructuralPartialEq for LogicalJoin

impl ToPb for LogicalJoin