Struct BatchExchange

pub struct BatchExchange {
    pub base: PlanBase<Batch>,
    input: PlanRef,
    sequential: bool,
}

BatchExchange imposes a particular distribution on its input without changing its content.

Fields

base: PlanBase<Batch>

input: PlanRef

sequential: bool

Implementations

impl BatchExchange

pub fn new(input: PlanRef, order: Order, dist: Distribution) -> Self

pub fn new_with_sequential( input: PlanRef, order: Order, dist: Distribution, ) -> Self

fn new_inner( input: PlanRef, order: Order, dist: Distribution, sequential: bool, ) -> Self

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 BatchExchange

fn clone(&self) -> BatchExchange

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ColPrunable for BatchExchange

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 BatchExchange

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

Formats the value using the given formatter.

impl Deref for BatchExchange

type Target = PlanBase<Batch>

The resulting type after dereferencing.

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

Dereferences the value.

impl Distill for BatchExchange

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

fn distill_to_string(&self) -> String

impl ExprRewritable for BatchExchange

fn has_rewritable_expr(&self) -> bool

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

impl ExprVisitable for BatchExchange

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

impl Hash for BatchExchange

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 BatchExchange

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

const NODE_TYPE: PlanNodeType = PlanNodeType::BatchExchange

type Convention = Batch

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

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 BatchExchange

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

Clone the node with a list of new inputs.

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

Get input nodes of the plan.

impl PlanTreeNodeUnary for BatchExchange

fn input(&self) -> PlanRef

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

fn rewrite_with_input( &self, _input: PlanRef, _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 PredicatePushdown for BatchExchange

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

Push predicate down for every logical plan node.

impl ToBatch for BatchExchange

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 ToBatchPb for BatchExchange

The serialization of Batch Exchange is default cuz it will be rewritten in scheduler.

fn to_batch_prost_body(&self) -> NodeBody

impl ToDistributedBatch for BatchExchange

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 BatchExchange

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 BatchExchange

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 TryToStreamPb for BatchExchange

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

impl Eq for BatchExchange

impl PlanNode for BatchExchange

impl StructuralPartialEq for BatchExchange

impl ToPb for BatchExchange