New Func Added

Author: julian-elastic

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

@@ -11,8 +11,11 @@
 import org.apache.lucene.util.automaton.Automaton;
 import org.apache.lucene.util.automaton.Operations;
 import org.apache.lucene.util.automaton.RegExp;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.xpack.esql.core.util.StringUtils;
 
+import java.io.IOException;
 import java.util.Objects;
 
 import static org.elasticsearch.xpack.esql.core.util.StringUtils.luceneWildcardToRegExp;
@@ -34,6 +37,9 @@ public WildcardPattern(String pattern) {
         // early initialization to force string validation
         this.regex = StringUtils.wildcardToJavaPattern(pattern, '\\');
     }
+    public WildcardPattern(StreamInput in) throws IOException{
+        this(in.readString());
+    }
 
     public String pattern() {
         return wildcard;
@@ -87,4 +93,12 @@ public boolean equals(Object obj) {
         WildcardPattern other = (WildcardPattern) obj;
         return Objects.equals(wildcard, other.wildcard);
     }
+
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeString(wildcard);
+    }
+
+    public static WildcardPattern readFrom(StreamInput out) throws IOException {
+        return new WildcardPattern(out);
+    }
 }

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

@@ -0,0 +1,120 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+package org.elasticsearch.xpack.esql.core.expression.predicate.regex;
+
+import org.apache.lucene.util.automaton.Automaton;
+import org.apache.lucene.util.automaton.Operations;
+import org.elasticsearch.common.io.stream.NamedWriteable;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import static org.elasticsearch.common.io.stream.NamedWriteableRegistry.Entry;
+
+/**
+ * Similar to basic regex, supporting '?' wildcard for single character (same as regex  ".")
+ * and '*' wildcard for multiple characters (same as regex ".*")
+ * <p>
+ * Allows escaping based on a regular char
+ *
+ */
+public class WildcardPatternList extends AbstractStringPattern implements NamedWriteable {
+    public static final Entry ENTRY = new Entry(
+        WildcardPatternList.class,
+        "WildcardPatternList",
+        WildcardPatternList::new
+    );
+    public static final String NAME = "WildcardPatternList";
+    private final List<WildcardPattern> patternList;
+
+    /*public WildcardPatternList(List<String> patterns) {
+        this.patternList = patterns.stream().map(WildcardPattern::new).toList();
+    }*/
+
+    public WildcardPatternList(List<WildcardPattern> patterns) {
+        this.patternList = patterns;
+    }
+
+    public WildcardPatternList(StreamInput in) throws IOException {
+        this(in.readCollectionAsList(WildcardPattern::new));
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeCollection(patternList, (o, pattern) -> pattern.writeTo(o));
+    }
+
+    @Override
+    public String getWriteableName() {
+        return NAME;
+    }
+    public static WildcardPatternList readFrom(StreamInput in) throws IOException{
+        return new WildcardPatternList(in.readCollectionAsList(WildcardPattern::readFrom));
+    }
+
+    public List<WildcardPattern> patternList() {
+        return patternList;
+    }
+    //public String pattern() {
+    //    return wildcard;
+    //}
+
+    @Override
+    public Automaton createAutomaton(boolean ignoreCase) {
+        List<Automaton> automatonList = patternList.stream().map(x->x.createAutomaton(ignoreCase)).toList();
+        return Operations.union(automatonList);
+    }
+
+    @Override
+    public String asJavaRegex() {
+        return patternList.stream().map(WildcardPattern::asJavaRegex).collect(Collectors.joining("|"));
+    }
+
+    @Override
+    public String pattern() {
+        return  "(\"" + patternList.stream().map(WildcardPattern::pattern).collect(Collectors.joining("\", \"")) + "\")";
+    }
+
+    /**
+     * Returns the pattern in (Lucene) wildcard format.
+     */
+    public String asLuceneWildcard() {
+        throw new RuntimeException("LIKELIST does not have a Lucine Wildcard");
+    }
+
+
+    /**
+     * Returns the pattern in (IndexNameExpressionResolver) wildcard format.
+     */
+    //public String asIndexNameWildcard() {
+    //    return wildcard;
+    //}
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(patternList);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+
+        if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        }
+
+        WildcardPatternList other = (WildcardPatternList) obj;
+        return Objects.equals(patternList, other.patternList);
+    }
+
+}

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

