Struct datafusion::physical_plan::joins::NestedLoopJoinExec

pub struct NestedLoopJoinExec { /* private fields */ }

NestedLoopJoinExec executes partitions in parallel. One input will be collected to a single partition, call it inner-table. The other side of the input is treated as outer-table, and the output Partitioning is from it. Giving an output partition number x, the execution will be:

for outer-table-batch in outer-table-partition-x
    check-join(outer-table-batch, inner-table-data)

One of the inputs will become inner table, and it is decided by the join type. Following is the relation table:

JoinType	Distribution (left, right)	Inner-table
Inner/Left/LeftSemi/LeftAnti	(UnspecifiedDistribution, SinglePartition)	right
Right/RightSemi/RightAnti/Full	(SinglePartition, UnspecifiedDistribution)	left
Full	(SinglePartition, SinglePartition)	left

Implementations

impl NestedLoopJoinExec

pub fn try_new( left: Arc<dyn ExecutionPlan>, right: Arc<dyn ExecutionPlan>, filter: Option<JoinFilter>, join_type: &JoinType ) -> Result<NestedLoopJoinExec, DataFusionError>

Try to create a nwe NestedLoopJoinExec

pub fn left(&self) -> &Arc<dyn ExecutionPlan>

left side

pub fn right(&self) -> &Arc<dyn ExecutionPlan>

right side

pub fn filter(&self) -> Option<&JoinFilter>

Filters applied before join output

pub fn join_type(&self) -> &JoinType

How the join is performed

Trait Implementations

impl Debug for NestedLoopJoinExec

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

Formats the value using the given formatter.

impl DisplayAs for NestedLoopJoinExec

fn fmt_as( &self, t: DisplayFormatType, f: &mut Formatter<'_> ) -> Result<(), Error>

Format according to DisplayFormatType, used when verbose representation looks different from the default one

impl ExecutionPlan for NestedLoopJoinExec

fn as_any(&self) -> &(dyn Any + 'static)

Returns the execution plan as Any so that it can be downcast to a specific implementation.

fn schema(&self) -> Arc<Schema>

Get the schema for this execution plan

fn output_partitioning(&self) -> Partitioning

Specifies how the output of this ExecutionPlan is split into partitions.

fn output_ordering(&self) -> Option<&[PhysicalSortExpr]>

If the output of this ExecutionPlan within each partition is sorted, returns Some(keys) with the description of how it was sorted.

fn required_input_distribution(&self) -> Vec<Distribution>

Specifies the data distribution requirements for all the children for this ExecutionPlan, By default it’s [Distribution::UnspecifiedDistribution] for each child,

fn equivalence_properties(&self) -> EquivalenceProperties

Get the EquivalenceProperties within the plan.

fn children(&self) -> Vec<Arc<dyn ExecutionPlan>>

Get a list of children ExecutionPlans that act as inputs to this plan. The returned list will be empty for leaf nodes such as scans, will contain a single value for unary nodes, or two values for binary nodes (such as joins).

fn with_new_children( self: Arc<NestedLoopJoinExec>, children: Vec<Arc<dyn ExecutionPlan>> ) -> Result<Arc<dyn ExecutionPlan>, DataFusionError>

Returns a new ExecutionPlan where all existing children were replaced by the children, oi order

fn execute( &self, partition: usize, context: Arc<TaskContext> ) -> Result<Pin<Box<dyn RecordBatchStream<Item = Result<RecordBatch, DataFusionError>> + Send>>, DataFusionError>

Begin execution of partition, returning a Stream of RecordBatches.

fn metrics(&self) -> Option<MetricsSet>

Return a snapshot of the set of Metrics for this ExecutionPlan. If no Metrics are available, return None.

fn statistics(&self) -> Result<Statistics, DataFusionError>

Returns statistics for this ExecutionPlan node. If statistics are not available, should return Statistics::new_unknown (the default), not an error.

fn unbounded_output(&self, _children: &[bool]) -> Result<bool, DataFusionError>

Specifies whether this plan generates an infinite stream of records. If the plan does not support pipelining, but its input(s) are infinite, returns an error to indicate this.

fn required_input_ordering(&self) -> Vec<Option<Vec<PhysicalSortRequirement>>>

Specifies the ordering required for all of the children of this ExecutionPlan.

fn maintains_input_order(&self) -> Vec<bool>

Returns false if this ExecutionPlan’s implementation may reorder rows within or between partitions.

fn benefits_from_input_partitioning(&self) -> Vec<bool>

Specifies whether the ExecutionPlan benefits from increased parallelization at its input for each child.

fn repartitioned( &self, _target_partitions: usize, _config: &ConfigOptions ) -> Result<Option<Arc<dyn ExecutionPlan>>, DataFusionError>

If supported, attempt to increase the partitioning of this ExecutionPlan to produce target_partitions partitions.