Refactors FunctionScoreQueryBuilder and Parser

Relates to #10217

This PR is against the query-refactoring branch.

Closes #12608

Author: alexksikes

core/src/main/java/org/elasticsearch/common/geo/GeoPoint.java

@@ -20,10 +20,16 @@
 package org.elasticsearch.common.geo;
 
 
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.common.io.stream.Streamable;
+
+import java.io.IOException;
+
 /**
  *
  */
-public final class GeoPoint {
+public final class GeoPoint implements Streamable {
 
     private double lat;
     private double lon;
@@ -136,4 +142,16 @@ public static GeoPoint parseFromLatLon(String latLon) {
         point.resetFromString(latLon);
         return point;
     }
+
+    @Override
+    public void readFrom(StreamInput in) throws IOException {
+        lat = in.readDouble();
+        lon = in.readDouble();
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeDouble(lat);
+        out.writeDouble(lon);
+    }
 }

core/src/main/java/org/elasticsearch/common/io/stream/StreamInput.java

@@ -31,9 +31,11 @@
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.bytes.BytesArray;
 import org.elasticsearch.common.bytes.BytesReference;
+import org.elasticsearch.common.geo.GeoPoint;
 import org.elasticsearch.common.text.StringAndBytesText;
 import org.elasticsearch.common.text.Text;
 import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.functionscore.ScoreFunctionBuilder;
 import org.joda.time.DateTime;
 import org.joda.time.DateTimeZone;
 
@@ -253,6 +255,22 @@ public Integer readOptionalVInt() throws IOException {
         return null;
     }
 
+    @Nullable
+    public Float readOptionalFloat() throws IOException {
+        if (readBoolean()) {
+            return readFloat();
+        }
+        return null;
+    }
+
+    @Nullable
+    public Double readOptionalDouble() throws IOException {
+        if (readBoolean()) {
+            return readDouble();
+        }
+        return null;
+    }
+
     private final CharsRefBuilder spare = new CharsRefBuilder();
 
     public String readString() throws IOException {
@@ -431,6 +449,8 @@ public Object readGenericValue() throws IOException {
                 return readDoubleArray();
             case 21:
                 return readBytesRef();
+            case 22:
+                return readOptionalStreamable(new GeoPoint());
             default:
                 throw new IOException("Can't read unknown type [" + type + "]");
         }
@@ -577,6 +597,18 @@ public QueryBuilder readQuery() throws IOException {
         return readNamedWriteable(QueryBuilder.class);
     }
 
+    public QueryBuilder readOptionalQuery() throws IOException {
+        if (readBoolean()) {
+            return readQuery();
+        } else {
+            return null;
+        }
+    }
+
+    public ScoreFunctionBuilder readScoreFunction() throws IOException {
+        return readNamedWriteable(ScoreFunctionBuilder.class);
+    }
+
     public static StreamInput wrap(BytesReference reference) {
         if (reference.hasArray() == false) {
             reference = reference.toBytesArray();

core/src/main/java/org/elasticsearch/common/io/stream/StreamOutput.java

@@ -30,9 +30,11 @@
 import org.elasticsearch.Version;
 import org.elasticsearch.common.Nullable;
 import org.elasticsearch.common.bytes.BytesReference;
+import org.elasticsearch.common.geo.GeoPoint;
 import org.elasticsearch.common.regex.Regex;
 import org.elasticsearch.common.text.Text;
 import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.functionscore.ScoreFunctionBuilder;
 import org.joda.time.ReadableInstant;
 
 import java.io.EOFException;
@@ -204,6 +206,24 @@ public void writeOptionalVInt(@Nullable Integer integer) throws IOException {
         }
     }
 
+    public void writeOptionalFloat(@Nullable Float aFloat) throws IOException {
+        if (aFloat == null) {
+            writeBoolean(false);
+        } else {
+            writeBoolean(true);
+            writeFloat(aFloat);
+        }
+    }
+
+    public void writeOptionalDouble(@Nullable Double aDouble) throws IOException {
+        if (aDouble == null) {
+            writeBoolean(false);
+        } else {
+            writeBoolean(true);
+            writeDouble(aDouble);
+        }
+    }
+
     public void writeOptionalText(@Nullable Text text) throws IOException {
         if (text == null) {
             writeInt(-1);
@@ -412,6 +432,9 @@ public void writeGenericValue(@Nullable Object value) throws IOException {
         } else if (value instanceof BytesRef) {
             writeByte((byte) 21);
             writeBytesRef((BytesRef) value);
+        } else if (value instanceof GeoPoint) {
+            writeByte((byte) 22);
+            writeOptionalStreamable((GeoPoint) value);
         } else {
             throw new IOException("Can't write type [" + type + "]");
         }
@@ -629,4 +652,17 @@ void writeNamedWriteable(NamedWriteable namedWriteable) throws IOException {
     public void writeQuery(QueryBuilder queryBuilder) throws IOException {
         writeNamedWriteable(queryBuilder);
     }
+
+    public void writeOptionalQuery(QueryBuilder queryBuilder) throws IOException {
+        if (queryBuilder != null) {
+            writeBoolean(true);
+            writeQuery(queryBuilder);
+        } else {
+            writeBoolean(false);
+        }
+    }
+
+    public void writeScoreFunction(ScoreFunctionBuilder scoreFunctionBuilder) throws IOException {
+        writeNamedWriteable(scoreFunctionBuilder);
+    }
 }

core/src/main/java/org/elasticsearch/common/lucene/search/function/CombineFunction.java

@@ -20,8 +20,14 @@
 package org.elasticsearch.common.lucene.search.function;
 
 import org.apache.lucene.search.Explanation;
+import org.elasticsearch.ElasticsearchException;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.common.io.stream.Writeable;
 
-public enum CombineFunction {
+import java.io.IOException;
+
+public enum CombineFunction implements Writeable<CombineFunction> {
     MULT {
         @Override
         public float combine(double queryBoost, double queryScore, double funcScore, double maxBoost) {
@@ -167,6 +173,8 @@ public Explanation explain(float queryBoost, Explanation queryExpl, Explanation
 
     };
 
+    private static final CombineFunction PROTOTYPE = MULT;
+
     public abstract float combine(double queryBoost, double queryScore, double funcScore, double maxBoost);
 
     public abstract String getName();
@@ -182,4 +190,24 @@ private static double deviation(double input) { // only with assert!
     }
 
     public abstract Explanation explain(float queryBoost, Explanation queryExpl, Explanation funcExpl, float maxBoost);
+
+    @Override
+    public CombineFunction readFrom(StreamInput in) throws IOException {
+        int ord = in.readVInt();
+        for (CombineFunction combineFunction : CombineFunction.values()) {
+            if (combineFunction.ordinal() == ord) {
+                return combineFunction;
+            }
+        }
+        throw new ElasticsearchException("unknown serialized combine function [" + ord + "]");
+    }
+
+    public static CombineFunction readCombineFunctionFrom(StreamInput in) throws IOException {
+        return PROTOTYPE.readFrom(in);
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeVInt(this.ordinal());
+    }
 }

core/src/main/java/org/elasticsearch/common/lucene/search/function/FieldValueFactorFunction.java

@@ -168,5 +168,13 @@ public double apply(double n) {
         public String toString() {
             return super.toString().toLowerCase(Locale.ROOT);
         }
+
+        public static Modifier fromString(String modifier) {
+            try {
+                return valueOf(modifier.toUpperCase(Locale.ROOT));
+            } catch (Throwable t) {
+                throw new IllegalArgumentException("Illegal modifier: " + modifier);
+            }
+        }
     }
 }

core/src/main/java/org/elasticsearch/common/lucene/search/function/FiltersFunctionScoreQuery.java

@@ -22,21 +22,17 @@
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.search.Explanation;
-import org.apache.lucene.search.IndexSearcher;
-import org.apache.lucene.search.Query;
-import org.apache.lucene.search.Scorer;
-import org.apache.lucene.search.Weight;
+import org.apache.lucene.search.*;
 import org.apache.lucene.util.Bits;
 import org.apache.lucene.util.ToStringUtils;
+import org.elasticsearch.ElasticsearchException;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.common.io.stream.Writeable;
 import org.elasticsearch.common.lucene.Lucene;
 
 import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Locale;
-import java.util.Set;
+import java.util.*;
 
 /**
  * A query that allows for a pluggable boost function / filter. If it matches
@@ -78,8 +74,34 @@ public int hashCode() {
         }
     }
 
-    public static enum ScoreMode {
-        First, Avg, Max, Sum, Min, Multiply
+    public enum ScoreMode implements Writeable<ScoreMode> {
+        First, Avg, Max, Sum, Min, Multiply;
+
+        private static final ScoreMode PROTOTYPE = Multiply;
+
+        public String getName() {
+            return name().toLowerCase();
+        }
+
+        @Override
+        public ScoreMode readFrom(StreamInput in) throws IOException {
+            int ord = in.readVInt();
+            for (ScoreMode scoreMode : ScoreMode.values()) {
+                if (scoreMode.ordinal() == ord) {
+                    return scoreMode;
+                }
+            }
+            throw new ElasticsearchException("unknown serialized score mode [" + ord + "]");
+        }
+
+        public static ScoreMode readScoreModeFrom(StreamInput in) throws IOException {
+            return PROTOTYPE.readFrom(in);
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            out.writeVInt(this.ordinal());
+        }
     }
 
     Query subQuery;

core/src/main/java/org/elasticsearch/index/query/QueryBuilders.java

@@ -19,6 +19,7 @@
 
 package org.elasticsearch.index.query;
 
+import org.apache.lucene.queryparser.xml.builders.MatchAllDocsQueryBuilder;
 import org.elasticsearch.action.search.SearchRequestBuilder;
 import org.elasticsearch.common.Nullable;
 import org.elasticsearch.common.bytes.BytesReference;

core/src/main/java/org/elasticsearch/index/query/QueryShardContext.java

@@ -21,7 +21,6 @@
 
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Maps;
-
 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.queryparser.classic.MapperQueryParser;
 import org.apache.lucene.queryparser.classic.QueryParserSettings;
@@ -38,11 +37,8 @@
 import org.elasticsearch.index.Index;
 import org.elasticsearch.index.analysis.AnalysisService;
 import org.elasticsearch.index.fielddata.IndexFieldData;
-import org.elasticsearch.index.mapper.ContentPath;
-import org.elasticsearch.index.mapper.MappedFieldType;
-import org.elasticsearch.index.mapper.Mapper;
-import org.elasticsearch.index.mapper.MapperBuilders;
-import org.elasticsearch.index.mapper.MapperService;
+import org.elasticsearch.index.fielddata.IndexFieldDataService;
+import org.elasticsearch.index.mapper.*;
 import org.elasticsearch.index.mapper.core.StringFieldMapper;
 import org.elasticsearch.index.mapper.object.ObjectMapper;
 import org.elasticsearch.index.query.support.NestedScope;
@@ -326,4 +322,8 @@ public Version indexVersionCreated() {
     public QueryParseContext parseContext() {
         return this.parseContext;
     }
+
+    public IndexFieldDataService fieldData() {
+        return indexQueryParser.fieldDataService;
+    }
 }

core/src/main/java/org/elasticsearch/index/query/functionscore/DecayFunction.java

@@ -32,9 +32,9 @@
 
 public interface DecayFunction {
 
-    public double evaluate(double value, double scale);
+    double evaluate(double value, double scale);
 
-    public Explanation explainFunction(String valueString, double value, double scale);
+    Explanation explainFunction(String valueString, double value, double scale);
 
     /**
      * The final scale parameter is computed from the scale parameter given by
@@ -49,6 +49,6 @@ public interface DecayFunction {
      *            the value which decay function should take once the distance
      *            reaches this scale
      * */
-    public double processScale(double scale, double decay);
+    double processScale(double scale, double decay);
 
 }