Trait datafusion::physical_expr::AggregateExpr
source · pub trait AggregateExpr: Send + Sync + Debug + PartialEq<dyn Any> {
// Required methods
fn as_any(&self) -> &(dyn Any + 'static);
fn field(&self) -> Result<Field, DataFusionError>;
fn create_accumulator(
&self
) -> Result<Box<dyn Accumulator, Global>, DataFusionError>;
fn state_fields(&self) -> Result<Vec<Field, Global>, DataFusionError>;
fn expressions(&self) -> Vec<Arc<dyn PhysicalExpr>, Global>;
// Provided methods
fn order_bys(&self) -> Option<&[PhysicalSortExpr]> { ... }
fn name(&self) -> &str { ... }
fn row_accumulator_supported(&self) -> bool { ... }
fn create_row_accumulator(
&self,
_start_index: usize
) -> Result<Box<dyn RowAccumulator, Global>, DataFusionError> { ... }
fn reverse_expr(&self) -> Option<Arc<dyn AggregateExpr>> { ... }
fn create_sliding_accumulator(
&self
) -> Result<Box<dyn Accumulator, 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
Any implementation of this trait also needs to implement the
PartialEq<dyn Any>
to allows comparing equality between the
trait objects.
Required Methods§
sourcefn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
Returns the aggregate expression as Any
so that it can be
downcast to a specific implementation.
sourcefn field(&self) -> Result<Field, DataFusionError>
fn field(&self) -> Result<Field, DataFusionError>
the field of the final result of this aggregation.
sourcefn create_accumulator(
&self
) -> Result<Box<dyn Accumulator, Global>, DataFusionError>
fn create_accumulator( &self ) -> Result<Box<dyn Accumulator, 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
sourcefn state_fields(&self) -> Result<Vec<Field, Global>, DataFusionError>
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
sourcefn expressions(&self) -> Vec<Arc<dyn PhysicalExpr>, Global>
fn expressions(&self) -> Vec<Arc<dyn PhysicalExpr>, 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§
sourcefn order_bys(&self) -> Option<&[PhysicalSortExpr]>
fn order_bys(&self) -> Option<&[PhysicalSortExpr]>
Order by requirements for the aggregate function
By default it is None
(there is no requirement)
Order-sensitive aggregators, such as FIRST_VALUE(x ORDER BY y)
should implement this
sourcefn name(&self) -> &str
fn name(&self) -> &str
Human readable name such as "MIN(c2)"
. The default
implementation returns placeholder text.
sourcefn row_accumulator_supported(&self) -> bool
fn row_accumulator_supported(&self) -> bool
If the aggregate expression is supported by row format
sourcefn create_row_accumulator(
&self,
_start_index: usize
) -> Result<Box<dyn RowAccumulator, Global>, DataFusionError>
fn create_row_accumulator( &self, _start_index: usize ) -> Result<Box<dyn RowAccumulator, 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.
sourcefn reverse_expr(&self) -> Option<Arc<dyn AggregateExpr>>
fn reverse_expr(&self) -> Option<Arc<dyn AggregateExpr>>
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).
sourcefn create_sliding_accumulator(
&self
) -> Result<Box<dyn Accumulator, Global>, DataFusionError>
fn create_sliding_accumulator( &self ) -> Result<Box<dyn Accumulator, Global>, DataFusionError>
Creates accumulator implementation that supports retract