Trait datafusion::physical_expr::AggregateExpr

source · 
pub trait AggregateExpr: Send + Sync + Debug + PartialEq<dyn Any> {

Show 15 methods    // Required methods
    fn as_any(&self) -> &(dyn Any + 'static);
    fn field(&self) -> Result<Field, DataFusionError>;
    fn create_accumulator(
        &self,
    ) -> Result<Box<dyn Accumulator>, DataFusionError>;
    fn state_fields(&self) -> Result<Vec<Field>, DataFusionError>;
    fn expressions(&self) -> Vec<Arc<dyn PhysicalExpr>>;

    // Provided methods
    fn order_bys(&self) -> Option<&[PhysicalSortExpr]> { ... }
    fn order_sensitivity(&self) -> AggregateOrderSensitivity { ... }
    fn with_beneficial_ordering(
        self: Arc<Self>,
        _requirement_satisfied: bool,
    ) -> Result<Option<Arc<dyn AggregateExpr>>, DataFusionError> { ... }
    fn name(&self) -> &str { ... }
    fn groups_accumulator_supported(&self) -> bool { ... }
    fn create_groups_accumulator(
        &self,
    ) -> Result<Box<dyn GroupsAccumulator>, DataFusionError> { ... }
    fn reverse_expr(&self) -> Option<Arc<dyn AggregateExpr>> { ... }
    fn create_sliding_accumulator(
        &self,
    ) -> Result<Box<dyn Accumulator>, DataFusionError> { ... }
    fn all_expressions(&self) -> AggregatePhysicalExpressions { ... }
    fn with_new_expressions(
        &self,
        _args: Vec<Arc<dyn PhysicalExpr>>,
        _order_by_exprs: Vec<Arc<dyn PhysicalExpr>>,
    ) -> Option<Arc<dyn AggregateExpr>> { ... }

}
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§

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>, 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>, 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>>

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 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

source

fn order_sensitivity(&self) -> AggregateOrderSensitivity

Indicates whether aggregator can produce the correct result with any arbitrary input ordering. By default, we assume that aggregate expressions are order insensitive.

source

fn with_beneficial_ordering( self: Arc<Self>, _requirement_satisfied: bool, ) -> Result<Option<Arc<dyn AggregateExpr>>, DataFusionError>

Sets the indicator whether ordering requirements of the aggregator is satisfied by its input. If this is not the case, aggregators with order sensitivity AggregateOrderSensitivity::Beneficial can still produce the correct result with possibly more work internally.

§Returns

Returns Ok(Some(updated_expr)) if the process completes successfully. If the expression can benefit from existing input ordering, but does not implement the method, returns an error. Order insensitive and hard requirement aggregators return Ok(None).

source

fn name(&self) -> &str

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

source

fn groups_accumulator_supported(&self) -> bool

If the aggregate expression has a specialized GroupsAccumulator implementation. If this returns true, [Self::create_groups_accumulator] will be called.

source

fn create_groups_accumulator( &self, ) -> Result<Box<dyn GroupsAccumulator>, DataFusionError>

Return a specialized GroupsAccumulator that manages state for all groups.

For maximum performance, a GroupsAccumulator should be implemented in addition to Accumulator.

source

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).

source

fn create_sliding_accumulator( &self, ) -> Result<Box<dyn Accumulator>, DataFusionError>

Creates accumulator implementation that supports retract

source

fn all_expressions(&self) -> AggregatePhysicalExpressions

Returns all expressions used in the AggregateExpr. These expressions are (1)function arguments, (2) order by expressions.

source

fn with_new_expressions( &self, _args: Vec<Arc<dyn PhysicalExpr>>, _order_by_exprs: Vec<Arc<dyn PhysicalExpr>>, ) -> Option<Arc<dyn AggregateExpr>>

Rewrites AggregateExpr, with new expressions given. The argument should be consistent with the return value of the AggregateExpr::all_expressions method. Returns Some(Arc<dyn AggregateExpr>) if re-write is supported, otherwise returns None.

Implementors§