Struct datafusion_physical_expr::PhysicalSortExpr

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

Represents Sort operation for a column in a RecordBatch

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

Check whether sort expression satisfies PhysicalSortRequirement.

If sort options is Some in PhysicalSortRequirement, expr and options field are compared for equality.

If sort options is None in PhysicalSortRequirement, only expr is compared for equality.

Trait Implementations

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

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for PhysicalSortExpr