Struct datafusion_physical_expr::equivalence::EquivalenceGroup

pub struct EquivalenceGroup {
    pub classes: Vec<EquivalenceClass>,
}

An EquivalenceGroup is a collection of EquivalenceClasses where each class represents a distinct equivalence class in a relation.

Fields

classes: Vec<EquivalenceClass>

Implementations

impl EquivalenceGroup

pub fn empty() -> Self

Creates an empty equivalence group.

pub fn new(classes: Vec<EquivalenceClass>) -> Self

Creates an equivalence group from the given equivalence classes.

pub fn len(&self) -> usize

Returns how many equivalence classes there are in this group.

pub fn is_empty(&self) -> bool

Checks whether this equivalence group is empty.

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

Returns an iterator over the equivalence classes in this group.

pub fn add_equal_conditions( &mut self, left: &Arc<dyn PhysicalExpr>, right: &Arc<dyn PhysicalExpr>, )

Adds the equality left = right to this equivalence group. New equality conditions often arise after steps like Filter(a = b), Alias(a, a as b) etc.

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

Extends this equivalence group with the other equivalence group.

pub fn normalize_expr( &self, expr: Arc<dyn PhysicalExpr>, ) -> Arc<dyn PhysicalExpr>

Normalizes the given physical expression according to this group. The expression is replaced with the first expression in the equivalence class it matches with (if any).

pub fn normalize_sort_expr( &self, sort_expr: PhysicalSortExpr, ) -> PhysicalSortExpr

Normalizes the given sort expression according to this group. The underlying physical expression is replaced with the first expression in the equivalence class it matches with (if any). If the underlying expression does not belong to any equivalence class in this group, returns the sort expression as is.

pub fn normalize_sort_requirement( &self, sort_requirement: PhysicalSortRequirement, ) -> PhysicalSortRequirement

Normalizes the given sort requirement according to this group. The underlying physical expression is replaced with the first expression in the equivalence class it matches with (if any). If the underlying expression does not belong to any equivalence class in this group, returns the given sort requirement as is.

pub fn normalize_exprs( &self, exprs: impl IntoIterator<Item = Arc<dyn PhysicalExpr>>, ) -> Vec<Arc<dyn PhysicalExpr>>

This function applies the normalize_expr function for all expressions in exprs and returns the corresponding normalized physical expressions.

pub fn normalize_sort_exprs( &self, sort_exprs: LexOrderingRef<'_>, ) -> LexOrdering

This function applies the normalize_sort_expr function for all sort expressions in sort_exprs and returns the corresponding normalized sort expressions.

pub fn normalize_sort_requirements( &self, sort_reqs: LexRequirementRef<'_>, ) -> LexRequirement

This function applies the normalize_sort_requirement function for all requirements in sort_reqs and returns the corresponding normalized sort requirements.

pub fn project_expr( &self, mapping: &ProjectionMapping, expr: &Arc<dyn PhysicalExpr>, ) -> Option<Arc<dyn PhysicalExpr>>

Projects expr according to the given projection mapping. If the resulting expression is invalid after projection, returns None.

pub fn project(&self, mapping: &ProjectionMapping) -> Self

Projects this equivalence group according to the given projection mapping.

pub fn join( &self, right_equivalences: &Self, join_type: &JoinType, left_size: usize, on: &[(PhysicalExprRef, PhysicalExprRef)], ) -> Self

Combine equivalence groups of the given join children.

Trait Implementations

impl Clone for EquivalenceGroup

fn clone(&self) -> EquivalenceGroup

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for EquivalenceGroup

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

Formats the value using the given formatter.