Struct datafusion_physical_expr::sort_properties::ExprOrdering

pub struct ExprOrdering {
    pub expr: Arc<dyn PhysicalExpr>,
    pub state: SortProperties,
    pub children_states: Vec<SortProperties>,
}

The ExprOrdering struct is designed to aid in the determination of ordering (represented by SortProperties) for a given PhysicalExpr. When analyzing the orderings of a PhysicalExpr, the process begins by assigning the ordering of its leaf nodes. By propagating these leaf node orderings upwards in the expression tree, the overall ordering of the entire PhysicalExpr can be derived.

This struct holds the necessary state information for each expression in the PhysicalExpr. It encapsulates the orderings (state) associated with the expression (expr), and orderings of the children expressions (children_states). The ExprOrdering of a parent expression is determined based on the ExprOrdering states of its children expressions.

Fields

expr: Arc<dyn PhysicalExpr>

state: SortProperties

children_states: Vec<SortProperties>

Implementations

impl ExprOrdering

pub fn new(expr: Arc<dyn PhysicalExpr>) -> Self

Creates a new ExprOrdering with SortProperties::Unordered states for expr and its children.

pub fn with_new_children(self, children_states: Vec<SortProperties>) -> Self

Updates this ExprOrdering’s children states with the given states.

pub fn children_expr_orderings(&self) -> Vec<ExprOrdering>

Creates new ExprOrdering objects for each child of the expression.

Trait Implementations

impl Debug for ExprOrdering

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

Formats the value using the given formatter.

impl TreeNode for ExprOrdering

fn apply_children<F>(&self, op: &mut F) -> Result<VisitRecursion>where F: FnMut(&Self) -> Result<VisitRecursion>,

Apply the closure F to the node’s children

fn map_children<F>(self, transform: F) -> Result<Self>where F: FnMut(Self) -> Result<Self>,

Apply transform F to the node’s children, the transform F might have a direction(Preorder or Postorder)

fn apply<F>(&self, op: &mut F) -> Result<VisitRecursion, DataFusionError>where F: FnMut(&Self) -> Result<VisitRecursion, DataFusionError>,

Use preorder to iterate the node on the tree so that we can stop fast for some cases.

fn visit<V>(&self, visitor: &mut V) -> Result<VisitRecursion, DataFusionError>where V: TreeNodeVisitor<N = Self>,

Visit the tree node using the given TreeNodeVisitor It performs a depth first walk of an node and its children.

fn transform<F>(self, op: &F) -> Result<Self, DataFusionError>where F: Fn(Self) -> Result<Transformed<Self>, DataFusionError>,

Convenience utils for writing optimizers rule: recursively apply the given op to the node tree. When op does not apply to a given node, it is left unchanged. The default tree traversal direction is transform_up(Postorder Traversal).

fn transform_down<F>(self, op: &F) -> Result<Self, DataFusionError>where F: Fn(Self) -> Result<Transformed<Self>, DataFusionError>,

Convenience utils for writing optimizers rule: recursively apply the given ‘op’ to the node and all of its children(Preorder Traversal). When the op does not apply to a given node, it is left unchanged.

fn transform_down_mut<F>(self, op: &mut F) -> Result<Self, DataFusionError>where F: FnMut(Self) -> Result<Transformed<Self>, DataFusionError>,

Convenience utils for writing optimizers rule: recursively apply the given ‘op’ to the node and all of its children(Preorder Traversal) using a mutable function, F. When the op does not apply to a given node, it is left unchanged.

fn transform_up<F>(self, op: &F) -> Result<Self, DataFusionError>where F: Fn(Self) -> Result<Transformed<Self>, DataFusionError>,

Convenience utils for writing optimizers rule: recursively apply the given ‘op’ first to all of its children and then itself(Postorder Traversal). When the op does not apply to a given node, it is left unchanged.

fn transform_up_mut<F>(self, op: &mut F) -> Result<Self, DataFusionError>where F: FnMut(Self) -> Result<Transformed<Self>, DataFusionError>,

Convenience utils for writing optimizers rule: recursively apply the given ‘op’ first to all of its children and then itself(Postorder Traversal) using a mutable function, F. When the op does not apply to a given node, it is left unchanged.

fn rewrite<R>(self, rewriter: &mut R) -> Result<Self, DataFusionError>where R: TreeNodeRewriter<N = Self>,

Transform the tree node using the given TreeNodeRewriter It performs a depth first walk of an node and its children.