Struct ExtensionStoragePushdown 

pub struct ExtensionStoragePushdown<A: AggregateFnVTable, E: ExtVTable> { /* private fields */ }

Runs aggregate A on the storage values of extension type E.

The input must have extension type E, and A must support its storage dtype. Binding fails for any other input. The wrapper has a separate aggregate ID, <A>[<E>], formed from the IDs of A and E. Registering it does not replace A.

Aggregates that already support extension dtypes directly do not need this wrapper.

Correctness

A registration must satisfy both conditions:

• The aggregation is defined for logical values of E.
• For every valid input, aggregating the storage values produces the storage representation of the logical aggregate result. This requires storage to preserve whichever properties A relies on, such as ordering, equality, arithmetic, or NaN classification.

For example, minimum is defined for timestamps, and their integer storage preserves their ordering, so both conditions hold. Summing timestamps fails the first condition even though their storage supports addition.

These conditions are not checked. An invalid registration can silently return incorrect results.

Results and partials

Results and partial states are those of A over the storage dtype. Results are not converted back to E. For example, the minimum and maximum of a timestamp column are raw i64 values in the column’s time unit.

Partial states can only be combined when the aggregate, options, and full input dtype match. This includes extension metadata, so timestamp partials with different time units must not be combined even if their storage dtypes match.

Example

Timestamps compare like their i64 storage, so is_sorted can be pushed down. Register the pair once on the session, then bind it like any other aggregate:

let session = vortex_array::array_session();

// Register `vortex.is_sorted[vortex.timestamp]`.
let is_sorted = ExtensionStoragePushdown::new(IsSorted, Timestamp);
session.aggregate_fns().register(is_sorted.clone());

// Aggregate a timestamp column through its storage.
let ext_dtype = Timestamp::new(TimeUnit::Milliseconds, Nullability::NonNullable).erased();
let column = ExtensionArray::new(
    ext_dtype.clone(),
    PrimitiveArray::from_iter([1_000i64, 2_000, 3_000]).into_array(),
)
.into_array();

let mut acc = Accumulator::try_new(
    is_sorted,
    IsSortedOptions { strict: true },
    DType::Extension(ext_dtype),
)?;
acc.accumulate(&column, &mut session.create_execution_ctx())?;
assert!(bool::try_from(&acc.finish()?)?);

Implementations

impl<A: AggregateFnVTable, E: ExtVTable> ExtensionStoragePushdown<A, E>

pub fn new(aggregate: A, ext: E) -> Self

Push aggregate down into the storage of extension type ext.

Only do this when aggregate over the storage is correct for ext; see ExtensionStoragePushdown for how to check.

Trait Implementations

impl<A: AggregateFnVTable, E: ExtVTable> AggregateFnVTable for ExtensionStoragePushdown<A, E>

fn try_accumulate( &self, args: AggregateArgs<'_, Self::Options>, state: &mut Self::Partial, batch: &ArrayRef, ctx: &mut ExecutionCtx, ) -> VortexResult<bool>

Unwrap extension arrays to their storage before decoding, so the storage accumulator sees the storage encoding.

type Options = <A as AggregateFnVTable>::Options

Options for this aggregate function.

type Partial = <A as AggregateFnVTable>::Partial

The partial accumulator state for a single group.

fn id(&self) -> AggregateFnId

Returns the ID of the aggregate function vtable.

fn serialize(&self, options: &Self::Options) -> VortexResult<Option<Vec<u8>>>

Serialize the options for this aggregate function.

fn deserialize( &self, metadata: &[u8], session: &VortexSession, ) -> VortexResult<Self::Options>

Deserialize the options of this aggregate function.

fn return_dtype( &self, options: &Self::Options, input_dtype: &DType, ) -> Option<DType>

The return DType of the aggregate.

fn partial_dtype( &self, options: &Self::Options, input_dtype: &DType, ) -> Option<DType>

DType of the intermediate partial accumulator state.

fn empty_partial( &self, args: AggregateArgs<'_, Self::Options>, ) -> VortexResult<Self::Partial>

The partial state of a group with no accumulated values.

fn partial_from_scalar( &self, args: AggregateArgs<'_, Self::Options>, scalar: &Scalar, ) -> VortexResult<Self::Partial>

Parse a partial scalar into the typed partial state.

fn merge_partials( &self, args: AggregateArgs<'_, Self::Options>, first: Self::Partial, second: Self::Partial, ) -> VortexResult<Self::Partial>

Merge two partial states into one.

fn to_scalar( &self, args: AggregateArgs<'_, Self::Options>, partial: &Self::Partial, ) -> VortexResult<Scalar>

Convert the partial state into a partial scalar of dtype args.partial_dtype.

fn is_saturated( &self, args: AggregateArgs<'_, Self::Options>, partial: &Self::Partial, ) -> bool

Is the partial state “saturated”, i.e. has it reached a state where the final result is fully determined.

fn accumulate( &self, args: AggregateArgs<'_, Self::Options>, state: &mut Self::Partial, batch: &Columnar, ctx: &mut ExecutionCtx, ) -> VortexResult<()>

Accumulate a new canonical array into the partial state.

fn finalize( &self, args: AggregateArgs<'_, Self::Options>, states: ArrayRef, ) -> VortexResult<ArrayRef>

Finalize an array of partial states into an array of aggregate results.

fn finalize_scalar( &self, args: AggregateArgs<'_, Self::Options>, partial: &Self::Partial, ) -> VortexResult<Scalar>

Finalize a partial state into an aggregate result of dtype args.return_dtype.

fn can_satisfy( &self, options: &Self::Options, requested: &AggregateFnRef, ) -> AggregateFnSatisfaction

Return whether this stored aggregate can satisfy requested.

fn zone_stat_default(&self, _input_dtype: &DType) -> Option<AggregateFnRef>

If this aggregate should be computed as a default zone statistic for input_dtype, return the bound aggregate to store. Default: not a zone-map default.

impl<A: Clone + AggregateFnVTable, E: Clone + ExtVTable> Clone for ExtensionStoragePushdown<A, E>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + AggregateFnVTable, E: Debug + ExtVTable> Debug for ExtensionStoragePushdown<A, E>

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

Formats the value using the given formatter.