fix: correct nullability of AND/OR expressions to resolve plan mismatch in CSE

Fixes #25978

The CommonSubexprEliminate optimizer rewrites CASE WHEN x IS NOT NULL
THEN x ELSE false END into x IS NOT NULL AND x. The default nullable
analysis for AND reports true (because x is nullable), even though the
expression is semantically guaranteed non-nullable.

This commit adds recursive IS NOT NULL / IS NULL guard detection in
Expr::nullable() for AND and OR operators, and includes an SLT
regression test.

Author: siddubakka

datafusion/expr/src/expr_schema.rs

@@ -435,6 +435,28 @@ impl ExprSchemable for Expr {
             Expr::ScalarSubquery(subquery) => Ok(scalar_subquery_nullable(subquery)),
             Expr::BinaryExpr(BinaryExpr { left, right, op }) => match op {
                 Operator::IsDistinctFrom | Operator::IsNotDistinctFrom => Ok(false),
+                Operator::And => {
+                    // Detect pattern: `x IS NOT NULL AND x` (or nested via AND chains).
+                    // If IS NOT NULL guard is present for the other operand,
+                    // the AND expression is guaranteed non-nullable.
+                    if contains_is_not_null(left.as_ref(), right.as_ref())
+                        || contains_is_not_null(right.as_ref(), left.as_ref())
+                    {
+                        return Ok(false);
+                    }
+                    Ok(left.nullable(input_schema)? || right.nullable(input_schema)?)
+                }
+                Operator::Or => {
+                    // Detect pattern: `x IS NULL OR x` (or nested via OR chains).
+                    // If IS NULL guard is present for the other operand,
+                    // the OR expression is guaranteed non-nullable.
+                    if contains_is_null(left.as_ref(), right.as_ref())
+                        || contains_is_null(right.as_ref(), left.as_ref())
+                    {
+                        return Ok(false);
+                    }
+                    Ok(left.nullable(input_schema)? || right.nullable(input_schema)?)
+                }
                 _ => Ok(left.nullable(input_schema)? || right.nullable(input_schema)?),
             },
             Expr::Like(Like { expr, pattern, .. })
@@ -1623,3 +1645,31 @@ mod tests {
         }
     }
 }
+
+/// Returns true if `expr` contains an `IS NOT NULL(target)` check,
+/// recursively searching through nested AND expressions.
+/// Used by `Expr::nullable()` to detect patterns like `x IS NOT NULL AND x`
+/// where the AND result is guaranteed non-nullable.
+fn contains_is_not_null(expr: &Expr, target: &Expr) -> bool {
+    if let Expr::IsNotNull(inner) = expr {
+        return inner.as_ref() == target;
+    }
+    if let Expr::BinaryExpr(BinaryExpr { left, right, op: Operator::And }) = expr {
+        return contains_is_not_null(left, target) || contains_is_not_null(right, target);
+    }
+    false
+}
+
+/// Returns true if `expr` contains an `IS NULL(target)` check,
+/// recursively searching through nested OR expressions.
+/// Used by `Expr::nullable()` to detect patterns like `x IS NULL OR x`
+/// where the OR result is guaranteed non-nullable.
+fn contains_is_null(expr: &Expr, target: &Expr) -> bool {
+    if let Expr::IsNull(inner) = expr {
+        return inner.as_ref() == target;
+    }
+    if let Expr::BinaryExpr(BinaryExpr { left, right, op: Operator::Or }) = expr {
+        return contains_is_null(left, target) || contains_is_null(right, target);
+    }
+    false
+}

datafusion/sqllogictest/test_files/issue_25978.slt

@@ -0,0 +1,48 @@
+# 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.
+
+##########
+# Regression test for https://github.com/apache/datafusion/issues/25978
+# A GROUP BY aggregate over a UNION ALL fails to plan when one branch
+# projects coalesce(<nullable boolean expression>, FALSE).
+# The CSE optimizer rewrites this into an AND/OR pattern whose
+# nullability was incorrectly reported, causing a physical vs logical
+# schema mismatch.
+##########
+
+statement ok
+CREATE TABLE t(v INT, f BOOLEAN) AS VALUES (1, true), (2, NULL), (3, false);
+
+# This query previously failed with:
+#   Internal error: Physical input schema should be the same as the one
+#   converted from logical input schema. Differences:
+#     - field nullability at index 1 [f]: (physical) true vs (logical) false.
+query IB rowsort
+SELECT v, coalesce(f, false)
+FROM (
+    SELECT v, f FROM t
+    UNION ALL
+    SELECT v, f FROM t
+)
+GROUP BY v, coalesce(f, false)
+----
+1 true
+2 false
+3 false
+
+statement ok
+DROP TABLE t;