Struct datafusion_python::datafusion_expr::SimpleAggregateUDF

pub struct SimpleAggregateUDF { /* private fields */ }

Implements AggregateUDFImpl for functions that have a single signature and return type.

Implementations

impl SimpleAggregateUDF

pub fn new( name: impl Into<String>, input_type: Vec<DataType>, return_type: DataType, volatility: Volatility, accumulator: Arc<dyn Fn(AccumulatorArgs<'_>) -> Result<Box<dyn Accumulator>, DataFusionError> + Sync + Send>, state_fields: Vec<Field>, ) -> SimpleAggregateUDF

Create a new AggregateUDFImpl from a name, input types, return type, state type and implementation. Implementing AggregateUDFImpl allows more flexibility

pub fn new_with_signature( name: impl Into<String>, signature: Signature, return_type: DataType, accumulator: Arc<dyn Fn(AccumulatorArgs<'_>) -> Result<Box<dyn Accumulator>, DataFusionError> + Sync + Send>, state_fields: Vec<Field>, ) -> SimpleAggregateUDF

Trait Implementations

impl AggregateUDFImpl for SimpleAggregateUDF

fn as_any(&self) -> &(dyn Any + 'static)

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 return_type( &self, _arg_types: &[DataType], ) -> Result<DataType, DataFusionError>

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

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

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

fn state_fields( &self, _args: StateFieldsArgs<'_>, ) -> Result<Vec<Field>, DataFusionError>

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

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

Return a specialized GroupsAccumulator that manages state for all groups.

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

Returns any aliases (alternate names) for this function.

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 coerce_types( &self, _arg_types: &[DataType], ) -> Result<Vec<DataType>, DataFusionError>

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

fn equals(&self, other: &dyn AggregateUDFImpl) -> bool

Return true if this aggregate UDF is equal to the other.

fn hash_value(&self) -> u64

Returns a hash value for this aggregate UDF.

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)

impl Debug for SimpleAggregateUDF

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

Formats the value using the given formatter.