ES|QL: support for parameters in LIKE and RLIKE

docs/changelog/138051.yaml

@@ -0,0 +1,5 @@
+pr: 138051
+summary: Support for parameters in LIKE and RLIKE
+area: ES|QL
+type: enhancement
+issues: []

docs/reference/query-languages/esql/_snippets/operators/detailedDescription/like.md

@@ -31,3 +31,15 @@ ROW message = "foobar"
 ```
 
 
+Patterns may be specified with REST query placeholders as well
+
+```esql
+FROM employees
+| WHERE first_name LIKE ?pattern
+| KEEP first_name, last_name
+```
+
+```{applies_to}
+stack: ga 9.3
+```
+

docs/reference/query-languages/esql/_snippets/operators/detailedDescription/rlike.md

@@ -31,3 +31,15 @@ ROW message = "foobar"
 ```
 
 
+Patterns may be specified with REST query placeholders as well
+
+```esql
+FROM employees
+| WHERE first_name RLIKE ?pattern
+| KEEP first_name, last_name
+```
+
+```{applies_to}
+stack: ga 9.3
+```
+

x-pack/plugin/esql/qa/server/src/main/java/org/elasticsearch/xpack/esql/qa/rest/RestEsqlTestCase.java

@@ -1858,6 +1858,46 @@ public void testMatchFunctionAcrossMultipleIndicesWithMissingField() throws IOEx
         }
     }
 