@@ -74,6 +74,19 @@ emp_no:integer | first_name:keyword
 10013          | Eberhardt      
 ;
 
+inLikeWithWildcard
+from employees | where first_name like ("Eberhardt*") | keep emp_no, first_name;
+
+emp_no:integer | first_name:keyword
+10013          | Eberhardt      
+;
+
+inLikeTwoArgs
+from employees | where first_name like ("Eberhardt*", "testString") | keep emp_no, first_name;
+
+emp_no:integer | first_name:keyword
+10013          | Eberhardt       
+;
 
 likeEvalNoWildcard
 from employees | eval x = concat(first_name, "X") | where x like "EberhardtX" | keep emp_no, first_name;

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

@@ -18,8 +18,9 @@ booleanExpression
     ;
 
 regexBooleanExpression
-    : valueExpression (NOT)? kind=LIKE pattern=string
-    | valueExpression (NOT)? kind=RLIKE pattern=string
+    : valueExpression (NOT)? LIKE valueExpression                            #likeExpression
+    | valueExpression (NOT)? RLIKE valueExpression                           #rlikeExpression
+    | valueExpression (NOT)? LIKE LP valueExpression (COMMA valueExpression)* RP   #logicalLikeList
     ;
 
 matchBooleanExpression

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/ExpressionWritables.java

@@ -82,6 +82,7 @@
 import org.elasticsearch.xpack.esql.expression.function.scalar.string.Trim;
 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.expression.function.scalar.string.regex.WildcardLikeList;
 import org.elasticsearch.xpack.esql.expression.function.scalar.util.Delay;
 import org.elasticsearch.xpack.esql.expression.predicate.logical.Not;
 import org.elasticsearch.xpack.esql.expression.predicate.nulls.IsNotNull;
