Struct OrderBy 

pub struct OrderBy { /* private fields */ }

Order by specification for queries

Implementations

impl OrderBy

pub fn new() -> Self

Create an empty order by

pub fn asc(self, column: impl Into<String>) -> Self

Add an ascending sort key

pub fn desc(self, column: impl Into<String>) -> Self

Add a descending sort key

pub fn then(self, key: SortKey) -> Self

Add a sort key

pub fn is_empty(&self) -> bool

Check if empty

pub fn keys(&self) -> &[SortKey]

Get sort keys

pub fn compare<R>( &self, a: &R, b: &R, get_value: impl Fn(&R, &str) -> Value, ) -> Ordering

Compare two rows according to all sort keys

The get_value closure takes a row and column name, returning the value.

pub fn sort_rows<R>( &self, rows: &mut [R], get_value: impl Fn(&R, &str) -> Value, )

Sort a slice of rows in place

pub fn dispatch_sort<R>( &self, rows: Vec<R>, prefix_keys: usize, limit: Option<usize>, get_value: impl Fn(&R, &str) -> Value, ) -> Vec<R>

Phase 3.2 dispatch entry point. Combines OrderBy::sort_rows and incremental_sort_top_k behind a single callable that the planner / executor invokes after deciding the strategy via planner::pathkeys::plan_sort.

prefix_keys is the number of leading sort keys the input already satisfies (0 if unknown). limit is the LIMIT k for top-k early termination, or None for an unbounded sort.

Behavior matrix:

• prefix_keys == 0 && limit == None → full sort_rows.
• prefix_keys == 0 && limit == Some(k) → full sort then truncate to k.
• prefix_keys > 0 && limit == Some(k) → call incremental_sort_top_k(prefix_keys, k).
• prefix_keys > 0 && limit == None → walk groups and sort within each, no early termination (still cheaper than full sort because each group is independent).

pub fn incremental_sort_top_k<R>( &self, rows: Vec<R>, prefix_keys: usize, k: usize, get_value: impl Fn(&R, &str) -> Value, ) -> Vec<R>

Incremental top-K sort.

Fase 4 P3 win: when the upstream operator already returns rows in prefix_keys order (e.g. an index scan whose key is a prefix of the requested ORDER BY), this method walks the input in chunks of equal-prefix rows, sorts each chunk by the remaining keys, emits up to k rows total, and terminates as soon as the budget is met.

Mirrors PG’s nodeIncrementalSort.c algorithm, simplified:

1. Walk rows left-to-right, grouping by equal-prefix.
2. For each group, full-sort by self.keys[prefix_keys..] (the suffix not already covered by upstream order).
3. Append at most k - emitted rows from the sorted group to the output, then advance to the next group.
4. Stop iteration entirely once emitted == k.

Caller contract: rows MUST already be sorted by self.keys[..prefix_keys]. Violating this produces wrong results — the planner is responsible for verifying input pathkey order before choosing this operator.

When prefix_keys == 0 this degenerates to a regular top-k sort using sort_rows + truncate. When prefix_keys >= self.keys.len() the input is already fully ordered and the method just truncates.

pub fn referenced_columns(&self) -> Vec<&str>

Get all referenced columns

Trait Implementations

impl Clone for OrderBy

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OrderBy

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

Formats the value using the given formatter.

impl Default for OrderBy

fn default() -> Self

Returns the “default value” for a type.