Struct AggregateExprBuilder 

pub struct AggregateExprBuilder {
    fun: Arc<AggregateUDF>,
    args: Vec<Arc<dyn PhysicalExpr>>,
    alias: Option<String>,
    human_display: String,
    schema: SchemaRef,
    order_bys: Vec<PhysicalSortExpr>,
    ignore_nulls: bool,
    is_distinct: bool,
    is_reversed: bool,
}

Builder for physical AggregateFunctionExpr

AggregateFunctionExpr contains the information necessary to call an aggregate expression.

Fields

fun: Arc<AggregateUDF>

args: Vec<Arc<dyn PhysicalExpr>>

Physical expressions of the aggregate function

alias: Option<String>

human_display: String

A human readable name

schema: SchemaRef

Arrow Schema for the aggregate function

order_bys: Vec<PhysicalSortExpr>

The physical order by expressions

ignore_nulls: bool

Whether to ignore null values

is_distinct: bool

Whether is distinct aggregate function

is_reversed: bool

Whether the expression is reversed

Implementations

impl AggregateExprBuilder

pub fn new(fun: Arc<AggregateUDF>, args: Vec<Arc<dyn PhysicalExpr>>) -> Self

pub fn build(self) -> Result<AggregateFunctionExpr>

Constructs an AggregateFunctionExpr from the builder

Note that an Self::alias must be provided before calling this method.

Example: Create an AggregateUDF

In the following example, AggregateFunctionExpr will be built using AggregateExprBuilder which provides a build function. Full example could be accessed from the source file.

fn build_aggregate_expr() -> Result<()> {
    let args = vec![Arc::new(Column::new("a", 0)) as Arc<dyn PhysicalExpr>];
    let order_by = vec![PhysicalSortExpr {
        expr: Arc::new(Column::new("x", 1)) as Arc<dyn PhysicalExpr>,
        options: Default::default(),
    }];

    let first_value = AggregateUDF::from(FirstValueUdf::new());

    let aggregate_expr = AggregateExprBuilder::new(
        Arc::new(first_value),
        args
    )
    .order_by(order_by)
    .alias("first_a_by_x")
    .ignore_nulls()
    .build()?;

    Ok(())
}

This creates a physical expression equivalent to SQL: first_value(a ORDER BY x) IGNORE NULLS AS first_a_by_x

pub fn alias(self, alias: impl Into<String>) -> Self

pub fn human_display(self, name: String) -> Self

pub fn schema(self, schema: SchemaRef) -> Self

pub fn order_by(self, order_bys: Vec<PhysicalSortExpr>) -> Self

pub fn reversed(self) -> Self

pub fn with_reversed(self, is_reversed: bool) -> Self

pub fn distinct(self) -> Self

pub fn with_distinct(self, is_distinct: bool) -> Self

pub fn ignore_nulls(self) -> Self

pub fn with_ignore_nulls(self, ignore_nulls: bool) -> Self

Trait Implementations

impl Clone for AggregateExprBuilder

fn clone(&self) -> AggregateExprBuilder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AggregateExprBuilder

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

Formats the value using the given formatter.