fix(query): preserve nullable self-equality filters

Author: youngsofun

src/query/sql/src/planner/optimizer/optimizers/operator/filter/infer_filter.rs

@@ -189,6 +189,12 @@ impl<'a> InferFilterOptimizer<'a> {
     }
 
     pub fn add_equal_expr(&mut self, left: &ScalarExpr, right: &ScalarExpr) -> bool {
+        if left == right {
+            // Under SQL three-valued logic, NULL = NULL is NULL rather than TRUE. Only
+            // absorb a reflexive equality when its operand is guaranteed to be non-null.
+            return !left.data_type().is_nullable_or_null();
+        }
+
         let left_ty = left.data_type();
         let right_ty = right.data_type();
         if !common_super_type_with_conversion(left_ty.as_ref(), right_ty.as_ref())

src/query/sql/test-support/data/results/tpcds/Q01_optimized.txt

@@ -56,7 +56,7 @@ TopN
                 │       │       │                                       │       └── limit: NONE
                 │       │       │                                       └── Scan
                 │       │       │                                           ├── table: default.store_returns (#4)
-                │       │       │                                           ├── filters: []
+                │       │       │                                           ├── filters: [eq(store_returns.sr_store_sk (#103), store_returns.sr_store_sk (#103))]
                 │       │       │                                           ├── order by: []
                 │       │       │                                           └── limit: NONE
                 │       │       └── Scan

src/query/sql/test-support/data/results/tpcds/Q01_physical.txt

@@ -111,7 +111,7 @@ TopN(Final)
             │       │       │                                       ├── read size: 0
             │       │       │                                       ├── partitions total: 0
             │       │       │                                       ├── partitions scanned: 0
-            │       │       │                                       ├── push downs: [filters: [], limit: NONE]
+            │       │       │                                       ├── push downs: [filters: [is_true(store_returns.sr_store_sk (#103) = store_returns.sr_store_sk (#103))], limit: NONE]
             │       │       │                                       ├── apply join filters: [#1]
             │       │       │                                       └── estimated rows: 0.00
             │       │       └── TableScan(Probe)

tests/sqllogictests/suites/query/issues/issue_20379.test

@@ -0,0 +1,28 @@
+# GitHub issue: https://github.com/databendlabs/databend/issues/20379
+# Reflexive equality is not a tautology for nullable operands because NULL = NULL is NULL.
+
+statement ok
+DROP TABLE IF EXISTS issue_20379_reflexive_equality
+
+statement ok
+CREATE TABLE issue_20379_reflexive_equality(c TIMESTAMP NULL)
+
+statement ok
+INSERT INTO issue_20379_reflexive_equality VALUES
+    ('2020-01-01 10:00:00'),
+    ('2020-05-05 08:30:00'),
+    (NULL)
+
+# The all-NULL group must not pass HAVING.
+query I
+SELECT count(*) FROM (
+    SELECT c
+    FROM issue_20379_reflexive_equality
+    GROUP BY c
+    HAVING min(c) = min(c)
+)
+----
+2
+
+statement ok
+DROP TABLE issue_20379_reflexive_equality