Struct CommonSubexprEliminate 

pub struct CommonSubexprEliminate {}

Performs Common Sub-expression Elimination optimization.

This optimization improves query performance by computing expressions that appear more than once and reusing those results rather than re-computing the same value

Currently only common sub-expressions within a single LogicalPlan are eliminated.

Example

Given a projection that computes the same expensive expression multiple times such as parsing as string as a date with to_date twice:

ProjectionExec(expr=[extract (day from to_date(c1)), extract (year from to_date(c1))])

This optimization will rewrite the plan to compute the common expression once using a new ProjectionExec and then rewrite the original expressions to refer to that new column.

ProjectionExec(exprs=[extract (day from new_col), extract (year from new_col)]) <-- reuse here
  ProjectionExec(exprs=[to_date(c1) as new_col]) <-- compute to_date once

Implementations

impl CommonSubexprEliminate

pub fn new() -> Self

fn try_optimize_proj( &self, projection: Projection, config: &dyn OptimizerConfig, ) -> Result<Transformed<LogicalPlan>>

fn try_optimize_sort( &self, sort: Sort, config: &dyn OptimizerConfig, ) -> Result<Transformed<LogicalPlan>>

fn try_optimize_filter( &self, filter: Filter, config: &dyn OptimizerConfig, ) -> Result<Transformed<LogicalPlan>>

fn try_optimize_window( &self, window: Window, config: &dyn OptimizerConfig, ) -> Result<Transformed<LogicalPlan>>

fn try_optimize_aggregate( &self, aggregate: Aggregate, config: &dyn OptimizerConfig, ) -> Result<Transformed<LogicalPlan>>

fn try_unary_plan( &self, exprs: Vec<Expr>, input: LogicalPlan, config: &dyn OptimizerConfig, ) -> Result<Transformed<(Vec<Expr>, LogicalPlan)>>

Rewrites the expr list and input to remove common subexpressions

Parameters

• exprs: List of expressions in the node
• input: input plan (that produces the columns referred to in exprs)

Return value

Returns (rewritten_exprs, new_input). new_input is either:

1. The original input of no common subexpressions were extracted
2. A newly added projection on top of the original input that computes the common subexpressions

Trait Implementations

impl Debug for CommonSubexprEliminate

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

Formats the value using the given formatter.

impl Default for CommonSubexprEliminate

fn default() -> Self

Returns the “default value” for a type.

impl OptimizerRule for CommonSubexprEliminate

fn supports_rewrite(&self) -> bool

👎Deprecated since 47.0.0: This method is no longer used

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

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

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

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

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

fn name(&self) -> &str

A human readable name for this optimizer rule