Struct datafusion::logical_expr::AggregateUDF

pub struct AggregateUDF {
    pub name: String,
    pub signature: Signature,
    pub return_type: Arc<dyn Fn(&[DataType]) -> Result<Arc<DataType>, DataFusionError> + Send + Sync>,
    pub accumulator: Arc<dyn Fn(&DataType) -> Result<Box<dyn Accumulator, Global>, DataFusionError> + Send + Sync>,
    pub state_type: Arc<dyn Fn(&DataType) -> Result<Arc<Vec<DataType, Global>>, DataFusionError> + Send + Sync>,
}

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 Accumulator, which peform the actual aggregation.

For more information, please see the examples.

Fields

name: String

name

signature: Signature

Signature (input arguments)

return_type: Arc<dyn Fn(&[DataType]) -> Result<Arc<DataType>, DataFusionError> + Send + Sync>

Return type

accumulator: Arc<dyn Fn(&DataType) -> Result<Box<dyn Accumulator, Global>, DataFusionError> + Send + Sync>

actual implementation

state_type: Arc<dyn Fn(&DataType) -> Result<Arc<Vec<DataType, Global>>, DataFusionError> + Send + Sync>

the accumulator’s state’s description as a function of the return type

Implementations

impl AggregateUDF

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

Create a new AggregateUDF

pub fn call(&self, args: Vec<Expr, Global>) -> 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.

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