Struct 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(AccumulatorArgs<'_>) -> Result<Box<dyn Accumulator>, 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, acc_args: AccumulatorArgs<'_>, ) -> Result<Box<dyn Accumulator>, DataFusionError>

Return an accumulator the given aggregate, given its return datatype

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

Return the fields used to store the intermediate state for this aggregator, given the name of the aggregate, value type and ordering fields. See AggregateUDFImpl::state_fields for more details.

This is used to support multi-phase aggregations

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

See AggregateUDFImpl::groups_accumulator_supported for more details.

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

See AggregateUDFImpl::create_groups_accumulator for more details.

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

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

pub fn with_beneficial_ordering( self, beneficial_ordering: bool, ) -> Result<Option<AggregateUDF>, DataFusionError>

See AggregateUDFImpl::with_beneficial_ordering for more details.

pub fn order_sensitivity(&self) -> AggregateOrderSensitivity

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

pub fn reverse_udf(&self) -> ReversedUDAF

Reserves the AggregateUDF (e.g. returns the AggregateUDF that will generate same result with this AggregateUDF when iterated in reverse order, and None if there is no such AggregateUDF).

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

Do the function rewrite

See AggregateUDFImpl::simplify for more details.

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

Returns true if the function is max, false if the function is min None in all other cases, used in certain optimizations or or aggregate

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

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 AggregateUDF