MappedFieldType should not extend FieldType (#57666)

modules/aggs-matrix-stats/src/test/java/org/elasticsearch/search/aggregations/matrix/stats/MatrixStatsAggregatorTests.java

@@ -42,8 +42,7 @@ public class MatrixStatsAggregatorTests extends AggregatorTestCase {
 
     public void testNoData() throws Exception {
         MappedFieldType ft =
-            new NumberFieldMapper.NumberFieldType(NumberFieldMapper.NumberType.DOUBLE);
-        ft.setName("field");
+            new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.DOUBLE);
 
         try (Directory directory = newDirectory();
             RandomIndexWriter indexWriter = new RandomIndexWriter(random(), directory)) {
@@ -62,9 +61,7 @@ public void testNoData() throws Exception {
     }
 
     public void testUnmapped() throws Exception {
-        MappedFieldType ft =
-            new NumberFieldMapper.NumberFieldType(NumberFieldMapper.NumberType.DOUBLE);
-        ft.setName("field");
+        MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.DOUBLE);
 
         try (Directory directory = newDirectory();
              RandomIndexWriter indexWriter = new RandomIndexWriter(random(), directory)) {
@@ -84,11 +81,9 @@ public void testUnmapped() throws Exception {
 
     public void testTwoFields() throws Exception {
         String fieldA = "a";
-        MappedFieldType ftA = new NumberFieldMapper.NumberFieldType(NumberFieldMapper.NumberType.DOUBLE);
-        ftA.setName(fieldA);
+        MappedFieldType ftA = new NumberFieldMapper.NumberFieldType(fieldA, NumberFieldMapper.NumberType.DOUBLE);
         String fieldB = "b";
-        MappedFieldType ftB = new NumberFieldMapper.NumberFieldType(NumberFieldMapper.NumberType.DOUBLE);
-        ftB.setName(fieldB);
+        MappedFieldType ftB = new NumberFieldMapper.NumberFieldType(fieldB, NumberFieldMapper.NumberType.DOUBLE);
 
         try (Directory directory = newDirectory();
             RandomIndexWriter indexWriter = new RandomIndexWriter(random(), directory)) {
@@ -123,11 +118,9 @@ public void testTwoFields() throws Exception {
 
     public void testTwoFieldsReduce() throws Exception {
         String fieldA = "a";
-        MappedFieldType ftA = new NumberFieldMapper.NumberFieldType(NumberFieldMapper.NumberType.DOUBLE);
-        ftA.setName(fieldA);
+        MappedFieldType ftA = new NumberFieldMapper.NumberFieldType(fieldA, NumberFieldMapper.NumberType.DOUBLE);
         String fieldB = "b";
-        MappedFieldType ftB = new NumberFieldMapper.NumberFieldType(NumberFieldMapper.NumberType.DOUBLE);
-        ftB.setName(fieldB);
+        MappedFieldType ftB = new NumberFieldMapper.NumberFieldType(fieldB, NumberFieldMapper.NumberType.DOUBLE);
 
         try (Directory directory = newDirectory();
              RandomIndexWriter indexWriter = new RandomIndexWriter(random(), directory)) {

modules/lang-expression/src/test/java/org/elasticsearch/script/expression/ExpressionFieldScriptTests.java

@@ -47,7 +47,7 @@ public class ExpressionFieldScriptTests extends ESTestCase {
     public void setUp() throws Exception {
         super.setUp();
 
-        NumberFieldMapper.NumberFieldType fieldType = new NumberFieldMapper.NumberFieldType(NumberFieldMapper.NumberType.DOUBLE);
+        NumberFieldMapper.NumberFieldType fieldType = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.DOUBLE);
         MapperService mapperService = mock(MapperService.class);
         when(mapperService.fieldType("field")).thenReturn(fieldType);
         when(mapperService.fieldType("alias")).thenReturn(fieldType);

modules/lang-expression/src/test/java/org/elasticsearch/script/expression/ExpressionNumberSortScriptTests.java

@@ -46,7 +46,7 @@ public class ExpressionNumberSortScriptTests extends ESTestCase {
     public void setUp() throws Exception {
         super.setUp();
 
-        NumberFieldType fieldType = new NumberFieldType(NumberType.DOUBLE);
+        NumberFieldType fieldType = new NumberFieldType("field", NumberType.DOUBLE);
         MapperService mapperService = mock(MapperService.class);
         when(mapperService.fieldType("field")).thenReturn(fieldType);
         when(mapperService.fieldType("alias")).thenReturn(fieldType);

modules/lang-expression/src/test/java/org/elasticsearch/script/expression/ExpressionTermsSetQueryTests.java

@@ -46,7 +46,7 @@ public class ExpressionTermsSetQueryTests extends ESTestCase {
     public void setUp() throws Exception {
         super.setUp();
 
-        NumberFieldType fieldType = new NumberFieldType(NumberType.DOUBLE);
+        NumberFieldType fieldType = new NumberFieldType("field", NumberType.DOUBLE);
         MapperService mapperService = mock(MapperService.class);
         when(mapperService.fieldType("field")).thenReturn(fieldType);
         when(mapperService.fieldType("alias")).thenReturn(fieldType);

modules/mapper-extras/src/main/java/org/elasticsearch/index/mapper/RankFeatureFieldMapper.java

@@ -20,6 +20,7 @@
 package org.elasticsearch.index.mapper;
 
 import org.apache.lucene.document.FeatureField;
+import org.apache.lucene.document.FieldType;
 import org.apache.lucene.index.IndexOptions;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.search.Query;
@@ -36,7 +37,6 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 
 /**
  * A {@link FieldMapper} that exposes Lucene's {@link FeatureField}.
@@ -46,40 +46,34 @@ public class RankFeatureFieldMapper extends FieldMapper {
     public static final String CONTENT_TYPE = "rank_feature";
 
     public static class Defaults {
-        public static final MappedFieldType FIELD_TYPE = new RankFeatureFieldType();
+        public static final FieldType FIELD_TYPE = new FieldType();
 
         static {
             FIELD_TYPE.setTokenized(false);
             FIELD_TYPE.setIndexOptions(IndexOptions.NONE);
-            FIELD_TYPE.setHasDocValues(false);
             FIELD_TYPE.setOmitNorms(true);
             FIELD_TYPE.freeze();
         }
     }
 
     public static class Builder extends FieldMapper.Builder<Builder> {
 
+        private boolean positiveScoreImpact = true;
+
         public Builder(String name) {
-            super(name, Defaults.FIELD_TYPE, Defaults.FIELD_TYPE);
+            super(name, Defaults.FIELD_TYPE);
             builder = this;
         }
 
-        @Override
-        public RankFeatureFieldType fieldType() {
-            return (RankFeatureFieldType) super.fieldType();
-        }
-
         public Builder positiveScoreImpact(boolean v) {
-            fieldType().setPositiveScoreImpact(v);
+            this.positiveScoreImpact = v;
             return builder;
         }
 
         @Override
         public RankFeatureFieldMapper build(BuilderContext context) {
-            setupFieldType(context);
-            return new RankFeatureFieldMapper(
-                    name, fieldType, defaultFieldType,
-                    context.indexSettings(), multiFieldsBuilder.build(this, context), copyTo);
+            return new RankFeatureFieldMapper(name, fieldType, new RankFeatureFieldType(buildFullName(context), meta, positiveScoreImpact),
+                context.indexSettings(), multiFieldsBuilder.build(this, context), copyTo, positiveScoreImpact);
         }
     }
 
@@ -102,9 +96,11 @@ public Mapper.Builder<?> parse(String name, Map<String, Object> node, ParserCont
 
     public static final class RankFeatureFieldType extends MappedFieldType {
 
-        private boolean positiveScoreImpact = true;
+        private final boolean positiveScoreImpact;
 
-        public RankFeatureFieldType() {
+        public RankFeatureFieldType(String name, Map<String, String> meta, boolean positiveScoreImpact) {
+            super(name, true, false, meta);
+            this.positiveScoreImpact = positiveScoreImpact;
             setIndexAnalyzer(Lucene.KEYWORD_ANALYZER);
             setSearchAnalyzer(Lucene.KEYWORD_ANALYZER);
         }
@@ -118,22 +114,6 @@ public RankFeatureFieldType clone() {
             return new RankFeatureFieldType(this);
         }
 
-        @Override
-        public boolean equals(Object o) {
-            if (super.equals(o) == false) {
-                return false;
-            }
-            RankFeatureFieldType other = (RankFeatureFieldType) o;
-            return Objects.equals(positiveScoreImpact, other.positiveScoreImpact);
-        }
-
-        @Override
-        public int hashCode() {
-            int h = super.hashCode();
-            h = 31 * h + Objects.hashCode(positiveScoreImpact);
-            return h;
-        }
-
         @Override
         public String typeName() {
             return CONTENT_TYPE;
@@ -143,11 +123,6 @@ public boolean positiveScoreImpact() {
             return positiveScoreImpact;
         }
 
-        public void setPositiveScoreImpact(boolean positiveScoreImpact) {
-            checkIfFrozen();
-            this.positiveScoreImpact = positiveScoreImpact;
-        }
-
         @Override
         public Query existsQuery(QueryShardContext context) {
             return new TermQuery(new Term("_feature", name()));
@@ -164,10 +139,14 @@ public Query termQuery(Object value, QueryShardContext context) {
         }
     }
 
-    private RankFeatureFieldMapper(String simpleName, MappedFieldType fieldType, MappedFieldType defaultFieldType,
-                                Settings indexSettings, MultiFields multiFields, CopyTo copyTo) {
-        super(simpleName, fieldType, defaultFieldType, indexSettings, multiFields, copyTo);
+    private final boolean positiveScoreImpact;
+
+    private RankFeatureFieldMapper(String simpleName, FieldType fieldType, MappedFieldType mappedFieldType,
+                                   Settings indexSettings, MultiFields multiFields, CopyTo copyTo,
+                                   boolean positiveScoreImpact) {
+        super(simpleName, fieldType, mappedFieldType, indexSettings, multiFields, copyTo);
         assert fieldType.indexOptions().compareTo(IndexOptions.DOCS_AND_FREQS) <= 0;
+        this.positiveScoreImpact = positiveScoreImpact;
     }
 
     @Override
@@ -202,7 +181,7 @@ protected void parseCreateField(ParseContext context) throws IOException {
                 name() + "] in the same document");
         }
 
-        if (fieldType().positiveScoreImpact() == false) {
+        if (positiveScoreImpact == false) {
             value = 1 / value;
         }
 
@@ -218,15 +197,19 @@ protected String contentType() {
     protected void doXContentBody(XContentBuilder builder, boolean includeDefaults, Params params) throws IOException {
         super.doXContentBody(builder, includeDefaults, params);
 
-        if (includeDefaults || fieldType().positiveScoreImpact() == false) {
-            builder.field("positive_score_impact", fieldType().positiveScoreImpact());
+        if (includeDefaults || positiveScoreImpact == false) {
+            builder.field("positive_score_impact", positiveScoreImpact);
         }
     }
 
+    @Override
+    protected boolean docValuesByDefault() {
+        return false;
+    }
+
     @Override
     protected void mergeOptions(FieldMapper other, List<String> conflicts) {
-        RankFeatureFieldType ft = (RankFeatureFieldType) other.fieldType();
-        if (fieldType().positiveScoreImpact != ft.positiveScoreImpact()) {
+        if (positiveScoreImpact != ((RankFeatureFieldMapper)other).positiveScoreImpact) {
             conflicts.add("mapper [" + name() + "] has different [positive_score_impact] values");
         }
     }

modules/mapper-extras/src/main/java/org/elasticsearch/index/mapper/RankFeatureMetaFieldMapper.java

@@ -19,9 +19,9 @@
 
 package org.elasticsearch.index.mapper;
 
+import org.apache.lucene.document.FieldType;
 import org.apache.lucene.index.IndexOptions;
 import org.apache.lucene.search.Query;
-import org.elasticsearch.common.lucene.Lucene;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.xcontent.XContentBuilder;
 import org.elasticsearch.index.query.QueryShardContext;
@@ -42,45 +42,41 @@ public class RankFeatureMetaFieldMapper extends MetadataFieldMapper {
     public static final String CONTENT_TYPE = "_feature";
 
     public static class Defaults {
-        public static final MappedFieldType FIELD_TYPE = new RankFeatureMetaFieldType();
+        public static final FieldType FIELD_TYPE = new FieldType();
 
         static {
             FIELD_TYPE.setIndexOptions(IndexOptions.DOCS_AND_FREQS);
             FIELD_TYPE.setTokenized(true);
             FIELD_TYPE.setStored(false);
             FIELD_TYPE.setOmitNorms(true);
-            FIELD_TYPE.setIndexAnalyzer(Lucene.KEYWORD_ANALYZER);
-            FIELD_TYPE.setSearchAnalyzer(Lucene.KEYWORD_ANALYZER);
-            FIELD_TYPE.setName(NAME);
             FIELD_TYPE.freeze();
         }
     }
 
     public static class Builder extends MetadataFieldMapper.Builder<Builder> {
 
-        public Builder(MappedFieldType existing) {
-            super(NAME, existing == null ? Defaults.FIELD_TYPE : existing, Defaults.FIELD_TYPE);
+        public Builder() {
+            super(NAME, Defaults.FIELD_TYPE);
         }
 
         @Override
         public RankFeatureMetaFieldMapper build(BuilderContext context) {
-            setupFieldType(context);
-            return new RankFeatureMetaFieldMapper(fieldType, context.indexSettings());
+            return new RankFeatureMetaFieldMapper(context.indexSettings());
         }
     }
 
     public static class TypeParser implements MetadataFieldMapper.TypeParser {
         @Override
         public MetadataFieldMapper.Builder<?> parse(String name,
                 Map<String, Object> node, ParserContext parserContext) throws MapperParsingException {
-            return new Builder(parserContext.mapperService().fieldType(NAME));
+            return new Builder();
         }
 
         @Override
         public MetadataFieldMapper getDefault(MappedFieldType fieldType, ParserContext context) {
             final Settings indexSettings = context.mapperService().getIndexSettings().getSettings();
             if (fieldType != null) {
-                return new RankFeatureMetaFieldMapper(indexSettings, fieldType);
+                return new RankFeatureMetaFieldMapper(indexSettings);
             } else {
                 return parse(NAME, Collections.emptyMap(), context)
                         .build(new BuilderContext(indexSettings, new ContentPath(1)));
@@ -90,7 +86,10 @@ public MetadataFieldMapper getDefault(MappedFieldType fieldType, ParserContext c
 
     public static final class RankFeatureMetaFieldType extends MappedFieldType {
 
-        public RankFeatureMetaFieldType() {
+        public static final RankFeatureMetaFieldType INSTANCE = new RankFeatureMetaFieldType();
+
+        private RankFeatureMetaFieldType() {
+            super(NAME, false, false, Collections.emptyMap());
         }
 
         protected RankFeatureMetaFieldType(RankFeatureMetaFieldType ref) {
@@ -118,12 +117,8 @@ public Query termQuery(Object value, QueryShardContext context) {
         }
     }
 
-    private RankFeatureMetaFieldMapper(Settings indexSettings, MappedFieldType existing) {
-        this(existing.clone(), indexSettings);
-    }
-
-    private RankFeatureMetaFieldMapper(MappedFieldType fieldType, Settings indexSettings) {
-        super(NAME, fieldType, Defaults.FIELD_TYPE, indexSettings);
+    private RankFeatureMetaFieldMapper(Settings indexSettings) {
+        super(Defaults.FIELD_TYPE, RankFeatureMetaFieldType.INSTANCE, indexSettings);
     }
 
     @Override