Trait datafusion::physical_plan::AggregateExpr

source · [−]
pub trait AggregateExpr: Send + Sync + Debug {
    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>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
    A: Allocator,;

    fn name(&self) -> &str { ... }
    fn row_accumulator_supported(&self) -> bool { ... }
    fn create_row_accumulator(
        &self,
        _start_index: usize
    ) -> Result<Box<dyn RowAccumulator + '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

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

the field of the final result of this aggregation.

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

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

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

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

If the aggregate expression is supported by row format

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.

Implementors