`MoveTowardsLeafNodes` placement implies speculative evaluation, but the docs don't say so

Open Beginner friendly
#27,487 3 comments 0 reactions 0 assignees View on GitHub

Maintainers usually reply within 1 day

@Inf1mum is already working on this.

Since Nov 17, 2026.

Assessment

Difficulty
2/5
Estimated time
1-3 hours
Newbie friendliness
75/100
Issue type
Documentation
Clarity
Clearly specified
Activity status
Active
Tech stack
rust

Research direction

Start with the docs for ExpressionPlacement::MoveTowardsLeafNodes and ScalarUDFImpl::placement, which the issue links. Read how leaf expression extraction and pushdown can evaluate expressions on rows excluded by CASE branches or filters, then document the safety requirement on both APIs. Done when both docs state that expressions with this placement must not fail or have side effects on any input row.

Written by the indexing model from the issue text.

Description

Describe the bug

ExpressionPlacement::MoveTowardsLeafNodes is documented as a performance hint: the expression is cheap and can be pushed down towards the leaves of the plan. When the optimizer acts on that hint, it also runs the expression on rows that the original plan never evaluated it on:

  • ExtractLeafExpressions extracts MoveTowardsLeafNodes sub-expressions from anywhere inside an expression tree, including the branches of CASE. In the extraction projection, they are evaluated for every input row, not just the rows the branch selects.
  • PushDownLeafProjections then pushes the extraction projections below Filter nodes, so the expressions also run on rows the filter removes.

So an expression with this placement must be safe to evaluate on rows that a filter or a conditional would exclude: it must not fail on them or have side effects. Neither ExpressionPlacement::MoveTowardsLeafNodes nor ScalarUDFImpl::placement states this. The built-in functions with this placement (get_field, input_file_name, file_row_index) meet the requirement as far as I can tell. A user-defined function that returns MoveTowardsLeafNodes because it is cheap, but fails on some inputs, can make a query fail even though SQL CASE and WHERE semantics say that input is never evaluated.

To Reproduce

The plan below shows how get_field is moved with the default configuration (datafusion.optimizer.enable_leaf_expression_pushdown = true):

CREATE TABLE t AS SELECT * FROM (VALUES
  (1,  named_struct('a', 1, 'b', 2)),
  (-1, named_struct('a', 3, 'b', 4))
) AS v(x, s);

EXPLAIN SELECT CASE WHEN x > 0 THEN s['a'] WHEN x < -100 THEN 0 END FROM t WHERE x <> 5;
logical_plan
01)Projection: CASE WHEN t.x > Int64(0) THEN __datafusion_extracted_1 WHEN t.x < Int64(-100) THEN Int64(0) END AS ...
02)--Filter: t.x != Int64(5)
03)----Projection: get_field(t.s, Utf8("a")) AS __datafusion_extracted_1, t.x
04)------TableScan: t projection=[x, s]

get_field(t.s, 'a') came from the first THEN branch, and it is now evaluated below the filter for every row of t.

Replace s['a'] with a UDF that returns MoveTowardsLeafNodes and fails on some values, for example a checked conversion that fails when its argument is 0. The query then fails on rows where x <= 0 or x = 5, even though the result would never include the UDF's value for those rows.

Expected behavior

Either of these would resolve it:

  1. Document the requirement (preferred). State on ExpressionPlacement::MoveTowardsLeafNodes and ScalarUDFImpl::placement that an expression with this placement may be evaluated on rows that enclosing filters or conditional expressions would exclude, so it must not fail or have side effects on any input row. This matches what the optimizer already relies on.
  2. Stop speculative evaluation: don't extract leaf expressions from conditional sub-expressions (CASE branches, the right side of short-circuiting AND/OR), and don't push extraction projections below filters when the extracted expression could fail. That would give up much of the benefit of the leaf pushdown optimization, which is mainly about evaluating get_field close to the scan.
Additional context

The question came up while reviewing #26589, which precomputes MoveTowardsLeafNodes expressions over the whole batch before evaluating CASE branches (https://github.com/apache/datafusion/pull/26589#discussion_r4581490634). That PR relies on the same assumption at the physical level, so documenting the requirement would cover both.

Dominant language
Rust
Stars
9.6k
Forks
2.6k
Avg merge
3d 5h
Merged PRs (30d)
352

Getting set up

Open in Codespaces

Starts the project's dev container in your browser, under your own GitHub account.

First steps

  1. Read the whole issue, then the project's contributing guide.
  2. Comment on the issue to say you are picking it up — it saves two people doing the same work.
  3. Fork the repository and make your change on a branch.
  4. Open a pull request that references the issue number.

More from apache/datafusion

All issues in apache/datafusion

Similar issues

More Rust issues

Get new issues in your inbox

A short digest of beginner-friendly GitHub issues.