Struct datafusion::physical_plan::aggregates::AggregateExec

pub struct AggregateExec {
    pub input: Arc<dyn ExecutionPlan>,
    pub input_schema: Arc<Schema>,
    /* 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: Arc<Schema>

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 new_with_aggr_expr_and_ordering_info( &self, required_input_ordering: Option<Vec<PhysicalSortRequirement>>, aggr_expr: Vec<Arc<dyn AggregateExpr>>, cache: PlanProperties, input_order_mode: InputOrderMode ) -> AggregateExec

Function used in ConvertFirstLast optimizer rule, where we need parts of the new value, others cloned from the old one

pub fn cache(&self) -> &PlanProperties

pub fn try_new( mode: AggregateMode, group_by: PhysicalGroupBy, aggr_expr: Vec<Arc<dyn AggregateExpr>>, filter_expr: Vec<Option<Arc<dyn PhysicalExpr>>>, input: Arc<dyn ExecutionPlan>, input_schema: Arc<Schema> ) -> Result<AggregateExec, DataFusionError>

Create a new hash aggregate execution plan

pub fn mode(&self) -> &AggregateMode

Aggregation mode (full, partial)

pub fn with_limit(self, limit: Option<usize>) -> AggregateExec

Set the limit of this AggExec

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<dyn AggregateExpr>]

Aggregate expressions

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

FILTER (WHERE clause) expression for each aggregate expression

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

Input plan

pub fn input_schema(&self) -> Arc<Schema>

Get the input schema before any aggregates are applied

pub fn limit(&self) -> Option<usize>

number of rows soft limit of the AggregateExec

pub fn get_minmax_desc(&self) -> Option<(Field, 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: Arc<Schema>, projection_mapping: &ProjectionMapping, mode: &AggregateMode, input_order_mode: &InputOrderMode ) -> 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

Trait Implementations

impl Debug for AggregateExec

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

Formats the value using the given formatter.

impl DisplayAs for AggregateExec

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 AggregateExec

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

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

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

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

fn properties(&self) -> &PlanProperties

Return properties of the output of the ExecutionPlan, such as output ordering(s), partitioning information etc.

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 required_input_ordering(&self) -> Vec<Option<Vec<PhysicalSortRequirement>>>

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 with_new_children( self: Arc<AggregateExec>, children: Vec<Arc<dyn ExecutionPlan>> ) -> Result<Arc<dyn ExecutionPlan>, DataFusionError>

Returns a new ExecutionPlan where all existing children were replaced by the children, in 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 static_name() -> &'static str

where Self: Sized,

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

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

Get the schema for this execution plan

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.