Struct PhysicalSortExpr 

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

Represents Sort operation for a column in a RecordBatch

Example:

// Sort by a ASC
let options = SortOptions::default();
let sort_expr = PhysicalSortExpr::new(col("a"), options);
assert_eq!(sort_expr.to_string(), "a ASC");

// Sort by a DESC NULLS LAST
let sort_expr = PhysicalSortExpr::new_default(col("a"))
  .desc()
  .nulls_last();
assert_eq!(sort_expr.to_string(), "a DESC NULLS LAST");

Fields

expr: Arc<dyn PhysicalExpr>

Physical expression representing the column to sort

options: SortOptions

Option to specify how the given column should be sorted

Implementations

impl PhysicalSortExpr

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

Create a new PhysicalSortExpr

pub fn new_default(expr: Arc<dyn PhysicalExpr>) -> Self

Create a new PhysicalSortExpr with default SortOptions

pub fn reverse(&self) -> Self

Reverses the sort expression. For instance, [a ASC NULLS LAST] turns into [a DESC NULLS FIRST]. Such reversals are useful in planning, e.g. when constructing equivalent window expressions.

pub fn asc(self) -> Self

Set the sort sort options to ASC

pub fn desc(self) -> Self

Set the sort sort options to DESC

pub fn nulls_first(self) -> Self

Set the sort sort options to NULLS FIRST

pub fn nulls_last(self) -> Self

Set the sort sort options to NULLS LAST

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

Like PhysicalExpr::fmt_sql prints a PhysicalSortExpr in a SQL-like format.

pub fn evaluate_to_sort_column(&self, batch: &RecordBatch) -> Result<SortColumn>

Evaluates the sort expression into a SortColumn that can be passed into the arrow sort kernel.

pub fn satisfy( &self, requirement: &PhysicalSortRequirement, schema: &Schema, ) -> bool

Checks whether this sort expression satisfies the given requirement. If sort options are unspecified in requirement, only expressions are compared for inequality. See options_compatible for details on how sort options compare with one another.

pub fn satisfy_expr(&self, sort_expr: &Self, schema: &Schema) -> bool

Checks whether this sort expression satisfies the given sort_expr. See options_compatible for details on how sort options compare with one another.

Trait Implementations

impl Clone for PhysicalSortExpr

fn clone(&self) -> PhysicalSortExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PhysicalSortExpr

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

Formats the value using the given formatter.

impl Display for PhysicalSortExpr

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

Formats the value using the given formatter.

impl From<PhysicalSortExpr> for PhysicalSortRequirement

fn from(value: PhysicalSortExpr) -> Self

Converts to this type from the input type.

impl From<PhysicalSortRequirement> for PhysicalSortExpr

fn from(value: PhysicalSortRequirement) -> Self

The default sort options ASC, NULLS LAST when the requirement does not specify sort options. This default is consistent with PostgreSQL.

Reference: https://www.postgresql.org/docs/current/queries-order.html

impl Hash for PhysicalSortExpr

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for PhysicalSortExpr

fn eq(&self, other: &Self) -> 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.

impl Eq for PhysicalSortExpr