@@ -216,6 +217,7 @@ public static List<NamedWriteableRegistry.Entry> unaryScalars() {
         entries.add(ToVersion.ENTRY);
         entries.add(Trim.ENTRY);
         entries.add(WildcardLike.ENTRY);
+        entries.add(WildcardLikeList.ENTRY);
         entries.add(Delay.ENTRY);
         // mv functions
         entries.addAll(MvFunctionWritables.getNamedWriteables());

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/EsqlFunctionRegistry.java

@@ -178,6 +178,7 @@
 import org.elasticsearch.xpack.esql.expression.function.scalar.string.ToLower;
 import org.elasticsearch.xpack.esql.expression.function.scalar.string.ToUpper;
 import org.elasticsearch.xpack.esql.expression.function.scalar.string.Trim;
+import org.elasticsearch.xpack.esql.expression.function.scalar.string.regex.WildcardLikeList;
 import org.elasticsearch.xpack.esql.expression.function.scalar.util.Delay;
 import org.elasticsearch.xpack.esql.parser.ParsingException;
 import org.elasticsearch.xpack.esql.session.Configuration;
@@ -417,6 +418,9 @@ private static FunctionDefinition[][] functions() {
             // IP
             new FunctionDefinition[] { def(CIDRMatch.class, CIDRMatch::new, "cidr_match") },
             new FunctionDefinition[] { def(IpPrefix.class, IpPrefix::new, "ip_prefix") },
+            //likelist
+            //new FunctionDefinition[] { def(WildcardLikeList.class, WildcardLikeList::new, "like_list") },
+
             // conversion functions
             new FunctionDefinition[] {
                 def(FromBase64.class, FromBase64::new, "from_base64"),

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

@@ -0,0 +1,130 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.esql.expression.function.scalar.string.regex;
+
+import org.elasticsearch.common.io.stream.NamedWriteableRegistry;
+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.FieldAttribute;
+import org.elasticsearch.xpack.esql.core.expression.predicate.regex.WildcardPatternList;
+import org.elasticsearch.xpack.esql.core.querydsl.query.Query;
+import org.elasticsearch.xpack.esql.core.querydsl.query.WildcardQuery;
+import org.elasticsearch.xpack.esql.core.tree.NodeInfo;
+import org.elasticsearch.xpack.esql.core.tree.Source;
+import org.elasticsearch.xpack.esql.expression.function.Example;
+import org.elasticsearch.xpack.esql.expression.function.FunctionInfo;
+import org.elasticsearch.xpack.esql.expression.function.Param;
+import org.elasticsearch.xpack.esql.io.stream.PlanStreamInput;
+import org.elasticsearch.xpack.esql.optimizer.rules.physical.local.LucenePushdownPredicates;
+import org.elasticsearch.xpack.esql.planner.TranslatorHandler;
+
+import java.io.IOException;
+
+public class WildcardLikeList extends RegexMatch<WildcardPatternList> {
+    public static final NamedWriteableRegistry.Entry ENTRY = new NamedWriteableRegistry.Entry(
+        Expression.class,
+        "WildcardLikeList",
+        WildcardLikeList::new
+    );
+    public static final String NAME = "LIKELIST";
+
+    @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>>
+        """, operator = NAME, examples = @Example(file = "docs", tag = "like"))
+    public WildcardLikeList(
+        Source source,
+        @Param(name = "str", type = { "keyword", "text" }, description = "A literal expression.") Expression left,
+        @Param(name = "pattern", type = { "keyword", "text" }, description = "Pattern.") WildcardPatternList patterns
+    ) {
+        this(source, left, patterns, false);
+    }
+
+    public WildcardLikeList(Source source, Expression left, WildcardPatternList patterns, boolean caseInsensitive) {
+        super(source, left, patterns, caseInsensitive);
+    }
+
+    public WildcardLikeList(StreamInput in) throws IOException {
+        this(
+            Source.readFrom((PlanStreamInput) in),
+            in.readNamedWriteable(Expression.class),
+            WildcardPatternList.readFrom(in),
+            deserializeCaseInsensitivity(in)
+        );
+    }
+
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        source().writeTo(out);
+        out.writeNamedWriteable(field());
+        pattern().writeTo(out);
+        serializeCaseInsensitivity(out);
+    }
+
+    @Override
+    public String name() {
+        return NAME;
+    }
+
+    @Override
+    public String getWriteableName() {
+        return ENTRY.name;
+    }
+
+    @Override
+    protected NodeInfo<WildcardLikeList> info() {
+        return NodeInfo.create(this, WildcardLikeList::new, field(), pattern(), caseInsensitive());
+    }
+
+    @Override
+    protected WildcardLikeList replaceChild(Expression newLeft) {
+        return new WildcardLikeList(source(), newLeft, pattern(), caseInsensitive());
+    }
+
+    @Override
+    public Translatable translatable(LucenePushdownPredicates pushdownPredicates) {
+        if(pattern().patternList().size() != 1){
+            //we only support a single pattern in the list for pushdown for now
+            return Translatable.NO;
+        }
+        return pushdownPredicates.isPushableAttribute(field()) ? Translatable.YES : Translatable.NO;
+
+    }
+
+    @Override
+    public Query asQuery(LucenePushdownPredicates pushdownPredicates, TranslatorHandler handler) {
+        var field = field();
+        LucenePushdownPredicates.checkIsPushableAttribute(field);
+        return translateField(handler.nameOf(field instanceof FieldAttribute fa ? fa.exactAttribute() : field));
+    }
+
+    private Query translateField(String targetFieldName) {
+        if (pattern().patternList().size() != 1) {
+            throw new IllegalArgumentException("WildcardLikeList can only be translated when it has a single pattern");
+        }
+        return new WildcardQuery(source(), targetFieldName, pattern().patternList().getFirst().asLuceneWildcard(), caseInsensitive());
+    }
+}