Struct AggregateExec 

pub struct AggregateExec {
    pub input: Arc<dyn ExecutionPlan>,
    pub input_schema: SchemaRef,
    /* private fields */
}

Hash aggregate execution plan

Fields

input: Arc<dyn ExecutionPlan>

Input plan, could be a partial aggregate or the input to the aggregate

input_schema: SchemaRef

Input schema before any aggregation is applied. For partial aggregate this will be the same as input.schema() but for the final aggregate it will be the same as the input to the partial aggregate, i.e., partial and final aggregates have same input_schema. We need the input schema of partial aggregate to be able to deserialize aggregate expressions from protobuf for final aggregate.

Implementations

impl AggregateExec

pub fn with_new_aggr_exprs( &self, aggr_expr: impl Into<Arc<[Arc<AggregateFunctionExpr>]>>, ) -> Self

Function used in OptimizeAggregateOrder optimizer rule, where we need parts of the new value, others cloned from the old one Rewrites aggregate exec with new aggregate expressions.

pub fn with_new_limit_options( &self, limit_options: Option<LimitOptions>, ) -> Self

Clone this exec, overriding only the limit hint.

pub fn cache(&self) -> &PlanProperties

pub fn try_new( mode: AggregateMode, group_by: impl Into<Arc<PhysicalGroupBy>>, aggr_expr: Vec<Arc<AggregateFunctionExpr>>, filter_expr: Vec<Option<Arc<dyn PhysicalExpr>>>, input: Arc<dyn ExecutionPlan>, input_schema: SchemaRef, ) -> Result<Self>

Create a new hash aggregate execution plan

pub fn mode(&self) -> &AggregateMode

Aggregation mode (full, partial)

pub fn with_limit_options(self, limit_options: Option<LimitOptions>) -> Self

Set the limit options for this AggExec

pub fn limit_options(&self) -> Option<LimitOptions>

Get the limit options (if set)

pub fn group_expr(&self) -> &PhysicalGroupBy

Grouping expressions

pub fn output_group_expr(&self) -> Vec<Arc<dyn PhysicalExpr>>

Grouping expressions as they occur in the output schema

pub fn aggr_expr(&self) -> &[Arc<AggregateFunctionExpr>]

Aggregate expressions

pub fn filter_expr(&self) -> &[Option<Arc<dyn PhysicalExpr>>]

FILTER (WHERE clause) expression for each aggregate expression

pub fn dynamic_filter_expr(&self) -> Option<&Arc<DynamicFilterPhysicalExpr>>

👎Deprecated since 55.0.0:

Use ExecutionPlan::dynamic_expressions_produced instead

Returns the dynamic filter expression for this aggregate, if set.

pub fn with_dynamic_filter_expr( self, filter: Arc<DynamicFilterPhysicalExpr>, ) -> Result<Self>

Replace the dynamic filter expression. This method errors if the aggregate does not support dynamic filtering or if the filter expression is incompatible with this AggregateExec.

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

Input plan

pub fn input_schema(&self) -> SchemaRef

Get the input schema before any aggregates are applied

pub fn get_minmax_desc(&self) -> Option<(FieldRef, bool)>

Finds the DataType and SortDirection for this Aggregate, if there is one

pub fn is_unordered_unfiltered_group_by_distinct(&self) -> bool

true, if this Aggregate has a group-by with no required or explicit ordering, no filtering and no aggregate expressions This method qualifies the use of the LimitedDistinctAggregation rewrite rule on an AggregateExec.

pub fn compute_properties( input: &Arc<dyn ExecutionPlan>, schema: SchemaRef, group_expr_mapping: &ProjectionMapping, is_true_no_grouping: bool, mode: &AggregateMode, input_order_mode: &InputOrderMode, aggr_exprs: &[Arc<AggregateFunctionExpr>], ) -> Result<PlanProperties>

This function creates the cache object that stores the plan properties such as schema, equivalence properties, ordering, partitioning, etc.

pub fn input_order_mode(&self) -> &InputOrderMode

impl AggregateExec

