Struct datafusion::common::tree_node::Transformed

pub struct Transformed<T> {
    pub data: T,
    pub transformed: bool,
    pub tnr: TreeNodeRecursion,
}

Result of tree walk / transformation APIs

Transformed is a wrapper around the tree node data (e.g. Expr or LogicalPlan). It is used to indicate whether the node was transformed and how the recursion should proceed.

TreeNode API users control the transformation by returning:

• The resulting (possibly transformed) node,
• transformed: flag indicating whether any change was made to the node
• tnr: TreeNodeRecursion specifying how to proceed with the recursion.

At the end of the transformation, the return value will contain:

• The final (possibly transformed) tree,
• transformed: flag indicating whether any change was made to the node
• tnr: TreeNodeRecursion specifying how the recursion ended.

See also

• Transformed::update_data to modify the node without changing the transformed flag
• Transformed::map_data for fallable operation that return the same type
• Transformed::transform_data to chain fallable transformations
• TransformedResult for working with Result<Transformed<U>>

Examples

Use Transformed::yes and Transformed::no to signal that a node was rewritten and the recursion should continue:

let expr = orig_expr();

// Create a new `Transformed` object signaling the node was not rewritten
let ret = Transformed::no(expr.clone());
assert!(!ret.transformed);

// Create a new `Transformed` object signaling the node was rewritten
let ret = Transformed::yes(expr);
assert!(ret.transformed)

Access the node within the Transformed object:

let expr = orig_expr();

// `Transformed` object signaling the node was not rewritten
let ret = Transformed::no(expr.clone());
// Access the inner object using .data
assert_eq!(expr, ret.data);

Transform the node within the Transformed object.

let expr = orig_expr();
let ret = Transformed::no(expr.clone())
  .transform_data(|expr| {
   // closure returns a result and potentially transforms the node
   // in this example, it does transform the node
   let new_expr = make_new_expr(expr);
   Ok(Transformed::yes(new_expr))
 }).unwrap();
// transformed flag is the union of the original ans closure's  transformed flag
assert!(ret.transformed);

Example APIs that use TreeNode

• TreeNode,
• TreeNode::rewrite,
• TreeNode::transform_down,
• TreeNode::transform_up,
• TreeNode::transform_down_up

Fields

data: T

transformed: bool

tnr: TreeNodeRecursion

Implementations

impl<T> Transformed<T>

pub fn new(data: T, transformed: bool, tnr: TreeNodeRecursion) -> Transformed<T>

Create a new Transformed object with the given information.

pub fn new_transformed(data: T, transformed: bool) -> Transformed<T>

Create a Transformed with transformed and [TreeNodeRecursion::Continue`].

pub fn yes(data: T) -> Transformed<T>

Wrapper for transformed data with TreeNodeRecursion::Continue statement.

pub fn no(data: T) -> Transformed<T>

Wrapper for unchanged data with TreeNodeRecursion::Continue statement.

pub fn update_data<U, F>(self, f: F) -> Transformed<U>

where F: FnOnce(T) -> U,

Applies an infallible f to the data of this Transformed object, without modifying the transformed flag.

pub fn map_data<U, F>(self, f: F) -> Result<Transformed<U>, DataFusionError>

where F: FnOnce(T) -> Result<U, DataFusionError>,

Applies a fallible f (returns Result) to the data of this Transformed object, without modifying the transformed flag.

pub fn transform_data<U, F>( self, f: F, ) -> Result<Transformed<U>, DataFusionError>

where F: FnOnce(T) -> Result<Transformed<U>, DataFusionError>,

Applies a fallible transforming f to the data of this Transformed object.

The returned Transformed object has the transformed flag set if either self or the return value of f have the transformed flag set.

pub fn transform_children<F>( self, f: F, ) -> Result<Transformed<T>, DataFusionError>

where F: FnOnce(T) -> Result<Transformed<T>, DataFusionError>,

Maps the Transformed object to the result of the given f depending on the current TreeNodeRecursion value and the fact that f is changing the current node’s children.

pub fn transform_sibling<F>( self, f: F, ) -> Result<Transformed<T>, DataFusionError>

where F: FnOnce(T) -> Result<Transformed<T>, DataFusionError>,

Maps the Transformed object to the result of the given f depending on the current TreeNodeRecursion value and the fact that f is changing the current node’s sibling.

pub fn transform_parent<F>( self, f: F, ) -> Result<Transformed<T>, DataFusionError>

where F: FnOnce(T) -> Result<Transformed<T>, DataFusionError>,

Maps the Transformed object to the result of the given f depending on the current TreeNodeRecursion value and the fact that f is changing the current node’s parent.

Trait Implementations

impl<T> Debug for Transformed<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> PartialEq for Transformed<T>

where T: PartialEq,

fn eq(&self, other: &Transformed<T>) -> 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<T> StructuralPartialEq for Transformed<T>