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/cases/regressions/20379_non_nullable_reflexive_equality.yaml

@@ -0,0 +1,7 @@
+name: "20379_non_nullable_reflexive_equality"
+description: "Non-nullable reflexive equality should still be eliminated during filter inference"
+
+sql: |
+  SELECT value
+  FROM (VALUES (1), (2)) AS t(value)
+  WHERE value = value;

src/query/sql/test-support/data/results/regressions/20379_non_nullable_reflexive_equality_optimized.txt

@@ -0,0 +1,5 @@
+Exchange(Merge)
+└── ConstantTableScan
+    ├── columns: [value (#0)]
+    └── num_rows: [2]
+

src/query/sql/test-support/data/results/regressions/20379_non_nullable_reflexive_equality_physical.txt

@@ -0,0 +1,7 @@
+Exchange
+├── output columns: [value (#0)]
+├── exchange type: Merge
+└── ConstantTableScan
+    ├── output columns: [value (#0)]
+    └── column 0: [1, 2]
+

src/query/sql/test-support/data/results/regressions/20379_non_nullable_reflexive_equality_raw.txt

@@ -0,0 +1,8 @@
+EvalScalar
+├── scalars: [value (#0) AS (#0)]
+└── Filter
+    ├── filters: [eq(value (#0), value (#0))]
+    └── ConstantTableScan
+        ├── columns: [value (#0)]
+        └── num_rows: [2]
+

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)

src/query/sql/tests/it/planner.rs

@@ -137,6 +137,12 @@ const LITE_REPLAY_CASE_SPECS: &[LiteReplayCaseSpec] = &[
         optimizer_skip_list: &[],
         default_node_num: 1,
     },
+    LiteReplayCaseSpec {
+        name: "20379_non_nullable_reflexive_equality",
+        warehouse_distribution: false,
+        optimizer_skip_list: &[],
+        default_node_num: 1,
+    },
     LiteReplayCaseSpec {
         name: "q17_histogram_join_order",
         warehouse_distribution: true,

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