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

impl PhysicalSortExpr

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

evaluate the sort expression into SortColumn that can be passed into 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.

Trait Implementations

impl AsRef<dyn PhysicalExpr> for PhysicalSortExpr

Access the PhysicalSortExpr as a PhysicalExpr

fn as_ref(&self) -> &(dyn PhysicalExpr + 'static)

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for PhysicalSortExpr

fn clone(&self) -> PhysicalSortExpr

Returns a copy 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

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<PhysicalSortExpr> for LexOrdering

fn from_iter<T: IntoIterator<Item = PhysicalSortExpr>>(iter: T) -> Self

Creates a value from an iterator.

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: &PhysicalSortExpr) -> 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