Switch back to using name

romseygeek · romseygeek · commit b3afee57d850 · 2021-02-22T13:03:40.000Z
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/DocValueFetcher.java b/server/src/main/java/org/elasticsearch/index/mapper/DocValueFetcher.java
@@ -19,16 +19,16 @@
  */
 public final class DocValueFetcher implements ValueFetcher {
     private final DocValueFormat format;
-    private final MappedFieldType fieldType;
+    private final String field;
 
-    public DocValueFetcher(DocValueFormat format, MappedFieldType fieldType) {
+    public DocValueFetcher(DocValueFormat format, String field) {
         this.format = format;
-        this.fieldType = fieldType;
+        this.field = field;
     }
 
     @Override
     public List<Object> fetchValues(ValuesLookup lookup) throws IOException {
-        return lookup.docValues(fieldType, format);
+        return lookup.docValues(field, format);
     }
 
 }
diff --git a/server/src/main/java/org/elasticsearch/runtimefields/mapper/AbstractScriptFieldType.java b/server/src/main/java/org/elasticsearch/runtimefields/mapper/AbstractScriptFieldType.java
@@ -200,7 +200,7 @@ protected final void checkAllowExpensiveQueries(SearchExecutionContext context)
 
     @Override
     public ValueFetcher valueFetcher(SearchExecutionContext context, String format) {
-        return new DocValueFetcher(docValueFormat(format, null), this);
+        return new DocValueFetcher(docValueFormat(format, null), name());
     }
 
     @Override
diff --git a/server/src/main/java/org/elasticsearch/search/fetch/subphase/FetchDocValuesPhase.java b/server/src/main/java/org/elasticsearch/search/fetch/subphase/FetchDocValuesPhase.java
@@ -47,7 +47,7 @@ public FetchSubPhaseProcessor getProcessor(FetchContext context) {
             }
             ValueFetcher fetcher = new DocValueFetcher(
                 ft.docValueFormat(fieldAndFormat.format, null),
-                ft
+                fieldAndFormat.field
             );
             fields.add(new DocValueField(fieldAndFormat.field, fetcher));
         }
diff --git a/server/src/main/java/org/elasticsearch/search/lookup/LeafDocLookup.java b/server/src/main/java/org/elasticsearch/search/lookup/LeafDocLookup.java
@@ -69,10 +69,14 @@ public int hashCode() {
         }
     }
 
