Struct TypeCoercionRewriter

pub struct TypeCoercionRewriter<'a> { /* private fields */ }

Rewrite expressions to apply type coercion.

Implementations

impl<'a> TypeCoercionRewriter<'a>

pub fn coerce_plan(&mut self, plan: LogicalPlan) -> Result<LogicalPlan>

Coerce the LogicalPlan.

Refer to TypeCoercionRewriter::coerce_join and TypeCoercionRewriter::coerce_union for type-coercion approach.

pub fn coerce_join(&mut self, join: Join) -> Result<LogicalPlan>

Coerce join equality expressions and join filter

Joins must be treated specially as their equality expressions are stored as a parallel list of left and right expressions, rather than a single equality expression

For example, on_exprs like t1.a = t2.b AND t1.x = t2.y will be stored as a list of (t1.a, t2.b), (t1.x, t2.y)

pub fn coerce_union(union_plan: Union) -> Result<LogicalPlan>

Coerce the union’s inputs to a common schema compatible with all inputs. This occurs after wildcard expansion and the coercion of the input expressions.

Trait Implementations

impl<'a> TreeNodeRewriter for TypeCoercionRewriter<'a>

type Node = Expr

The node type which is rewritable.

fn f_up(&mut self, expr: Expr) -> Result<Transformed<Expr>>

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

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.