Add ExpressionQueryBuilder with serialization

Author: julian-elastic

server/src/main/java/org/elasticsearch/index/query/AutomatonTranslatable.java

@@ -0,0 +1,18 @@
+/*
+ * 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.index.query;
+
+import org.apache.lucene.util.automaton.Automaton;
+
+/**
+ * Query that matches documents based on a Lucene Automaton.
+ */
+public interface AutomatonTranslatable {
+    Automaton getAutomaton();
+
+    String getAutomatonDescription();
+}

x-pack/plugin/esql-core/src/main/java/org/elasticsearch/xpack/esql/core/querydsl/query/AutomatonQuery.java renamed to x-pack/plugin/esql-core/src/main/java/org/elasticsearch/xpack/esql/core/querydsl/query/EsqlAutomatonQuery.java

@@ -16,13 +16,13 @@
 /**
  * Query that matches documents based on a Lucene Automaton.
  */
-public class AutomatonQuery extends Query {
+public class EsqlAutomatonQuery extends Query {
 
     private final String field;
     private final Automaton automaton;
     private final String automatonDescription;
 
-    public AutomatonQuery(Source source, String field, Automaton automaton, String automatonDescription) {
+    public EsqlAutomatonQuery(Source source, String field, Automaton automaton, String automatonDescription) {
         super(source);
         this.field = field;
         this.automaton = automaton;
@@ -53,7 +53,7 @@ public boolean equals(Object obj) {
             return false;
         }
 
-        AutomatonQuery other = (AutomatonQuery) obj;
+        EsqlAutomatonQuery other = (EsqlAutomatonQuery) obj;
         return Objects.equals(field, other.field)
             && Objects.equals(automaton, other.automaton)
             && Objects.equals(automatonDescription, other.automatonDescription);

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

@@ -7,55 +7,76 @@
 
 package org.elasticsearch.xpack.esql.expression.function.scalar.string.regex;
 
+import org.apache.lucene.util.automaton.Automaton;
+import org.elasticsearch.common.breaker.CircuitBreaker;
+import org.elasticsearch.common.breaker.NoopCircuitBreaker;
 import org.elasticsearch.common.io.stream.NamedWriteableRegistry;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.common.util.BigArrays;
+import org.elasticsearch.compute.data.BlockFactory;
+import org.elasticsearch.compute.data.BlockStreamInput;
+import org.elasticsearch.index.query.AutomatonTranslatable;
 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.WildcardPattern;
 import org.elasticsearch.xpack.esql.core.expression.predicate.regex.WildcardPatternList;
-import org.elasticsearch.xpack.esql.core.querydsl.query.AutomatonQuery;
 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.Param;
+import org.elasticsearch.xpack.esql.io.stream.ExpressionQuery;
 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 org.elasticsearch.xpack.esql.session.Configuration;
 
 import java.io.IOException;
 import java.util.stream.Collectors;
 
-public class WildcardLikeList extends RegexMatch<WildcardPatternList> {
+public class WildcardLikeList extends RegexMatch<WildcardPatternList> implements AutomatonTranslatable {
     public static final NamedWriteableRegistry.Entry ENTRY = new NamedWriteableRegistry.Entry(
         Expression.class,
         "WildcardLikeList",
         WildcardLikeList::new
     );
+    private Configuration configuration;
 
     /**
      * The documentation for this function is in WildcardLike, and shown to the users `LIKE` in the docs.
      */
     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
+        @Param(name = "pattern", type = { "keyword", "text" }, description = "Pattern.") WildcardPatternList patterns,
+        Configuration configuration
     ) {
-        this(source, left, patterns, false);
+        this(source, left, patterns, false, configuration);
     }
 
-    public WildcardLikeList(Source source, Expression left, WildcardPatternList patterns, boolean caseInsensitive) {
+    public WildcardLikeList(
+        Source source,
+        Expression left,
+        WildcardPatternList patterns,
+        boolean caseInsensitive,
+        Configuration configuration
+    ) {
         super(source, left, patterns, caseInsensitive);
+        this.configuration = configuration;
     }
 
     public WildcardLikeList(StreamInput in) throws IOException {
         this(
             Source.readFrom((PlanStreamInput) in),
             in.readNamedWriteable(Expression.class),
             new WildcardPatternList(in),
-            deserializeCaseInsensitivity(in)
+            deserializeCaseInsensitivity(in),
+            null
         );
+        BlockFactory blockFactory = new BlockFactory(new NoopCircuitBreaker(CircuitBreaker.REQUEST), BigArrays.NON_RECYCLING_INSTANCE);
+        BlockStreamInput blockStreamInput = new BlockStreamInput(in, blockFactory);
+        this.configuration = new Configuration(blockStreamInput);
     }
 
     @Override
@@ -64,6 +85,7 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeNamedWriteable(field());
         pattern().writeTo(out);
         serializeCaseInsensitivity(out);
+        configuration.writeTo(out);
     }
 
     @Override
@@ -78,12 +100,12 @@ public String getWriteableName() {
 
     @Override
     protected NodeInfo<WildcardLikeList> info() {
-        return NodeInfo.create(this, WildcardLikeList::new, field(), pattern(), caseInsensitive());
+        return NodeInfo.create(this, WildcardLikeList::new, field(), pattern(), caseInsensitive(), configuration);
     }
 
     @Override
     protected WildcardLikeList replaceChild(Expression newLeft) {
-        return new WildcardLikeList(source(), newLeft, pattern(), caseInsensitive());
+        return new WildcardLikeList(source(), newLeft, pattern(), caseInsensitive(), configuration);
     }
 
     /**
@@ -104,20 +126,27 @@ public Translatable translatable(LucenePushdownPredicates pushdownPredicates) {
     public Query asQuery(LucenePushdownPredicates pushdownPredicates, TranslatorHandler handler) {
         var field = field();
         LucenePushdownPredicates.checkIsPushableAttribute(field);
-        return translateField(handler.nameOf(field instanceof FieldAttribute fa ? fa.exactAttribute() : field));
+        String targetFieldName = handler.nameOf(field instanceof FieldAttribute fa ? fa.exactAttribute() : field);
+        return translateField(targetFieldName);
     }
 
     /**
      * Translates the field to a {@link WildcardQuery} using the first pattern in the list.
      * Throws an {@link IllegalArgumentException} if the pattern list contains more than one pattern.
      */
     private Query translateField(String targetFieldName) {
-        return new AutomatonQuery(source(), targetFieldName, pattern().createAutomaton(caseInsensitive()), getAutomatonDescription());
+        return new ExpressionQuery(source(), targetFieldName, this, configuration);
     }
 
-    private String getAutomatonDescription() {
+    @Override
+    public String getAutomatonDescription() {
         // we use the information used to create the automaton to describe the query here
         String patternDesc = pattern().patternList().stream().map(WildcardPattern::pattern).collect(Collectors.joining("\", \""));
         return "LIKE(\"" + patternDesc + "\"), caseInsensitive=" + caseInsensitive();
     }
+
+    @Override
+    public Automaton getAutomaton() {
+        return pattern().createAutomaton(caseInsensitive());
+    }
 }

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/io/stream/ExpressionQuery.java

@@ -0,0 +1,66 @@
+/*
+ * 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.io.stream;
+
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.xpack.esql.core.expression.Expression;
+import org.elasticsearch.xpack.esql.core.querydsl.query.Query;
+import org.elasticsearch.xpack.esql.core.tree.Source;
+import org.elasticsearch.xpack.esql.session.Configuration;
+
+import java.util.Objects;
+
+/**
+ * Query that matches documents based on a Lucene Automaton.
+ */
+public class ExpressionQuery extends Query {
+
+    private final String targetFieldName;
+    private final Expression expression;
+    private final Configuration config;
+
+    public ExpressionQuery(Source source, String targetFieldName, Expression expression, Configuration config) {
+        super(source);
+        this.targetFieldName = targetFieldName;
+        this.expression = expression;
+        this.config = config;
+    }
+
+    public String field() {
+        return targetFieldName;
+    }
+
+    @Override
+    protected QueryBuilder asBuilder() {
+        return new ExpressionQueryBuilder(targetFieldName, expression, config);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(targetFieldName, expression);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+
+        if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        }
+
+        ExpressionQuery other = (ExpressionQuery) obj;
+        return Objects.equals(targetFieldName, other.targetFieldName)
+            && Objects.equals(expression, other.expression);
+    }
+
+    @Override
+    protected String innerToString() {
+        return "AutomatonQuery{" + "field='" + targetFieldName + '\'' + '}';
+    }
+}

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/io/stream/ExpressionQueryBuilder.java

@@ -0,0 +1,143 @@
+/*
+ * 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.io.stream;
+
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.AutomatonQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.util.automaton.Automaton;
+import org.elasticsearch.TransportVersion;
+import org.elasticsearch.common.Strings;
+import org.elasticsearch.common.breaker.CircuitBreaker;
+import org.elasticsearch.common.breaker.NoopCircuitBreaker;
+import org.elasticsearch.common.io.stream.NamedWriteable;
+import org.elasticsearch.common.io.stream.NamedWriteableRegistry;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.common.util.BigArrays;
+import org.elasticsearch.compute.data.BlockFactory;
+import org.elasticsearch.compute.data.BlockStreamInput;
+import org.elasticsearch.compute.operator.Operator;
+import org.elasticsearch.index.query.AbstractQueryBuilder;
+import org.elasticsearch.index.query.AutomatonTranslatable;
+import org.elasticsearch.index.query.MultiTermQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.SearchExecutionContext;
+import org.elasticsearch.xcontent.XContentBuilder;
+import org.elasticsearch.xpack.esql.core.expression.Expression;
+import org.elasticsearch.xpack.esql.session.Configuration;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.util.Objects;
+
+/**
+ * Implements an Automaton query, which matches documents based on a Lucene Automaton.
+ * It does not support serialization or XContent representation.
+ */
+public class ExpressionQueryBuilder extends AbstractQueryBuilder<ExpressionQueryBuilder> implements MultiTermQueryBuilder {
+    public static final NamedWriteableRegistry.Entry ENTRY = new NamedWriteableRegistry.Entry(
+        QueryBuilder.class,
+        "expressionQueryBuilder",
+        ExpressionQueryBuilder::new
+    );
+    private final String fieldName;
+    private final Expression expression;
+    private final Configuration config;
+
+    public ExpressionQueryBuilder(String fieldName, Expression expression, Configuration config) {
+        if (Strings.isEmpty(fieldName)) {
+            throw new IllegalArgumentException("field name is null or empty");
+        }
+        if (expression == null) {
+            throw new IllegalArgumentException("expression cannot be null");
+        }
+        this.fieldName = fieldName;
+        this.expression = expression;
+        this.config = config;
+    }
+
+    /**
+     * Read from a stream.
+     */
+    public ExpressionQueryBuilder(StreamInput in) throws IOException {
+        super(in);
+        fieldName = in.readString();
+        BlockFactory blockFactory = new BlockFactory(new NoopCircuitBreaker(CircuitBreaker.REQUEST), BigArrays.NON_RECYCLING_INSTANCE);
+        BlockStreamInput blockStreamInput = new BlockStreamInput(in, blockFactory);
+        this.config = new Configuration(blockStreamInput);
+        PlanStreamInput planStreamInput = new PlanStreamInput(blockStreamInput, in.namedWriteableRegistry(), config);
+        this.expression = planStreamInput.readNamedWriteable(Expression.class);
+    }
+
+    @Override
+    protected void doWriteTo(StreamOutput out) throws IOException {
+        out.writeString(this.fieldName);
+        config.writeTo(out);
+        PlanStreamOutput planStreamOutput = new PlanStreamOutput(out, config);
+        planStreamOutput.writeNamedWriteable(expression);
+    }
+
+    @Override
+    public String fieldName() {
+        return fieldName;
+    }
+
+    @Override
+    public String getWriteableName() {
+        return ENTRY.name;
+    }
+
+    @Override
+    protected void doXContent(XContentBuilder builder, Params params) throws IOException {
+        throw new UnsupportedEncodingException("AutomatonQueryBuilder does not support doXContent");
+    }
+
+    @Override
+    protected Query doToQuery(SearchExecutionContext context) throws IOException {
+        if (expression instanceof AutomatonTranslatable automatonTranslatable) {
+            Automaton automaton = automatonTranslatable.getAutomaton();
+            String description = automatonTranslatable.getAutomatonDescription();
+            return new AutomatonQueryWithDescription(new Term(fieldName), automaton, description);
+        } else {
+            throw new UnsupportedOperationException("ExpressionQueryBuilder does not support non-automaton expressions");
+        }
+    }
+
+    @Override
+    protected int doHashCode() {
+        return Objects.hash(fieldName, expression);
+    }
+
+    @Override
+    protected boolean doEquals(ExpressionQueryBuilder other) {
+        return Objects.equals(fieldName, other.fieldName) && Objects.equals(expression, other.expression);
+    }
+
+    @Override
+    public TransportVersion getMinimalSupportedVersion() {
+        throw new UnsupportedOperationException("AutomatonQueryBuilder does not support getMinimalSupportedVersion");
+    }
+
+    static class AutomatonQueryWithDescription extends AutomatonQuery {
+        private final String description;
+
+        AutomatonQueryWithDescription(Term term, Automaton automaton, String description) {
+            super(term, automaton);
+            this.description = description;
+        }
+
+        @Override
+        public String toString(String field) {
+            if (this.field.equals(field)) {
+                return description;
+            }
+            return this.field + ":" + description;
+        }
+    }
+}