opt: collapse repeated "%" wildcards in LIKE patterns

mgartner · ADustyOldMuffin · sriram2000na · mgartner · commit 9c297fabbcdc · 2025-11-25T14:56:57.000-05:00
A pattern in a `LIKE` comparison with sequential "%" wildcards is now normalized into a string with at most one sequential wildcard. For example, `c LIKE '%%abc%%%'` is now normalized into `c LIKE '%abc%'`. Fixes #80192 Release note (performance improvement): The optimizer now collapses repeated "%" wildcard characters in LIKE patterns. This may improve performance of queries with theses types of LIKE patterns. Co-authored-by: Daniel Hix <danieljacobhix@gmail.com> Co-authored-by: Sriram <sriraam2000na@gmail.com> Co-authored-by: Marcus Gartner <magartner@gmail.com> Co-authored-by: dils2k <dils.matchanov@gmail.com>
diff --git a/pkg/sql/opt/norm/comp_funcs.go b/pkg/sql/opt/norm/comp_funcs.go
@@ -9,6 +9,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/sql/opt"
 	"github.com/cockroachdb/cockroach/pkg/sql/opt/memo"
 	"github.com/cockroachdb/cockroach/pkg/sql/sem/builtins/builtinsregistry"
+	"github.com/cockroachdb/cockroach/pkg/sql/sem/eval"
 	"github.com/cockroachdb/cockroach/pkg/sql/sem/tree"
 	"github.com/cockroachdb/cockroach/pkg/sql/types"
 	"github.com/cockroachdb/errors"
@@ -141,3 +142,34 @@ func (c *CustomFuncs) MakeIntersectionFunction(args memo.ScalarListExpr) opt.Sca
 		},
 	)
 }
+
+// CollapseRepeatedLikePatternWildcards returns a new pattern string datum with
+// repeated "%" wildcards collapsed. It returns ok=false if the pattern is not a
+// constant string or there are no repeated characters to collapse.
+func (c *CustomFuncs) CollapseRepeatedLikePatternWildcards(
+	pattern opt.ScalarExpr,
+) (_ opt.ScalarExpr, ok bool) {
+	patternConst, ok := pattern.(*memo.ConstExpr)
+	if !ok {
+		return nil, false
+	}
+	switch t := patternConst.Value.(type) {
+	case *tree.DString:
+		orig := string(*t)
+		collapsed := eval.CollapseLikeWildcards(orig)
+		if orig != collapsed {
+			return c.f.ConstructConstVal(tree.NewDString(collapsed), types.String), true
+		}
+	case *tree.DCollatedString:
+		orig := t.Contents
+		collapsed := eval.CollapseLikeWildcards(orig)
+		if orig != collapsed {
+			d, err := tree.NewDCollatedString(collapsed, t.Locale, &c.f.evalCtx.CollationEnv)
+			if err != nil {
+				panic(err)
+			}
+			return c.f.ConstructConstVal(d, patternConst.Typ), true
+		}
+	}
+	return nil, false
+}
diff --git a/pkg/sql/opt/norm/rules/comp.opt b/pkg/sql/opt/norm/rules/comp.opt
@@ -279,3 +279,20 @@ $left
 (Ne $left:* (False))
 =>
 $left
+
+# CollapseLikePatternWildcards collapses repeated '%' wildcards into a single
+# '%' in the pattern of a LIKE expression.
+[CollapseRepeatedLikePatternWildcards, Normalize]
+(Like | NotLike | ILike | NotILike
+    $input:*
+    $pattern:* &
+        (Let
+            (
+                $collapsed
+                $ok
+            ):(CollapseRepeatedLikePatternWildcards $pattern)
+            $ok
+        )
+)
+=>
+((OpName) $input $collapsed)
diff --git a/pkg/sql/opt/norm/testdata/rules/comp b/pkg/sql/opt/norm/testdata/rules/comp
@@ -1085,3 +1085,114 @@ project
  │    └── columns: b:2
  └── projections
       └── b:2 [as="?column?":5, outer=(2)]
