Module aggregate 

Structs

AggregateIterator

Iterator that performs hash-based aggregation over input rows.

AvgAccumulator

Accumulator for AVG.

CountAccumulator

Accumulator for COUNT / COUNT(DISTINCT).

GroupConcatAccumulator

Accumulator for GROUP_CONCAT.

MinMaxAccumulator

Accumulator for MIN / MAX.

PercentileDiscAccumulator

Accumulator for the ordered-set aggregate PERCENTILE_DISC (issue #148).

StreamingAggregateIterator

Iterator that performs streaming aggregation over sorted input.

StringAggAccumulator

Accumulator for STRING_AGG.

SumAccumulator

Accumulator for SUM.

TotalAccumulator

Accumulator for TOTAL (SUM that returns 0.0 on empty/all-NULL input).

Enums

AggregateMode

Aggregate execution mode.

Traits

Accumulator

Accumulator interface for aggregate function execution.

Functions

build_aggregate_schema

Build output schema for aggregate results.

build_partial_aggregate_schema

Build internal partial aggregate schema.

create_accumulator

Create a new accumulator instance for the aggregate function.

create_accumulator_for_aggregate

Create an accumulator using the aggregate expression’s resolved result type and its aggregate-local ordering (issue #148).

encode_group_key

Encode group key values into a deterministic byte sequence.

exact_partial_aggregate_is_proven

Returns whether an aggregate’s partial state can be merged without changing the current local SQL result. Floating-point, DISTINCT, and order-sensitive aggregates must instead be replayed from ordered inputs. A FILTER predicate does not affect this proof: it applies per input row before the accumulator, so it commutes with Partial/Final splitting — but the distributed catalog still classifies filtered aggregates as local-only before any state reaches this kernel.

execute_parallel_aggregate_rows

Execute a deterministic single-process parallel partial-to-final aggregate.

execute_parallel_aggregate_rows_with_policy

Execute a deterministic parallel aggregate with memory fallback controls.

merge_exact_aggregate_states

Merge only aggregate states whose merge rule is proven to preserve the current local SQL result. This is the coordinator-side kernel used by the distributed result assembler after every worker has acknowledged cleanup.

should_use_single_for_parallel

Return true when aggregate execution must remain Single for correctness. FILTER is applied per input row and therefore commutes with Partial/Final splitting; ordered aggregates (aggregate-local ORDER BY and ordered-set aggregates such as PERCENTILE_DISC) buffer whole groups and stay Single (issue #148, D11).

Type Aliases

GroupKeyBytes

Byte-encoded group key for hash-based aggregation.