Don't expose TextFieldMapper subfields

server/src/main/java/org/elasticsearch/index/mapper/TextFieldMapper.java

@@ -57,7 +57,6 @@
 import org.apache.lucene.util.automaton.Automaton;
 import org.apache.lucene.util.automaton.Operations;
 import org.elasticsearch.Version;
-import org.elasticsearch.common.collect.Iterators;
 import org.elasticsearch.common.lucene.Lucene;
 import org.elasticsearch.common.lucene.search.AutomatonQueries;
 import org.elasticsearch.common.lucene.search.MultiPhrasePrefixQuery;
@@ -80,7 +79,6 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -92,6 +90,7 @@ public class TextFieldMapper extends FieldMapper {
 
     public static final String CONTENT_TYPE = "text";
     private static final String FAST_PHRASE_SUFFIX = "._index_phrase";
+    private static final String FAST_PREFIX_SUFFIX = "._index_prefix";
 
     public static class Defaults {
         public static final double FIELDDATA_MIN_FREQUENCY = 0;
@@ -330,7 +329,7 @@ private TextFieldType buildFieldType(FieldType fieldType, ContentPath contentPat
             return ft;
         }
 
-        private PrefixFieldMapper buildPrefixMapper(ContentPath contentPath, FieldType fieldType, TextFieldType tft) {
+        private SubFieldInfo buildPrefixInfo(ContentPath contentPath, FieldType fieldType, TextFieldType tft) {
             if (indexPrefixes.get() == null) {
                 return null;
             }
@@ -358,16 +357,15 @@ private PrefixFieldMapper buildPrefixMapper(ContentPath contentPath, FieldType f
             if (fieldType.storeTermVectorOffsets()) {
                 pft.setStoreTermVectorOffsets(true);
             }
-            PrefixFieldType prefixFieldType = new PrefixFieldType(tft, fullName + "._index_prefix", indexPrefixes.get());
-            tft.setPrefixFieldType(prefixFieldType);
-            return new PrefixFieldMapper(pft, prefixFieldType, new PrefixWrappedAnalyzer(
+            tft.setIndexPrefixes(indexPrefixes.get().minChars, indexPrefixes.get().maxChars);
+            return new SubFieldInfo(fullName + "._index_prefix", pft, new PrefixWrappedAnalyzer(
                 analyzers.getIndexAnalyzer().analyzer(),
                 analyzers.positionIncrementGap.get(),
-                prefixFieldType.minChars,
-                prefixFieldType.maxChars));
+                indexPrefixes.get().minChars,
+                indexPrefixes.get().maxChars));
         }
 
-        private PhraseFieldMapper buildPhraseMapper(FieldType fieldType, TextFieldType parent) {
+        private SubFieldInfo buildPhraseInfo(FieldType fieldType, TextFieldType parent) {
             if (indexPhrases.get() == false) {
                 return null;
             }
@@ -381,24 +379,24 @@ private PhraseFieldMapper buildPhraseMapper(FieldType fieldType, TextFieldType p
             parent.setIndexPhrases();
             PhraseWrappedAnalyzer a
                 = new PhraseWrappedAnalyzer(analyzers.getIndexAnalyzer().analyzer(), analyzers.positionIncrementGap.get());
-            return new PhraseFieldMapper(phraseFieldType, new PhraseFieldType(parent), a);
+            return new SubFieldInfo(parent.name() + FAST_PHRASE_SUFFIX, phraseFieldType, a);
         }
 
         public Map<String, NamedAnalyzer> indexAnalyzers(String name,
-                                                         PhraseFieldMapper phraseFieldMapper,
-                                                         PrefixFieldMapper prefixFieldMapper) {
+                                                         SubFieldInfo phraseFieldInfo,
+                                                         SubFieldInfo prefixFieldInfo) {
             Map<String, NamedAnalyzer> analyzers = new HashMap<>();
             NamedAnalyzer main = this.analyzers.getIndexAnalyzer();
             analyzers.put(name, main);
-            if (phraseFieldMapper != null) {
+            if (phraseFieldInfo != null) {
                 analyzers.put(
-                    phraseFieldMapper.name(),
-                    new NamedAnalyzer(main.name() + "_phrase", AnalyzerScope.INDEX, phraseFieldMapper.analyzer));
+                    phraseFieldInfo.field,
+                    new NamedAnalyzer(main.name() + "_phrase", AnalyzerScope.INDEX, phraseFieldInfo.analyzer));
             }
-            if (prefixFieldMapper != null) {
+            if (prefixFieldInfo != null) {
                 analyzers.put(
-                    prefixFieldMapper.name(),
-                    new NamedAnalyzer(main.name() + "_prefix", AnalyzerScope.INDEX, prefixFieldMapper.analyzer));
+                    prefixFieldInfo.field,
+                    new NamedAnalyzer(main.name() + "_prefix", AnalyzerScope.INDEX, prefixFieldInfo.analyzer));
             }
             return analyzers;
         }
@@ -407,12 +405,18 @@ public Map<String, NamedAnalyzer> indexAnalyzers(String name,
         public TextFieldMapper build(ContentPath contentPath) {
             FieldType fieldType = TextParams.buildFieldType(index, store, indexOptions, norms, termVectors);
             TextFieldType tft = buildFieldType(fieldType, contentPath);
-            PhraseFieldMapper phraseFieldMapper = buildPhraseMapper(fieldType, tft);
-            PrefixFieldMapper prefixFieldMapper = buildPrefixMapper(contentPath, fieldType, tft);
+            SubFieldInfo phraseFieldInfo = buildPhraseInfo(fieldType, tft);
+            SubFieldInfo prefixFieldInfo = buildPrefixInfo(contentPath, fieldType, tft);
+            MultiFields multiFields = multiFieldsBuilder.build(this, contentPath);
+            for (Mapper mapper : multiFields) {
+                if (mapper.name().endsWith(FAST_PHRASE_SUFFIX) || mapper.name().endsWith(FAST_PREFIX_SUFFIX)) {
+                    throw new MapperParsingException("Cannot use reserved field name [" + mapper.name() + "]");
+                }
+            }
             return new TextFieldMapper(name, fieldType, tft,
-                indexAnalyzers(tft.name(), phraseFieldMapper, prefixFieldMapper),
-                prefixFieldMapper, phraseFieldMapper,
-                multiFieldsBuilder.build(this, contentPath), copyTo.build(), this);
+                indexAnalyzers(tft.name(), phraseFieldInfo, prefixFieldInfo),
+                prefixFieldInfo, phraseFieldInfo,
+                multiFields, copyTo.build(), this);
         }
     }
 
@@ -478,55 +482,22 @@ protected TokenStreamComponents wrapComponents(String fieldName, TokenStreamComp
         }
     }
 
-    static final class PhraseFieldType extends StringFieldType {
-
-        final TextFieldType parent;
-
-        PhraseFieldType(TextFieldType parent) {
-            super(parent.name() + FAST_PHRASE_SUFFIX, true, false, false, parent.getTextSearchInfo(), Collections.emptyMap());
-            this.parent = parent;
-        }
-
-        @Override
-        public String typeName() {
-            return "phrase";
-        }
-
-        @Override
-        public ValueFetcher valueFetcher(QueryShardContext context, SearchLookup searchLookup, String format) {
-            // Because this internal field is modelled as a multi-field, SourceValueFetcher will look up its
-            // parent field in _source. So we don't need to use the parent field name here.
-            return SourceValueFetcher.toString(name(), context, format);
-        }
-
-        @Override
-        public Query existsQuery(QueryShardContext context) {
-            throw new UnsupportedOperationException();
-        }
-    }
-
-    static final class PrefixFieldType extends StringFieldType {
+    private static final class PrefixFieldType extends StringFieldType {
 
         final int minChars;
         final int maxChars;
         final TextFieldType parentField;
 
-        PrefixFieldType(TextFieldType parentField, String name, PrefixConfig config) {
-            this(parentField, name, config.minChars, config.maxChars);
-        }
-
-        PrefixFieldType(TextFieldType parentField, String name, int minChars, int maxChars) {
-            super(name, true, false, false, parentField.getTextSearchInfo(), Collections.emptyMap());
+        PrefixFieldType(TextFieldType parentField, int minChars, int maxChars) {
+            super(parentField.name() + FAST_PREFIX_SUFFIX, true, false, false, parentField.getTextSearchInfo(), Collections.emptyMap());
             this.minChars = minChars;
             this.maxChars = maxChars;
             this.parentField = parentField;
         }
 
         @Override
         public ValueFetcher valueFetcher(QueryShardContext context, SearchLookup searchLookup, String format) {
-            // Because this internal field is modelled as a multi-field, SourceValueFetcher will look up its
-            // parent field in _source. So we don't need to use the parent field name here.
-            return SourceValueFetcher.toString(name(), context, format);
+            throw new UnsupportedOperationException();
         }
 
         boolean accept(int length) {
@@ -590,67 +561,18 @@ public Query existsQuery(QueryShardContext context) {
         }
     }
 
-    private static final class PhraseFieldMapper extends FieldMapper {
+    private static final class SubFieldInfo {
 
         private final Analyzer analyzer;
         private final FieldType fieldType;
+        private final String field;
 
-        PhraseFieldMapper(FieldType fieldType, PhraseFieldType mappedFieldType, PhraseWrappedAnalyzer analyzer) {
-            super(mappedFieldType.name(), mappedFieldType, MultiFields.empty(), CopyTo.empty());
+        SubFieldInfo(String field, FieldType fieldType, Analyzer analyzer) {
             this.fieldType = fieldType;
             this.analyzer = analyzer;
+            this.field = field;
         }
 
-        @Override
-        protected void parseCreateField(ParseContext context) {
-            throw new UnsupportedOperationException();
-        }
-
-        @Override
-        public Builder getMergeBuilder() {
-            return null;
-        }
-
-        @Override
-        protected String contentType() {
-            return "phrase";
-        }
-    }
-
-    private static final class PrefixFieldMapper extends FieldMapper {
-
-        private final Analyzer analyzer;
-        private final FieldType fieldType;
-
-        protected PrefixFieldMapper(FieldType fieldType, PrefixFieldType mappedFieldType, Analyzer analyzer) {
-            super(mappedFieldType.name(), mappedFieldType, MultiFields.empty(), CopyTo.empty());
-            this.analyzer = analyzer;
-            this.fieldType = fieldType;
-        }
-
-        void addField(ParseContext context, String value) {
-            context.doc().add(new Field(fieldType().name(), value, fieldType));
-        }
-
-        @Override
-        protected void parseCreateField(ParseContext context) {
-            throw new UnsupportedOperationException();
-        }
-
-        @Override
-        public Builder getMergeBuilder() {
-            return null;
-        }
-
-        @Override
-        protected String contentType() {
-            return "prefix";
-        }
-
-        @Override
-        public String toString() {
-            return fieldType().toString();
-        }
     }
 
     public static class TextFieldType extends StringFieldType {
@@ -702,8 +624,8 @@ int fielddataMinSegmentSize() {
             return filter.minSegmentSize;
         }
 
-        void setPrefixFieldType(PrefixFieldType prefixFieldType) {
-            this.prefixFieldType = prefixFieldType;
+        void setIndexPrefixes(int minChars, int maxChars) {
+            this.prefixFieldType = new PrefixFieldType(this, minChars, maxChars);
         }
 
         void setIndexPhrases() {
@@ -862,14 +784,14 @@ public IndexFieldData.Builder fielddataBuilder(String fullyQualifiedIndexName, S
 
     private final Builder builder;
     private final FieldType fieldType;
-    private final PrefixFieldMapper prefixFieldMapper;
-    private final PhraseFieldMapper phraseFieldMapper;
+    private final SubFieldInfo prefixFieldInfo;
+    private final SubFieldInfo phraseFieldInfo;
 
     protected TextFieldMapper(String simpleName, FieldType fieldType,
                               TextFieldType mappedFieldType,
                               Map<String, NamedAnalyzer> indexAnalyzers,
-                              PrefixFieldMapper prefixFieldMapper,
-                              PhraseFieldMapper phraseFieldMapper,
+                              SubFieldInfo prefixFieldInfo,
+                              SubFieldInfo phraseFieldInfo,
                               MultiFields multiFields, CopyTo copyTo, Builder builder) {
         super(simpleName, mappedFieldType, indexAnalyzers, multiFields, copyTo);
         assert mappedFieldType.getTextSearchInfo().isTokenized();
@@ -878,8 +800,8 @@ protected TextFieldMapper(String simpleName, FieldType fieldType,
             throw new IllegalArgumentException("Cannot enable fielddata on a [text] field that is not indexed: [" + name() + "]");
         }
         this.fieldType = fieldType;
-        this.prefixFieldMapper = prefixFieldMapper;
-        this.phraseFieldMapper = phraseFieldMapper;
+        this.prefixFieldInfo = prefixFieldInfo;
+        this.phraseFieldInfo = phraseFieldInfo;
         this.builder = builder;
     }
 
@@ -907,30 +829,15 @@ protected void parseCreateField(ParseContext context) throws IOException {
             if (fieldType.omitNorms()) {
                 createFieldNamesField(context);
             }
-            if (prefixFieldMapper != null) {
-                prefixFieldMapper.addField(context, value);
+            if (prefixFieldInfo != null) {
+                context.doc().add(new Field(prefixFieldInfo.field, value, prefixFieldInfo.fieldType));
             }
-            if (phraseFieldMapper != null) {
-                context.doc().add(new Field(phraseFieldMapper.fieldType().name(), value, phraseFieldMapper.fieldType));
+            if (phraseFieldInfo != null) {
+                context.doc().add(new Field(phraseFieldInfo.field, value, phraseFieldInfo.fieldType));
             }
         }
     }
 
-    @Override
-    public Iterator<Mapper> iterator() {
-        List<Mapper> subIterators = new ArrayList<>();
-        if (prefixFieldMapper != null) {
-            subIterators.add(prefixFieldMapper);
-        }
-        if (phraseFieldMapper != null) {
-            subIterators.add(phraseFieldMapper);
-        }
-        if (subIterators.size() == 0) {
-            return super.iterator();
-        }
-        return Iterators.concat(super.iterator(), subIterators.iterator());
-    }
-
     @Override
     protected String contentType() {
         return CONTENT_TYPE;
@@ -1014,10 +921,11 @@ public static Query createPhrasePrefixQuery(TokenStream stream, String field, in
         }
 
         if (terms.length == 1) {
-            Term[] newTerms = Arrays.stream(terms[0])
+            SynonymQuery.Builder sb = new SynonymQuery.Builder(prefixField);
+            Arrays.stream(terms[0])
                 .map(term -> new Term(prefixField, term.bytes()))
-                .toArray(Term[]::new);
-            return new SynonymQuery(newTerms);
+                .forEach(sb::addTerm);
+            return sb.build();
         }
 
         SpanNearQuery.Builder spanQuery = new SpanNearQuery.Builder(field, true);