kumarUjjawal commented on code in PR #21621: URL: https://github.com/apache/datafusion/pull/21621#discussion_r3969487271
########## datafusion/optimizer/src/push_down_limit/topk_through_join.rs: ########## @@ -0,0 +1,1185 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +//! Sort(fetch) → Join pushdown — a sub-module of `push_down_limit`. +//! +//! When a `Sort` with a fetch limit (TopK) sits above a join whose +//! preserved side is known (LEFT / RIGHT / LeftMark / RightMark / CROSS) +//! and all sort expressions come from the preserved side, we insert a +//! copy of the `Sort(fetch)` onto that input to reduce rows entering +//! the join. The outer `Sort` is kept because a 1-to-many join can +//! produce more than N output rows from N preserved-side rows. +//! +//! Dispatched from `PushDownLimit::rewrite` when the plan node is +//! `LogicalPlan::Sort` with `fetch.is_some()`. + +use std::collections::HashMap; +use std::sync::Arc; + +use crate::utils::{has_all_column_refs, schema_columns}; + +use datafusion_common::tree_node::{Transformed, TreeNode}; +use datafusion_common::{Column, Result, internal_err}; +use datafusion_expr::logical_plan::{ + JoinType, LogicalPlan, Projection, Sort as SortPlan, SubqueryAlias, +}; +use datafusion_expr::{Expr, SortExpr}; + +/// Which child of a join is being treated as the preserved side. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum Side { + Left, + Right, +} + +/// Top-level pushdown for `Sort(fetch) → ... → Join` patterns. The plan +/// passed in is guaranteed by the caller to be `LogicalPlan::Sort` with +/// `fetch.is_some()`; we re-bind to a borrow inside. +pub(super) fn push_topk_through_join( + plan: LogicalPlan, +) -> Result<Transformed<LogicalPlan>> { + let LogicalPlan::Sort(sort) = &plan else { + return Ok(Transformed::no(plan)); + }; + let Some(fetch) = sort.fetch else { + return Ok(Transformed::no(plan)); + }; + + // Don't push if any sort expression is non-deterministic (e.g. + // `random()`). Duplicating such expressions would produce different + // values at each evaluation point, potentially changing results. + if sort.expr.iter().any(|se| se.expr.is_volatile()) { + return Ok(Transformed::no(plan)); + } + + // Peel through transparent nodes (SubqueryAlias, Projection) to + // find the Join. Track intermediates so we can reconstruct the tree + // and resolve sort expressions through them. + let mut current = sort.input.as_ref(); + let mut intermediates: Vec<&LogicalPlan> = Vec::new(); + let join = loop { + match current { + LogicalPlan::Join(join) => break join, + LogicalPlan::Projection(proj) => { + intermediates.push(current); + current = proj.input.as_ref(); + } + LogicalPlan::SubqueryAlias(sq) => { + intermediates.push(current); + current = sq.input.as_ref(); + } + _ => return Ok(Transformed::no(plan)), Review Comment: Preserve this optimization when the optimizer is configured with one pass. For `Sort(fetch) -> Filter -> Left Join`, `PushDownLimit` currently reaches this code before `PushDownFilter`. This traversal stops at the `Filter`, then `PushDownFilter` moves the filter below the join later in the same pass. With `datafusion.optimizer.max_passes = 1` or `OptimizerContext::with_max_passes(1)`, this rule is not run again and the TopK is never pushed down. Please add a one-pass regression and arrange for the specialized TopK transformation to run after filter pushdown, without moving the ordinary limit transformation past filters. ########## datafusion/optimizer/src/push_down_limit/topk_through_join.rs: ########## @@ -0,0 +1,1185 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +//! Sort(fetch) → Join pushdown — a sub-module of `push_down_limit`. +//! +//! When a `Sort` with a fetch limit (TopK) sits above a join whose +//! preserved side is known (LEFT / RIGHT / LeftMark / RightMark / CROSS) +//! and all sort expressions come from the preserved side, we insert a +//! copy of the `Sort(fetch)` onto that input to reduce rows entering +//! the join. The outer `Sort` is kept because a 1-to-many join can +//! produce more than N output rows from N preserved-side rows. +//! +//! Dispatched from `PushDownLimit::rewrite` when the plan node is +//! `LogicalPlan::Sort` with `fetch.is_some()`. + +use std::collections::HashMap; +use std::sync::Arc; + +use crate::utils::{has_all_column_refs, schema_columns}; + +use datafusion_common::tree_node::{Transformed, TreeNode}; +use datafusion_common::{Column, Result, internal_err}; +use datafusion_expr::logical_plan::{ + JoinType, LogicalPlan, Projection, Sort as SortPlan, SubqueryAlias, +}; +use datafusion_expr::{Expr, SortExpr}; + +/// Which child of a join is being treated as the preserved side. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum Side { + Left, + Right, +} + +/// Top-level pushdown for `Sort(fetch) → ... → Join` patterns. The plan +/// passed in is guaranteed by the caller to be `LogicalPlan::Sort` with +/// `fetch.is_some()`; we re-bind to a borrow inside. +pub(super) fn push_topk_through_join( + plan: LogicalPlan, +) -> Result<Transformed<LogicalPlan>> { + let LogicalPlan::Sort(sort) = &plan else { + return Ok(Transformed::no(plan)); + }; + let Some(fetch) = sort.fetch else { + return Ok(Transformed::no(plan)); + }; + + // Don't push if any sort expression is non-deterministic (e.g. + // `random()`). Duplicating such expressions would produce different + // values at each evaluation point, potentially changing results. + if sort.expr.iter().any(|se| se.expr.is_volatile()) { + return Ok(Transformed::no(plan)); + } + + // Peel through transparent nodes (SubqueryAlias, Projection) to + // find the Join. Track intermediates so we can reconstruct the tree + // and resolve sort expressions through them. + let mut current = sort.input.as_ref(); + let mut intermediates: Vec<&LogicalPlan> = Vec::new(); + let join = loop { + match current { + LogicalPlan::Join(join) => break join, + LogicalPlan::Projection(proj) => { + intermediates.push(current); + current = proj.input.as_ref(); + } + LogicalPlan::SubqueryAlias(sq) => { + intermediates.push(current); + current = sq.input.as_ref(); + } + _ => return Ok(Transformed::no(plan)), + } + }; + + // Determine which side(s) of the join are preserved. + // + // - LEFT / LeftMark: only left preserved. + // - RIGHT / RightMark: symmetric. + // - CROSS JOIN (Inner with no `on` keys and no filter): + // every row from both sides appears in the output (Cartesian + // product), so we can push to whichever side has all the sort + // columns. + // + // For LEFT/RIGHT, non-equijoin filters in the ON clause are safe: + // outer joins guarantee all preserved-side rows appear in the + // output regardless of the filter. For Inner joins (cross-join + // detection), the filter check is strict (`filter.is_none()`) — + // any filter on Inner can drop rows from either side. + let preserved_candidates: &[Side] = match join.join_type { + JoinType::Left | JoinType::LeftMark => &[Side::Left], + JoinType::Right | JoinType::RightMark => &[Side::Right], + JoinType::Inner if join.on.is_empty() && join.filter.is_none() => { + &[Side::Left, Side::Right] + } + _ => return Ok(Transformed::no(plan)), + }; + + // Resolve sort expressions through all intermediate nodes + // (Projection, SubqueryAlias) so column references match the + // join's schema. + let mut resolved_sort_exprs = sort.expr.clone(); + for node in &intermediates { + match node { + LogicalPlan::Projection(proj) => { + resolved_sort_exprs = + resolve_sort_exprs_through_projection(&resolved_sort_exprs, proj)?; + } + LogicalPlan::SubqueryAlias(sq) => { + resolved_sort_exprs = + resolve_sort_exprs_through_subquery_alias(&resolved_sort_exprs, sq)?; + } + _ => { + return internal_err!( + "push_topk_through_join: unexpected intermediate node: {}", + node.display() + ); + } + } + } + + // After resolving through projections, sort expressions may now + // contain volatile functions (e.g. `random() AS col`). Duplicating + // them would change results. + if resolved_sort_exprs.iter().any(|se| se.expr.is_volatile()) { + return Ok(Transformed::no(plan)); + } + + // Pick the first preserved-side candidate whose schema contains all + // referenced sort columns. For LEFT/RIGHT this is the fixed side; + // for CROSS we try both. + let Some(preserved_side) = preserved_candidates.iter().copied().find(|&side| { + let schema = match side { + Side::Left => join.left.schema(), + Side::Right => join.right.schema(), + }; + let cols = schema_columns(schema); + resolved_sort_exprs + .iter() + .all(|se| has_all_column_refs(&se.expr, &cols)) + }) else { + return Ok(Transformed::no(plan)); + }; + + let preserved_child = match preserved_side { + Side::Left => &join.left, + Side::Right => &join.right, + }; + + // Scan deep inside the preserved child (through SubqueryAlias and + // Projection layers) to find an existing Sort. If found with same + // exprs, tighten its fetch in-place. Otherwise, insert a new Sort + // directly below the join as the preserved child's wrapper. + let mut inner_child = preserved_child.as_ref(); + let mut deep_resolved_exprs = resolved_sort_exprs.clone(); + loop { + match inner_child { + LogicalPlan::SubqueryAlias(sq) => { + deep_resolved_exprs = + resolve_sort_exprs_through_subquery_alias(&deep_resolved_exprs, sq)?; + inner_child = sq.input.as_ref(); + } + LogicalPlan::Projection(proj) => { + deep_resolved_exprs = + resolve_sort_exprs_through_projection(&deep_resolved_exprs, proj)?; + inner_child = proj.input.as_ref(); + } + _ => break, + } + } + + // If the inner child is a Limit (PushDownLimit's own Limit handling + // hasn't merged it with the Sort yet), skip this iteration. + if matches!(inner_child, LogicalPlan::Limit(_)) { + return Ok(Transformed::no(plan)); + } + + // Determine action based on existing inner Sort: + // - Same exprs, tighter fetch → skip (already optimal) + // - Same exprs, larger/no fetch → tighten in-place + // - Different exprs or no Sort → insert new Sort below the join + // + // If `deep_resolved_exprs` became volatile while resolving through + // projections inside the preserved child (e.g. `random() AS col`), + // structural equality with an existing inner Sort is unsound: two + // identical `random()` exprs evaluate to different values. Fall + // back to inserting a new Sort with `resolved_sort_exprs`. + let deep_exprs_volatile = deep_resolved_exprs.iter().any(|se| se.expr.is_volatile()); + let inner_sort = match inner_child { + LogicalPlan::Sort(s) if !deep_exprs_volatile => Some(s), + _ => None, + }; + let new_preserved_child = if let Some(child_sort) = inner_sort { + let same_exprs = sort_exprs_equal(&child_sort.expr, &deep_resolved_exprs); + let child_fetch_tighter = match child_sort.fetch { + Some(child_fetch) => child_fetch <= fetch, + None => false, + }; + if same_exprs && child_fetch_tighter { + return Ok(Transformed::no(plan)); + } + if same_exprs { + rebuild_with_tightened_sort( + preserved_child.as_ref(), + &deep_resolved_exprs, + fetch, + )? + } else { + // Different exprs — insert new Sort above the preserved + // child. If the inner Sort has no fetch, our pushed Sort + // is the only row reduction. If it has a fetch, re-sorting + // a small set is cheap and still reduces join input. + Arc::new(LogicalPlan::Sort(SortPlan { + expr: resolved_sort_exprs, + input: Arc::clone(preserved_child), + fetch: Some(fetch), + })) + } + } else { + Arc::new(LogicalPlan::Sort(SortPlan { + expr: resolved_sort_exprs, + input: Arc::clone(preserved_child), + fetch: Some(fetch), + })) + }; + + let mut new_join = join.clone(); + match preserved_side { + Side::Left => new_join.left = new_preserved_child, + Side::Right => new_join.right = new_preserved_child, + } + + // Rebuild the tree: join → intermediate nodes → top-level sort. + let mut new_sort_input = Arc::new(LogicalPlan::Join(new_join)); + for node in intermediates.into_iter().rev() { + new_sort_input = Arc::new(match node { + LogicalPlan::Projection(proj) => { + let mut new_proj = proj.clone(); + new_proj.input = new_sort_input; + LogicalPlan::Projection(new_proj) + } + LogicalPlan::SubqueryAlias(sq) => LogicalPlan::SubqueryAlias( + SubqueryAlias::try_new(new_sort_input, sq.alias.clone())?, + ), + _ => { + return internal_err!( + "push_topk_through_join: unexpected intermediate node: {}", + node.display() + ); + } + }); + } + + Ok(Transformed::yes(LogicalPlan::Sort(SortPlan { + expr: sort.expr.clone(), + input: new_sort_input, + fetch: sort.fetch, + }))) +} + +/// Replace column references in sort expressions using a name→expr map. +fn replace_columns_in_sort_exprs( + sort_exprs: &[SortExpr], + replace_map: &HashMap<String, Expr>, +) -> Result<Vec<SortExpr>> { + sort_exprs + .iter() + .map(|sort_expr| { + let new_expr = sort_expr.expr.clone().transform(|expr| { + let replacement = match &expr { + Expr::Column(col) => replace_map.get(&col.flat_name()).cloned(), + _ => None, + }; + Ok(replacement.map_or_else(|| Transformed::no(expr), Transformed::yes)) + })?; + Ok(SortExpr { + expr: new_expr.data, + ..*sort_expr + }) + }) + .collect() +} + +/// Resolve sort expressions through a projection by replacing column +/// references with the underlying projection expressions. +fn resolve_sort_exprs_through_projection( + sort_exprs: &[SortExpr], + projection: &Projection, +) -> Result<Vec<SortExpr>> { + let replace_map: HashMap<String, Expr> = projection + .schema + .iter() + .zip(projection.expr.iter()) + .map(|((qualifier, field), expr)| { + let key = Column::from((qualifier, field)).flat_name(); Review Comment: Please key this replacement map by `Column` rather than `Column::flat_name()`. `flat_name()` collapses structurally distinct columns: the unqualified column `(None, "t1.b")` and qualified column `(Some(t1), "b")` both become `"t1.b"`. For example: ```sql SELECT t1.a, t2.y AS "t1.b", t1.b FROM t1 LEFT JOIN t2 ON t1.a = t2.a ORDER BY "t1.b" LIMIT 1; ``` The projection contains two distinct columns that collide in this map. Depending on projection order, the rule can replace the sort key for the alias `t2.y` with the input column `t1.b` and push down the wrong TopK, which can prune the actual winning row. Please use `HashMap<Column, Expr>` with structural lookup and add a regression test containing this quoted-identifier collision. ########## datafusion/optimizer/src/push_down_limit/topk_through_join.rs: ########## @@ -0,0 +1,1185 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +//! Sort(fetch) → Join pushdown — a sub-module of `push_down_limit`. +//! +//! When a `Sort` with a fetch limit (TopK) sits above a join whose +//! preserved side is known (LEFT / RIGHT / LeftMark / RightMark / CROSS) +//! and all sort expressions come from the preserved side, we insert a +//! copy of the `Sort(fetch)` onto that input to reduce rows entering +//! the join. The outer `Sort` is kept because a 1-to-many join can +//! produce more than N output rows from N preserved-side rows. +//! +//! Dispatched from `PushDownLimit::rewrite` when the plan node is +//! `LogicalPlan::Sort` with `fetch.is_some()`. + +use std::collections::HashMap; +use std::sync::Arc; + +use crate::utils::{has_all_column_refs, schema_columns}; + +use datafusion_common::tree_node::{Transformed, TreeNode}; +use datafusion_common::{Column, Result, internal_err}; +use datafusion_expr::logical_plan::{ + JoinType, LogicalPlan, Projection, Sort as SortPlan, SubqueryAlias, +}; +use datafusion_expr::{Expr, SortExpr}; + +/// Which child of a join is being treated as the preserved side. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum Side { + Left, + Right, +} + +/// Top-level pushdown for `Sort(fetch) → ... → Join` patterns. The plan +/// passed in is guaranteed by the caller to be `LogicalPlan::Sort` with +/// `fetch.is_some()`; we re-bind to a borrow inside. +pub(super) fn push_topk_through_join( + plan: LogicalPlan, +) -> Result<Transformed<LogicalPlan>> { + let LogicalPlan::Sort(sort) = &plan else { + return Ok(Transformed::no(plan)); + }; + let Some(fetch) = sort.fetch else { + return Ok(Transformed::no(plan)); + }; + + // Don't push if any sort expression is non-deterministic (e.g. + // `random()`). Duplicating such expressions would produce different + // values at each evaluation point, potentially changing results. + if sort.expr.iter().any(|se| se.expr.is_volatile()) { + return Ok(Transformed::no(plan)); + } + + // Peel through transparent nodes (SubqueryAlias, Projection) to + // find the Join. Track intermediates so we can reconstruct the tree + // and resolve sort expressions through them. + let mut current = sort.input.as_ref(); + let mut intermediates: Vec<&LogicalPlan> = Vec::new(); + let join = loop { + match current { + LogicalPlan::Join(join) => break join, + LogicalPlan::Projection(proj) => { + intermediates.push(current); + current = proj.input.as_ref(); + } + LogicalPlan::SubqueryAlias(sq) => { + intermediates.push(current); + current = sq.input.as_ref(); + } + _ => return Ok(Transformed::no(plan)), + } + }; + + // Determine which side(s) of the join are preserved. + // + // - LEFT / LeftMark: only left preserved. + // - RIGHT / RightMark: symmetric. + // - CROSS JOIN (Inner with no `on` keys and no filter): + // every row from both sides appears in the output (Cartesian + // product), so we can push to whichever side has all the sort + // columns. + // + // For LEFT/RIGHT, non-equijoin filters in the ON clause are safe: + // outer joins guarantee all preserved-side rows appear in the + // output regardless of the filter. For Inner joins (cross-join + // detection), the filter check is strict (`filter.is_none()`) — + // any filter on Inner can drop rows from either side. + let preserved_candidates: &[Side] = match join.join_type { + JoinType::Left | JoinType::LeftMark => &[Side::Left], + JoinType::Right | JoinType::RightMark => &[Side::Right], + JoinType::Inner if join.on.is_empty() && join.filter.is_none() => { Review Comment: We should not apply this CROSS JOIN rewrite unless the opposite input is proven non-empty. The comment that every row from both inputs appears in the output is false when either input is empty. This changes observable behavior for fallible sort expressions. For example, if `l` contains `x = 0` and `r` is empty: ```sql SELECT l.x FROM l CROSS JOIN r ORDER BY 10 / l.x LIMIT 1; ``` The original top-level sort receives no rows and returns an empty result. After this rewrite, `CrossJoinExec` collects and evaluates the left-side sort before discovering that the right side is empty, so the query can fail with division by zero. Please either skip CROSS JOIN here or require proof that the opposite input is non-empty. A regression should cover an empty opposite side and a fallible sort expression. ########## benchmarks/src/push_down_topk.rs: ########## Review Comment: Please remove this duplicate legacy runner and use the existing SQL benchmark suite. Already introduced in #22760 ########## datafusion/sqllogictest/test_files/push_down_topk_through_join.slt: ########## Review Comment: We should update the intro https://github.com/SubhamSinghal/datafusion/blob/c4ff1b4b15b40ddf2e4062258693d224ea28ee77/datafusion/sqllogictest/test_files/push_down_topk_through_join.slt#L18 ########## datafusion/core/src/optimizer_rule_reference.md: ########## @@ -35,33 +35,34 @@ Rule order matters. The default pipeline may change between releases. ### Logical Optimizer Rules -| order | rule | summary | -| ----- | ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | -| 1 | `rewrite_set_comparison` | Rewrites `ANY` and `ALL` set-comparison subqueries into `EXISTS`-based boolean expressions with correct SQL NULL semantics. | -| 2 | `optimize_unions` | Flattens nested unions and removes unions with a single input. | -| 3 | `unions_to_filter` | Merges `UNION DISTINCT` branches that share the same source into a single filtered branch with a disjunctive predicate. | -| 4 | `simplify_expressions` | Constant-folds and simplifies expressions while preserving output names. | -| 5 | `replace_distinct_aggregate` | Rewrites `DISTINCT` and `DISTINCT ON` operators into aggregate-based plans that later rules can optimize further. | -| 6 | `eliminate_join` | Replaces keyless inner joins with a literal `false` filter by an empty relation. | -| 7 | `decorrelate_predicate_subquery` | Converts eligible `IN` and `EXISTS` predicate subqueries into semi or anti joins. | -| 8 | `scalar_subquery_to_join` | Rewrites eligible scalar subqueries into joins and adds schema-preserving projections. | -| 9 | `decorrelate_lateral_join` | Rewrites eligible lateral joins into regular joins. | -| 10 | `extract_equijoin_predicate` | Splits join filters into equijoin keys and residual predicates. | -| 11 | `eliminate_duplicated_expr` | Removes duplicate expressions from projections, aggregates, and similar operators. | -| 12 | `eliminate_filter` | Drops always-true filters and replaces always-false or NULL filters with empty relations. | -| 13 | `eliminate_cross_join` | Uses filter predicates to replace cross joins with inner joins when join keys can be found. | -| 14 | `eliminate_limit` | Removes no-op limits and simplifies trivial limit shapes. | -| 15 | `propagate_empty_relation` | Pushes empty-relation knowledge upward so operators fed by no rows collapse early. | -| 16 | `filter_null_join_keys` | Adds `IS NOT NULL` filters to nullable equijoin keys that can never match. | -| 17 | `eliminate_outer_join` | Rewrites outer joins to inner joins when later filters reject the NULL-extended rows. | -| 18 | `push_down_limit` | Moves literal limits closer to scans and unions and merges adjacent limits. | -| 19 | `push_down_filter` | Moves filters as early as possible through filter-commutative operators. | -| 20 | `single_distinct_aggregation_to_group_by` | Rewrites single-column `DISTINCT` aggregations into two-stage `GROUP BY` plans. | -| 21 | `eliminate_group_by_constant` | Removes constant or functionally redundant expressions from `GROUP BY`. | -| 22 | `common_sub_expression_eliminate` | Computes repeated subexpressions once and reuses the result. | -| 23 | `extract_leaf_expressions` | Pulls cheap leaf expressions closer to data sources so later pruning and filter rules can act earlier. | -| 24 | `push_down_leaf_projections` | Pushes the helper projections created by leaf extraction toward leaf inputs. | -| 25 | `optimize_projections` | Prunes unused columns and removes unnecessary logical projections. | +| order | rule | summary | +| ----------------------------------------------------------------------------------- | ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | +| 1 | `rewrite_set_comparison` | Rewrites `ANY` and `ALL` set-comparison subqueries into `EXISTS`-based boolean expressions with correct SQL NULL semantics. | +| 2 | `optimize_unions` | Flattens nested unions and removes unions with a single input. | +| 3 | `unions_to_filter` | Merges `UNION DISTINCT` branches that share the same source into a single filtered branch with a disjunctive predicate. | +| 4 | `simplify_expressions` | Constant-folds and simplifies expressions while preserving output names. | +| 5 | `replace_distinct_aggregate` | Rewrites `DISTINCT` and `DISTINCT ON` operators into aggregate-based plans that later rules can optimize further. | +| 6 | `eliminate_join` | Replaces keyless inner joins with a literal `false` filter by an empty relation. | +| 7 | `decorrelate_predicate_subquery` | Converts eligible `IN` and `EXISTS` predicate subqueries into semi or anti joins. | +| 8 | `scalar_subquery_to_join` | Rewrites eligible scalar subqueries into joins and adds schema-preserving projections. | +| 9 | `decorrelate_lateral_join` | Rewrites eligible lateral joins into regular joins. | +| 10 | `extract_equijoin_predicate` | Splits join filters into equijoin keys and residual predicates. | +| 11 | `eliminate_duplicated_expr` | Removes duplicate expressions from projections, aggregates, and similar operators. | +| 12 | `eliminate_filter` | Drops always-true filters and replaces always-false or NULL filters with empty relations. | +| 13 | `eliminate_cross_join` | Uses filter predicates to replace cross joins with inner joins when join keys can be found. | +| 14 | `eliminate_limit` | Removes no-op limits and simplifies trivial limit shapes. | +| 15 | `propagate_empty_relation` | Pushes empty-relation knowledge upward so operators fed by no rows collapse early. | +| 16 | `filter_null_join_keys` | Adds `IS NOT NULL` filters to nullable equijoin keys that can never match. | +| 17 | `eliminate_outer_join` | Rewrites outer joins to inner joins when later filters reject the NULL-extended rows. | +| 18 | `push_down_limit` | Moves literal limits closer to scans and unions and merges adjacent limits, and pushes | Review Comment: This description is split into two Markdown table rows. Line 58 becomes a standalone one-cell row, so the generated optimizer-reference table is malformed. Please keep the complete `push_down_limit` description in the summary cell, using `<br>` if a visual line break is needed. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected] --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