+
+# --------------------------------------------------
+# CollapseRepeatedLikePatternWildcards
+# --------------------------------------------------
+
+norm expect=CollapseRepeatedLikePatternWildcards
+SELECT
+    s LIKE '%%%ab%%%',
+    s LIKE '%%%abc%%%def%%%',
+    s LIKE '%%%abc%%%def%%%ghi',
+    s LIKE '\\%%%abc\\%%%def\\%%%ghi',
+    s LIKE '%%%🐛🐛%%🏠%%%',
+    s NOT LIKE '%%%ab%%%',
+    s ILIKE '%%%ab%%%',
+    s NOT ILIKE '%%%ab%%%'
+FROM a
+----
+project
+ ├── columns: "?column?":12 "?column?":13 "?column?":14 "?column?":15 "?column?":16 "?column?":17 "?column?":18 "?column?":19
+ ├── scan a
+ │    └── columns: s:4
+ └── projections
+      ├── s:4 LIKE '%ab%' [as="?column?":12, outer=(4)]
+      ├── s:4 LIKE '%abc%def%' [as="?column?":13, outer=(4)]
+      ├── s:4 LIKE '%abc%def%ghi' [as="?column?":14, outer=(4)]
+      ├── s:4 LIKE e'\\\\%abc\\\\%def\\\\%ghi' [as="?column?":15, outer=(4)]
+      ├── s:4 LIKE e'%\U0001F41B\U0001F41B%\U0001F3E0%' [as="?column?":16, outer=(4)]
+      ├── s:4 NOT LIKE '%ab%' [as="?column?":17, outer=(4)]
+      ├── s:4 ILIKE '%ab%' [as="?column?":18, outer=(4)]
+      └── s:4 NOT ILIKE '%ab%' [as="?column?":19, outer=(4)]
+
+# Collated strings can be collapsed.
+norm expect=CollapseRepeatedLikePatternWildcards
+SELECT
+    s COLLATE "en_US" LIKE '%%%ab%%%' COLLATE "en_US",
+    s COLLATE "en_US" LIKE '%%%abc%%%def%%%' COLLATE "en_US",
+    s COLLATE "en_US" LIKE '%%%abc%%%def%%%ghi' COLLATE "en_US",
+    s COLLATE "en_US" LIKE '\\%%%abc\\%%%def\\%%%ghi' COLLATE "en_US",
+    s COLLATE "en_US" LIKE '%%%🐛🐛%%🏠%%%' COLLATE "en_US",
+    s COLLATE "en_US" NOT LIKE '%%%ab%%%' COLLATE "en_US"
+FROM a
+----
+project
+ ├── columns: "?column?":12 "?column?":13 "?column?":14 "?column?":15 "?column?":16 "?column?":17
+ ├── immutable
+ ├── scan a
+ │    └── columns: s:4
+ └── projections
+      ├── s:4 COLLATE en_US LIKE '%ab%' COLLATE en_US [as="?column?":12, outer=(4), immutable]
+      ├── s:4 COLLATE en_US LIKE '%abc%def%' COLLATE en_US [as="?column?":13, outer=(4), immutable]
+      ├── s:4 COLLATE en_US LIKE '%abc%def%ghi' COLLATE en_US [as="?column?":14, outer=(4), immutable]
+      ├── s:4 COLLATE en_US LIKE e'\\\\%abc\\\\%def\\\\%ghi' COLLATE en_US [as="?column?":15, outer=(4), immutable]
+      ├── s:4 COLLATE en_US LIKE e'%\U0001F41B\U0001F41B%\U0001F3E0%' COLLATE en_US [as="?column?":16, outer=(4), immutable]
+      └── s:4 COLLATE en_US NOT LIKE '%ab%' COLLATE en_US [as="?column?":17, outer=(4), immutable]
+
+# Escaped wildcards should not be collapsed.
+norm expect-not=CollapseRepeatedLikePatternWildcards
+SELECT
+    s LIKE '\%%ab\%%',
+    s LIKE '\%%abc\%%def\%%',
+    s LIKE '%\%abc%\%def%\%',
+    s LIKE '-%%' ESCAPE '-'
+FROM a
+----
+project
+ ├── columns: "?column?":12 "?column?":13 "?column?":14 like_escape:15
+ ├── immutable
+ ├── scan a
+ │    └── columns: s:4
+ └── projections
+      ├── s:4 LIKE e'\\%%ab\\%%' [as="?column?":12, outer=(4)]
+      ├── s:4 LIKE e'\\%%abc\\%%def\\%%' [as="?column?":13, outer=(4)]
+      ├── s:4 LIKE e'%\\%abc%\\%def%\\%' [as="?column?":14, outer=(4)]
+      └── like_escape(s:4, '-%%', '-') [as=like_escape:15, outer=(4), immutable]
+
+# The rule should not fire when there are no repeated wildcards.
+norm expect-not=CollapseRepeatedLikePatternWildcards
+SELECT
+    s LIKE 'ab',
+    s LIKE '%ab%',
+    s LIKE '%a%b%'
+FROM a
+----
+project
+ ├── columns: "?column?":12 "?column?":13 "?column?":14
+ ├── scan a
+ │    └── columns: s:4
+ └── projections
+      ├── s:4 LIKE 'ab' [as="?column?":12, outer=(4)]
+      ├── s:4 LIKE '%ab%' [as="?column?":13, outer=(4)]
+      └── s:4 LIKE '%a%b%' [as="?column?":14, outer=(4)]
+
+norm expect-not=CollapseRepeatedLikePatternWildcards
+SELECT s LIKE NULL FROM a
+----
+project
+ ├── columns: "?column?":12
+ ├── fd: ()-->(12)
+ ├── scan a
+ └── projections
+      └── NULL [as="?column?":12]
+
+norm expect-not=CollapseRepeatedLikePatternWildcards
+SELECT s LIKE s FROM a
+----
+project
+ ├── columns: "?column?":12
+ ├── scan a
+ │    └── columns: s:4
+ └── projections
+      └── s:4 LIKE s:4 [as="?column?":12, outer=(4)]
diff --git a/pkg/sql/sem/eval/match.go b/pkg/sql/sem/eval/match.go
@@ -78,6 +78,89 @@ func ConvertLikeToRegexp(
 	return re, nil
 }
 
