Method build

datafusion/physical-expr/src/aggregate.rs:250–322

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. ``` # use std::any::Any; # use std::sync::Arc;

(self)

    /// This creates a physical expression equivalent to SQL:
    /// `first_value(a ORDER BY x) IGNORE NULLS AS first_a_by_x`
    pub fn build(self) -> Result<AggregateFunctionExpr> {
        let Self {
            fun,
            args,
            alias,
            output_metadata,
            human_display,
            human_display_alias,
            schema,
            order_bys,
            ignore_nulls,
            is_distinct,
            is_reversed,
        } = self;
        assert_or_internal_err!(!args.is_empty(), "args should not be empty");

        let ordering_types = order_bys
            .iter()
            .map(|e| e.expr.data_type(&schema))
            .collect::<Result<Vec<_>>>()?;

        let ordering_fields = utils::ordering_fields(&order_bys, &ordering_types);

        let input_exprs_fields = args
            .iter()
            .map(|arg| arg.return_field(&schema))
            .collect::<Result<Vec<_>>>()?;

        check_arg_count(
            fun.name(),
            &input_exprs_fields,
            &fun.signature().type_signature,
        )?;

        let mut return_field = fun.return_field(&input_exprs_fields)?;
        if let Some(output_metadata) = output_metadata {
            return_field = output_metadata.add_to_field_ref(return_field);
        }
        let is_nullable = fun.is_nullable();
        let name = match alias {
            None => {
                return internal_err!(
                    "AggregateExprBuilder::alias must be provided prior to calling build"
                );
            }
            Some(alias) => alias,
        };

        let human_display =
            AggregateHumanDisplay::try_new(human_display, human_display_alias, &name)?;

        let arg_fields = args
            .iter()
            .map(|e| e.return_field(schema.as_ref()))
            .collect::<Result<Vec<_>>>()?;

        Ok(AggregateFunctionExpr {
            fun: Arc::unwrap_or_clone(fun),