working search on constant_keyword

Author: piergm

server/src/internalClusterTest/java/org/elasticsearch/search/fetch/subphase/highlight/HighlighterSearchIT.java

@@ -75,6 +75,7 @@
 import static org.elasticsearch.index.query.QueryBuilders.constantScoreQuery;
 import static org.elasticsearch.index.query.QueryBuilders.existsQuery;
 import static org.elasticsearch.index.query.QueryBuilders.fuzzyQuery;
+import static org.elasticsearch.index.query.QueryBuilders.matchAllQuery;
 import static org.elasticsearch.index.query.QueryBuilders.matchPhrasePrefixQuery;
 import static org.elasticsearch.index.query.QueryBuilders.matchPhraseQuery;
 import static org.elasticsearch.index.query.QueryBuilders.matchQuery;
@@ -3551,7 +3552,7 @@ public Analyzer get() {
     }
 
     public void testConstantKeywordFieldHighlighting() throws IOException {
-        // check that keyword highlighting works
+        // check that constant_keyword highlighting works
         XContentBuilder mappings = jsonBuilder();
         mappings.startObject();
         mappings.startObject("_doc")
@@ -3573,24 +3574,21 @@ public void testConstantKeywordFieldHighlighting() throws IOException {
             .setId("1")
             .setSource(
                 jsonBuilder().startObject()
-                    .field("level", "DEBUG")
-                     .field("message", "some text")
+                    .field("message", "some text")
                     .endObject()
             )
             .get();
         refresh();
         SearchResponse search = client().prepareSearch()
             .setSource(
-                new SearchSourceBuilder().query(QueryBuilders.matchQuery("message", "some"))
+                new SearchSourceBuilder().query(QueryBuilders.termQuery("level", "DEBUG"))
                     .highlighter(new HighlightBuilder().field("*"))
             )
             .get();
         assertNoFailures(search);
-
         assertThat(
-
-            search.getHits().getAt(0).getHighlightFields().get("message").getFragments()[0].toString(),
-            equalTo("<em>some</em> text")
+            search.getHits().getAt(0).getHighlightFields().get("level").getFragments()[0].toString(),
+            equalTo("<em>DEBUG</em>")
         );
     }
 

server/src/internalClusterTest/java/org/elasticsearch/search/fetch/subphase/highlight/constantkeyword/MockConstantFieldMapper.java

@@ -8,16 +8,11 @@
 
 package org.elasticsearch.search.fetch.subphase.highlight.constantkeyword;
 
-import org.elasticsearch.common.lucene.Lucene;
-import org.elasticsearch.index.analysis.NamedAnalyzer;
 import org.elasticsearch.index.mapper.DocumentParserContext;
 import org.elasticsearch.index.mapper.FieldMapper;
 import org.elasticsearch.index.mapper.MapperBuilderContext;
-import org.elasticsearch.index.mapper.MapperParsingException;
-import org.elasticsearch.xcontent.XContentBuilder;
 
 import java.util.Map;
-import java.util.Objects;
 
 class MockConstantFieldMapper extends FieldMapper {
     @Override
@@ -34,35 +29,20 @@ private static MockConstantFieldMapper toType(FieldMapper in) {
 
     public static class Builder extends FieldMapper.Builder {
 
-        // This is defined as updateable because it can be updated once, from [null] to any value,
-        // by a dynamic mapping update. Once it has been set, however, the value cannot be changed.
-        private final Parameter<String> value = new Parameter<>("value", true, () -> null, (n, c, o) -> {
-            if (o instanceof Number == false && o instanceof CharSequence == false) {
-                throw new MapperParsingException(
-                    "Property [value] on field [" + n + "] must be a number or a string, but got [" + o + "]"
-                );
-            }
-            return o.toString();
-        }, m -> toType(m).fieldType().value, XContentBuilder::field, Objects::toString);
-        private final Parameter<Map<String, String>> meta = Parameter.metaParam();
+        private final Parameter<String> value = Parameter.stringParam("value", false, m -> toType(m).fieldType().value, null);
 
         protected Builder(String name) {
             super(name);
-            value.setSerializerCheck((id, ic, v) -> v != null);
-            value.setMergeValidator((previous, current, c) -> previous == null || Objects.equals(previous, current));
         }
 
         @Override
         protected Parameter<?>[] getParameters() {
-            return new Parameter<?>[]{value, meta};
+            return new Parameter<?>[] { value };
         }
 
         @Override
         public MockConstantFieldMapper build(MapperBuilderContext context) {
-            return new MockConstantFieldMapper(
-                name,
-                new MockConstantFieldType(context.buildFullName(name), value.getValue(), meta.getValue())
-            );
+            return new MockConstantFieldMapper(name, new MockConstantFieldType(context.buildFullName(name), value.getValue(), Map.of()));
         }
     }
 
@@ -72,21 +52,15 @@ public MockConstantFieldMapper build(MapperBuilderContext context) {
     }
 
     @Override
-    public Map<String, NamedAnalyzer> indexAnalyzers() {
-        return Map.of(mappedFieldType.name(), Lucene.KEYWORD_ANALYZER);
-    }
-
-    @Override
-    protected void parseCreateField(DocumentParserContext context) {
-    }
+    protected void parseCreateField(DocumentParserContext context) {}
 
     @Override
     protected String contentType() {
         return MockConstantFieldType.CONTENT_TYPE;
     }
 
     @Override
-    public Builder getMergeBuilder() {
-        return new Builder(mappedFieldType.name());
+    public FieldMapper.Builder getMergeBuilder() {
+        return new Builder(mappedFieldType.name()).init(this);
     }
 }

server/src/internalClusterTest/java/org/elasticsearch/search/fetch/subphase/highlight/constantkeyword/MockConstantFieldType.java

@@ -15,18 +15,13 @@
 import org.apache.lucene.search.Query;
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.common.regex.Regex;
-import org.elasticsearch.index.fielddata.FieldData;
 import org.elasticsearch.index.fielddata.FieldDataContext;
 import org.elasticsearch.index.fielddata.IndexFieldData;
-import org.elasticsearch.index.fielddata.plain.ConstantIndexFieldData;
 import org.elasticsearch.index.mapper.ConstantFieldType;
 import org.elasticsearch.index.mapper.KeywordFieldMapper;
 import org.elasticsearch.index.mapper.ValueFetcher;
 import org.elasticsearch.index.query.SearchExecutionContext;
-import org.elasticsearch.script.field.KeywordDocValuesField;
-import org.elasticsearch.search.aggregations.support.CoreValuesSourceType;
 
-import java.util.Locale;
 import java.util.Map;
 
 public class MockConstantFieldType extends ConstantFieldType {
@@ -55,12 +50,7 @@ public String familyTypeName() {
 
     @Override
     public IndexFieldData.Builder fielddataBuilder(FieldDataContext fieldDataContext) {
-        return new ConstantIndexFieldData.Builder(
-            value,
-            name(),
-            CoreValuesSourceType.KEYWORD,
-            (dv, n) -> new KeywordDocValuesField(FieldData.toString(dv), n)
-        );
+        throw new UnsupportedOperationException();
     }
 
     @Override
@@ -83,22 +73,7 @@ public Object valueForDisplay(Object value) {
 
     @Override
     public TermsEnum getTerms(IndexReader reader, String prefix, boolean caseInsensitive, String searchAfter) {
-        if (value == null) {
-            return TermsEnum.EMPTY;
-        }
-        boolean matches = caseInsensitive
-            ? value.toLowerCase(Locale.ROOT).startsWith(prefix.toLowerCase(Locale.ROOT))
-            : value.startsWith(prefix);
-        if (matches == false) {
-            return TermsEnum.EMPTY;
-        }
-        if (searchAfter != null) {
-            if (searchAfter.compareTo(value) >= 0) {
-                // The constant value is before the searchAfter value so must be ignored
-                return TermsEnum.EMPTY;
-            }
-        }
-        return TermsEnum.EMPTY;
+        throw new UnsupportedOperationException();
     }
 
     @Override