Struct Sort 

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

Implementations

impl Sort<'static>

pub fn new( child: Box<dyn PhysicalOperator>, keys: Vec<SortKey>, params: Vec<SQLParam>, ) -> Self

pub fn with_keep( child: Box<dyn PhysicalOperator>, keys: Vec<SortKey>, params: Vec<SQLParam>, keep: usize, ) -> Self

Top-K variant: retain only the first keep rows of the sorted order. Uses a partial selection, so the cost is O(n + k log k) instead of O(n log n).

impl<'a> Sort<'a>

pub fn with_evaluator( child: Box<dyn PhysicalOperator + 'a>, keys: Vec<SortKey>, evaluator: SharedExpressionEvaluator<'a>, ) -> Self

pub fn with_evaluator_and_work_mem( child: Box<dyn PhysicalOperator + 'a>, keys: Vec<SortKey>, evaluator: SharedExpressionEvaluator<'a>, work_mem_bytes: usize, ) -> Self

pub fn with_evaluator_and_keep( child: Box<dyn PhysicalOperator + 'a>, keys: Vec<SortKey>, evaluator: SharedExpressionEvaluator<'a>, keep: usize, ) -> Self

Trait Implementations

impl PhysicalOperator for Sort<'_>

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 output_ordering(&self) -> &[PhysicalOrder]

Leading output ordering known to be preserved by this operator.

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 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 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 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.