-    public ScriptDocValues<?> get(MappedFieldType fieldType, DocValueFormat format) {
-        FormatKey key = new FormatKey(fieldType.name(), format);
+    public ScriptDocValues<?> get(String name, DocValueFormat format) {
+        FormatKey key = new FormatKey(name, format);
         ScriptDocValues<?> scriptValues = localCacheFormattedData.get(key);
         if (scriptValues == null) {
+            MappedFieldType fieldType = fieldTypeLookup.apply(name);
+            if (fieldType == null) {
+                throw new IllegalArgumentException("Unknown field [" + name + "]");
+            }
             // load fielddata on behalf of the script: otherwise it would need additional permissions
             // to deal with pagedbytes/ramusagestimator/etc
             scriptValues = AccessController.doPrivileged(new PrivilegedAction<ScriptDocValues<?>>() {
diff --git a/server/src/main/java/org/elasticsearch/search/lookup/LeafSearchLookup.java b/server/src/main/java/org/elasticsearch/search/lookup/LeafSearchLookup.java
@@ -9,7 +9,6 @@
 package org.elasticsearch.search.lookup;
 
 import org.apache.lucene.index.LeafReaderContext;
-import org.elasticsearch.index.mapper.MappedFieldType;
 import org.elasticsearch.search.DocValueFormat;
 
 import java.util.ArrayList;
@@ -56,8 +55,8 @@ public LeafDocLookup doc() {
     }
 
     @Override
-    public List<Object> docValues(MappedFieldType fieldType, DocValueFormat format) {
-        return new ArrayList<>(this.docMap.get(fieldType, format));
+    public List<Object> docValues(String field, DocValueFormat format) {
+        return new ArrayList<>(this.docMap.get(field, format));
     }
 
     public void setDocument(int docId) {
diff --git a/server/src/main/java/org/elasticsearch/search/lookup/ValuesLookup.java b/server/src/main/java/org/elasticsearch/search/lookup/ValuesLookup.java
@@ -30,7 +30,7 @@ public interface ValuesLookup {
     /**
      * Returns a LeafDocLookup positioned on the current document
      */
-    List<Object> docValues(MappedFieldType fieldType, DocValueFormat format);
+    List<Object> docValues(String field, DocValueFormat format);
 
     /**
      * Override the source exposed by a ValuesLookup
@@ -46,8 +46,8 @@ public SourceLookup source() {
             }
 
             @Override
-            public List<Object> docValues(MappedFieldType fieldType, DocValueFormat format) {
-                return in.docValues(fieldType, format);
+            public List<Object> docValues(String field, DocValueFormat format) {
+                return in.docValues(field, format);
             }
         };
     }
@@ -65,7 +65,7 @@ public SourceLookup source() {
             }
 
             @Override
-            public List<Object> docValues(MappedFieldType fieldType, DocValueFormat format) {
+            public List<Object> docValues(String field, DocValueFormat format) {
                 throw new UnsupportedOperationException("FieldData is not available from a source-only lookup");
             }
         };
@@ -84,7 +84,7 @@ public SourceLookup source() {
             }
 
             @Override
-            public List<Object> docValues(MappedFieldType fieldType, DocValueFormat format) {
+            public List<Object> docValues(String field, DocValueFormat format) {
                 throw new UnsupportedOperationException("FieldData is not available from a source-only lookup");
             }
         };
diff --git a/test/framework/src/main/java/org/elasticsearch/index/mapper/MapperTestCase.java b/test/framework/src/main/java/org/elasticsearch/index/mapper/MapperTestCase.java
@@ -305,7 +305,7 @@ protected final List<?> fetchFromDocValues(MapperService mapperService, MappedFi
             iw.addDocument(mapperService.documentMapper().parse(source(b -> b.field(ft.name(), sourceValue))).rootDoc());
         }, iw -> {
             SearchLookup lookup = new SearchLookup(mapperService::fieldType, fieldDataLookup);
-            ValueFetcher valueFetcher = new DocValueFetcher(format, ft);
+            ValueFetcher valueFetcher = new DocValueFetcher(format, ft.name());
             IndexSearcher searcher = newSearcher(iw);
             LeafReaderContext context = searcher.getIndexReader().leaves().get(0);
             LeafSearchLookup leaf = lookup.getLeafSearchLookup(context);
diff --git a/x-pack/plugin/mapper-flattened/src/main/java/org/elasticsearch/xpack/flattened/mapper/FlattenedFieldMapper.java b/x-pack/plugin/mapper-flattened/src/main/java/org/elasticsearch/xpack/flattened/mapper/FlattenedFieldMapper.java
@@ -11,16 +11,11 @@
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.OrdinalMap;
 import org.apache.lucene.index.Term;
-import org.apache.lucene.search.AutomatonQuery;
 import org.apache.lucene.search.MultiTermQuery;
 import org.apache.lucene.search.PrefixQuery;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.SortField;
-import org.apache.lucene.search.TermInSetQuery;
-import org.apache.lucene.search.TermQuery;
-import org.apache.lucene.search.TermRangeQuery;
 import org.apache.lucene.util.BytesRef;
-import org.elasticsearch.ElasticsearchException;
 import org.elasticsearch.common.lucene.Lucene;
 import org.elasticsearch.common.lucene.search.AutomatonQueries;
 import org.elasticsearch.common.unit.Fuzziness;
@@ -58,13 +53,10 @@
 
 import java.io.IOException;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Supplier;
 
-import static org.elasticsearch.search.SearchService.ALLOW_EXPENSIVE_QUERIES;
-
 /**
  * A field mapper that accepts a JSON object and flattens it into a single field. This data type
  * can be a useful alternative to an 'object' mapping when the object has a large, unknown set
@@ -170,19 +162,17 @@ public FlattenedFieldMapper build(ContentPath contentPath) {
      */
     public static final class KeyedFlattenedFieldType extends StringFieldType {
         private final String key;
-        private final String root;
 
-        public KeyedFlattenedFieldType(String root, boolean indexed, boolean hasDocValues, String key,
+        public KeyedFlattenedFieldType(String name, boolean indexed, boolean hasDocValues, String key,
                                        boolean splitQueriesOnWhitespace, Map<String, String> meta) {
-            super(root + "." + key, indexed, false, hasDocValues,
+            super(name, indexed, false, hasDocValues,
                 splitQueriesOnWhitespace ? TextSearchInfo.WHITESPACE_MATCH_ONLY : TextSearchInfo.SIMPLE_MATCH_ONLY,
                 meta);
             this.key = key;
-            this.root = root;
         }
 
-        private KeyedFlattenedFieldType(String root, String key, RootFlattenedFieldType ref) {
-            this(root, ref.isSearchable(), ref.hasDocValues(), key, ref.splitQueriesOnWhitespace, ref.meta());
+        private KeyedFlattenedFieldType(String name, String key, RootFlattenedFieldType ref) {
+            this(name, ref.isSearchable(), ref.hasDocValues(), key, ref.splitQueriesOnWhitespace, ref.meta());
         }
 
         @Override
@@ -196,7 +186,7 @@ public String key() {
 
         @Override
         public Query existsQuery(SearchExecutionContext context) {
-            Term term = new Term(root, FlattenedFieldParser.createKeyedValue(key, ""));
+            Term term = new Term(name(), FlattenedFieldParser.createKeyedValue(key, ""));
             return new PrefixQuery(term);
         }
 
@@ -215,15 +205,8 @@ public Query rangeQuery(Object lowerTerm,
                     "] fields must include both an upper and a lower bound.");
             }
 
-            if (context.allowExpensiveQueries() == false) {
-                throw new ElasticsearchException("[range] queries on [text] or [keyword] fields cannot be executed when '" +
-                    ALLOW_EXPENSIVE_QUERIES.getKey() + "' is set to false.");
-            }
-            failIfNotIndexed();
-            return new TermRangeQuery(root,
-                indexedValueForSearch(lowerTerm),
-                indexedValueForSearch(upperTerm),
-                includeLower, includeUpper);
+            return super.rangeQuery(lowerTerm, upperTerm,
+                includeLower, includeUpper, context);
         }
 
         @Override
@@ -251,51 +234,7 @@ public Query wildcardQuery(String value,
 
         @Override
         public Query termQueryCaseInsensitive(Object value, SearchExecutionContext context) {
-            return AutomatonQueries.caseInsensitiveTermQuery(new Term(root, indexedValueForSearch(value)));
-        }
-
-        @Override
-        public Query termQuery(Object value, SearchExecutionContext context) {
-            failIfNotIndexed();
-            return new TermQuery(new Term(root, indexedValueForSearch(value)));
-        }
-
-        @Override
-        public Query termsQuery(Collection<?> values, SearchExecutionContext context) {
-            failIfNotIndexed();
-            BytesRef[] bytesRefs = values.stream().map(this::indexedValueForSearch).toArray(BytesRef[]::new);
-            return new TermInSetQuery(root, bytesRefs);
-        }
-
-        @Override
-        public Query prefixQuery(String value, MultiTermQuery.RewriteMethod method, boolean caseInsensitive, SearchExecutionContext context) {
-            if (context.allowExpensiveQueries() == false) {
-                throw new ElasticsearchException("[prefix] queries cannot be executed when '" +
-                    ALLOW_EXPENSIVE_QUERIES.getKey() + "' is set to false. For optimised prefix queries on text " +
-                    "fields please enable [index_prefixes].");
-            }
-            failIfNotIndexed();
-            if (caseInsensitive) {
-                AutomatonQuery query = AutomatonQueries.caseInsensitivePrefixQuery((new Term(root, indexedValueForSearch(value))));
-                if (method != null) {
-                    query.setRewriteMethod(method);
-                }
-                return query;
-
-            }
-            PrefixQuery query = new PrefixQuery(new Term(root, indexedValueForSearch(value)));
-            if (method != null) {
-                query.setRewriteMethod(method);
-            }
-            return query;
-        }
-
-        @Override
-        protected void failIfNotIndexed() {
-            if (isIndexed == false) {
-                // we throw an IAE rather than an ISE so that it translates to a 4xx code rather than 5xx code on the http layer
-                throw new IllegalArgumentException("Cannot search on field [" + root + "] since it is not indexed.");
-            }
+            return AutomatonQueries.caseInsensitiveTermQuery(new Term(name(), indexedValueForSearch(value)));
         }
 
         @Override
@@ -314,7 +253,7 @@ public BytesRef indexedValueForSearch(Object value) {
         @Override
         public IndexFieldData.Builder fielddataBuilder(String fullyQualifiedIndexName, Supplier<SearchLookup> searchLookup) {
             failIfNoDocValues();
-            return new KeyedFlattenedFieldData.Builder(root + "._keyed", key, CoreValuesSourceType.KEYWORD);
+            return new KeyedFlattenedFieldData.Builder(name(), key, CoreValuesSourceType.KEYWORD);
         }
 
         @Override
@@ -501,7 +440,7 @@ public RootFlattenedFieldType fieldType() {
 
     @Override
     public KeyedFlattenedFieldType keyedFieldType(String key) {
-        return new KeyedFlattenedFieldType(name(), key, fieldType());
+        return new KeyedFlattenedFieldType(keyedFieldName(), key, fieldType());
     }
 
     public String keyedFieldName() {

Original file line number	Diff line number	Diff line change
`@@ -19,16 +19,16 @@`
`19`	`19`	`*/`
`20`	`20`	`public final class DocValueFetcher implements ValueFetcher {`
`21`	`21`	`private final DocValueFormat format;`
`22`		`- private final MappedFieldType fieldType;`
	`22`	`+ private final String field;`
`23`	`23`
`24`		`- public DocValueFetcher(DocValueFormat format, MappedFieldType fieldType) {`
	`24`	`+ public DocValueFetcher(DocValueFormat format, String field) {`
`25`	`25`	`this.format = format;`
`26`		`- this.fieldType = fieldType;`
	`26`	`+ this.field = field;`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`@Override`
`30`	`30`	`public List<Object> fetchValues(ValuesLookup lookup) throws IOException {`
`31`		`- return lookup.docValues(fieldType, format);`
	`31`	`+ return lookup.docValues(field, format);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -200,7 +200,7 @@ protected final void checkAllowExpensiveQueries(SearchExecutionContext context)`
`200`	`200`
`201`	`201`	`@Override`
`202`	`202`	`public ValueFetcher valueFetcher(SearchExecutionContext context, String format) {`
`203`		`- return new DocValueFetcher(docValueFormat(format, null), this);`
	`203`	`+ return new DocValueFetcher(docValueFormat(format, null), name());`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public FetchSubPhaseProcessor getProcessor(FetchContext context) {`
`47`	`47`	`}`
`48`	`48`	`ValueFetcher fetcher = new DocValueFetcher(`
`49`	`49`	`ft.docValueFormat(fieldAndFormat.format, null),`
`50`		`- ft`
	`50`	`+ fieldAndFormat.field`
`51`	`51`	`);`
`52`	`52`	`fields.add(new DocValueField(fieldAndFormat.field, fetcher));`
`53`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,6 @@`
`9`	`9`	`package org.elasticsearch.search.lookup;`
`10`	`10`
`11`	`11`	`import org.apache.lucene.index.LeafReaderContext;`
`12`		`-import org.elasticsearch.index.mapper.MappedFieldType;`
`13`	`12`	`import org.elasticsearch.search.DocValueFormat;`
`14`	`13`
`15`	`14`	`import java.util.ArrayList;`
`@@ -56,8 +55,8 @@ public LeafDocLookup doc() {`
`56`	`55`	`}`
`57`	`56`
`58`	`57`	`@Override`
`59`		`- public List<Object> docValues(MappedFieldType fieldType, DocValueFormat format) {`
`60`		`- return new ArrayList<>(this.docMap.get(fieldType, format));`
	`58`	`+ public List<Object> docValues(String field, DocValueFormat format) {`
	`59`	`+ return new ArrayList<>(this.docMap.get(field, format));`
`61`	`60`	`}`
`62`	`61`
`63`	`62`	`public void setDocument(int docId) {`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public interface ValuesLookup {`
`30`	`30`	`/**`
`31`	`31`	`* Returns a LeafDocLookup positioned on the current document`
`32`	`32`	`*/`
`33`		`- List<Object> docValues(MappedFieldType fieldType, DocValueFormat format);`
	`33`	`+ List<Object> docValues(String field, DocValueFormat format);`
`34`	`34`
`35`	`35`	`/**`
`36`	`36`	`* Override the source exposed by a ValuesLookup`
`@@ -46,8 +46,8 @@ public SourceLookup source() {`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`@Override`
`49`		`- public List<Object> docValues(MappedFieldType fieldType, DocValueFormat format) {`
`50`		`- return in.docValues(fieldType, format);`
	`49`	`+ public List<Object> docValues(String field, DocValueFormat format) {`
	`50`	`+ return in.docValues(field, format);`
`51`	`51`	`}`
`52`	`52`	`};`
`53`	`53`	`}`
`@@ -65,7 +65,7 @@ public SourceLookup source() {`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`@Override`
`68`		`- public List<Object> docValues(MappedFieldType fieldType, DocValueFormat format) {`
	`68`	`+ public List<Object> docValues(String field, DocValueFormat format) {`
`69`	`69`	`throw new UnsupportedOperationException("FieldData is not available from a source-only lookup");`
`70`	`70`	`}`
`71`	`71`	`};`
`@@ -84,7 +84,7 @@ public SourceLookup source() {`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`@Override`
`87`		`- public List<Object> docValues(MappedFieldType fieldType, DocValueFormat format) {`
	`87`	`+ public List<Object> docValues(String field, DocValueFormat format) {`
`88`	`88`	`throw new UnsupportedOperationException("FieldData is not available from a source-only lookup");`
`89`	`89`	`}`
`90`	`90`	`};`