Integrate LIKE/RLIKE LIST with ReplaceStringCasingWithInsensitiveRegexMatch rule

Author: julian-elastic

x-pack/plugin/esql-core/src/main/java/org/elasticsearch/xpack/esql/core/expression/predicate/regex/RegexMatch.java

@@ -15,6 +15,7 @@
 import org.elasticsearch.xpack.esql.core.type.DataType;
 
 import java.util.Objects;
+import java.util.function.Predicate;
 
 import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.ParamOrdinal.DEFAULT;
 import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.isStringAndExact;
@@ -67,6 +68,14 @@ public Boolean fold(FoldContext ctx) {
         throw new UnsupportedOperationException();
     }
 
+    /**
+     * Returns an equivalent optimized expression taking into account the case of the pattern(s)
+     * @param unwrappedField the field with to_upper/to_lower function removed
+     * @param matchesCaseFn a predicate to check if a pattern matches the case
+     * @return an optimized equivalent Expression or this if no optimization is possible
+     */
+    public abstract Expression optimizeStringCasingWithInsensitiveRegexMatch(Expression unwrappedField, Predicate<String> matchesCaseFn);
+
     @Override
     public boolean equals(Object obj) {
         if (super.equals(obj)) {

x-pack/plugin/esql/qa/testFixtures/src/main/resources/where-like.csv-spec

@@ -534,6 +534,60 @@ emp_no:integer | first_name:keyword
 10055          | Georgy    
 ;
 
+likeListWithUpperAllLower
+required_capability: like_with_list_of_patterns
+FROM employees 
+| WHERE TO_UPPER(first_name) LIKE ("geor*", "wei*") 
+| KEEP emp_no, first_name 
+| SORT emp_no;
+
+emp_no:integer | first_name:keyword
+;
+
+likeListWithUpperAllUpper
+required_capability: like_with_list_of_patterns
+FROM employees 
+| WHERE TO_UPPER(first_name) LIKE ("GEOR*", "WEI*")
+| KEEP emp_no, first_name 
+| SORT emp_no;
+
+emp_no:integer | first_name:keyword
+10001          | Georgi
+10040          | Weiyi
+10055          | Georgy
+;
+
+likeListWithUpperMixedCase
+required_capability: like_with_list_of_patterns
+FROM employees 
+| WHERE TO_UPPER(first_name) LIKE ("GeOr*", "wEiY*", "bErNi")
+| KEEP emp_no, first_name 
+| SORT emp_no;
+
+emp_no:integer | first_name:keyword
+;
+
+likeListWithUpperMultiplePatternsMixedCase
+required_capability: like_with_list_of_patterns
+FROM employees 
+| WHERE TO_UPPER(first_name) LIKE ("geor*", "WEIYI*", "bErnI*") 
+| KEEP emp_no, first_name 
+| SORT emp_no;
+
+emp_no:integer | first_name:keyword
+10040          | Weiyi
+;
+
+likeListWithUpperNoMatch
+required_capability: like_with_list_of_patterns
+FROM employees 
+| WHERE TO_UPPER(first_name) LIKE ("notaname*") 
+| KEEP emp_no, first_name 
+| SORT emp_no;
+
+emp_no:integer | first_name:keyword
+;
+
 rlikeListEmptyArgWildcard
 required_capability: rlike_with_list_of_patterns
 FROM employees 

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/string/regex/RLike.java

@@ -11,6 +11,7 @@
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.xpack.esql.core.expression.Expression;
+import org.elasticsearch.xpack.esql.core.expression.Literal;
 import org.elasticsearch.xpack.esql.core.expression.predicate.regex.RLikePattern;
 import org.elasticsearch.xpack.esql.core.querydsl.query.Query;
 import org.elasticsearch.xpack.esql.core.querydsl.query.RegexQuery;
@@ -24,6 +25,7 @@
 import org.elasticsearch.xpack.esql.planner.TranslatorHandler;
 
 import java.io.IOException;
+import java.util.function.Predicate;
 
 public class RLike extends RegexMatch<RLikePattern> {
     public static final NamedWriteableRegistry.Entry ENTRY = new NamedWriteableRegistry.Entry(Expression.class, "RLike", RLike::new);
@@ -108,4 +110,15 @@ public Query asQuery(LucenePushdownPredicates pushdownPredicates, TranslatorHand
         // TODO: see whether escaping is needed
         return new RegexQuery(source(), handler.nameOf(fa.exactAttribute()), pattern().asJavaRegex(), caseInsensitive());
     }
+
+    /**
+     * Pushes down string casing optimization for a single pattern using the provided predicate.
+     * Returns a new RLike with case insensitivity or a Literal.FALSE if not matched.
+     */
+    public Expression optimizeStringCasingWithInsensitiveRegexMatch(Expression unwrappedField, Predicate<String> matchesCaseFn) {
+        if (matchesCaseFn.test(pattern().pattern()) == false) {
+            return Literal.of(this, Boolean.FALSE);
+        }
+        return new RLike(source(), unwrappedField, pattern(), true);
+    }
 }

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/string/regex/RLikeList.java

@@ -17,6 +17,7 @@
 import org.elasticsearch.index.query.SearchExecutionContext;
 import org.elasticsearch.xpack.esql.core.expression.Expression;
 import org.elasticsearch.xpack.esql.core.expression.FieldAttribute;
+import org.elasticsearch.xpack.esql.core.expression.Literal;
 import org.elasticsearch.xpack.esql.core.expression.predicate.regex.RLikePattern;
 import org.elasticsearch.xpack.esql.core.expression.predicate.regex.RLikePatternList;
 import org.elasticsearch.xpack.esql.core.querydsl.query.Query;
@@ -29,6 +30,8 @@
 import org.elasticsearch.xpack.esql.planner.TranslatorHandler;
 
 import java.io.IOException;
+import java.util.List;
+import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
@@ -145,6 +148,22 @@ public org.apache.lucene.search.Query asLuceneQuery(
         );
     }
 
+    /**
+     * Pushes down string casing optimization by filtering patterns using the provided predicate.
+     * Returns a new RegexMatch or a Literal.FALSE if none match.
+     */
+    public Expression optimizeStringCasingWithInsensitiveRegexMatch(Expression unwrappedField, Predicate<String> matchesCaseFn) {
+        List<RLikePattern> filtered = pattern().patternList()
+            .stream()
+            .filter(p -> matchesCaseFn.test(p.pattern()))
+            .collect(Collectors.toList());
+        // none of the patterns matches the case of the field, return false
+        if (filtered.isEmpty()) {
+            return Literal.of(this, Boolean.FALSE);
+        }
+        return new RLikeList(source(), unwrappedField, new RLikePatternList(filtered), true);
+    }
+
     @Override
     protected NodeInfo<? extends Expression> info() {
         return NodeInfo.create(this, RLikeList::new, field(), pattern(), caseInsensitive());

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/string/regex/WildcardLike.java

@@ -12,6 +12,7 @@
 import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.xpack.esql.core.expression.Expression;
 import org.elasticsearch.xpack.esql.core.expression.FieldAttribute;
+import org.elasticsearch.xpack.esql.core.expression.Literal;
 import org.elasticsearch.xpack.esql.core.expression.predicate.regex.WildcardPattern;
 import org.elasticsearch.xpack.esql.core.querydsl.query.Query;
 import org.elasticsearch.xpack.esql.core.querydsl.query.WildcardQuery;
@@ -25,6 +26,7 @@
 import org.elasticsearch.xpack.esql.planner.TranslatorHandler;
 
 import java.io.IOException;
+import java.util.function.Predicate;
 
 public class WildcardLike extends RegexMatch<WildcardPattern> {
     public static final NamedWriteableRegistry.Entry ENTRY = new NamedWriteableRegistry.Entry(
@@ -132,4 +134,15 @@ public Query asQuery(LucenePushdownPredicates pushdownPredicates, TranslatorHand
     private Query translateField(String targetFieldName, boolean forceStringMatch) {
         return new WildcardQuery(source(), targetFieldName, pattern().asLuceneWildcard(), caseInsensitive(), forceStringMatch);
     }
+
+    /**
+     * Pushes down string casing optimization for a single pattern using the provided predicate.
+     * Returns a new WildcardLike with case insensitivity or a Literal.FALSE if not matched.
+     */
+    public Expression optimizeStringCasingWithInsensitiveRegexMatch(Expression unwrappedField, Predicate<String> matchesCaseFn) {
+        if (matchesCaseFn.test(pattern().pattern()) == false) {
+            return Literal.of(this, Boolean.FALSE);
+        }
+        return new WildcardLike(source(), unwrappedField, pattern(), true);
+    }
 }

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/string/regex/WildcardLikeList.java

@@ -18,6 +18,7 @@
 import org.elasticsearch.index.query.SearchExecutionContext;
 import org.elasticsearch.xpack.esql.core.expression.Expression;
 import org.elasticsearch.xpack.esql.core.expression.FieldAttribute;
+import org.elasticsearch.xpack.esql.core.expression.Literal;
 import org.elasticsearch.xpack.esql.core.expression.predicate.regex.WildcardPattern;
 import org.elasticsearch.xpack.esql.core.expression.predicate.regex.WildcardPatternList;
 import org.elasticsearch.xpack.esql.core.querydsl.query.Query;
@@ -31,6 +32,8 @@
 import org.elasticsearch.xpack.esql.planner.TranslatorHandler;
 
 import java.io.IOException;
+import java.util.List;
+import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
@@ -177,4 +180,20 @@ private String getLuceneQueryDescription() {
     private Query translateField(String targetFieldName) {
         return new ExpressionQuery(source(), targetFieldName, this);
     }
+
+    /**
+     * Pushes down string casing optimization by filtering patterns using the provided predicate.
+     * Returns a new RegexMatch or a Literal.FALSE if none match.
+     */
+    public Expression optimizeStringCasingWithInsensitiveRegexMatch(Expression unwrappedField, Predicate<String> matchesCaseFn) {
+        List<WildcardPattern> filtered = pattern().patternList()
+            .stream()
+            .filter(p -> matchesCaseFn.test(p.pattern()))
+            .collect(Collectors.toList());
+        // none of the patterns matches the case of the field, return false
+        if (filtered.isEmpty()) {
+            return Literal.of(this, Boolean.FALSE);
+        }
+        return new WildcardLikeList(source(), unwrappedField, new WildcardPatternList(filtered), true);
+    }
 }

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/optimizer/rules/logical/ReplaceStringCasingWithInsensitiveRegexMatch.java

@@ -8,16 +8,13 @@
 package org.elasticsearch.xpack.esql.optimizer.rules.logical;
 
 import org.elasticsearch.xpack.esql.core.expression.Expression;
-import org.elasticsearch.xpack.esql.core.expression.Literal;
-import org.elasticsearch.xpack.esql.core.expression.predicate.regex.RLikePatternList;
 import org.elasticsearch.xpack.esql.core.expression.predicate.regex.RegexMatch;
 import org.elasticsearch.xpack.esql.core.expression.predicate.regex.StringPattern;
-import org.elasticsearch.xpack.esql.core.expression.predicate.regex.WildcardPatternList;
 import org.elasticsearch.xpack.esql.expression.function.scalar.string.ChangeCase;
-import org.elasticsearch.xpack.esql.expression.function.scalar.string.regex.RLike;
-import org.elasticsearch.xpack.esql.expression.function.scalar.string.regex.WildcardLike;
 import org.elasticsearch.xpack.esql.optimizer.LogicalOptimizerContext;
 
+import java.util.function.Predicate;
+
 import static org.elasticsearch.xpack.esql.optimizer.rules.logical.ReplaceStringCasingWithInsensitiveEquals.unwrapCase;
 
 public class ReplaceStringCasingWithInsensitiveRegexMatch extends OptimizerRules.OptimizerExpressionRule<
@@ -29,29 +26,12 @@ public ReplaceStringCasingWithInsensitiveRegexMatch() {
 
     @Override
     protected Expression rule(RegexMatch<? extends StringPattern> regexMatch, LogicalOptimizerContext unused) {
-        Expression e = regexMatch;
-        if (regexMatch.pattern() instanceof WildcardPatternList || regexMatch.pattern() instanceof RLikePatternList) {
-            // This optimization is not supported for WildcardPatternList and RLikePatternList for now
-            return e;
-        }
         if (regexMatch.field() instanceof ChangeCase changeCase) {
-            var pattern = regexMatch.pattern().pattern();
-            e = changeCase.caseType().matchesCase(pattern) ? insensitiveRegexMatch(regexMatch) : Literal.of(regexMatch, Boolean.FALSE);
+            Predicate<String> matchesCase = changeCase.caseType()::matchesCase;
+            Expression unwrappedField = unwrapCase(regexMatch.field());
+            return regexMatch.optimizeStringCasingWithInsensitiveRegexMatch(unwrappedField, matchesCase);
         }
-        return e;
-    }
-
-    private static Expression insensitiveRegexMatch(RegexMatch<? extends StringPattern> regexMatch) {
-        return switch (regexMatch) {
-            case RLike rlike -> new RLike(rlike.source(), unwrapCase(rlike.field()), rlike.pattern(), true);
-            case WildcardLike wildcardLike -> new WildcardLike(
-                wildcardLike.source(),
-                unwrapCase(wildcardLike.field()),
-                wildcardLike.pattern(),
-                true
-            );
-            default -> regexMatch;
-        };
+        return regexMatch;
     }
 
 }