Trait datafusion::physical_plan::AggregateExpr

source · 
pub trait AggregateExpr: Send + Sync + Debug {
    // Required methods
    fn as_any(&self) -> &(dyn Any + 'static);
    fn field(&self) -> Result<Field, DataFusionError>;
    fn create_accumulator(
        &self
    ) -> Result<Box<dyn Accumulator + 'static, Global>, DataFusionError>;
    fn state_fields(&self) -> Result<Vec<Field, Global>, DataFusionError>;
    fn expressions(&self) -> Vec<Arc<dyn PhysicalExpr + 'static>, Global> ⓘ;

    // Provided methods
    fn name(&self) -> &str { ... }
    fn row_accumulator_supported(&self) -> bool { ... }
    fn supports_bounded_execution(&self) -> bool { ... }
    fn create_row_accumulator(
        &self,
        _start_index: usize
    ) -> Result<Box<dyn RowAccumulator + 'static, Global>, DataFusionError> { ... }
    fn reverse_expr(&self) -> Option<Arc<dyn AggregateExpr + 'static>> { ... }
    fn create_sliding_accumulator(
        &self
    ) -> Result<Box<dyn Accumulator + 'static, Global>, DataFusionError> { ... }
}
Expand description

An aggregate expression that:

  • knows its resulting field
  • knows how to create its accumulator
  • knows its accumulator’s state’s field
  • knows the expressions from whose its accumulator will receive values

Required Methods§

source

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

Returns the aggregate expression as Any so that it can be downcast to a specific implementation.

source

fn field(&self) -> Result<Field, DataFusionError>

the field of the final result of this aggregation.

source

fn create_accumulator( &self ) -> Result<Box<dyn Accumulator + 'static, Global>, DataFusionError>

the accumulator used to accumulate values from the expressions. the accumulator expects the same number of arguments as expressions and must return states with the same description as state_fields

source

fn state_fields(&self) -> Result<Vec<Field, Global>, DataFusionError>

the fields that encapsulate the Accumulator’s state the number of fields here equals the number of states that the accumulator contains

source

fn expressions(&self) -> Vec<Arc<dyn PhysicalExpr + 'static>, Global> ⓘ

expressions that are passed to the Accumulator. Single-column aggregations such as sum return a single value, others (e.g. cov) return many.

Provided Methods§

source

fn name(&self) -> &str

Human readable name such as "MIN(c2)". The default implementation returns placeholder text.

source

fn row_accumulator_supported(&self) -> bool

If the aggregate expression is supported by row format

source

fn supports_bounded_execution(&self) -> bool

Specifies whether this aggregate function can run using bounded memory. Any accumulator returning “true” needs to implement retract_batch.

source

fn create_row_accumulator( &self, _start_index: usize ) -> Result<Box<dyn RowAccumulator + 'static, Global>, DataFusionError>

RowAccumulator to access/update row-based aggregation state in-place. Currently, row accumulator only supports states of fixed-sized type.

We recommend implementing RowAccumulator along with the standard Accumulator, when its state is of fixed size, as RowAccumulator is more memory efficient and CPU-friendly.

source

fn reverse_expr(&self) -> Option<Arc<dyn AggregateExpr + 'static>>

Construct an expression that calculates the aggregate in reverse. Typically the “reverse” expression is itself (e.g. SUM, COUNT). For aggregates that do not support calculation in reverse, returns None (which is the default value).

source

fn create_sliding_accumulator( &self ) -> Result<Box<dyn Accumulator + 'static, Global>, DataFusionError>

Creates accumulator implementation that supports retract

Implementors§