Struct SedonaAggregateUDF 

pub struct SedonaAggregateUDF { /* private fields */ }

Top-level aggregate user-defined function

This struct implements datafusion’s AggregateUDFImpl and implements kernel dispatch such that implementations can be registered flexibly.

Implementations

impl SedonaAggregateUDF

pub fn new( name: &str, kernels: impl IntoSedonaAccumulatorRefs, volatility: Volatility, ) -> Self

Create a new SedonaAggregateUDF

pub fn from_impl(name: &str, kernels: impl IntoSedonaAccumulatorRefs) -> Self

Create a new immutable SedonaAggregateUDF

pub fn add_kernel(&mut self, kernels: impl IntoSedonaAccumulatorRefs)

Add a new kernel to an Aggregate UDF

Because kernels are resolved in reverse order, the new kernel will take precedence over any previously added kernels that apply to the same types.

pub fn kernels(&self) -> &[SedonaAccumulatorRef]

Trait Implementations

impl AggregateUDFImpl for SedonaAggregateUDF

fn as_any(&self) -> &dyn Any

Returns this object as an Any trait object

fn name(&self) -> &str

Returns this function’s name

fn signature(&self) -> &Signature

Returns the function’s Signature for information about what input types are accepted and the function’s Volatility.

fn coerce_types(&self, arg_types: &[DataType]) -> Result<Vec<DataType>>

Coerce arguments of a function call to types that the function can evaluate.

fn state_fields(&self, args: StateFieldsArgs<'_>) -> Result<Vec<FieldRef>>

Return the fields used to store the intermediate state of this accumulator.

fn return_field(&self, arg_fields: &[FieldRef]) -> Result<FieldRef>

What type will be returned by this function, given the arguments?

fn return_type(&self, _arg_types: &[DataType]) -> Result<DataType>

What DataType will be returned by this function, given the types of the arguments

fn groups_accumulator_supported(&self, args: AccumulatorArgs<'_>) -> bool

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

fn create_groups_accumulator( &self, args: AccumulatorArgs<'_>, ) -> Result<Box<dyn GroupsAccumulator>>

Return a specialized GroupsAccumulator that manages state for all groups.

fn accumulator( &self, acc_args: AccumulatorArgs<'_>, ) -> Result<Box<dyn Accumulator>>

Return a new Accumulator that aggregates values for a specific group during query execution.

fn documentation(&self) -> Option<&Documentation>

Returns the documentation for this Aggregate UDF.

fn aliases(&self) -> &[String]

Returns any aliases (alternate names) for this function.

fn schema_name( &self, params: &AggregateFunctionParams, ) -> Result<String, DataFusionError>

Returns the name of the column this expression would create

fn human_display( &self, params: &AggregateFunctionParams, ) -> Result<String, DataFusionError>

Returns a human readable expression.

fn window_function_schema_name( &self, params: &WindowFunctionParams, ) -> Result<String, DataFusionError>

Returns the name of the column this expression would create

fn display_name( &self, params: &AggregateFunctionParams, ) -> Result<String, DataFusionError>

Returns the user-defined display name of function, given the arguments

fn window_function_display_name( &self, params: &WindowFunctionParams, ) -> Result<String, DataFusionError>

Returns the user-defined display name of function, given the arguments

fn is_nullable(&self) -> bool

Whether the aggregate function is nullable.

fn create_sliding_accumulator( &self, args: AccumulatorArgs<'_>, ) -> Result<Box<dyn Accumulator>, DataFusionError>

Sliding accumulator is an alternative accumulator that can be used for window functions. It has retract method to revert the previous update.

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

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

fn order_sensitivity(&self) -> AggregateOrderSensitivity

Gets the order sensitivity of the UDF. See AggregateOrderSensitivity for possible options.

fn simplify( &self, ) -> Option<Box<dyn Fn(AggregateFunction, &dyn SimplifyInfo) -> Result<Expr, DataFusionError>>>

Optionally apply per-UDaF simplification / rewrite rules.

fn reverse_expr(&self) -> ReversedUDAF

Returns the reverse expression of the aggregate function.

fn is_descending(&self) -> Option<bool>

If this function is max, return true If the function is min, return false Otherwise return None (the default)

fn value_from_stats( &self, _statistics_args: &StatisticsArgs<'_>, ) -> Option<ScalarValue>

Return the value of this aggregate function if it can be determined entirely from statistics and arguments.

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

Returns default value of the function given the input is all null.

fn supports_null_handling_clause(&self) -> bool

If this function supports [IGNORE NULLS | RESPECT NULLS] clause, return true If the function does not, return false

fn supports_within_group_clause(&self) -> bool

If this function supports the WITHIN GROUP (ORDER BY column [ASC|DESC]) SQL syntax, return true. Otherwise, return false (default) which will cause an error when parsing SQL where this syntax is detected for this function.

fn set_monotonicity(&self, _data_type: &DataType) -> SetMonotonicity

Indicates whether the aggregation function is monotonic as a set function. See SetMonotonicity for details.

impl Clone for SedonaAggregateUDF

fn clone(&self) -> SedonaAggregateUDF

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SedonaAggregateUDF

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

Formats the value using the given formatter.

impl Hash for SedonaAggregateUDF

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SedonaAggregateUDF

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.

impl Eq for SedonaAggregateUDF