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, ) -> PhysicalSortExpr

Create a new PhysicalSortExpr

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

Create a new PhysicalSortExpr with default SortOptions

pub fn reverse(&self) -> PhysicalSortExpr

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

Set the sort sort options to ASC

pub fn desc(self) -> PhysicalSortExpr

Set the sort sort options to DESC

pub fn nulls_first(self) -> PhysicalSortExpr

Set the sort sort options to NULLS FIRST

pub fn nulls_last(self) -> PhysicalSortExpr

Set the sort sort options to NULLS LAST

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

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

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

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: &PhysicalSortExpr, 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.

impl PhysicalSortExpr

Protobuf conversions for PhysicalSortExpr.

This is the flat PhysicalSortExprNode representation used wherever the wire format stores an ordering (scan output orderings, range partitioning, window frames, …). It is not the PhysicalExprNode::Sort wrapping that SortExec uses for its own expr field.

pub fn try_to_proto( &self, ctx: &PhysicalExprEncodeCtx<'_>, ) -> Result<PhysicalSortExprNode, DataFusionError>

Available on crate feature proto only.

Serialize this sort expression, encoding its child expression through ctx.

pub fn try_from_proto( node: &PhysicalSortExprNode, ctx: &PhysicalExprDecodeCtx<'_>, ) -> Result<PhysicalSortExpr, DataFusionError>

Available on crate feature proto only.

Reconstruct a PhysicalSortExpr from its protobuf representation.

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<(), Error>

Formats the value using the given formatter.

impl Display for PhysicalSortExpr

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

Formats the value using the given formatter.

impl Eq for PhysicalSortExpr

impl From<PhysicalSortRequirement> for PhysicalSortExpr

fn from(value: PhysicalSortRequirement) -> PhysicalSortExpr

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>(&self, state: &mut H)

where H: Hasher,

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

Equality operator ==.

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

Inequality operator !=.