Struct BatchLookupJoin 

pub struct BatchLookupJoin {
    pub base: PlanBase<Batch>,
    core: Join<BatchPlanRef>,
    eq_join_predicate: EqJoinPredicate,
    right_table: Arc<TableCatalog>,
    right_output_column_ids: Vec<ColumnId>,
    lookup_prefix_len: usize,
    distributed_lookup: bool,
    as_of: Option<AsOf>,
    asof_desc: Option<AsOfJoinDesc>,
}

Fields

base: PlanBase<Batch>

core: Join<BatchPlanRef>

eq_join_predicate: EqJoinPredicate

The join condition must be equivalent to logical.on, but separated into equal and non-equal parts to facilitate execution later

right_table: Arc<TableCatalog>

Table description of the right side table

right_output_column_ids: Vec<ColumnId>

Output column ids of the right side table

lookup_prefix_len: usize

The prefix length of the order key of right side table.

distributed_lookup: bool

If distributed_lookup is true, it will generate DistributedLookupJoinNode for ToBatchPb. Otherwise, it will generate LookupJoinNode.

as_of: Option<AsOf>

asof_desc: Option<AsOfJoinDesc>

Implementations

impl BatchLookupJoin

pub fn new( core: Join<PlanRef>, eq_join_predicate: EqJoinPredicate, right_table: Arc<TableCatalog>, right_output_column_ids: Vec<ColumnId>, lookup_prefix_len: usize, distributed_lookup: bool, as_of: Option<AsOf>, asof_desc: Option<AsOfJoinDesc>, ) -> Self

fn derive_dist(left: &Distribution, core: &Join<PlanRef>) -> Distribution

fn eq_join_predicate(&self) -> &EqJoinPredicate

pub fn right_table(&self) -> &TableCatalog

fn clone_with_distributed_lookup( &self, input: PlanRef, distributed_lookup: bool, ) -> Self

pub fn lookup_prefix_len(&self) -> usize

Methods from Deref<Target = PlanBase<Batch>>

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 BatchLookupJoin

fn clone(&self) -> BatchLookupJoin

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BatchLookupJoin

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

Formats the value using the given formatter.

impl Deref for BatchLookupJoin

type Target = PlanBase<Batch>

The resulting type after dereferencing.

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

Dereferences the value.

impl Distill for BatchLookupJoin

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

fn distill_to_string(&self) -> String

impl ExprRewritable<Batch> for BatchLookupJoin

fn has_rewritable_expr(&self) -> bool

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

impl ExprVisitable for BatchLookupJoin

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

impl Hash for BatchLookupJoin

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 BatchLookupJoin

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

const NODE_TYPE: BatchPlanNodeType = BatchPlanNodeType::BatchLookupJoin

type Convention = Batch

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

Get the reference to the PlanBase with corresponding convention.

impl PlanTreeNode<Batch> for BatchLookupJoin

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

Clone the node with a list of new inputs.

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

Get input nodes of the plan.

impl PlanTreeNodeUnary<Batch> for BatchLookupJoin

fn input(&self) -> PlanRef

fn clone_with_input(&self, input: PlanRef) -> Self

fn rewrite_with_input( &self, _input: PlanRef<C>, _input_col_change: ColIndexMapping, ) -> (Self, ColIndexMapping)

where Self: Sized,

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

impl ToDistributedBatch for BatchLookupJoin

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

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<BatchPlanRef>

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

impl ToLocalBatch for BatchLookupJoin

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

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

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

impl TryToBatchPb for BatchLookupJoin

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

impl BatchPlanNode for BatchLookupJoin

impl Eq for BatchLookupJoin

impl StructuralPartialEq for BatchLookupJoin