Struct HashAggregate 

pub struct HashAggregate<'a> { /* private fields */ }

Implementations

impl HashAggregate<'static>

pub fn new( child: Box<dyn PhysicalOperator>, group_keys: Vec<(String, ScalarExpr)>, aggregates: Vec<AggregateSpec>, params: Vec<SQLParam>, ) -> Self

pub fn new_with_work_mem( child: Box<dyn PhysicalOperator>, group_keys: Vec<(String, ScalarExpr)>, aggregates: Vec<AggregateSpec>, params: Vec<SQLParam>, work_mem_bytes: usize, ) -> Self

impl<'a> HashAggregate<'a>

pub fn with_executor( child: Box<dyn PhysicalOperator + 'a>, output_schema: Vec<String>, executor: Box<dyn AggregateExecutor + 'a>, ) -> Self

Construct a physical aggregate backed by the engine’s full aggregate registry. Input is delivered incrementally through AggregateExecutor::consume.

pub fn with_typed_executor( child: Box<dyn PhysicalOperator + 'a>, output_schema: Vec<String>, output_types: Vec<Option<ColumnType>>, executor: Box<dyn AggregateExecutor + 'a>, ) -> Self

pub fn output_has_spilled(&self) -> bool

Whether final aggregate rows exceeded their output budget and were written to disk during the current/most recent invocation.

Trait Implementations

impl PhysicalOperator for HashAggregate<'_>

fn row_schema(&self) -> &RowSchema

Complete logical-to-physical row layout emitted by this operator. Every Batch returned by Self::next must carry this exact schema; operators must reject a child that violates that invariant.

fn open(&mut self) -> ExecResult<()>

fn next(&mut self) -> ExecResult<Option<Batch>>

fn close(&mut self) -> ExecResult<()>

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

Schema column names in logical output order.

fn estimated_cardinality(&self) -> Option<u64>

Planner/runtime cardinality estimate for choosing physical strategies. None means the operator cannot provide a useful estimate. The value is advisory rather than a correctness bound.

fn output_ordering(&self) -> &[PhysicalOrder]

Leading output ordering known to be preserved by this operator.

fn consume_into_aggregate( &mut self, _executor: &mut dyn AggregateExecutor, ) -> ExecResult<bool>

Let a leaf consume its native projected rows directly into an aggregate executor. Returning false promises that no input was consumed, so the caller can fall back to ordinary Batch pulls.

fn backward_scan_support(&self) -> BackwardScanSupport

Describe backwards-scan support without changing the operator tree. The default is deliberately conservative so a scrollable cursor freezes the complete output of unclassified plans.

fn next_direction( &mut self, direction: PhysicalScanDirection, ) -> ExecResult<Option<Batch>>

Pull one directional batch. Native backwards-capable pipelines keep batches to one row so a consumer can reverse direction between adjacent fetches.

fn rewind(&mut self) -> ExecResult<()>

Rewind a native backwards-capable pipeline without recomputing rows held by semantic materialization boundaries.