norm: rule to simplify const comparison with ANY values

Given a constant value compared using the ANY or
SOME operators, we check for constants
in the right hand side that can be used to
simplify the comparison to True. For example,
the expression: 0.1 < ANY (c0, 0.4) can now be simplified since 0.1 < 0.4.

Fixes #132328
Release note: None
Epic: CRDB-42979

Author: dils2k

pkg/sql/opt/norm/fold_constants_funcs.go

@@ -193,6 +193,45 @@ func (c *CustomFuncs) IsConstValueOrGroupOfConstValues(input opt.ScalarExpr) boo
 	return memo.CanExtractConstDatum(input)
 }
 
+// FoldComparisonWithAny evaluates a comparison expression over a constant on
+// the left-hand side and an ANY/SOME clause on the right-hand side.
+// It returns a constant expression if it finds elements in the clause
+// that make the comparison a definite value, and the evaluation causes
+// no error. Otherwise, it returns ok=false.
+func (c *CustomFuncs) FoldComparisonWithAny(
+	cmp opt.Operator, left, right opt.ScalarExpr,
+) (_ opt.ScalarExpr, ok bool) {
+	rightTuple := right.(*memo.TupleExpr)
+	allConst := true
+	hasNull := false
+	for _, expr := range rightTuple.Elems {
+		if !c.IsConstValueOrGroupOfConstValues(expr) {
+			allConst = false
+			continue
+		}
+		folded, ok := c.FoldComparison(cmp, left, expr)
+		if !ok {
+			continue
+		}
+		if _, ok := folded.(*memo.TrueExpr); ok {
+			return folded, true
+		}
+		if _, ok := folded.(*memo.NullExpr); ok {
+			hasNull = true
+		}
+	}
+	if allConst {
+		// In case every element in right tuple is a constant but none of them
+		// made the comparison return TrueExpr, we can safely fold
+		// expression to either FalseExpr or NullExpr.
+		if hasNull {
+			return c.f.ConstructNull(types.Bool), true
+		}
+		return c.f.ConstructFalse(), true
+	}
+	return nil, false
+}
+
 // IsNeverNull returns true if the input is a non-null constant value,
 // any tuple, or any array.
 func (c *CustomFuncs) IsNeverNull(input opt.ScalarExpr) bool {

pkg/sql/opt/norm/rules/fold_constants.opt

@@ -101,6 +101,27 @@ $result
 =>
 $result
 
+# FoldComparisonWithAny evaluates a comparison operation over a constant
+# and an ANY/SOME clause, replacing the entire expression with a constant.
+# It iterates over elements in the clause and tries to find constants that
+# make the comparison a definite value.
+[FoldComparisonWithAny, Normalize]
+(AnyScalar
+    $left:* & (IsConstValueOrGroupOfConstValues $left)
+    $right:* & (IsTuple $right)
+    $cmp:* &
+        (Let
+            ($result $ok):(FoldComparisonWithAny
+                $cmp
+                $left
+                $right
+            )
+            $ok
+        )
+)
+=>
+$result
+
 # FoldComparison is similar to FoldBinary, but it involves a comparison
 # operation. As with FoldBinary, FoldComparison applies as long as the
 # evaluation would not cause an error.

pkg/sql/opt/norm/testdata/rules/fold_constants

@@ -788,6 +788,132 @@ values
  ├── fd: ()-->(1)
  └── (false,)
 
+# --------------------------------------------------
+# FoldComparisonWithAny
+# --------------------------------------------------
+norm expect=FoldComparisonWithAny
+SELECT 1 >= any(1, (select x from t limit 1))
+----
+values
+ ├── columns: "?column?":4!null
+ ├── cardinality: [1 - 1]
+ ├── key: ()
+ ├── fd: ()-->(4)
+ └── (true,)
+
+norm expect=FoldComparisonWithAny
+SELECT 5 > any(8, 9, 10, 11)
+----
+values
+ ├── columns: "?column?":1!null
+ ├── cardinality: [1 - 1]
+ ├── key: ()
+ ├── fd: ()-->(1)
+ └── (false,)
+
+norm expect=FoldComparisonWithAny
+SELECT 1 <= any(1, 2, 3, (select x from t limit 1))
+----
+values
+ ├── columns: "?column?":4!null
+ ├── cardinality: [1 - 1]
+ ├── key: ()
+ ├── fd: ()-->(4)
+ └── (true,)
+
+norm expect=FoldComparisonWithAny
+SELECT 10 < any(1, 2, 3, 4)
+----
+values
+ ├── columns: "?column?":1!null
+ ├── cardinality: [1 - 1]
+ ├── key: ()
+ ├── fd: ()-->(1)
+ └── (false,)
+
+norm expect=FoldComparisonWithAny
+SELECT 10 < any(1, 2, NULL, 4)
+----
+values
+ ├── columns: "?column?":1
+ ├── cardinality: [1 - 1]
+ ├── key: ()
+ ├── fd: ()-->(1)
+ └── (NULL,)
+
+norm expect=FoldComparisonWithAny
+SELECT 10 > any(1, 2, NULL, 4)
+----
+values
+ ├── columns: "?column?":1!null
+ ├── cardinality: [1 - 1]
+ ├── key: ()
+ ├── fd: ()-->(1)
+ └── (true,)
+
+norm expect=FoldComparisonWithAny
+SELECT 10 > any(1, 2, NULL, (select x from t limit 1))
+----
+values
+ ├── columns: "?column?":4!null
+ ├── cardinality: [1 - 1]
+ ├── key: ()
+ ├── fd: ()-->(4)
+ └── (true,)
+
+norm expect=FoldComparisonWithAny
+SELECT 'cockroaches' LIKE any('%bugs%', '%roaches%')
+----
+values
+ ├── columns: "?column?":1!null
+ ├── cardinality: [1 - 1]
+ ├── key: ()
+ ├── fd: ()-->(1)
+ └── (true,)
+
+norm expect=FoldComparisonWithAny
+SELECT 'cockroaches' LIKE any('%bugs%', '%birds%')
+----
+values
+ ├── columns: "?column?":1!null
+ ├── cardinality: [1 - 1]
+ ├── key: ()
+ ├── fd: ()-->(1)
+ └── (false,)
+
+norm expect-not=FoldComparisonWithAny
+SELECT 1 > any(5, 4, random()+1)
+----
+values
+ ├── columns: "?column?":1
+ ├── cardinality: [1 - 1]
+ ├── volatile
+ ├── key: ()
+ ├── fd: ()-->(1)
+ └── (1 > ANY (5, 4, random() + 1.0),)
+
+norm expect-not=FoldComparisonWithAny
+SELECT 1 > any(5, NULL, random()+1)
+----
+values
+ ├── columns: "?column?":1
+ ├── cardinality: [1 - 1]
+ ├── volatile
+ ├── key: ()
+ ├── fd: ()-->(1)
+ └── (1 > ANY (5, NULL, random() + 1.0),)
+
+norm expect-not=FoldComparisonWithAny
+SELECT 1 > any(NULL, random()+1)
+----
+values
+ ├── columns: "?column?":1
+ ├── cardinality: [1 - 1]
+ ├── volatile
+ ├── key: ()
+ ├── fd: ()-->(1)
+ └── (1 > ANY (NULL, random() + 1.0),)
+
 # --------------------------------------------------
 # FoldCast
 # --------------------------------------------------