Struct SemiJoinReductionFromSelectiveDimension 

pub struct SemiJoinReductionFromSelectiveDimension { /* private fields */ }

Reduce a fact stream by a selective dimension it is inner-joined to, before the join that needs it.

The query that motivated this

TPC-H q7’s FROM clause is supplier, lineitem, orders, customer, nation n1, nation n2, and the plan is left-deep in that order — so the two 25-row nation tables land at the very TOP, above every big join:

Inner Join: n2.n_nationkey = customer.c_nationkey     <- n_name IN (FRANCE, GERMANY)
  Inner Join: n1.n_nationkey = supplier.s_nationkey   <- n_name IN (FRANCE, GERMANY)
    Inner Join: customer.c_custkey = orders.o_custkey
      Inner Join: orders.o_orderkey = lineitem.l_orderkey
        Inner Join: supplier.s_suppkey = lineitem.l_suppkey   <- ALL 1M suppliers

s_nationkey is carried as payload from the bottom join all the way up, through two shuffles measured at 9.48 GB each, before the nation filter is ever applied. TPC-H spreads supplier nations uniformly over 25, so ~8% of suppliers qualify: the bottom join emits about twelve times more rows than any of them can survive.

Measured at SF100 on 2026-08-08, those two shuffles and the stage that consumes them are 81% of q7 (s4 43.4%, s5 37.7%).

The rewrite

  Inner(N, Big)  on N.k = Big.k    ==>    Inner(N, LeftSemi(Big, N') on Big.k)

where N' is N descended to its nearest Filter and projected to the key — the same selective_key_source the aggregate rule uses.

The reducer is introduced at the TOP of the big side and deliberately left there: SemiJoinPushdownThroughInnerJoin already carries a LeftSemi down through inner joins, one level per optimizer pass, and the optimizer runs to a fixed point. So this rule does not need its own descent, and the reducer ends up landing directly on the supplier scan.

Why it is safe

• The join must be Inner. Under an outer join the unmatched rows are preserved, so removing them early changes the result.
• Removing exactly what the join would remove. A Big row whose key has no match in N cannot appear in Inner(N, Big). The reducer removes precisely those rows and no others, so the output is identical.
• No duplication. LeftSemi emits each left row at most once however many N rows match, so multiplicity — and every count and sum above — is unchanged.
• Nulls agree. A null key satisfies neither the reducer nor the join.
• The schema is untouched. LeftSemi projects only its left side, so the parent join’s on columns resolve exactly as before.

Why it is guarded

• The dimension must carry a Filter. Without one the reducer removes nothing and costs an extra pass — the same guard, and the same reason, as the aggregate rule.
• The big side must contain an inner join. If it is a bare scan there is nothing to push past: the reducer would sit directly beneath the join that already does that work.
• Idempotence is structural, not shallow. The pushdown rule moves the reducer down, so after one pass the big side’s top node is an inner join again and a shallow already_reduced check would let this rule add a second reducer on every pass, forever. carries_reducer searches the whole subtree for this exact probe instead.

Implementations

impl SemiJoinReductionFromSelectiveDimension

pub fn forced() -> Self

The rule with its env gate bypassed, for tests and explicit opt-in.

Trait Implementations

impl Debug for SemiJoinReductionFromSelectiveDimension

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

Formats the value using the given formatter.

impl Default for SemiJoinReductionFromSelectiveDimension

fn default() -> SemiJoinReductionFromSelectiveDimension

Returns the “default value” for a type.

impl OptimizerRule for SemiJoinReductionFromSelectiveDimension

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