Struct AggregateFunctionExpr

pub struct AggregateFunctionExpr { /* private fields */ }

Physical aggregate expression of a UDAF.

Implementations

impl AggregateFunctionExpr

pub fn fun(&self) -> &AggregateUDF

Return the AggregateUDF used by this AggregateFunctionExpr

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

pub fn name(&self) -> &str

Human readable name such as "MIN(c2)".

pub fn is_distinct(&self) -> bool

Return if the aggregation is distinct

pub fn ignore_nulls(&self) -> bool

Return if the aggregation ignores nulls

pub fn is_reversed(&self) -> bool

Return if the aggregation is reversed

pub fn is_nullable(&self) -> bool

Return if the aggregation is nullable

pub fn field(&self) -> Field

the field of the final result of this aggregation.

pub fn create_accumulator(&self) -> Result<Box<dyn Accumulator>>

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

pub fn state_fields(&self) -> Result<Vec<Field>>

the field of the final result of this aggregation.

pub fn order_bys(&self) -> Option<LexOrderingRef<'_>>

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

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

pub fn with_beneficial_ordering( self: Arc<Self>, beneficial_ordering: bool, ) -> Result<Option<AggregateFunctionExpr>>

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

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

Creates accumulator implementation that supports retract

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

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

Return a specialized GroupsAccumulator that manages state for all groups.

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

pub fn reverse_expr(&self) -> Option<AggregateFunctionExpr>

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

pub fn all_expressions(&self) -> AggregatePhysicalExpressions

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

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

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

pub fn get_minmax_desc(&self) -> Option<(Field, bool)>

If this function is max, return (output_field, true) if the function is min, return (output_field, false) otherwise return None (the default)

output_field is the name of the column produced by this aggregate

Note: this is used to use special aggregate implementations in certain conditions

pub fn default_value(&self, data_type: &DataType) -> Result<ScalarValue>

Returns default value of the function given the input is Null Most of the aggregate function return Null if input is Null, while count returns 0 if input is Null

Trait Implementations

impl Clone for AggregateFunctionExpr

fn clone(&self) -> AggregateFunctionExpr

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AggregateFunctionExpr

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

Formats the value using the given formatter.

impl PartialEq for AggregateFunctionExpr

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.