Struct OrderingEquivalenceClass

pub struct OrderingEquivalenceClass {
    pub orderings: Vec<LexOrdering>,
}

An OrderingEquivalenceClass object keeps track of different alternative orderings than can describe a schema. For example, consider the following table:

|a|b|c|d|
|1|4|3|1|
|2|3|3|2|
|3|1|2|2|
|3|2|1|3|

Here, both vec![a ASC, b ASC] and vec![c DESC, d ASC] describe the table ordering. In this case, we say that these orderings are equivalent.

Fields

orderings: Vec<LexOrdering>

Implementations

impl OrderingEquivalenceClass

pub fn empty() -> Self

Creates new empty ordering equivalence class.

pub fn clear(&mut self)

Clears (empties) this ordering equivalence class.

pub fn new(orderings: Vec<LexOrdering>) -> Self

Creates new ordering equivalence class from the given orderings.

pub fn contains(&self, ordering: &LexOrdering) -> bool

Checks whether ordering is a member of this equivalence class.

pub fn is_empty(&self) -> bool

Checks whether this ordering equivalence class is empty.

pub fn iter(&self) -> impl Iterator<Item = &LexOrdering>

Returns an iterator over the equivalent orderings in this class.

pub fn len(&self) -> usize

Returns how many equivalent orderings there are in this class.

pub fn extend(&mut self, other: Self)

Extend this ordering equivalence class with the other class.

pub fn add_new_orderings( &mut self, orderings: impl IntoIterator<Item = LexOrdering>, )

Adds new orderings into this ordering equivalence class.

pub fn add_new_ordering(&mut self, ordering: LexOrdering)

Adds a single ordering to the existing ordering equivalence class.

pub fn output_ordering(&self) -> Option<LexOrdering>

Returns the concatenation of all the orderings. This enables merge operations to preserve all equivalent orderings simultaneously.

pub fn join_suffix(self, other: &Self) -> Self

pub fn add_offset(&mut self, offset: usize)

Adds offset value to the index of each expression inside this ordering equivalence class.

pub fn get_options(&self, expr: &Arc<dyn PhysicalExpr>) -> Option<SortOptions>

Gets sort options associated with this expression if it is a leading ordering expression. Otherwise, returns None.

Trait Implementations

impl Clone for OrderingEquivalenceClass

fn clone(&self) -> OrderingEquivalenceClass

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OrderingEquivalenceClass

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

Formats the value using the given formatter.

impl Default for OrderingEquivalenceClass

fn default() -> OrderingEquivalenceClass

Returns the “default value” for a type.

impl Display for OrderingEquivalenceClass

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

Formats the value using the given formatter.

impl Hash for OrderingEquivalenceClass

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 IntoIterator for OrderingEquivalenceClass

type Item = LexOrdering

The type of the elements being iterated over.

type IntoIter = IntoIter<LexOrdering>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for OrderingEquivalenceClass

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

impl StructuralPartialEq for OrderingEquivalenceClass