+    public void testParamsWithLike() throws IOException {
+        assumeTrue("like parameter support", EsqlCapabilities.Cap.LIKE_PARAMETER_SUPPORT.isEnabled());
+        bulkLoadTestData(11);
+        var anonymous_query = requestObjectBuilder().query(
+            format(null, "from {} | where keyword like ? | keep keyword | sort keyword", testIndexName())
+        ).params("[\"key*0\"]");
+        Map<String, Object> result = runEsql(anonymous_query);
+        assertEquals(List.of(List.of("keyword0"), List.of("keyword10")), result.get("values"));
+    }
+
+    public void testParamsWithLikeList() throws IOException {
+        assumeTrue("like parameter support", EsqlCapabilities.Cap.LIKE_PARAMETER_SUPPORT.isEnabled());
+        bulkLoadTestData(11);
+        var positional_query = requestObjectBuilder().query(
+            format(null, "from {} | where keyword like (?1, ?2) | keep keyword | sort keyword", testIndexName())
+        ).params("[\"key*0\", \"key*1\"]");
+        Map<String, Object> result = runEsql(positional_query);
+        assertEquals(List.of(List.of("keyword0"), List.of("keyword1"), List.of("keyword10")), result.get("values"));
+    }
+
+    public void testParamsWithRLike() throws IOException {
+        assumeTrue("like parameter support", EsqlCapabilities.Cap.LIKE_PARAMETER_SUPPORT.isEnabled());
+        bulkLoadTestData(11);
+        var query = requestObjectBuilder().query(
+            format(null, "from {} | where keyword rlike ?pattern | keep keyword | sort keyword", testIndexName())
+        ).params("[{\"pattern\" : \"key.*0\"}]");
+        Map<String, Object> result = runEsql(query);
+        assertEquals(List.of(List.of("keyword0"), List.of("keyword10")), result.get("values"));
+    }
+
+    public void testParamsWithRLikeList() throws IOException {
+        assumeTrue("like parameter support", EsqlCapabilities.Cap.LIKE_PARAMETER_SUPPORT.isEnabled());
+        bulkLoadTestData(11);
+        var query = requestObjectBuilder().query(
+            format(null, "from {} | where keyword rlike (?p1, ?p2) | keep keyword | sort keyword", testIndexName())
+        ).params("[{\"p1\" : \"key.*0\"}, {\"p2\" : \"key.*1\"}]");
+        Map<String, Object> result = runEsql(query);
+        assertEquals(List.of(List.of("keyword0"), List.of("keyword1"), List.of("keyword10")), result.get("values"));
+    }
+
     @SuppressWarnings("fallthrough")
     public void testRandomTimezoneBuckets() throws IOException {
         assumeTrue("timezone support for date_trunc is required", EsqlCapabilities.Cap.DATE_TRUNC_TIMEZONE_SUPPORT.isEnabled());

x-pack/plugin/esql/src/main/antlr/EsqlBaseParser.g4

@@ -214,6 +214,11 @@ identifierOrParameter
     | doubleParameter
     ;
 
+stringOrParameter
+    : string
+    | parameter
+    ;
+
 limitCommand
     : LIMIT constant
     ;

x-pack/plugin/esql/src/main/antlr/parser/Expression.g4

@@ -18,10 +18,10 @@ booleanExpression
     ;
 
 regexBooleanExpression
-    : valueExpression (NOT)? LIKE string                               #likeExpression
-    | valueExpression (NOT)? RLIKE string                              #rlikeExpression
-    | valueExpression (NOT)? LIKE LP string  (COMMA string )* RP       #likeListExpression
-    | valueExpression (NOT)? RLIKE LP string  (COMMA string )* RP      #rlikeListExpression
+    : valueExpression (NOT)? LIKE stringOrParameter                                     #likeExpression
+    | valueExpression (NOT)? RLIKE stringOrParameter                                    #rlikeExpression
+    | valueExpression (NOT)? LIKE LP stringOrParameter (COMMA stringOrParameter )* RP   #likeListExpression
+    | valueExpression (NOT)? RLIKE LP stringOrParameter (COMMA stringOrParameter )* RP  #rlikeListExpression
     ;
 
 matchBooleanExpression

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/EsqlCapabilities.java

@@ -1688,6 +1688,11 @@ public enum Cap {
          */
         TIME_SERIES_WINDOW_V1,
 
+        /**
+         * Support like/rlike parameters https://github.com/elastic/elasticsearch/issues/131356
+         */
+        LIKE_PARAMETER_SUPPORT,
+
         /**
          * PromQL support in ESQL, before it is released into tech preview.
          * When implementing new functionality or breaking changes,

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

@@ -31,30 +31,50 @@ public class RLike extends RegexMatch<RLikePattern> {
     public static final NamedWriteableRegistry.Entry ENTRY = new NamedWriteableRegistry.Entry(Expression.class, "RLike", RLike::new);
     public static final String NAME = "RLIKE";
 
-    @FunctionInfo(returnType = "boolean", description = """
-        Use `RLIKE` to filter data based on string patterns using
-        <<regexp-syntax,regular expressions>>. `RLIKE` usually acts on a field placed on
-        the left-hand side of the operator, but it can also act on a constant (literal)
-        expression. The right-hand side of the operator represents the pattern.""", detailedDescription = """
-        Matching special characters (eg. `.`, `*`, `(`...) will require escaping.
-        The escape character is backslash `\\`. Since also backslash is a special character in string literals,
-        it will require further escaping.
-
-        <<load-esql-example, file=string tag=rlikeEscapingSingleQuotes>>
-
-        To reduce the overhead of escaping, we suggest using triple quotes strings `\"\"\"`
-
-        <<load-esql-example, file=string tag=rlikeEscapingTripleQuotes>>
-        ```{applies_to}
-        stack: ga 9.2
-        serverless: ga
-        ```
-
-        Both a single pattern or a list of patterns are supported. If a list of patterns is provided,
-        the expression will return true if any of the patterns match.
-
-        <<load-esql-example, file=where-like tag=rlikeListDocExample>>
-        """, operator = NAME, examples = @Example(file = "docs", tag = "rlike"))
+    @FunctionInfo(
+        returnType = "boolean",
+        description = """
+            Use `RLIKE` to filter data based on string patterns using
+            <<regexp-syntax,regular expressions>>. `RLIKE` usually acts on a field placed on
+            the left-hand side of the operator, but it can also act on a constant (literal)
+            expression. The right-hand side of the operator represents the pattern.""",
+
+        // we use an inline example here because ?pattern not supported in csv-spec test
+        detailedDescription = """
+            Matching special characters (eg. `.`, `*`, `(`...) will require escaping.
+            The escape character is backslash `\\`. Since also backslash is a special character in string literals,
+            it will require further escaping.
+
+            <<load-esql-example, file=string tag=rlikeEscapingSingleQuotes>>
+
+            To reduce the overhead of escaping, we suggest using triple quotes strings `\"\"\"`
+
+            <<load-esql-example, file=string tag=rlikeEscapingTripleQuotes>>
+            ```{applies_to}
+            stack: ga 9.2
+            serverless: ga
+            ```
+
+            Both a single pattern or a list of patterns are supported. If a list of patterns is provided,
+            the expression will return true if any of the patterns match.
+
+            <<load-esql-example, file=where-like tag=rlikeListDocExample>>
+
+            Patterns may be specified with REST query placeholders as well
+
+            ```esql
+            FROM employees
+            | WHERE first_name RLIKE ?pattern
+            | KEEP first_name, last_name
+            ```
+
+            ```{applies_to}
+            stack: ga 9.3
+            ```
+            """,
+        operator = NAME,
+        examples = @Example(file = "docs", tag = "rlike")
+    )
     public RLike(
         Source source,
         @Param(name = "str", type = { "keyword", "text" }, description = "A literal value.") Expression value,

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

@@ -36,36 +36,55 @@ public class WildcardLike extends RegexMatch<WildcardPattern> {
     );
     public static final String NAME = "LIKE";
 
-    @FunctionInfo(returnType = "boolean", description = """
-        Use `LIKE` to filter data based on string patterns using wildcards. `LIKE`
-        usually acts on a field placed on the left-hand side of the operator, but it can
-        also act on a constant (literal) expression. The right-hand side of the operator
-        represents the pattern.
-
-        The following wildcard characters are supported:
-
-        * `*` matches zero or more characters.
-        * `?` matches one character.""", detailedDescription = """
-        Matching the exact characters `*` and `.` will require escaping.
-        The escape character is backslash `\\`. Since also backslash is a special character in string literals,
-        it will require further escaping.
-
-        <<load-esql-example, file=string tag=likeEscapingSingleQuotes>>
-
-        To reduce the overhead of escaping, we suggest using triple quotes strings `\"\"\"`
-
-        <<load-esql-example, file=string tag=likeEscapingTripleQuotes>>
-
-        ```{applies_to}
-        stack: ga 9.1
-        serverless: ga
-        ```
-        Both a single pattern or a list of patterns are supported. If a list of patterns is provided,
-        the expression will return true if any of the patterns match.
-
-        <<load-esql-example, file=where-like tag=likeListDocExample>>
-
-        """, operator = NAME, examples = @Example(file = "docs", tag = "like"))
+    @FunctionInfo(
+        returnType = "boolean",
+        description = """
+            Use `LIKE` to filter data based on string patterns using wildcards. `LIKE`
+            usually acts on a field placed on the left-hand side of the operator, but it can
+            also act on a constant (literal) expression. The right-hand side of the operator
+            represents the pattern.
+
+            The following wildcard characters are supported:
+
+            * `*` matches zero or more characters.
+            * `?` matches one character.""",
+
+        // we use an inline example here because ?pattern not supported in csv-spec test
+        detailedDescription = """
+            Matching the exact characters `*` and `.` will require escaping.
+            The escape character is backslash `\\`. Since also backslash is a special character in string literals,
+            it will require further escaping.
+
+            <<load-esql-example, file=string tag=likeEscapingSingleQuotes>>
+
+            To reduce the overhead of escaping, we suggest using triple quotes strings `\"\"\"`
+
+            <<load-esql-example, file=string tag=likeEscapingTripleQuotes>>
+
+            ```{applies_to}
+            stack: ga 9.1
+            serverless: ga
+            ```
+            Both a single pattern or a list of patterns are supported. If a list of patterns is provided,
+            the expression will return true if any of the patterns match.
+
+            <<load-esql-example, file=where-like tag=likeListDocExample>>
+
+            Patterns may be specified with REST query placeholders as well
+
+            ```esql
+            FROM employees
+            | WHERE first_name LIKE ?pattern
+            | KEEP first_name, last_name
+            ```
+
+            ```{applies_to}
+            stack: ga 9.3
+            ```
+            """,
+        operator = NAME,
+        examples = @Example(file = "docs", tag = "like")
+    )
     public WildcardLike(
         Source source,
         @Param(name = "str", type = { "keyword", "text" }, description = "A literal expression.") Expression left,