Struct PushDownLeafProjections 

pub struct PushDownLeafProjections {}

Pushes extraction projections down through schema-preserving nodes towards leaf nodes (pass 2 of 2, after ExtractLeafExpressions).

Handles two types of projections:

• Pure extraction projections (all __datafusion_extracted aliases + columns): pushes through Filter/Sort/Limit, merges into existing projections, or routes into multi-input node inputs (Join, SubqueryAlias, etc.)
• Mixed projections (user projections containing MoveTowardsLeafNodes sub-expressions): splits into a recovery projection + extraction projection, then pushes the extraction projection down.

Example: Pushing through a Filter

After pass 1, the extraction projection sits directly below the filter:

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

Pass 2 pushes the extraction projection through the recovery and filter, and a subsequent OptimizeProjections pass removes the (now-redundant) recovery projection:

Filter: __datafusion_extracted_1 = 'active'
  Projection: user['status'] AS __datafusion_extracted_1, id, user                 <-- extraction (pushed down)
    TableScan: t [id, user]

Implementations

impl PushDownLeafProjections

pub fn new() -> Self

Trait Implementations

impl Debug for PushDownLeafProjections

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

Formats the value using the given formatter.

impl Default for PushDownLeafProjections

fn default() -> PushDownLeafProjections

Returns the “default value” for a type.

impl OptimizerRule for PushDownLeafProjections

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