Struct TypeCoercionRewriter 

pub struct TypeCoercionRewriter<'a> {
    pub(crate) schema: &'a DFSchema,
}

Rewrite expressions to apply type coercion.

Fields

schema: &'a DFSchema

Implementations

impl<'a> TypeCoercionRewriter<'a>

pub fn new(schema: &'a DFSchema) -> Self

Create a new TypeCoercionRewriter with a provided schema representing both the inputs and output of the LogicalPlan node.

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.

fn coerce_limit(limit: Limit) -> Result<LogicalPlan>

Coerce the fetch and skip expression to Int64 type.

fn coerce_join_filter(&self, expr: Expr) -> Result<Expr>

fn coerce_binary_op( &self, left: Expr, left_schema: &DFSchema, op: Operator, right: Expr, right_schema: &DFSchema, ) -> Result<(Expr, Expr)>

Trait Implementations

impl TreeNodeRewriterWithPayload for TypeCoercionRewriter<'_>

type Node = Expr

type Payload<'a> = &'a DFSchema

fn f_up(&mut self, expr: Expr, schema: &DFSchema) -> 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<'a>( &mut self, node: Self::Node, _payload: Self::Payload<'a>, ) -> 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.