Struct datafusion_python::optimizer::unwrap_cast_in_comparison::UnwrapCastInComparison

pub struct UnwrapCastInComparison {}

UnwrapCastInComparison attempts to remove casts from comparisons to literals (ScalarValues) by applying the casts to the literals if possible. It is inspired by the optimizer rule UnwrapCastInBinaryComparison of Spark.

Removing casts often improves performance because:

1. The cast is done once (to the literal) rather than to every value
2. Can enable other optimizations such as predicate pushdown that don’t support casting

The rule is applied to expressions of the following forms:

1. cast(left_expr as data_type) comparison_op literal_expr
2. literal_expr comparison_op cast(left_expr as data_type)
3. cast(literal_expr) IN (expr1, expr2, ...)
4. literal_expr IN (cast(expr1) , cast(expr2), ...)

If the expression matches one of the forms above, the rule will ensure the value of literal is in range(min, max) of the expr’s data_type, and if the scalar is within range, the literal will be casted to the data type of expr on the other side, and the cast will be removed from the other side.

Example

If the DataType of c1 is INT32. Given the filter

Filter: cast(c1 as INT64) > INT64(10)`

This rule will remove the cast and rewrite the expression to:

Filter: c1 > INT32(10)

Implementations

impl UnwrapCastInComparison

pub fn new() -> UnwrapCastInComparison

Trait Implementations

impl Default for UnwrapCastInComparison

fn default() -> UnwrapCastInComparison

Returns the “default value” for a type.

impl OptimizerRule for UnwrapCastInComparison

fn name(&self) -> &str

A human readable name for this optimizer rule

fn apply_order(&self) -> Option<ApplyOrder>

How should the rule be applied by the optimizer? See comments on ApplyOrder for details.

fn supports_rewrite(&self) -> bool

Does this rule support rewriting owned plans (rather than by reference)?

fn rewrite( &self, plan: LogicalPlan, _config: &dyn OptimizerConfig, ) -> Result<Transformed<LogicalPlan>, DataFusionError>

Try to rewrite plan to an optimized form, returning Transformed::yes if the plan was rewritten and Transformed::no if it was not.

fn try_optimize( &self, _plan: &LogicalPlan, _config: &dyn OptimizerConfig, ) -> Result<Option<LogicalPlan>, DataFusionError>

👎Deprecated since 40.0.0: please implement supports_rewrite and rewrite instead

Try and rewrite plan to an optimized form, returning None if the plan cannot be optimized by this rule.