Struct LogicalApply

pub struct LogicalApply {
    pub base: PlanBase<Logical>,
    left: PlanRef,
    right: PlanRef,
    on: Condition,
    join_type: JoinType,
    correlated_id: CorrelatedId,
    correlated_indices: Vec<usize>,
    max_one_row: bool,
    translated: bool,
}

LogicalApply represents a correlated join, where the right side may refer to columns from the left side.

Fields

base: PlanBase<Logical>

left: PlanRef

right: PlanRef

on: Condition

join_type: JoinType

correlated_id: CorrelatedId

Id of the Apply operator. So correlated_input_ref can refer the Apply operator exactly by correlated_id.

correlated_indices: Vec<usize>

The indices of CorrelatedInputRefs in right.

max_one_row: bool

Whether we require the subquery to produce at most one row. If true, we have to report an error if the subquery produces more than one row.

translated: bool

An apply has been translated by translate_apply(), so we should not translate it in translate_apply_rule again. This flag is used to avoid infinite loop in General Unnesting(Translate Apply), since we use a top-down apply order instead of bottom-up to improve the multi-scalar subqueries optimization time.

Implementations

impl LogicalApply

pub(crate) fn new( left: PlanRef, right: PlanRef, join_type: JoinType, on: Condition, correlated_id: CorrelatedId, correlated_indices: Vec<usize>, max_one_row: bool, translated: bool, ) -> Self

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

pub fn join_type(&self) -> JoinType

Get the join type of the logical apply.

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

pub fn correlated_id(&self) -> CorrelatedId

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

pub fn translated(&self) -> bool

pub fn max_one_row(&self) -> bool

pub fn translate_apply( self, domain: PlanRef, eq_predicates: Vec<ExprImpl>, ) -> PlanRef

Translate Apply.

Used to convert other kinds of Apply to cross Apply.

Before:

    LogicalApply
   /            \
 LHS           RHS

After:

     LogicalJoin
   /            \
 LHS        LogicalApply
            /           \
         Domain         RHS

fn rewrite_on(on: Condition, offset: usize, apply_left_len: usize) -> Condition

fn concat_schema(&self) -> Schema

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 LogicalApply

fn clone(&self) -> LogicalApply

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ColPrunable for LogicalApply

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 LogicalApply

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

Formats the value using the given formatter.

impl Deref for LogicalApply

type Target = PlanBase<Logical>

The resulting type after dereferencing.

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

Dereferences the value.

impl Distill for LogicalApply

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

fn distill_to_string(&self) -> String

impl ExprRewritable for LogicalApply

fn has_rewritable_expr(&self) -> bool

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

impl ExprVisitable for LogicalApply

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

impl Hash for LogicalApply

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 LogicalApply

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

const NODE_TYPE: PlanNodeType = PlanNodeType::LogicalApply

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 LogicalApply

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 LogicalApply

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)

where Self: Sized,

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

impl PredicatePushdown for LogicalApply

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

Push predicate down for every logical plan node.

impl ToBatch for LogicalApply

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 LogicalApply

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 LogicalApply

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 LogicalApply

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 LogicalApply

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

impl TryToStreamPb for LogicalApply

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

impl Eq for LogicalApply

impl PlanNode for LogicalApply

impl StructuralPartialEq for LogicalApply

impl ToPb for LogicalApply