Struct EliminateOuterJoin 

pub struct EliminateOuterJoin;

Attempt to simplify outer joins when filters make their null-padded rows impossible to observe.

Outer joins are generally more expensive than inner joins and can block predicate pushdown and other optimizations. When a filter above an outer join removes every row the join would add for unmatched input rows, the join can be changed to a cheaper join type.

For example:

SELECT ...
FROM a LEFT JOIN b ON ...
WHERE b.xx = 100

For unmatched rows from a, the LEFT JOIN would produce a row with b.xx set to NULL. The predicate b.xx = 100 does not pass for those rows, so the query does not need the LEFT JOIN’s null-padded output and the join can be rewritten as an inner join.

The same reasoning can also simplify FULL joins to LEFT, RIGHT, or INNER joins when filters remove the rows padded on one or both sides.

This rule looks for a filter above an outer join:

Filter(predicate)
  Join(LEFT/RIGHT/FULL)

It also handles plan shapes where projection pruning has inserted one or more Projection nodes between the filter and join:

Filter(predicate over projection output)
  Projection(...)
    ...
      Join(LEFT/RIGHT/FULL)

In the projection case, the rule rewrites a copy of the predicate through each Projection so it can analyze the predicate against the Join inputs. The original filter predicate and Projection nodes are preserved when the plan is rebuilt.

Implementations

impl EliminateOuterJoin

pub fn new() -> Self

Trait Implementations

impl Debug for EliminateOuterJoin

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

Formats the value using the given formatter.

impl Default for EliminateOuterJoin

fn default() -> EliminateOuterJoin

Returns the “default value” for a type.

impl OptimizerRule for EliminateOuterJoin

Attempt to eliminate outer joins.

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

👎Deprecated since 47.0.0:

This method is no longer used

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

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.