Struct MergeWrapper 

pub struct MergeWrapper {
    inner: AggregateUDF,
    name: String,
    merge_signature: Signature,
    original_phy_expr: Arc<AggregateFunctionExpr>,
    return_type: DataType,
}

TODO(discord9): mark this function as non-ser/de able

This wrapper shouldn’t be register as a udaf, as it contain extra data that is not serializable. and changes for different logical plans.

Fields

inner: AggregateUDF

name: String

merge_signature: Signature

original_phy_expr: Arc<AggregateFunctionExpr>

The original physical expression of the aggregate function, can’t store the original aggregate function directly, as PhysicalExpr didn’t implement Any

return_type: DataType

Implementations

impl MergeWrapper

pub fn new( inner: AggregateUDF, original_phy_expr: Arc<AggregateFunctionExpr>, original_input_types: Vec<DataType>, ) -> Result<Self>

pub fn inner(&self) -> &AggregateUDF

Trait Implementations

impl AggregateUDFImpl for MergeWrapper

fn return_type(&self, _arg_types: &[DataType]) -> Result<DataType>

Notice here the arg_types is actually the state_fields’s data types, so return fixed return type instead of using arg_types to determine the return type.

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

Coerce types also do nothing, as optimizer should be able to already make struct types

fn state_fields(&self, _args: StateFieldsArgs<'_>) -> Result<Vec<FieldRef>>

Just return the original aggregate function’s state fields.

fn accumulator<'a, 'b>( &'a self, acc_args: AccumulatorArgs<'b>, ) -> Result<Box<dyn Accumulator>>

Return a new [Accumulator] that aggregates values for a specific group during query execution.

fn as_any(&self) -> &dyn Any

Returns this object as an Any trait object

fn name(&self) -> &str

Returns this function’s name

fn is_nullable(&self) -> bool

Whether the aggregate function is nullable.

fn signature(&self) -> &Signature

Returns the function’s [Signature] for information about what input types are accepted and the function’s Volatility.

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

Returns any aliases (alternate names) for this function.

fn schema_name( &self, params: &AggregateFunctionParams, ) -> Result<String, DataFusionError>

Returns the name of the column this expression would create

fn human_display( &self, params: &AggregateFunctionParams, ) -> Result<String, DataFusionError>

Returns a human readable expression.

fn window_function_schema_name( &self, params: &WindowFunctionParams, ) -> Result<String, DataFusionError>

Returns the name of the column this expression would create

fn display_name( &self, params: &AggregateFunctionParams, ) -> Result<String, DataFusionError>

Returns the user-defined display name of function, given the arguments

fn window_function_display_name( &self, params: &WindowFunctionParams, ) -> Result<String, DataFusionError>

Returns the user-defined display name of function, given the arguments

fn return_field( &self, arg_fields: &[Arc<Field>], ) -> Result<Arc<Field>, DataFusionError>

What type will be returned by this function, given the arguments?

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

If the aggregate expression has a specialized [GroupsAccumulator] implementation. If this returns true, [Self::create_groups_accumulator] will be called.

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

Return a specialized [GroupsAccumulator] that manages state for all groups.

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

Sliding accumulator is an alternative accumulator that can be used for window functions. It has retract method to revert the previous update.

fn with_beneficial_ordering( self: Arc<Self>, _beneficial_ordering: bool, ) -> Result<Option<Arc<dyn AggregateUDFImpl>>, DataFusionError>

Sets the indicator whether ordering requirements of the AggregateUDFImpl is satisfied by its input. If this is not the case, UDFs with order sensitivity AggregateOrderSensitivity::Beneficial can still produce the correct result with possibly more work internally.

fn order_sensitivity(&self) -> AggregateOrderSensitivity

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

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

Optionally apply per-UDaF simplification / rewrite rules.

fn reverse_expr(&self) -> ReversedUDAF

Returns the reverse expression of the aggregate function.

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

If this function is max, return true If the function is min, return false Otherwise return None (the default)

fn value_from_stats( &self, _statistics_args: &StatisticsArgs<'_>, ) -> Option<ScalarValue>

Return the value of this aggregate function if it can be determined entirely from statistics and arguments.

fn default_value( &self, data_type: &DataType, ) -> Result<ScalarValue, DataFusionError>

Returns default value of the function given the input is all null.

fn supports_null_handling_clause(&self) -> bool

If this function supports [IGNORE NULLS | RESPECT NULLS] clause, return true If the function does not, return false

fn is_ordered_set_aggregate(&self) -> bool

If this function is ordered-set aggregate function, return true otherwise, return false

fn documentation(&self) -> Option<&Documentation>

Returns the documentation for this Aggregate UDF.

fn set_monotonicity(&self, _data_type: &DataType) -> SetMonotonicity

Indicates whether the aggregation function is monotonic as a set function. See [SetMonotonicity] for details.

impl Clone for MergeWrapper

fn clone(&self) -> MergeWrapper

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MergeWrapper

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

Formats the value using the given formatter.

impl Hash for MergeWrapper

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

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 MergeWrapper

fn eq(&self, other: &Self) -> 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 MergeWrapper