colexec: IsDistinctFrom optimization is not used in "self-equality" case

[jordanlewis]

In the following example, I would expect that the vectorized engine would plan the isNullProjOp to execute the optimizer's IS DISTINCT FROM operator. But, we instead plan a defaultCmpProjOp.

[email protected]:26257/defaultdb> create table a (a int);
CREATE TABLE
[email protected]:26257/defaultdb> explain(vec) select a = a from a;
                 info
---------------------------------------
  │
  └ Node 1
    └ *colexec.orProjOp
      ├ *colfetcher.ColBatchScan
      ├ *colexecproj.defaultCmpProjOp
      │ └ *colexecbase.castOpNullAny
      │   └ *colexecbase.constNullOp
      └ *colexecbase.castOpNullAny
        └ *colexecbase.constNullOp
(9 rows)

Time: 1ms total (execution 0ms / network 0ms)

[email protected]:26257/defaultdb> explain(opt) select a = a from a;
                                   info
---------------------------------------------------------------------------
  project
   ├── scan a
   └── projections
        └── (a IS DISTINCT FROM CAST(NULL AS INT8)) OR CAST(NULL AS BOOL)
(4 rows)

Time: 0ms total (execution 0ms / network 0ms)

[email protected]:26257/defaultdb>

The reason for this issue is that vectorized only permits the optimization for IS DISTINCT FROM when the right argument is a constant tree.DNull, but the optimizer hands down a Cast(tree.DNull, <type>). However, the following simplistic patch does not correct the problem because this code path is only used when the right side is a constant tree.Datum.

I'm not sure the most elegant way to correct this problem so I'm filing for discussion. @yuzefovich what do you think? This isn't too high priority but I'm curious.

git diff pkg/sql/colexec/colbuilder/execplan.go
diff --git a/pkg/sql/colexec/colbuilder/execplan.go b/pkg/sql/colexec/colbuilder/execplan.go
index 8b0e20cbc7..52434e04c7 100644
--- a/pkg/sql/colexec/colbuilder/execplan.go
+++ b/pkg/sql/colexec/colbuilder/execplan.go
@@ -2188,10 +2188,16 @@ func planProjectionExpr(
                                        allocator, typs[leftIdx], input, leftIdx, resultIdx, datumTuple, negate,
                                )
                        case tree.IsDistinctFrom, tree.IsNotDistinctFrom:
-                               if right != tree.DNull {
-                                       // Optimized IsDistinctFrom and IsNotDistinctFrom are
-                                       // supported only with NULL argument, so we fallback to the
-                                       // default comparison operator.
+                               // We support an optimized IsDistinctFrom and IsNotDistinctFrom when
+                               // the argument is NULL or the argument is CAST(NULL, anytype).
+                               if right == tree.DNull {
+                                       // Fall through.
+                               } else if cast, ok := right.(*tree.CastExpr); ok {
+                                       if cast.Expr != tree.DNull {
+                                               break
+                                       }
+                                       // Fall through.
+                               } else {
                                        break
                                }
                                // IS NULL is replaced with IS NOT DISTINCT FROM NULL, so we