fix(query): avoid eliminating aggregate union branch (#19987)

Author: KKould

src/query/sql/src/planner/optimizer/optimizers/rule/union_rules/rule_eliminate_union.rs

@@ -55,12 +55,20 @@ impl RuleEliminateUnion {
             return Ok(false);
         }
         if child_num == 0 {
-            Ok(matches!(
+            return Ok(matches!(
                 s_expr.plan(),
                 RelOperator::ConstantTableScan(ConstantTableScan { num_rows: 0, .. })
-            ))
-        } else {
+            ));
+        }
+
+        // Only pass through unary operators that preserve empty input as empty output.
+        if matches!(
+            s_expr.plan().rel_op(),
+            RelOp::Filter | RelOp::EvalScalar | RelOp::Sort | RelOp::Limit | RelOp::Exchange
+        ) {
             Self::is_empty_scan(s_expr.child(0)?)
+        } else {
+            Ok(false)
         }
     }
 }
@@ -122,3 +130,35 @@ impl Rule for RuleEliminateUnion {
         &self.matchers
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeSet;
+
+    use super::*;
+    use crate::plans::Aggregate;
+    use crate::plans::Filter;
+
+    fn empty_scan_expr() -> SExpr {
+        let empty_scan =
+            ConstantTableScan::new_empty_scan(DataSchemaRefExt::create(vec![]), BTreeSet::new());
+        SExpr::create_leaf(Arc::new(RelOperator::ConstantTableScan(empty_scan)))
+    }
+
+    #[test]
+    fn only_empty_preserving_unary_nodes_are_transparent() -> Result<()> {
+        let filter = SExpr::create_unary(
+            Arc::new(RelOperator::Filter(Filter { predicates: vec![] })),
+            Arc::new(empty_scan_expr()),
+        );
+        assert!(RuleEliminateUnion::is_empty_scan(&filter)?);
+
+        let aggregate = SExpr::create_unary(
+            Arc::new(RelOperator::Aggregate(Aggregate::default())),
+            Arc::new(empty_scan_expr()),
+        );
+        assert!(!RuleEliminateUnion::is_empty_scan(&aggregate)?);
+
+        Ok(())
+    }
+}

tests/sqllogictests/suites/query/union.test

@@ -173,6 +173,16 @@ select 1 as c union all select 3.3::Double;
 1.0
 3.3
 
+query I
+SELECT x FROM (
+  SELECT 1 AS x
+  UNION ALL
+  SELECT count(*) AS x FROM (SELECT * FROM numbers(1) WHERE false)
+) ORDER BY x
+----
+0
+1
+
 query I
 with
 t1 as (select number as a from numbers(10)),