SQL: Fix issue with LIKE/RLIKE as painless script (#53495)

Add missing asScript() implementation for LIKE/RLIKE expressions.

When LIKE/RLIKE are used for example in GROUP BY or are wrapped with
scalar functions in a WHERE clause, the translation must produce a
painless script which will be executed to implement the correct
behaviour and previously this was completely missing, and as a
consquence wrong results were silently (no error) returned.

Fixes: #53486
(cherry picked from commit eaa8ead)

x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/predicate/regex/Like.java

@@ -6,8 +6,6 @@
 package org.elasticsearch.xpack.sql.expression.predicate.regex;
 
 import org.elasticsearch.xpack.sql.expression.Expression;
-import org.elasticsearch.xpack.sql.expression.gen.processor.Processor;
-import org.elasticsearch.xpack.sql.expression.predicate.regex.RegexProcessor.RegexOperation;
 import org.elasticsearch.xpack.sql.tree.NodeInfo;
 import org.elasticsearch.xpack.sql.tree.Source;
 
@@ -26,15 +24,4 @@ protected NodeInfo<Like> info() {
     protected Like replaceChild(Expression newLeft) {
         return new Like(source(), newLeft, pattern());
     }
-
-    @Override
-    public Boolean fold() {
-        Object val = field().fold();
-        return RegexOperation.match(val, pattern().asJavaRegex());
-    }
-
-    @Override
-    protected Processor makeProcessor() {
-        return new RegexProcessor(pattern().asJavaRegex());
-    }
 }

x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/predicate/regex/LikePattern.java

@@ -17,7 +17,7 @@
  *
  * To prevent conflicts with ES, the string and char must be validated to not contain '*'.
  */
-public class LikePattern {
+public class LikePattern implements StringPattern {
 
     private final String pattern;
     private final char escape;
@@ -43,9 +43,7 @@ public char escape() {
         return escape;
     }
 
-    /**
-     * Returns the pattern in (Java) regex format.
-     */
+    @Override
     public String asJavaRegex() {
         return regex;
     }
@@ -83,4 +81,4 @@ public boolean equals(Object obj) {
         return Objects.equals(pattern, other.pattern)
                 && escape == other.escape;
     }
-}
+}

x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/predicate/regex/RLike.java

@@ -6,14 +6,12 @@
 package org.elasticsearch.xpack.sql.expression.predicate.regex;
 
 import org.elasticsearch.xpack.sql.expression.Expression;
-import org.elasticsearch.xpack.sql.expression.gen.processor.Processor;
-import org.elasticsearch.xpack.sql.expression.predicate.regex.RegexProcessor.RegexOperation;
-import org.elasticsearch.xpack.sql.tree.Source;
 import org.elasticsearch.xpack.sql.tree.NodeInfo;
+import org.elasticsearch.xpack.sql.tree.Source;
 
-public class RLike extends RegexMatch<String> {
+public class RLike extends RegexMatch<RLikePattern> {
 
-    public RLike(Source source, Expression value, String pattern) {
+    public RLike(Source source, Expression value, RLikePattern pattern) {
         super(source, value, pattern);
     }
 
@@ -26,15 +24,4 @@ protected NodeInfo<RLike> info() {
     protected RLike replaceChild(Expression newChild) {
         return new RLike(source(), newChild, pattern());
     }
-
-    @Override
-    public Boolean fold() {
-        Object val = field().fold();
-        return RegexOperation.match(val, pattern());
-    }
-
-    @Override
-    protected Processor makeProcessor() {
-        return new RegexProcessor(pattern());
-    }
 }

x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/predicate/regex/RLikePattern.java

@@ -0,0 +1,20 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+package org.elasticsearch.xpack.sql.expression.predicate.regex;
+
+public class RLikePattern implements StringPattern {
+
+    private final String regexpPattern;
+
+    public RLikePattern(String regexpPattern) {
+        this.regexpPattern = regexpPattern;
+    }
+
+    @Override
+    public String asJavaRegex() {
+        return regexpPattern;
+    }
+}

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

@@ -10,22 +10,26 @@
 import org.elasticsearch.xpack.sql.expression.Expressions;
 import org.elasticsearch.xpack.sql.expression.Nullability;
 import org.elasticsearch.xpack.sql.expression.function.scalar.UnaryScalarFunction;
+import org.elasticsearch.xpack.sql.expression.gen.processor.Processor;
+import org.elasticsearch.xpack.sql.expression.gen.script.ScriptTemplate;
 import org.elasticsearch.xpack.sql.tree.Source;
 import org.elasticsearch.xpack.sql.type.DataType;
 
 import java.util.Objects;
 
+import static org.elasticsearch.common.logging.LoggerMessageFormat.format;
 import static org.elasticsearch.xpack.sql.expression.TypeResolutions.isStringAndExact;
+import static org.elasticsearch.xpack.sql.expression.gen.script.ParamsBuilder.paramsBuilder;
 
-public abstract class RegexMatch<T> extends UnaryScalarFunction {
+public abstract class RegexMatch<T extends StringPattern> extends UnaryScalarFunction {
 
     private final T pattern;
-    
+
     protected RegexMatch(Source source, Expression value, T pattern) {
         super(source, value);
         this.pattern = pattern;
     }
-    
+
     public T pattern() {
         return pattern;
     }
@@ -53,8 +57,30 @@ public boolean foldable() {
         // right() is not directly foldable in any context but Like can fold it.
         return field().foldable();
     }
-
+
+    @Override
+    public Boolean fold() {
+        Object val = field().fold();
+        return RegexProcessor.RegexOperation.match(val, pattern().asJavaRegex());
+    }
+
     @Override
+    protected Processor makeProcessor() {
+        return new RegexProcessor(pattern().asJavaRegex());
+    }
+
+    @Override
+    public ScriptTemplate asScript() {
+        ScriptTemplate fieldAsScript = asScript(field());
+        return new ScriptTemplate(
+                formatTemplate(format("{sql}.", "regex({},{})", fieldAsScript.template())),
+                paramsBuilder()
+                        .script(fieldAsScript.params())
+                        .variable(pattern.asJavaRegex())
+                        .build(),
+                dataType());
+    }
+
     public boolean equals(Object obj) {
         return super.equals(obj) && Objects.equals(((RegexMatch<?>) obj).pattern(), pattern());
     }

x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/predicate/regex/StringPattern.java

@@ -0,0 +1,13 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+package org.elasticsearch.xpack.sql.expression.predicate.regex;
+
+interface StringPattern {
+    /**
+     * Returns the pattern in (Java) regex format.
+     */
+    String asJavaRegex();
+}

x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/ExpressionBuilder.java

@@ -60,6 +60,7 @@
 import org.elasticsearch.xpack.sql.expression.predicate.regex.Like;
 import org.elasticsearch.xpack.sql.expression.predicate.regex.LikePattern;
 import org.elasticsearch.xpack.sql.expression.predicate.regex.RLike;
+import org.elasticsearch.xpack.sql.expression.predicate.regex.RLikePattern;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.ArithmeticBinaryContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.ArithmeticUnaryContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.BooleanLiteralContext;
@@ -234,7 +235,7 @@ public Expression visitPredicated(PredicatedContext ctx) {
                 e = new Like(source, exp, visitPattern(pCtx.pattern()));
                 break;
             case SqlBaseParser.RLIKE:
-                e = new RLike(source, exp, string(pCtx.regex));
+                e = new RLike(source, exp, new RLikePattern(string(pCtx.regex)));
                 break;
             case SqlBaseParser.NULL:
                 // shortcut to avoid double negation later on (since there's no IsNull (missing in ES is a negated exists))

x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/planner/QueryTranslator.java

@@ -341,7 +341,7 @@ protected QueryTranslation asQuery(RegexMatch e, boolean onAggs) {
             }
 
             if (e instanceof RLike) {
-                String pattern = ((RLike) e).pattern();
+                String pattern = ((RLike) e).pattern().asJavaRegex();
                 q = new RegexQuery(e.source(), targetFieldName, pattern);
             }
 
@@ -864,4 +864,4 @@ protected static Query wrapIfNested(Query query, Expression exp) {
             return query;
         }
     }
-}
+}

x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/optimizer/OptimizerTests.java

@@ -93,6 +93,7 @@
 import org.elasticsearch.xpack.sql.expression.predicate.regex.Like;
 import org.elasticsearch.xpack.sql.expression.predicate.regex.LikePattern;
 import org.elasticsearch.xpack.sql.expression.predicate.regex.RLike;
+import org.elasticsearch.xpack.sql.expression.predicate.regex.RLikePattern;
 import org.elasticsearch.xpack.sql.optimizer.Optimizer.BinaryComparisonSimplification;
 import org.elasticsearch.xpack.sql.optimizer.Optimizer.BooleanLiteralsOnTheRight;
 import org.elasticsearch.xpack.sql.optimizer.Optimizer.BooleanSimplification;
@@ -361,7 +362,7 @@ public void testConstantFoldingLikes() {
                 new ConstantFolding().rule(new Like(EMPTY, of(EMPTY, "test_emp"), new LikePattern("test%", (char) 0)))
                         .canonical());
         assertEquals(TRUE,
-                new ConstantFolding().rule(new RLike(EMPTY, of(EMPTY, "test_emp"), "test.emp")).canonical());
+                new ConstantFolding().rule(new RLike(EMPTY, of(EMPTY, "test_emp"), new RLikePattern("test.emp"))).canonical());
     }
 
     public void testConstantFoldingDatetime() {
@@ -495,7 +496,7 @@ public void testGenericNullableExpression() {
         // comparison
         assertNullLiteral(rule.rule(new GreaterThan(EMPTY, getFieldAttribute(), NULL)));
         // regex
-        assertNullLiteral(rule.rule(new RLike(EMPTY, NULL, "123")));
+        assertNullLiteral(rule.rule(new RLike(EMPTY, NULL, new RLikePattern("123"))));
     }
 
     public void testNullFoldingOnCast() {

x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/planner/QueryTranslatorTests.java

@@ -540,6 +540,23 @@ private void assertDifferentRLikeAndNotRLikePatterns(String firstPattern, String
         assertEquals("keyword", rqsq.field());
     }
 
+    public void testLikeRLikeAsPainlessScripts() {
+        LogicalPlan p = plan("SELECT count(*), CASE WHEN keyword LIKE '%foo%' THEN 1 WHEN keyword RLIKE '.*bar.*' THEN 2 " +
+                             "ELSE 3 END AS t FROM test GROUP BY t");
+        assertTrue(p instanceof Aggregate);
+        Expression condition = ((Aggregate) p).groupings().get(0);
+        assertFalse(condition.foldable());
+        GroupingContext groupingContext = QueryFolder.FoldAggregate.groupBy(((Aggregate) p).groupings());
+        assertNotNull(groupingContext);
+        ScriptTemplate scriptTemplate = groupingContext.tail.script();
+        assertEquals("InternalSqlScriptUtils.caseFunction([InternalSqlScriptUtils.regex(InternalSqlScriptUtils.docValue(" +
+                     "doc,params.v0),params.v1),params.v2,InternalSqlScriptUtils.regex(InternalSqlScriptUtils.docValue(" +
+                     "doc,params.v3),params.v4),params.v5,params.v6])",
+                scriptTemplate.toString());
+        assertEquals("[{v=keyword}, {v=^.*foo.*$}, {v=1}, {v=keyword}, {v=.*bar.*}, {v=2}, {v=3}]",
+                scriptTemplate.params().toString());
+    }
+
     public void testTranslateNotExpression_WhereClause_Painless() {
         LogicalPlan p = plan("SELECT * FROM test WHERE NOT(POSITION('x', keyword) = 0)");
         assertTrue(p instanceof Project);