Trait TreeNodeRewriter 

pub trait TreeNodeRewriter: Sized {
    type Node: TreeNode;

    // Provided methods
    fn f_down(
        &mut self,
        node: Self::Node,
    ) -> Result<Transformed<Self::Node>, DataFusionError> { ... }
    fn f_up(
        &mut self,
        node: Self::Node,
    ) -> Result<Transformed<Self::Node>, DataFusionError> { ... }
}

A Visitor for recursively rewriting TreeNodes via TreeNode::rewrite.

For example you can implement this trait on a struct to rewrite Expr or LogicalPlan that needs to track state during the rewrite.

See TreeNode for more details on available APIs

When passed to TreeNode::rewrite, TreeNodeRewriter::f_down and TreeNodeRewriter::f_up are invoked recursively on the tree. See TreeNodeRecursion for more details on controlling the traversal.

Return Value

The returns value of f_up and f_down specifies how the tree walk should proceed. See TreeNodeRecursion for details. If an Err is returned, the recursion stops immediately.

Note: If using the default implementations of TreeNodeRewriter::f_up or TreeNodeRewriter::f_down that do nothing, consider using TreeNode::transform_up or TreeNode::transform_down instead.

See Also:

• TreeNode::visit to inspect borrowed TreeNodes

Required Associated Types

type Node: TreeNode

The node type which is rewritable.

Provided Methods

fn f_down( &mut self, node: Self::Node, ) -> Result<Transformed<Self::Node>, DataFusionError>

Invoked while traversing down the tree before any children are rewritten. Default implementation returns the node as is and continues recursion.

fn f_up( &mut self, node: Self::Node, ) -> Result<Transformed<Self::Node>, DataFusionError>

Invoked while traversing up the tree after all children have been rewritten. Default implementation returns the node as is and continues recursion.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a> TreeNodeRewriter for PhysicalExprSimplifier<'a>

type Node = Arc<dyn PhysicalExpr>

fn f_up( &mut self, node: <PhysicalExprSimplifier<'a> as TreeNodeRewriter>::Node, ) -> Result<Transformed<<PhysicalExprSimplifier<'a> as TreeNodeRewriter>::Node>, DataFusionError>

Implementors

impl TreeNodeRewriter for TypeCoercionRewriter<'_>

type Node = Expr

impl TreeNodeRewriter for PullUpCorrelatedExpr

type Node = LogicalPlan

impl TreeNodeRewriter for GuaranteeRewriter<'_>

type Node = Expr