pub fn try_from_proto( node: &PhysicalPlanNode, ctx: &ExecutionPlanDecodeCtx<'_>, ) -> Result<Arc<dyn ExecutionPlan>>

Available on crate feature proto only.

Reconstruct an AggregateExec from its protobuf representation.

Grouping expressions are decoded against the child schema. Aggregate arguments, ordering, filters, and the dynamic filter are decoded against the aggregate input schema carried in the protobuf node.

Trait Implementations

impl Clone for AggregateExec

fn clone(&self) -> AggregateExec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AggregateExec

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

Formats the value using the given formatter.

impl DisplayAs for AggregateExec

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

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

impl ExecutionPlan for AggregateExec

fn properties(&self) -> &Arc<PlanProperties>

Return a reference to Any that can be used for down-casting

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

The output ordering of AggregateExec is determined by its group_by columns. Although this method is not explicitly used by any optimizer rules yet, overriding the default implementation ensures that it accurately reflects the actual behavior.

If the InputOrderMode is Linear, the group_by columns don’t have an ordering, which means the results do not either. However, in the Ordered and PartiallyOrdered cases, the group_by columns do have an ordering, which is preserved in the output.

fn gather_filters_for_pushdown( &self, phase: FilterPushdownPhase, parent_filters: Vec<Arc<dyn PhysicalExpr>>, config: &ConfigOptions, ) -> Result<FilterDescription>

Push down parent filters when possible (see implementation comment for details), and also pushdown self dynamic filters (see AggrDynFilter for details)

fn handle_child_pushdown_result( &self, phase: FilterPushdownPhase, child_pushdown_result: ChildPushdownResult, _config: &ConfigOptions, ) -> Result<FilterPushdownPropagation<Arc<dyn ExecutionPlan>>>

If child accepts self’s dynamic filter, keep self.dynamic_filter with Some, otherwise clear it to None.

fn name(&self) -> &'static str

Short name for the ExecutionPlan, such as ‘DataSourceExec’.

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

👎Deprecated since 55.0.0:

Use input_distribution_requirements

Specifies simple per-child input distribution requirements.

fn input_distribution_requirements(&self) -> InputDistributionRequirements

Specifies the input distribution requirements for this plan.

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

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

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 replace_children( self: Arc<Self>, children: Vec<Arc<dyn ExecutionPlan>>, options: ReplaceChildrenOptions, ) -> Result<Arc<dyn ExecutionPlan>>

Returns a clone of the existing plan with the children replaced, skipping recomputation of plan properties when the options indicate the new children’s properties are unchanged.

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

👎Deprecated since 55.0.0:

Use ExecutionPlan::replace_children with ReplaceChildrenOptions

Deprecated.

fn apply_expressions( &self, f: &mut dyn FnMut(&Arc<dyn PhysicalExpr>) -> Result<TreeNodeRecursion>, ) -> Result<TreeNodeRecursion>

Apply a closure f to each root expression that this node owns and uses during execution, either by evaluating it or updating it dynamically.

fn dynamic_expressions_produced(&self) -> Vec<Arc<dyn PhysicalExpr>>

Returns the dynamic expressions produced by this plan node.

fn with_new_children_and_same_properties( self: Arc<Self>, children: Vec<Arc<dyn ExecutionPlan>>, ) -> Result<Arc<dyn ExecutionPlan>>

👎Deprecated since 55.0.0:

Use ExecutionPlan::replace_children with ReplaceChildrenOptions

Deprecated. Implement ExecutionPlan::replace_children instead.

fn execute( &self, partition: usize, context: Arc<TaskContext>, ) -> Result<SendableRecordBatchStream>

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 child_stats_requests(&self, partition: Option<usize>) -> Vec<ChildStats>

Returns, per child, which statistics the StatisticsContext should resolve before calling Self::statistics_from_inputs.

fn statistics_from_inputs( &self, input_stats: &[Arc<Statistics>], args: &StatisticsArgs, ) -> Result<Arc<Statistics>>

Returns statistics for a specific partition of this ExecutionPlan node, given pre-computed child statistics.

fn cardinality_effect(&self) -> CardinalityEffect

Gets the effect on cardinality, if known

fn try_to_proto( &self, ctx: &ExecutionPlanEncodeCtx<'_>, ) -> Result<Option<PhysicalPlanNode>>

Available on crate feature proto only.

Serialize this plan to its protobuf representation, if it knows how.

fn static_name() -> &'static str

where Self: Sized,

Short name for the ExecutionPlan, such as ‘DataSourceExec’. Like name but can be called without an instance.

fn downcast_delegate(&self) -> Option<&dyn ExecutionPlan>

Returns the plan that provides this plan’s public ExecutionPlan downcast identity.

fn schema(&self) -> SchemaRef

Get the schema for this execution plan

fn check_invariants(&self, check: InvariantLevel) -> Result<()>

Returns an error if this individual node does not conform to its invariants. These invariants are typically only checked in debug mode.

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

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

fn reset_state(self: Arc<Self>) -> Result<Arc<dyn ExecutionPlan>>

Reset any internal state within this ExecutionPlan.

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

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

fn partition_statistics( &self, partition: Option<usize>, ) -> Result<Arc<Statistics>>

👎Deprecated since 55.0.0:

Use StatisticsContext::compute instead

Returns statistics for a specific partition of this ExecutionPlan node.

fn supports_limit_pushdown(&self) -> bool

Returns true if a limit can be safely pushed down through this ExecutionPlan node.

fn with_fetch(&self, _limit: Option<usize>) -> Option<Arc<dyn ExecutionPlan>>

Returns a fetching variant of this ExecutionPlan node, if it supports fetch limits. Returns None otherwise.

fn fetch(&self) -> Option<usize>

Gets the fetch count for the operator, None means there is no fetch.

fn try_swapping_with_projection( &self, _projection: &ProjectionExec, ) -> Result<Option<Arc<dyn ExecutionPlan>>>

Attempts to push down the given projection into the input of this ExecutionPlan.

fn with_new_state( &self, _state: Arc<dyn Any + Send + Sync>, ) -> Option<Arc<dyn ExecutionPlan>>

Injects arbitrary run-time state into this execution plan, returning a new plan instance that incorporates that state if it is relevant to the concrete node implementation.

fn try_pushdown_sort( &self, _order: &[PhysicalSortExpr], ) -> Result<SortOrderPushdownResult<Arc<dyn ExecutionPlan>>>

Try to push down sort ordering requirements to this node.

fn with_preserve_order( &self, _preserve_order: bool, ) -> Option<Arc<dyn ExecutionPlan>>

Returns a variant of this ExecutionPlan that is aware of order-sensitivity.