Enum SortOrderPushdownResult 

pub enum SortOrderPushdownResult<T> {
    Exact {
        inner: T,
    },
    Inexact {
        inner: T,
    },
    Unsupported,
}

Result of attempting to push down sort ordering to a node.

Used by ExecutionPlan::try_pushdown_sort to communicate whether and how sort ordering was successfully pushed down.

Variants

Exact

The source can guarantee exact ordering (data is perfectly sorted).

When this is returned, the optimizer can safely remove the Sort operator entirely since the data source guarantees the requested ordering.

Fields

inner: T

The optimized node that provides exact ordering

Inexact

The source has optimized for the ordering but cannot guarantee perfect sorting.

This indicates the data source has been optimized (e.g., reordered files/row groups based on statistics, enabled reverse scanning) but the data may not be perfectly sorted. The optimizer should keep the Sort operator but benefits from the optimization (e.g., faster TopK queries due to early termination).

Fields

inner: T

The optimized node that provides approximate ordering

Unsupported

The source cannot optimize for this ordering.

The data source does not support the requested sort ordering and no optimization was applied.

Implementations

impl<T> SortOrderPushdownResult<T>

pub fn into_inner(self) -> Option<T>

Extract the inner value if present

pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> SortOrderPushdownResult<U>

Map the inner value to a different type while preserving the variant.

pub fn try_map<U, E, F: FnOnce(T) -> Result<U, E>>( self, f: F, ) -> Result<SortOrderPushdownResult<U>, E>

Try to map the inner value, returning an error if the function fails.

pub fn into_inexact(self) -> Self

Convert this result to Inexact, downgrading Exact if present.

This is useful when an operation (like merging multiple partitions) cannot guarantee exact ordering even if the input provides it.

Examples

let exact = SortOrderPushdownResult::Exact { inner: 42 };
let inexact = exact.into_inexact();
assert!(matches!(inexact, SortOrderPushdownResult::Inexact { inner: 42 }));

let already_inexact = SortOrderPushdownResult::Inexact { inner: 42 };
let still_inexact = already_inexact.into_inexact();
assert!(matches!(still_inexact, SortOrderPushdownResult::Inexact { inner: 42 }));

let unsupported = SortOrderPushdownResult::<i32>::Unsupported;
let still_unsupported = unsupported.into_inexact();
assert!(matches!(still_unsupported, SortOrderPushdownResult::Unsupported));

Trait Implementations

impl<T: Clone> Clone for SortOrderPushdownResult<T>

fn clone(&self) -> SortOrderPushdownResult<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for SortOrderPushdownResult<T>

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

Formats the value using the given formatter.