+// CollapseLikeWildcards collapses repeated "%" wildcards in the given pattern
+// string, returning the collapsed string. Wildcards escaped with a backslash
+// "\" are not collapsed.
+func CollapseLikeWildcards(pattern string) string {
+	// NOTE: It is safe to iterate byte-wise forward and backward because no
+	// multibyte UTF-8 characters contain ASCII bytes.
+
+	// Trim leading and trailing repeated "%" wildcards first.
+	start := 0
+	for start < len(pattern) && pattern[start] == '%' {
+		start++
+	}
+	if start > 1 {
+		pattern = pattern[start-1:]
+	}
+
+	end := len(pattern)
+	for end > 0 && pattern[end-1] == '%' {
+		end--
+	}
+	// An odd number of preceding backslashes means that the first "%" is
+	// escaped.
+	escapeCount := 0
+	for i := end - 1; i >= 0 && pattern[i] == '\\'; i-- {
+		escapeCount++
+	}
+	if escaped := escapeCount&1 == 1; escaped {
+		end++
+	}
+	if end < len(pattern) {
+		pattern = pattern[:end+1]
+	}
+
+	// Next, we successively find sections without repeated "%" and copy them
+	// into sb. start and end form the bounds of the current section, with end
+	// being exclusive.
+	var sb strings.Builder
+	start = 0
+	end = 0
+	if end < len(pattern) && pattern[end] == '%' {
+		// Skip over the first character if it matches "%".
+		end = 1
+	}
+	for start < len(pattern) {
+		// Advance end to the next unescaped '%'.
+		escaped := false
+		for end < len(pattern) && (pattern[end] != '%' || escaped) {
+			escaped = pattern[end] == '\\' && !escaped
+			end++
+		}
+
+		// Increment end to include the "%" wildcard at the end of the section,
+		// if there is one.
+		if end < len(pattern) {
+			end++
+		}
+
+		// If the entire pattern, after trimming the prefix and suffix, is
+		// without duplicate '%', return it as-is.
+		if end == len(pattern) && start == 0 {
+			return pattern
+		}
+
+		if sb.Cap() == 0 {
+			sb.Grow(len(pattern))
+		}
+		sb.WriteString(pattern[start:end])
+
+		// Find the start of the next section, skipping over duplicate "%"
+		// wildcards.
+		start = end
+		for start < len(pattern) {
+			if pattern[start] != '%' {
+				break
+			}
+			start++
+		}
+		end = start
+	}
+
+	return sb.String()
+}
+
 func matchLike(ctx *Context, left, right tree.Datum, caseInsensitive bool) (tree.Datum, error) {
 	if left == tree.DNull || right == tree.DNull {
 		return tree.DNull, nil
diff --git a/pkg/sql/sem/eval/match_test.go b/pkg/sql/sem/eval/match_test.go
@@ -10,6 +10,62 @@ import (
 	"testing"
 )
 
+func TestCollapseLikeWildcards(t *testing.T) {
+	for _, tc := range []struct {
+		pattern, expected string
+	}{
+		{"", ""},
+		{"a", "a"},
+		{"abc", "abc"},
+		{"%", "%"},
+		{"%%", "%"},
+		{"%%%%%%%%%", "%"},
+		{"%%a", "%a"},
+		{"%%abc", "%abc"},
+		{"a%%", "a%"},
+		{"abc%%", "abc%"},
+		{"%%%a%%%", "%a%"},
+		{"%%%abc%%%", "%abc%"},
+		{"a%%%b", "a%b"},
+		{"%%a%%%b%%", "%a%b%"},
+		{"%%%🐛🐛%%🏠%%%", "%🐛🐛%🏠%"},
+		{"\\%%", "\\%%"},
+		{"\\%\\%", "\\%\\%"},
+		{"\\%%\\%%", "\\%%\\%%"},
+		{"\\%%%\\%%%", "\\%%\\%%"},
+		{"\\\\%%", "\\\\%"},
+		{"\\\\\\%%", "\\\\\\%%"},
+		{"abc\\\\\\%%", "abc\\\\\\%%"},
+		{"\\\\\\%%abc", "\\\\\\%%abc"},
+		{"a\\%%%%b", "a\\%%b"},
+		{"a\\%%%\\\\%%%b", "a\\%%\\\\%b"},
+		{"a\\\\\\%%\\\\\\\\%%%b", "a\\\\\\%%\\\\\\\\%b"},
+		{"\\%%%abc%%\\%", "\\%%abc%\\%"},
+		{"%%\\%a%\\%%b\\%%%", "%\\%a%\\%%b\\%%"},
+		{"\\\\%%%a%%\\\\%%b\\\\%%%", "\\\\%a%\\\\%b\\\\%"},
+		{"%%\\%🐛🐛\\\\%%🏠\\%\\\\%%", "%\\%🐛🐛\\\\%🏠\\%\\\\%"},
+	} {
+		if res := CollapseLikeWildcards(tc.pattern); res != tc.expected {
+			t.Errorf("expected %q to collapse to %q, got %q", tc.pattern, tc.expected, res)
+		}
+	}
+}
+
+func BenchmarkCollapseLikeWildcards(b *testing.B) {
+	for _, pattern := range []string{
+		"somepatternwithoutwildcards",
+		"%%%%%apatternwithbeginningandtrailingwildcards%%%%%",
+		"%%%%%pattern%%%with%%%morewildcards%%%%%",
+		"%%%%%🐛🐛🐛🐛🐛%%%%%🏠🏠🏠🏠🏠🏠%%%%%",
+	} {
+		b.Run(pattern, func(b *testing.B) {
+			for b.Loop() {
+				_ = CollapseLikeWildcards(pattern)
+			}
+		})
+	}
+}
+
 // TestOptimizedLike checks that for certain patterns we are using optimized
 // evaluation of LIKE and ILIKE rather than regex-powered evaluation.
 func TestOptimizedLike(t *testing.T) {
