Struct ExtractLeafExpressions 

pub struct ExtractLeafExpressions {}

Extracts MoveTowardsLeafNodes sub-expressions from non-projection nodes into extraction projections (pass 1 of 2).

This handles Filter, Sort, Limit, Aggregate, and Join nodes. For Projection nodes, extraction and pushdown are handled by PushDownLeafProjections.

Key Concepts

Extraction projection: a projection inserted below a node that pre-computes a cheap expression and exposes it under an alias (__datafusion_extracted_N). The parent node then references the alias instead of the original expression.

Recovery projection: a projection inserted above a node to restore the original output schema when extraction changes it. Schema-preserving nodes (Filter, Sort, Limit) gain extra columns from the extraction projection that bubble up; the recovery projection selects only the original columns to hide the extras.

Example

Given a filter with a struct field access:

Filter: user['status'] = 'active'
  TableScan: t [id, user]

This rule:

1. Inserts an extraction projection below the filter:
2. Adds a recovery projection above to hide the extra column:

Projection: id, user                                                        <-- recovery projection
  Filter: __datafusion_extracted_1 = 'active'
    Projection: user['status'] AS __datafusion_extracted_1, id, user         <-- extraction projection
      TableScan: t [id, user]

Important: The PushDownFilter rule is aware of projections created by this rule and will not push filters through them. It uses ExpressionPlacement to detect MoveTowardsLeafNodes expressions and skip filter pushdown past them.

Implementations

impl ExtractLeafExpressions

pub fn new() -> Self

Create a new ExtractLeafExpressions

Trait Implementations

impl Debug for ExtractLeafExpressions

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

Formats the value using the given formatter.

impl Default for ExtractLeafExpressions

fn default() -> ExtractLeafExpressions

Returns the “default value” for a type.

impl OptimizerRule for ExtractLeafExpressions

fn name(&self) -> &str

A human readable name for this optimizer rule

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 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

👎Deprecated since 47.0.0:

This method is no longer used

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