Struct deltalake::datafusion::logical_expr::AggregateUDF

pub struct AggregateUDF { /* private fields */ }

Logical representation of a user-defined aggregate function (UDAF).

An aggregate function combines the values from multiple input rows into a single output “aggregate” (summary) row. It is different from a scalar function because it is stateful across batches. User defined aggregate functions can be used as normal SQL aggregate functions (GROUP BY clause) as well as window functions (OVER clause).

AggregateUDF provides DataFusion the information needed to plan and call aggregate functions, including name, type information, and a factory function to create an Accumulator instance, to perform the actual aggregation.

For more information, please see the examples:

1. For simple use cases, use create_udaf (examples in simple_udaf.rs).

2. For advanced use cases, use AggregateUDFImpl which provides full API access (examples in advanced_udaf.rs).

API Note

This is a separate struct from AggregateUDFImpl to maintain backwards compatibility with the older API.

Implementations

impl AggregateUDF

pub fn new( name: &str, signature: &Signature, return_type: &Arc<dyn Fn(&[DataType]) -> Result<Arc<DataType>, DataFusionError> + Sync + Send>, accumulator: &Arc<dyn Fn(&DataType) -> Result<Box<dyn Accumulator>, DataFusionError> + Sync + Send>, state_type: &Arc<dyn Fn(&DataType) -> Result<Arc<Vec<DataType>>, DataFusionError> + Sync + Send> ) -> AggregateUDF

👎Deprecated since 34.0.0: please implement AggregateUDFImpl instead

Create a new AggregateUDF

See AggregateUDFImpl for a more convenient way to create a AggregateUDF using trait objects

pub fn new_from_impl<F>(fun: F) -> AggregateUDF

where F: AggregateUDFImpl + 'static,

Create a new AggregateUDF from a [AggregateUDFImpl] trait object

Note this is the same as using the From impl (AggregateUDF::from)

pub fn inner(&self) -> Arc<dyn AggregateUDFImpl>

Return the underlying AggregateUDFImpl trait object for this function

pub fn with_aliases( self, aliases: impl IntoIterator<Item = &'static str> ) -> AggregateUDF

Adds additional names that can be used to invoke this function, in addition to name

If you implement AggregateUDFImpl directly you should return aliases directly.

pub fn call(&self, args: Vec<Expr>) -> Expr

creates an Expr that calls the aggregate function.

This utility allows using the UDAF without requiring access to the registry, such as with the DataFrame API.

pub fn name(&self) -> &str

Returns this function’s name

See AggregateUDFImpl::name for more details.

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

Returns the aliases for this function.

pub fn signature(&self) -> &Signature

Returns this function’s signature (what input types are accepted)

See AggregateUDFImpl::signature for more details.

pub fn return_type( &self, args: &[DataType] ) -> Result<DataType, DataFusionError>

Return the type of the function given its input types

See AggregateUDFImpl::return_type for more details.

pub fn accumulator( &self, return_type: &DataType ) -> Result<Box<dyn Accumulator>, DataFusionError>

Return an accumulator the given aggregate, given its return datatype.

pub fn state_type( &self, return_type: &DataType ) -> Result<Vec<DataType>, DataFusionError>

Return the type of the intermediate state used by this aggregator, given its return datatype. Supports multi-phase aggregations

pub fn groups_accumulator_supported(&self) -> bool

See AggregateUDFImpl::groups_accumulator_supported for more details.

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

See AggregateUDFImpl::create_groups_accumulator for more details.

Trait Implementations

impl Clone for AggregateUDF

fn clone(&self) -> AggregateUDF

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AggregateUDF

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

Formats the value using the given formatter.

impl<F> From<F> for AggregateUDF

where F: AggregateUDFImpl + Send + Sync + 'static,

fn from(fun: F) -> AggregateUDF

Converts to this type from the input type.

impl Hash for AggregateUDF

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

where H: Hasher,

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 AggregateUDF

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for AggregateUDF