Struct CollectLeftAccumulator 

struct CollectLeftAccumulator {
    expr: Arc<dyn PhysicalExpr>,
    min: MinAccumulator,
    max: MaxAccumulator,
}

Accumulator for collecting min/max bounds from build-side data during hash join.

This struct encapsulates the logic for progressively computing column bounds (minimum and maximum values) for a specific join key expression as batches are processed during the build phase of a hash join.

The bounds are used for dynamic filter pushdown optimization, where filters based on the actual data ranges can be pushed down to the probe side to eliminate unnecessary data early.

Fields

expr: Arc<dyn PhysicalExpr>

The physical expression to evaluate for each batch

min: MinAccumulator

Accumulator for tracking the minimum value across all batches

max: MaxAccumulator

Accumulator for tracking the maximum value across all batches

Implementations

impl CollectLeftAccumulator

fn try_new(expr: Arc<dyn PhysicalExpr>, schema: &SchemaRef) -> Result<Self>

Creates a new accumulator for tracking bounds of a join key expression.

Arguments

• expr - The physical expression to track bounds for
• schema - The schema of the input data

Returns

A new CollectLeftAccumulator instance configured for the expression’s data type

fn update_batch(&mut self, batch: &RecordBatch) -> Result<()>

Updates the accumulators with values from a new batch.

Evaluates the expression on the batch and updates both min and max accumulators with the resulting values.

Arguments

• batch - The record batch to process

Returns

Ok(()) if the update succeeds, or an error if expression evaluation fails

fn evaluate(self) -> Result<ColumnBounds>

Finalizes the accumulation and returns the computed bounds.

Consumes self to extract the final min and max values from the accumulators.

Returns

The ColumnBounds containing the minimum and maximum values observed