Struct PhysicalSortRequirement

pub struct PhysicalSortRequirement {
    pub expr: Arc<dyn PhysicalExpr>,
    pub options: Option<SortOptions>,
}

Represents sort requirement associated with a plan

If the requirement includes SortOptions then both the expression and the sort options must match.

If the requirement does not include SortOptions) then only the expressions must match.

Examples

With sort options (A, DESC NULLS FIRST):

• ORDER BY A DESC NULLS FIRST matches
• ORDER BY A ASC NULLS FIRST does not match (ASC vs DESC)
• ORDER BY B DESC NULLS FIRST does not match (different expr)

Without sort options (A, None):

• ORDER BY A DESC NULLS FIRST matches
• ORDER BY A ASC NULLS FIRST matches (ASC and NULL options ignored)
• ORDER BY B DESC NULLS FIRST does not match (different expr)

Fields

expr: Arc<dyn PhysicalExpr>

Physical expression representing the column to sort

options: Option<SortOptions>

Option to specify how the given column should be sorted. If unspecified, there are no constraints on sort options.

Implementations

impl PhysicalSortRequirement

pub fn new( expr: Arc<dyn PhysicalExpr>, options: Option<SortOptions>, ) -> PhysicalSortRequirement

Creates a new requirement.

If options is Some(..), creates an exact requirement, which must match both options and expr.

If options is None, Creates a new expr_only requirement, which must match only expr.

See PhysicalSortRequirement for examples.

pub fn with_expr(self, expr: Arc<dyn PhysicalExpr>) -> PhysicalSortRequirement

Replace the required expression for this requirement with the new one

pub fn compatible(&self, other: &PhysicalSortRequirement) -> bool

Returns whether this requirement is equal or more specific than other.

pub fn from_sort_exprs<'a>( ordering: impl IntoIterator<Item = &'a PhysicalSortExpr>, ) -> LexRequirement

👎Deprecated since 43.0.0: use LexRequirement::from_lex_ordering

pub fn to_sort_exprs( requirements: impl IntoIterator<Item = PhysicalSortRequirement>, ) -> LexOrdering

👎Deprecated since 43.0.0: use LexOrdering::from_lex_requirement

Trait Implementations

impl Clone for PhysicalSortRequirement

fn clone(&self) -> PhysicalSortRequirement

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PhysicalSortRequirement

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

Formats the value using the given formatter.

impl Display for PhysicalSortRequirement

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

Formats the value using the given formatter.

impl From<PhysicalSortExpr> for PhysicalSortRequirement

fn from(value: PhysicalSortExpr) -> PhysicalSortRequirement

Converts to this type from the input type.

impl From<PhysicalSortRequirement> for PhysicalSortExpr

fn from(value: PhysicalSortRequirement) -> PhysicalSortExpr

If options is None, the default sort options ASC, NULLS LAST is used.

The default is picked to be consistent with PostgreSQL: https://www.postgresql.org/docs/current/queries-order.html

impl FromIterator<PhysicalSortRequirement> for LexRequirement

fn from_iter<T>(iter: T) -> LexRequirement

where T: IntoIterator<Item = PhysicalSortRequirement>,

Creates a value from an iterator.

impl PartialEq for PhysicalSortRequirement

fn eq(&self, other: &PhysicalSortRequirement) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.