opt: normalize LIKE ... ESCAPE

An expression in the form `a LIKE b ESCAPE '/'`, which is parsed as
`like_escape(a, b, '/')`, is now normalized to `a LIKE b`. This is valid
because `\` is the default escape character, so the expressions are
equivalent.

This normalization allows for further optimization, for example:

```sql
CREATE TABLE t (s STRING, INDEX (s));

EXPLAIN SELECT s FROM t WHERE s LIKE 'foo\_bar' ESCAPE '\';
-- BEFORE:
--  • filter
--  │ filter: like_escape(s, e'foo\\_bar', e'\\')
--  │
--  └── • scan
--        table: t@t_pkey
--        spans: FULL SCAN

-- AFTER:
--   • scan
--     table: t@t_s_idx
--     spans: [/'foo_bar' - /'foo_bar']
```

Informs #30192

Release note (performance improvement): Queries with filters in the form
`a LIKE b ESCAPE '\'` are now index-accelerated in some cases which they
were not before.

Author: mgartner

pkg/sql/opt/norm/rules/scalar.opt

@@ -452,3 +452,21 @@ $udf
 (Indirection $input:* $index:* & (IsJSON $input))
 =>
 (FetchVal $input $index)
+
+# ConvertLikeEscapeToLike converts a LIKE x ESCAPE '\' expression, which is
+# parsed as a like_escape function call, to a LIKE expression. This is valid
+# because the default escape character is '\'.
+#
+# Note that the FunctionExpr match pattern is enough to ensure that we are not
+# transforming a UDF because UDF invocations are always built as UDFCallExprs.
+[ConvertLikeEscapeToLike, Normalize]
+(Function
+    $args:*
+    $private:(FunctionPrivate "like_escape") &
+        (Let ($input $iOk):(ScalarExprAt $args 0) $iOk) &
+        (Let ($pattern $pOk):(ScalarExprAt $args 1) $pOk) &
+        (Let ($escape $eOk):(ScalarExprAt $args 2) $eOk) &
+        (ConstStringEquals $escape "\\")
+)
+=>
+(Like $input $pattern)

pkg/sql/opt/norm/testdata/rules/scalar

@@ -2689,3 +2689,60 @@ project
  └── projections
       ├── b.arr:5[1] [as=arr:8, outer=(5)]
       └── b.arr:5[2] [as=arr:9, outer=(5)]
+
+# --------------------------------------------------
+# ConvertLikeEscapeToLike
+# --------------------------------------------------
+
+norm expect=ConvertLikeEscapeToLike
+SELECT s LIKE 'foo%' ESCAPE '\' FROM a
+----
+project
+ ├── columns: like_escape:8
+ ├── scan a
+ │    └── columns: s:4
+ └── projections
+      └── s:4 LIKE 'foo%' [as=like_escape:8, outer=(4)]
+
+norm expect=ConvertLikeEscapeToLike
+SELECT like_escape(s, 'foo%', '\') FROM a
+----
+project
+ ├── columns: like_escape:8
+ ├── scan a
+ │    └── columns: s:4
+ └── projections
+      └── s:4 LIKE 'foo%' [as=like_escape:8, outer=(4)]
+
+norm expect-not=ConvertLikeEscapeToLike
+SELECT s LIKE 'foo%' ESCAPE '/' FROM a
+----
+project
+ ├── columns: like_escape:8
+ ├── immutable
+ ├── scan a
+ │    └── columns: s:4
+ └── projections
+      └── like_escape(s:4, 'foo%', '/') [as=like_escape:8, outer=(4), immutable]
+
+norm expect-not=ConvertLikeEscapeToLike
+SELECT s LIKE 'foo%' ESCAPE 'f' FROM a
+----
+project
+ ├── columns: like_escape:8
+ ├── immutable
+ ├── scan a
+ │    └── columns: s:4
+ └── projections
+      └── like_escape(s:4, 'foo%', 'f') [as=like_escape:8, outer=(4), immutable]
+
+norm expect-not=ConvertLikeEscapeToLike
+SELECT not_like_escape(s, 'foo%', '\') FROM a
+----
+project
+ ├── columns: not_like_escape:8
+ ├── immutable
+ ├── scan a
+ │    └── columns: s:4
+ └── projections
+      └── not_like_escape(s:4, 'foo%', e'\\') [as=not_like_escape:8, outer=(4), immutable]