Replace usages of 'flat object' with 'flattened'. (#64023)

The `flattened` field type went through a couple renames during its
development. This PR makes sure to standardize all naming to 'flattened'.

x-pack/plugin/mapper-flattened/src/internalClusterTest/java/org/elasticsearch/xpack/flattened/mapper/FlatObjectFieldMapperTests.java → x-pack/plugin/mapper-flattened/src/internalClusterTest/java/org/elasticsearch/xpack/flattened/mapper/FlattenedFieldMapperTests.java

@@ -23,8 +23,8 @@ import org.elasticsearch.index.mapper.ParsedDocument;
 import org.elasticsearch.index.mapper.SourceToParse;
 import org.elasticsearch.plugins.Plugin;
 import org.elasticsearch.xpack.flattened.FlattenedMapperPlugin;
-import org.elasticsearch.xpack.flattened.mapper.FlatObjectFieldMapper.KeyedFlatObjectFieldType;
-import org.elasticsearch.xpack.flattened.mapper.FlatObjectFieldMapper.RootFlatObjectFieldType;
+import org.elasticsearch.xpack.flattened.mapper.FlattenedFieldMapper.KeyedFlattenedFieldType;
+import org.elasticsearch.xpack.flattened.mapper.FlattenedFieldMapper.RootFlattenedFieldType;
 
 import java.io.IOException;
 import java.util.Arrays;
@@ -36,7 +36,7 @@ import static org.apache.lucene.analysis.BaseTokenStreamTestCase.assertTokenStre
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.equalTo;
 
-public class FlatObjectFieldMapperTests extends MapperTestCase {
+public class FlattenedFieldMapperTests extends MapperTestCase {
 
     @Override
     protected void minimalMapping(XContentBuilder b) throws IOException {
@@ -59,11 +59,11 @@ public class FlatObjectFieldMapperTests extends MapperTestCase {
         checker.registerUpdateCheck(b -> b.field("eager_global_ordinals", true),
             m -> assertTrue(m.fieldType().eagerGlobalOrdinals()));
         checker.registerUpdateCheck(b -> b.field("ignore_above", 256),
-            m -> assertEquals(256, ((FlatObjectFieldMapper)m).ignoreAbove()));
+            m -> assertEquals(256, ((FlattenedFieldMapper)m).ignoreAbove()));
         checker.registerUpdateCheck(b -> b.field("split_queries_on_whitespace", true),
             m -> assertEquals("_whitespace", m.fieldType().getTextSearchInfo().getSearchAnalyzer().name()));
         checker.registerUpdateCheck(b -> b.field("depth_limit", 10),
-            m -> assertEquals(10, ((FlatObjectFieldMapper)m).depthLimit()));
+            m -> assertEquals(10, ((FlattenedFieldMapper)m).depthLimit()));
     }
 
     @Override
@@ -330,12 +330,12 @@ public class FlatObjectFieldMapperTests extends MapperTestCase {
             b.field("split_queries_on_whitespace", true);
         }));
 
-        RootFlatObjectFieldType rootFieldType = (RootFlatObjectFieldType) mapperService.fieldType("field");
+        RootFlattenedFieldType rootFieldType = (RootFlattenedFieldType) mapperService.fieldType("field");
         assertThat(rootFieldType.getTextSearchInfo().getSearchAnalyzer().name(), equalTo("_whitespace"));
         assertTokenStreamContents(rootFieldType.getTextSearchInfo().getSearchAnalyzer().analyzer().tokenStream("", "Hello World"),
             new String[] {"Hello", "World"});
 
-        KeyedFlatObjectFieldType keyedFieldType = (KeyedFlatObjectFieldType) mapperService.fieldType("field.key");
+        KeyedFlattenedFieldType keyedFieldType = (KeyedFlattenedFieldType) mapperService.fieldType("field.key");
         assertThat(keyedFieldType.getTextSearchInfo().getSearchAnalyzer().name(), equalTo("_whitespace"));
         assertTokenStreamContents(keyedFieldType.getTextSearchInfo().getSearchAnalyzer().analyzer().tokenStream("", "Hello World"),
             new String[] {"Hello", "World"});

x-pack/plugin/mapper-flattened/src/internalClusterTest/java/org/elasticsearch/xpack/flattened/mapper/FlatObjectSearchTests.java → x-pack/plugin/mapper-flattened/src/internalClusterTest/java/org/elasticsearch/xpack/flattened/mapper/FlattenedFieldSearchTests.java

@@ -50,7 +50,7 @@ import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
 import static org.hamcrest.Matchers.notNullValue;
 
-public class FlatObjectSearchTests extends ESSingleNodeTestCase {
+public class FlattenedFieldSearchTests extends ESSingleNodeTestCase {
 
     protected Collection<Class<? extends Plugin>> getPlugins() {
         return pluginList(FlattenedMapperPlugin.class, LocalStateCompositeXPackPlugin.class);
@@ -61,7 +61,7 @@ public class FlatObjectSearchTests extends ESSingleNodeTestCase {
         XContentBuilder mapping = XContentFactory.jsonBuilder().startObject()
             .startObject("_doc")
                 .startObject("properties")
-                    .startObject("flat_object")
+                    .startObject("flattened")
                         .field("type", "flattened")
                         .field("split_queries_on_whitespace", true)
                     .endObject()
@@ -145,7 +145,7 @@ public class FlatObjectSearchTests extends ESSingleNodeTestCase {
             .setRefreshPolicy(RefreshPolicy.IMMEDIATE)
             .setSource(XContentFactory.jsonBuilder()
                 .startObject()
-                    .startObject("flat_object")
+                    .startObject("flattened")
                         .field("field1", "value")
                         .field("field2", "2.718")
                     .endObject()
@@ -153,19 +153,19 @@ public class FlatObjectSearchTests extends ESSingleNodeTestCase {
             .get();
 
         SearchResponse response = client().prepareSearch("test")
-            .setQuery(queryStringQuery("flat_object.field1:value"))
+            .setQuery(queryStringQuery("flattened.field1:value"))
             .get();
         assertSearchResponse(response);
         assertHitCount(response, 1);
 
         response = client().prepareSearch("test")
-            .setQuery(queryStringQuery("flat_object.field1:value AND flat_object:2.718"))
+            .setQuery(queryStringQuery("flattened.field1:value AND flattened:2.718"))
             .get();
         assertSearchResponse(response);
         assertHitCount(response, 1);
 
         response = client().prepareSearch("test")
-            .setQuery(queryStringQuery("2.718").field("flat_object.field2"))
+            .setQuery(queryStringQuery("2.718").field("flattened.field2"))
             .get();
         assertSearchResponse(response);
         assertHitCount(response, 1);
@@ -176,7 +176,7 @@ public class FlatObjectSearchTests extends ESSingleNodeTestCase {
             .setRefreshPolicy(RefreshPolicy.IMMEDIATE)
             .setSource(XContentFactory.jsonBuilder()
                 .startObject()
-                    .startObject("flat_object")
+                    .startObject("flattened")
                         .field("field1", "value")
                         .field("field2", "2.718")
                     .endObject()
@@ -184,19 +184,19 @@ public class FlatObjectSearchTests extends ESSingleNodeTestCase {
             .get();
 
         SearchResponse response = client().prepareSearch("test")
-            .setQuery(simpleQueryStringQuery("value").field("flat_object.field1"))
+            .setQuery(simpleQueryStringQuery("value").field("flattened.field1"))
             .get();
         assertSearchResponse(response);
         assertHitCount(response, 1);
 
         response = client().prepareSearch("test")
-            .setQuery(simpleQueryStringQuery("+value +2.718").field("flat_object"))
+            .setQuery(simpleQueryStringQuery("+value +2.718").field("flattened"))
             .get();
         assertSearchResponse(response);
         assertHitCount(response, 1);
 
         response = client().prepareSearch("test")
-            .setQuery(simpleQueryStringQuery("+value +3.141").field("flat_object"))
+            .setQuery(simpleQueryStringQuery("+value +3.141").field("flattened"))
             .get();
         assertSearchResponse(response);
         assertHitCount(response, 0);
@@ -236,12 +236,12 @@ public class FlatObjectSearchTests extends ESSingleNodeTestCase {
         BulkRequestBuilder bulkRequest = client().prepareBulk("test")
             .setRefreshPolicy(RefreshPolicy.IMMEDIATE);
 
-        // Add a random number of documents containing a flat object field, plus
+        // Add a random number of documents containing a flattened field, plus
         // a small number of dummy documents.
         for (int i = 0; i < numDocs; ++i) {
             bulkRequest.add(client().prepareIndex()
                 .setSource(XContentFactory.jsonBuilder().startObject()
-                    .startObject("flat_object")
+                    .startObject("flattened")
                         .field("first", i)
                         .field("second", i / 2)
                     .endObject()
@@ -256,22 +256,22 @@ public class FlatObjectSearchTests extends ESSingleNodeTestCase {
         BulkResponse bulkResponse = bulkRequest.get();
         assertNoFailures(bulkResponse);
 
-        // Test the root flat object field.
+        // Test the root flattened field.
         SearchResponse response = client().prepareSearch("test")
             .addAggregation(cardinality("cardinality")
                 .precisionThreshold(precisionThreshold)
-                .field("flat_object"))
+                .field("flattened"))
             .get();
 
         assertSearchResponse(response);
         Cardinality count = response.getAggregations().get("cardinality");
         assertCardinality(count, numDocs, precisionThreshold);
 
-        // Test two keyed flat object fields.
+        // Test two keyed flattened fields.
         SearchResponse firstResponse = client().prepareSearch("test")
             .addAggregation(cardinality("cardinality")
                 .precisionThreshold(precisionThreshold)
-                .field("flat_object.first"))
+                .field("flattened.first"))
             .get();
         assertSearchResponse(firstResponse);
 
@@ -281,7 +281,7 @@ public class FlatObjectSearchTests extends ESSingleNodeTestCase {
         SearchResponse secondResponse = client().prepareSearch("test")
             .addAggregation(cardinality("cardinality")
                 .precisionThreshold(precisionThreshold)
-                .field("flat_object.second"))
+                .field("flattened.second"))
             .get();
         assertSearchResponse(secondResponse);
 
@@ -400,7 +400,7 @@ public class FlatObjectSearchTests extends ESSingleNodeTestCase {
             .setRefreshPolicy(RefreshPolicy.IMMEDIATE)
             .setSource(XContentFactory.jsonBuilder()
                 .startObject()
-                .startObject("flat_object")
+                .startObject("flattened")
                 .field("key", "value")
                 .field("other_key", "other_value")
                 .endObject()
@@ -408,20 +408,20 @@ public class FlatObjectSearchTests extends ESSingleNodeTestCase {
             .get();
 
         SearchResponse response = client().prepareSearch("test")
-            .addDocValueField("flat_object")
-            .addDocValueField("flat_object.key")
+            .addDocValueField("flattened")
+            .addDocValueField("flattened.key")
             .get();
         assertSearchResponse(response);
         assertHitCount(response, 1);
 
         Map<String, DocumentField> fields = response.getHits().getAt(0).getFields();
 
-        DocumentField field = fields.get("flat_object");
-        assertEquals("flat_object", field.getName());
+        DocumentField field = fields.get("flattened");
+        assertEquals("flattened", field.getName());
         assertEquals(Arrays.asList("other_value", "value"), field.getValues());
 
-        DocumentField keyedField = fields.get("flat_object.key");
-        assertEquals("flat_object.key", keyedField.getName());
+        DocumentField keyedField = fields.get("flattened.key");
+        assertEquals("flattened.key", keyedField.getName());
         assertEquals("value", keyedField.getValue());
     }
 
@@ -430,7 +430,7 @@ public class FlatObjectSearchTests extends ESSingleNodeTestCase {
             .setRefreshPolicy(RefreshPolicy.IMMEDIATE)
             .setSource(XContentFactory.jsonBuilder()
                 .startObject()
-                .startObject("flat_object")
+                .startObject("flattened")
                 .field("key", "A")
                 .field("other_key", "D")
                 .endObject()
@@ -441,7 +441,7 @@ public class FlatObjectSearchTests extends ESSingleNodeTestCase {
             .setRefreshPolicy(RefreshPolicy.IMMEDIATE)
             .setSource(XContentFactory.jsonBuilder()
                 .startObject()
-                .startObject("flat_object")
+                .startObject("flattened")
                 .field("key", "B")
                 .field("other_key", "C")
                 .endObject()
@@ -452,28 +452,28 @@ public class FlatObjectSearchTests extends ESSingleNodeTestCase {
             .setRefreshPolicy(RefreshPolicy.IMMEDIATE)
             .setSource(XContentFactory.jsonBuilder()
                 .startObject()
-                .startObject("flat_object")
+                .startObject("flattened")
                 .field("other_key", "E")
                 .endObject()
                 .endObject())
             .get();
 
         SearchResponse response = client().prepareSearch("test")
-            .addSort("flat_object", SortOrder.DESC)
+            .addSort("flattened", SortOrder.DESC)
             .get();
         assertSearchResponse(response);
         assertHitCount(response, 3);
         assertOrderedSearchHits(response, "3", "1", "2");
 
         response = client().prepareSearch("test")
-            .addSort("flat_object.key", SortOrder.DESC)
+            .addSort("flattened.key", SortOrder.DESC)
             .get();
         assertSearchResponse(response);
         assertHitCount(response, 3);
         assertOrderedSearchHits(response, "2", "1", "3");
 
         response = client().prepareSearch("test")
-            .addSort(new FieldSortBuilder("flat_object.key").order(SortOrder.DESC).missing("Z"))
+            .addSort(new FieldSortBuilder("flattened.key").order(SortOrder.DESC).missing("Z"))
             .get();
         assertSearchResponse(response);
         assertHitCount(response, 3);

x-pack/plugin/mapper-flattened/src/internalClusterTest/java/org/elasticsearch/xpack/flattened/mapper/FlatObjectIndexFieldDataTests.java → x-pack/plugin/mapper-flattened/src/internalClusterTest/java/org/elasticsearch/xpack/flattened/mapper/FlattenedIndexFieldDataTests.java

@@ -29,14 +29,14 @@ import org.elasticsearch.plugins.Plugin;
 import org.elasticsearch.test.ESSingleNodeTestCase;
 import org.elasticsearch.xpack.core.LocalStateCompositeXPackPlugin;
 import org.elasticsearch.xpack.flattened.FlattenedMapperPlugin;
-import org.elasticsearch.xpack.flattened.mapper.FlatObjectFieldMapper.KeyedFlatObjectFieldData;
-import org.elasticsearch.xpack.flattened.mapper.FlatObjectFieldMapper.KeyedFlatObjectFieldType;
+import org.elasticsearch.xpack.flattened.mapper.FlattenedFieldMapper.KeyedFlattenedFieldData;
+import org.elasticsearch.xpack.flattened.mapper.FlattenedFieldMapper.KeyedFlattenedFieldType;
 
 import java.io.IOException;
 import java.util.Collection;
 import java.util.concurrent.atomic.AtomicInteger;
 
-public class FlatObjectIndexFieldDataTests extends ESSingleNodeTestCase  {
+public class FlattenedIndexFieldDataTests extends ESSingleNodeTestCase  {
 
     @Override
     protected Collection<Class<? extends Plugin>> getPlugins() {
@@ -53,7 +53,7 @@ public class FlatObjectIndexFieldDataTests extends ESSingleNodeTestCase  {
             indexService.mapperService());
 
         Mapper.BuilderContext ctx = new Mapper.BuilderContext(indexService.getIndexSettings().getSettings(), new ContentPath(1));
-        FlatObjectFieldMapper fieldMapper = new FlatObjectFieldMapper.Builder("json").build(ctx);
+        FlattenedFieldMapper fieldMapper = new FlattenedFieldMapper.Builder("json").build(ctx);
 
         AtomicInteger onCacheCalled = new AtomicInteger();
         ifdService.setListener(new IndexFieldDataCache.Listener() {
@@ -79,25 +79,25 @@ public class FlatObjectIndexFieldDataTests extends ESSingleNodeTestCase  {
             new ShardId("test", "_na_", 1));
 
         // Load global field data for subfield 'key'.
-        KeyedFlatObjectFieldType fieldType1 = fieldMapper.keyedFieldType("key");
+        KeyedFlattenedFieldType fieldType1 = fieldMapper.keyedFieldType("key");
         IndexFieldData<?> ifd1 = ifdService.getForField(fieldType1, "test", () -> {
             throw new UnsupportedOperationException("search lookup not available");
         });
-        assertTrue(ifd1 instanceof KeyedFlatObjectFieldData);
+        assertTrue(ifd1 instanceof KeyedFlattenedFieldData);
 
-        KeyedFlatObjectFieldData fieldData1 = (KeyedFlatObjectFieldData) ifd1;
+        KeyedFlattenedFieldData fieldData1 = (KeyedFlattenedFieldData) ifd1;
         assertEquals("key", fieldData1.getKey());
         fieldData1.loadGlobal(reader);
         assertEquals(1, onCacheCalled.get());
 
         // Load global field data for the subfield 'other_key'.
-        KeyedFlatObjectFieldType fieldType2 = fieldMapper.keyedFieldType("other_key");
+        KeyedFlattenedFieldType fieldType2 = fieldMapper.keyedFieldType("other_key");
         IndexFieldData<?> ifd2 = ifdService.getForField(fieldType2, "test", () -> {
             throw new UnsupportedOperationException("search lookup not available");
         });
-        assertTrue(ifd2 instanceof KeyedFlatObjectFieldData);
+        assertTrue(ifd2 instanceof KeyedFlattenedFieldData);
 
-        KeyedFlatObjectFieldData fieldData2 = (KeyedFlatObjectFieldData) ifd2;
+        KeyedFlattenedFieldData fieldData2 = (KeyedFlattenedFieldData) ifd2;
         assertEquals("other_key", fieldData2.getKey());
         fieldData2.loadGlobal(reader);
         assertEquals(1, onCacheCalled.get());

x-pack/plugin/mapper-flattened/src/main/java/org/elasticsearch/xpack/flattened/FlattenedMapperPlugin.java

@@ -9,7 +9,7 @@ package org.elasticsearch.xpack.flattened;
 import org.elasticsearch.index.mapper.Mapper;
 import org.elasticsearch.plugins.MapperPlugin;
 import org.elasticsearch.plugins.Plugin;
-import org.elasticsearch.xpack.flattened.mapper.FlatObjectFieldMapper;
+import org.elasticsearch.xpack.flattened.mapper.FlattenedFieldMapper;
 
 import java.util.Map;
 
@@ -21,6 +21,6 @@ public class FlattenedMapperPlugin extends Plugin implements MapperPlugin {
 
     @Override
     public Map<String, Mapper.TypeParser> getMappers() {
-        return singletonMap(FlatObjectFieldMapper.CONTENT_TYPE, FlatObjectFieldMapper.PARSER);
+        return singletonMap(FlattenedFieldMapper.CONTENT_TYPE, FlattenedFieldMapper.PARSER);
     }
 }

x-pack/plugin/mapper-flattened/src/main/java/org/elasticsearch/xpack/flattened/mapper/FlatObjectFieldMapper.java → x-pack/plugin/mapper-flattened/src/main/java/org/elasticsearch/xpack/flattened/mapper/FlattenedFieldMapper.java

@@ -65,10 +65,10 @@ import java.util.function.Supplier;
  * representations, and indexes each one as a keyword. It creates both a 'keyed' version of the token
  * to allow searches on particular key-value pairs, as well as a 'root' token without the key
  *
- * As an example, given a flat object field called 'flat_object' and the following input
+ * As an example, given a flattened field called 'field' and the following input
  *
  * {
- *   "flat_object": {
+ *   "field": {
  *     "key1": "some value",
  *     "key2": {
  *       "key3": true
@@ -76,12 +76,12 @@ import java.util.function.Supplier;
  *   }
  * }
  *
- * the mapper will produce untokenized string fields with the name "flat_object" and values
- * "some value" and "true", as well as string fields called "flat_object._keyed" with values
+ * the mapper will produce untokenized string fields with the name "field" and values
+ * "some value" and "true", as well as string fields called "field._keyed" with values
  * "key\0some value" and "key2.key3\0true". Note that \0 is used as a reserved separator
- *  character (see {@link FlatObjectFieldParser#SEPARATOR}).
+ *  character (see {@link FlattenedFieldParser#SEPARATOR}).
  */
-public final class FlatObjectFieldMapper extends DynamicKeyFieldMapper {
+public final class FlattenedFieldMapper extends DynamicKeyFieldMapper {
 
     public static final String CONTENT_TYPE = "flattened";
     private static final String KEYED_FIELD_SUFFIX = "._keyed";
@@ -91,7 +91,7 @@ public final class FlatObjectFieldMapper extends DynamicKeyFieldMapper {
     }
 
     private static Builder builder(Mapper in) {
-        return ((FlatObjectFieldMapper)in).builder;
+        return ((FlattenedFieldMapper)in).builder;
     }
 
     public static class Builder extends ParametrizedFieldMapper.Builder {
@@ -135,7 +135,7 @@ public final class FlatObjectFieldMapper extends DynamicKeyFieldMapper {
         }
 
         @Override
-        public FlatObjectFieldMapper build(BuilderContext context) {
+        public FlattenedFieldMapper build(BuilderContext context) {
             MultiFields multiFields = multiFieldsBuilder.build(this, context);
             if (multiFields.iterator().hasNext()) {
                 throw new IllegalArgumentException(CONTENT_TYPE + " field [" + name + "] does not support [fields]");
@@ -144,12 +144,12 @@ public final class FlatObjectFieldMapper extends DynamicKeyFieldMapper {
             if (copyTo.copyToFields().isEmpty() == false) {
                 throw new IllegalArgumentException(CONTENT_TYPE + " field [" + name + "] does not support [copy_to]");
             }
-            MappedFieldType ft = new RootFlatObjectFieldType(
+            MappedFieldType ft = new RootFlattenedFieldType(
                 buildFullName(context), indexed.get(), hasDocValues.get(), meta.get(), splitQueriesOnWhitespace.get());
             if (eagerGlobalOrdinals.get()) {
                 ft.setEagerGlobalOrdinals(true);
             }
-            return new FlatObjectFieldMapper(name, ft, this);
+            return new FlattenedFieldMapper(name, ft, this);
         }
     }
 
@@ -157,13 +157,13 @@ public final class FlatObjectFieldMapper extends DynamicKeyFieldMapper {
 
     /**
      * A field type that represents the values under a particular JSON key, used
-     * when searching under a specific key as in 'my_flat_object.key: some_value'.
+     * when searching under a specific key as in 'my_flattened.key: some_value'.
      */
-    public static final class KeyedFlatObjectFieldType extends StringFieldType {
+    public static final class KeyedFlattenedFieldType extends StringFieldType {
         private final String key;
 
-        public KeyedFlatObjectFieldType(String name, boolean indexed, boolean hasDocValues, String key,
-                                        boolean splitQueriesOnWhitespace, Map<String, String> meta) {
+        public KeyedFlattenedFieldType(String name, boolean indexed, boolean hasDocValues, String key,
+                                       boolean splitQueriesOnWhitespace, Map<String, String> meta) {
             super(name, indexed, false, hasDocValues,
                 splitQueriesOnWhitespace ? TextSearchInfo.WHITESPACE_MATCH_ONLY : TextSearchInfo.SIMPLE_MATCH_ONLY,
                 meta);
@@ -171,7 +171,7 @@ public final class FlatObjectFieldMapper extends DynamicKeyFieldMapper {
             this.key = key;
         }
 
-        private KeyedFlatObjectFieldType(String name, String key, RootFlatObjectFieldType ref) {
+        private KeyedFlattenedFieldType(String name, String key, RootFlattenedFieldType ref) {
             this(name, ref.isSearchable(), ref.hasDocValues(), key, ref.splitQueriesOnWhitespace, ref.meta());
         }
 
@@ -186,7 +186,7 @@ public final class FlatObjectFieldMapper extends DynamicKeyFieldMapper {
 
         @Override
         public Query existsQuery(QueryShardContext context) {
-            Term term = new Term(name(), FlatObjectFieldParser.createKeyedValue(key, ""));
+            Term term = new Term(name(), FlattenedFieldParser.createKeyedValue(key, ""));
             return new PrefixQuery(term);
         }
 
@@ -246,14 +246,14 @@ public final class FlatObjectFieldMapper extends DynamicKeyFieldMapper {
             String stringValue = value instanceof BytesRef
                 ? ((BytesRef) value).utf8ToString()
                 : value.toString();
-            String keyedValue = FlatObjectFieldParser.createKeyedValue(key, stringValue);
+            String keyedValue = FlattenedFieldParser.createKeyedValue(key, stringValue);
             return new BytesRef(keyedValue);
         }
 
         @Override
         public IndexFieldData.Builder fielddataBuilder(String fullyQualifiedIndexName, Supplier<SearchLookup> searchLookup) {
             failIfNoDocValues();
-            return new KeyedFlatObjectFieldData.Builder(name(), key, CoreValuesSourceType.BYTES);
+            return new KeyedFlattenedFieldData.Builder(name(), key, CoreValuesSourceType.BYTES);
         }
 
         @Override
@@ -266,19 +266,19 @@ public final class FlatObjectFieldMapper extends DynamicKeyFieldMapper {
      * A field data implementation that gives access to the values associated with
      * a particular JSON key.
      *
-     * This class wraps the field data that is built directly on the keyed flat object field,
+     * This class wraps the field data that is built directly on the keyed flattened field,
      * and filters out values whose prefix doesn't match the requested key. Loading and caching
-     * is fully delegated to the wrapped field data, so that different {@link KeyedFlatObjectFieldData}
-     * for the same flat object field share the same global ordinals.
+     * is fully delegated to the wrapped field data, so that different {@link KeyedFlattenedFieldData}
+     * for the same flattened field share the same global ordinals.
      *
      * Because of the code-level complexity it would introduce, it is currently not possible
      * to retrieve the underlying global ordinals map through {@link #getOrdinalMap()}.
      */
-    public static class KeyedFlatObjectFieldData implements IndexOrdinalsFieldData {
+    public static class KeyedFlattenedFieldData implements IndexOrdinalsFieldData {
         private final String key;
         private final IndexOrdinalsFieldData delegate;
 
-        private KeyedFlatObjectFieldData(String key, IndexOrdinalsFieldData delegate) {
+        private KeyedFlattenedFieldData(String key, IndexOrdinalsFieldData delegate) {
             this.delegate = delegate;
             this.key = key;
         }
@@ -315,30 +315,30 @@ public final class FlatObjectFieldMapper extends DynamicKeyFieldMapper {
         @Override
         public LeafOrdinalsFieldData load(LeafReaderContext context) {
             LeafOrdinalsFieldData fieldData = delegate.load(context);
-            return new KeyedFlatObjectLeafFieldData(key, fieldData);
+            return new KeyedFlattenedLeafFieldData(key, fieldData);
         }
 
         @Override
         public LeafOrdinalsFieldData loadDirect(LeafReaderContext context) throws Exception {
             LeafOrdinalsFieldData fieldData = delegate.loadDirect(context);
-            return new KeyedFlatObjectLeafFieldData(key, fieldData);
+            return new KeyedFlattenedLeafFieldData(key, fieldData);
         }
 
         @Override
         public IndexOrdinalsFieldData loadGlobal(DirectoryReader indexReader) {
             IndexOrdinalsFieldData fieldData = delegate.loadGlobal(indexReader);
-            return new KeyedFlatObjectFieldData(key, fieldData);
+            return new KeyedFlattenedFieldData(key, fieldData);
         }
 
         @Override
         public IndexOrdinalsFieldData loadGlobalDirect(DirectoryReader indexReader) throws Exception {
             IndexOrdinalsFieldData fieldData = delegate.loadGlobalDirect(indexReader);
-            return new KeyedFlatObjectFieldData(key, fieldData);
+            return new KeyedFlattenedFieldData(key, fieldData);
         }
 
         @Override
         public OrdinalMap getOrdinalMap() {
-            throw new UnsupportedOperationException("The field data for the flat object field ["
+            throw new UnsupportedOperationException("The field data for the flattened field ["
                 + delegate.getFieldName() + "] does not allow access to the underlying ordinal map.");
         }
 
@@ -362,20 +362,20 @@ public final class FlatObjectFieldMapper extends DynamicKeyFieldMapper {
             public IndexFieldData<?> build(IndexFieldDataCache cache, CircuitBreakerService breakerService) {
                 IndexOrdinalsFieldData delegate = new SortedSetOrdinalsIndexFieldData(
                     cache, fieldName, valuesSourceType, breakerService, AbstractLeafOrdinalsFieldData.DEFAULT_SCRIPT_FUNCTION);
-                return new KeyedFlatObjectFieldData(key, delegate);
+                return new KeyedFlattenedFieldData(key, delegate);
             }
         }
     }
 
     /**
      * A field type that represents all 'root' values. This field type is used in
-     * searches on the flat object field itself, e.g. 'my_flat_object: some_value'.
+     * searches on the flattened field itself, e.g. 'my_flattened: some_value'.
      */
-    public static final class RootFlatObjectFieldType extends StringFieldType {
+    public static final class RootFlattenedFieldType extends StringFieldType {
         private final boolean splitQueriesOnWhitespace;
 
-        public RootFlatObjectFieldType(String name, boolean indexed, boolean hasDocValues, Map<String, String> meta,
-                                       boolean splitQueriesOnWhitespace) {
+        public RootFlattenedFieldType(String name, boolean indexed, boolean hasDocValues, Map<String, String> meta,
+                                      boolean splitQueriesOnWhitespace) {
             super(name, indexed, false, hasDocValues,
                 splitQueriesOnWhitespace ? TextSearchInfo.WHITESPACE_MATCH_ONLY : TextSearchInfo.SIMPLE_MATCH_ONLY, meta);
             this.splitQueriesOnWhitespace = splitQueriesOnWhitespace;
@@ -408,15 +408,15 @@ public final class FlatObjectFieldMapper extends DynamicKeyFieldMapper {
         }
     }
 
-    private final FlatObjectFieldParser fieldParser;
+    private final FlattenedFieldParser fieldParser;
     private final Builder builder;
 
-    private FlatObjectFieldMapper(String simpleName,
-                                  MappedFieldType mappedFieldType,
-                                  Builder builder) {
+    private FlattenedFieldMapper(String simpleName,
+                                 MappedFieldType mappedFieldType,
+                                 Builder builder) {
         super(simpleName, mappedFieldType, CopyTo.empty());
         this.builder = builder;
-        this.fieldParser = new FlatObjectFieldParser(mappedFieldType.name(), keyedFieldName(),
+        this.fieldParser = new FlattenedFieldParser(mappedFieldType.name(), keyedFieldName(),
             mappedFieldType, builder.depthLimit.get(), builder.ignoreAbove.get(), builder.nullValue.get());
     }
 
@@ -426,8 +426,8 @@ public final class FlatObjectFieldMapper extends DynamicKeyFieldMapper {
     }
 
     @Override
-    protected FlatObjectFieldMapper clone() {
-        return (FlatObjectFieldMapper) super.clone();
+    protected FlattenedFieldMapper clone() {
+        return (FlattenedFieldMapper) super.clone();
     }
 
     int depthLimit() {
@@ -439,13 +439,13 @@ public final class FlatObjectFieldMapper extends DynamicKeyFieldMapper {
     }
 
     @Override
-    public RootFlatObjectFieldType fieldType() {
-        return (RootFlatObjectFieldType) super.fieldType();
+    public RootFlattenedFieldType fieldType() {
+        return (RootFlattenedFieldType) super.fieldType();
     }
 
     @Override
-    public KeyedFlatObjectFieldType keyedFieldType(String key) {
-        return new KeyedFlatObjectFieldType(keyedFieldName(), key, fieldType());
+    public KeyedFlattenedFieldType keyedFieldType(String key) {
+        return new KeyedFlattenedFieldType(keyedFieldName(), key, fieldType());
     }
 
     public String keyedFieldName() {

x-pack/plugin/mapper-flattened/src/main/java/org/elasticsearch/xpack/flattened/mapper/FlatObjectFieldParser.java → x-pack/plugin/mapper-flattened/src/main/java/org/elasticsearch/xpack/flattened/mapper/FlattenedFieldParser.java

@@ -21,10 +21,10 @@ import java.util.ArrayList;
 import java.util.List;
 
 /**
- * A helper class for {@link FlatObjectFieldMapper} parses a JSON object
+ * A helper class for {@link FlattenedFieldMapper} parses a JSON object
  * and produces a pair of indexable fields for each leaf value.
  */
-class FlatObjectFieldParser {
+class FlattenedFieldParser {
     static final String SEPARATOR = "\0";
     private static final byte SEPARATOR_BYTE = '\0';
 
@@ -36,12 +36,12 @@ class FlatObjectFieldParser {
     private final int ignoreAbove;
     private final String nullValue;
 
-    FlatObjectFieldParser(String rootFieldName,
-                          String keyedFieldName,
-                          MappedFieldType fieldType,
-                          int depthLimit,
-                          int ignoreAbove,
-                          String nullValue) {
+    FlattenedFieldParser(String rootFieldName,
+                         String keyedFieldName,
+                         MappedFieldType fieldType,
+                         int depthLimit,
+                         int ignoreAbove,
+                         String nullValue) {
         this.rootFieldName = rootFieldName;
         this.keyedFieldName = keyedFieldName;
         this.fieldType = fieldType;

x-pack/plugin/mapper-flattened/src/main/java/org/elasticsearch/xpack/flattened/mapper/KeyedFlatObjectLeafFieldData.java → x-pack/plugin/mapper-flattened/src/main/java/org/elasticsearch/xpack/flattened/mapper/KeyedFlattenedLeafFieldData.java

@@ -22,21 +22,21 @@ import java.io.UncheckedIOException;
 import java.util.Collection;
 
 /**
- * The atomic field data implementation for {@link FlatObjectFieldMapper.KeyedFlatObjectFieldType}.
+ * The atomic field data implementation for {@link FlattenedFieldMapper.KeyedFlattenedFieldType}.
  *
- * This class wraps the field data that is built directly on the keyed flat object field,
+ * This class wraps the field data that is built directly on the keyed flattened field,
  * and filters out values whose prefix doesn't match the requested key.
  *
  * In order to support all usage patterns, the delegate's ordinal values are shifted
  * to range from 0 to the number of total values.
  */
-public class KeyedFlatObjectLeafFieldData implements LeafOrdinalsFieldData {
+public class KeyedFlattenedLeafFieldData implements LeafOrdinalsFieldData {
 
     private final String key;
     private final LeafOrdinalsFieldData delegate;
 
-    KeyedFlatObjectLeafFieldData(String key,
-                                 LeafOrdinalsFieldData delegate) {
+    KeyedFlattenedLeafFieldData(String key,
+                                LeafOrdinalsFieldData delegate) {
         this.key = key;
         this.delegate = delegate;
     }
@@ -138,7 +138,7 @@ public class KeyedFlatObjectLeafFieldData implements LeafOrdinalsFieldData {
     }
 
     private static int compare(BytesRef key, BytesRef term) {
-        BytesRef extractedKey = FlatObjectFieldParser.extractKey(term);
+        BytesRef extractedKey = FlattenedFieldParser.extractKey(term);
         return key.compareTo(extractedKey);
     }
 

x-pack/plugin/mapper-flattened/src/test/java/org/elasticsearch/index/mapper/FlatObjectFieldLookupTests.java → x-pack/plugin/mapper-flattened/src/test/java/org/elasticsearch/index/mapper/FlattenedFieldLookupTests.java

@@ -14,8 +14,8 @@ import org.elasticsearch.index.fielddata.ScriptDocValues;
 import org.elasticsearch.search.lookup.LeafDocLookup;
 import org.elasticsearch.search.lookup.SearchLookup;
 import org.elasticsearch.test.ESTestCase;
-import org.elasticsearch.xpack.flattened.mapper.FlatObjectFieldMapper;
-import org.elasticsearch.xpack.flattened.mapper.FlatObjectFieldMapper.KeyedFlatObjectFieldType;
+import org.elasticsearch.xpack.flattened.mapper.FlattenedFieldMapper;
+import org.elasticsearch.xpack.flattened.mapper.FlattenedFieldMapper.KeyedFlattenedFieldType;
 
 import java.util.Arrays;
 import java.util.Collections;
@@ -35,11 +35,11 @@ import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-public class FlatObjectFieldLookupTests extends ESTestCase {
+public class FlattenedFieldLookupTests extends ESTestCase {
 
     public void testFieldTypeLookup() {
         String fieldName = "object1.object2.field";
-        FlatObjectFieldMapper mapper = createFlatObjectMapper(fieldName);
+        FlattenedFieldMapper mapper = createFlattenedMapper(fieldName);
 
         FieldTypeLookup lookup = new FieldTypeLookup(singletonList(mapper), emptyList());
         assertEquals(mapper.fieldType(), lookup.get(fieldName));
@@ -49,15 +49,15 @@ public class FlatObjectFieldLookupTests extends ESTestCase {
 
         MappedFieldType searchFieldType = lookup.get(searchFieldName);
         assertEquals(mapper.keyedFieldName(), searchFieldType.name());
-        assertThat(searchFieldType, instanceOf(KeyedFlatObjectFieldType.class));
+        assertThat(searchFieldType, instanceOf(KeyedFlattenedFieldType.class));
 
-        FlatObjectFieldMapper.KeyedFlatObjectFieldType keyedFieldType = (KeyedFlatObjectFieldType) searchFieldType;
+        KeyedFlattenedFieldType keyedFieldType = (KeyedFlattenedFieldType) searchFieldType;
         assertEquals(objectKey, keyedFieldType.key());
     }
 
     public void testFieldTypeLookupWithAlias() {
         String fieldName = "object1.object2.field";
-        FlatObjectFieldMapper mapper = createFlatObjectMapper(fieldName);
+        FlattenedFieldMapper mapper = createFlattenedMapper(fieldName);
 
         String aliasName = "alias";
         FieldAliasMapper alias = new FieldAliasMapper(aliasName, aliasName, fieldName);
@@ -70,9 +70,9 @@ public class FlatObjectFieldLookupTests extends ESTestCase {
 
         MappedFieldType searchFieldType = lookup.get(searchFieldName);
         assertEquals(mapper.keyedFieldName(), searchFieldType.name());
-        assertThat(searchFieldType, instanceOf(KeyedFlatObjectFieldType.class));
+        assertThat(searchFieldType, instanceOf(KeyedFlattenedFieldType.class));
 
-        KeyedFlatObjectFieldType keyedFieldType = (KeyedFlatObjectFieldType) searchFieldType;
+        KeyedFlattenedFieldType keyedFieldType = (KeyedFlattenedFieldType) searchFieldType;
         assertEquals(objectKey, keyedFieldType.key());
     }
 
@@ -81,9 +81,9 @@ public class FlatObjectFieldLookupTests extends ESTestCase {
         String field2 = "object1.field";
         String field3 = "object2.field";
 
-        FlatObjectFieldMapper mapper1 = createFlatObjectMapper(field1);
-        FlatObjectFieldMapper mapper2 = createFlatObjectMapper(field2);
-        FlatObjectFieldMapper mapper3 = createFlatObjectMapper(field3);
+        FlattenedFieldMapper mapper1 = createFlattenedMapper(field1);
+        FlattenedFieldMapper mapper2 = createFlattenedMapper(field2);
+        FlattenedFieldMapper mapper3 = createFlattenedMapper(field3);
 
         FieldTypeLookup lookup = new FieldTypeLookup(Arrays.asList(mapper1, mapper2), emptyList());
         assertNotNull(lookup.get(field1 + ".some.key"));
@@ -101,19 +101,19 @@ public class FlatObjectFieldLookupTests extends ESTestCase {
         assertEquals(0, DynamicKeyFieldTypeLookup.getMaxKeyDepth(mappers, aliases));
 
         // Add a flattened object field.
-        String flatObjectName = "object1.object2.field";
-        FlatObjectFieldMapper flatObjectField = createFlatObjectMapper(flatObjectName);
-        mappers.put(flatObjectName, flatObjectField);
+        String name = "object1.object2.field";
+        FlattenedFieldMapper flattenedMapper = createFlattenedMapper(name);
+        mappers.put(name, flattenedMapper);
         assertEquals(3, DynamicKeyFieldTypeLookup.getMaxKeyDepth(mappers, aliases));
 
         // Add a short alias to that field.
         String aliasName = "alias";
-        aliases.put(aliasName, flatObjectName);
+        aliases.put(aliasName, name);
         assertEquals(3,  DynamicKeyFieldTypeLookup.getMaxKeyDepth(mappers, aliases));
 
         // Add a longer alias to that field.
         String longAliasName = "object1.object2.object3.alias";
-        aliases.put(longAliasName, flatObjectName);
+        aliases.put(longAliasName, name);
         assertEquals(4,  DynamicKeyFieldTypeLookup.getMaxKeyDepth(mappers, aliases));
 
         // Update the long alias to refer to a non-flattened object field.
@@ -124,9 +124,9 @@ public class FlatObjectFieldLookupTests extends ESTestCase {
 
     public void testFieldLookupIterator() {
         MockFieldMapper mapper = new MockFieldMapper("foo");
-        FlatObjectFieldMapper flatObjectMapper = createFlatObjectMapper("object1.object2.field");
+        FlattenedFieldMapper flattenedMapper = createFlattenedMapper("object1.object2.field");
 
-        FieldTypeLookup lookup = new FieldTypeLookup(Arrays.asList(mapper, flatObjectMapper), emptyList());
+        FieldTypeLookup lookup = new FieldTypeLookup(Arrays.asList(mapper, flattenedMapper), emptyList());
 
         Set<String> fieldNames = new HashSet<>();
         for (MappedFieldType fieldType : lookup) {
@@ -134,15 +134,15 @@ public class FlatObjectFieldLookupTests extends ESTestCase {
         }
 
         assertThat(fieldNames, containsInAnyOrder(
-            mapper.name(), flatObjectMapper.name(), flatObjectMapper.keyedFieldName()));
+            mapper.name(), flattenedMapper.name(), flattenedMapper.keyedFieldName()));
     }
 
-    private FlatObjectFieldMapper createFlatObjectMapper(String fieldName) {
+    private FlattenedFieldMapper createFlattenedMapper(String fieldName) {
         Settings settings = Settings.builder()
             .put("index.version.created", Version.CURRENT)
             .build();
         Mapper.BuilderContext context = new Mapper.BuilderContext(settings, new ContentPath());
-        return new FlatObjectFieldMapper.Builder(fieldName).build(context);
+        return new FlattenedFieldMapper.Builder(fieldName).build(context);
     }
 
     public void testScriptDocValuesLookup() {
@@ -152,13 +152,13 @@ public class FlatObjectFieldLookupTests extends ESTestCase {
         ScriptDocValues<?> docValues2 = mock(ScriptDocValues.class);
         IndexFieldData<?> fieldData2 = createFieldData(docValues2);
 
-        KeyedFlatObjectFieldType fieldType1
-            = new KeyedFlatObjectFieldType("field", true, true, "key1", false, Collections.emptyMap());
-        KeyedFlatObjectFieldType fieldType2
-            = new KeyedFlatObjectFieldType( "field", true, true, "key2", false, Collections.emptyMap());
+        KeyedFlattenedFieldType fieldType1
+            = new KeyedFlattenedFieldType("field", true, true, "key1", false, Collections.emptyMap());
+        KeyedFlattenedFieldType fieldType2
+            = new KeyedFlattenedFieldType( "field", true, true, "key2", false, Collections.emptyMap());
 
         BiFunction<MappedFieldType, Supplier<SearchLookup>, IndexFieldData<?>> fieldDataSupplier = (fieldType, searchLookup) -> {
-            KeyedFlatObjectFieldType keyedFieldType = (KeyedFlatObjectFieldType) fieldType;
+            KeyedFlattenedFieldType keyedFieldType = (KeyedFlattenedFieldType) fieldType;
             return keyedFieldType.key().equals("key1") ? fieldData1 : fieldData2;
         };
 

x-pack/plugin/mapper-flattened/src/test/java/org/elasticsearch/xpack/flattened/mapper/FlatObjectFieldParserTests.java → x-pack/plugin/mapper-flattened/src/test/java/org/elasticsearch/xpack/flattened/mapper/FlattenedFieldParserTests.java

@@ -23,13 +23,13 @@ import org.junit.Before;
 import java.io.IOException;
 import java.util.List;
 
-public class FlatObjectFieldParserTests extends ESTestCase {
-    private FlatObjectFieldParser parser;
+public class FlattenedFieldParserTests extends ESTestCase {
+    private FlattenedFieldParser parser;
 
     @Before
     public void setUp() throws Exception {
         super.setUp();
-        parser = new FlatObjectFieldParser("field", "field._keyed",
+        parser = new FlattenedFieldParser("field", "field._keyed",
             new FakeFieldType("field"),
             Integer.MAX_VALUE,
             Integer.MAX_VALUE,
@@ -209,7 +209,7 @@ public class FlatObjectFieldParserTests extends ESTestCase {
         String input = "{ \"parent1\": { \"key\" : \"value\" }," +
             "\"parent2\": [{ \"key\" : { \"key\" : \"value\" }}]}";
         XContentParser xContentParser = createXContentParser(input);
-        FlatObjectFieldParser configuredParser = new FlatObjectFieldParser("field", "field._keyed",
+        FlattenedFieldParser configuredParser = new FlattenedFieldParser("field", "field._keyed",
             new FakeFieldType("field"), 2, Integer.MAX_VALUE, null);
 
         IllegalArgumentException e = expectThrows(IllegalArgumentException.class,
@@ -221,7 +221,7 @@ public class FlatObjectFieldParserTests extends ESTestCase {
         String input = "{ \"parent1\": { \"key\" : \"value\" }," +
             "\"parent2\": [{ \"key\" : { \"key\" : \"value\" }}]}";
         XContentParser xContentParser = createXContentParser(input);
-        FlatObjectFieldParser configuredParser = new FlatObjectFieldParser("field", "field._keyed",
+        FlattenedFieldParser configuredParser = new FlattenedFieldParser("field", "field._keyed",
             new FakeFieldType("field"), 3, Integer.MAX_VALUE, null);
 
         List<IndexableField> fields = configuredParser.parse(xContentParser);
@@ -231,7 +231,7 @@ public class FlatObjectFieldParserTests extends ESTestCase {
     public void testIgnoreAbove() throws Exception {
         String input = "{ \"key\": \"a longer field than usual\" }";
         XContentParser xContentParser = createXContentParser(input);
-        FlatObjectFieldParser configuredParser = new FlatObjectFieldParser("field", "field._keyed",
+        FlattenedFieldParser configuredParser = new FlattenedFieldParser("field", "field._keyed",
             new FakeFieldType("field"), Integer.MAX_VALUE, 10, null);
 
         List<IndexableField> fields = configuredParser.parse(xContentParser);
@@ -248,7 +248,7 @@ public class FlatObjectFieldParserTests extends ESTestCase {
         xContentParser = createXContentParser(input);
 
         MappedFieldType fieldType = new FakeFieldType("field");
-        FlatObjectFieldParser configuredParser = new FlatObjectFieldParser("field", "field._keyed",
+        FlattenedFieldParser configuredParser = new FlattenedFieldParser("field", "field._keyed",
             fieldType, Integer.MAX_VALUE, Integer.MAX_VALUE, "placeholder");
 
         fields = configuredParser.parse(xContentParser);

x-pack/plugin/mapper-flattened/src/test/java/org/elasticsearch/xpack/flattened/mapper/KeyedFlatObjectFieldTypeTests.java → x-pack/plugin/mapper-flattened/src/test/java/org/elasticsearch/xpack/flattened/mapper/KeyedFlattenedFieldTypeTests.java

@@ -18,20 +18,20 @@ import org.elasticsearch.ElasticsearchException;
 import org.elasticsearch.common.lucene.search.AutomatonQueries;
 import org.elasticsearch.common.unit.Fuzziness;
 import org.elasticsearch.index.mapper.FieldTypeTestCase;
-import org.elasticsearch.xpack.flattened.mapper.FlatObjectFieldMapper.KeyedFlatObjectFieldType;
+import org.elasticsearch.xpack.flattened.mapper.FlattenedFieldMapper.KeyedFlattenedFieldType;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-public class KeyedFlatObjectFieldTypeTests extends FieldTypeTestCase {
+public class KeyedFlattenedFieldTypeTests extends FieldTypeTestCase {
 
-    private static KeyedFlatObjectFieldType createFieldType() {
-        return new KeyedFlatObjectFieldType("field", true, true, "key", false, Collections.emptyMap());
+    private static KeyedFlattenedFieldType createFieldType() {
+        return new KeyedFlattenedFieldType("field", true, true, "key", false, Collections.emptyMap());
     }
 
     public void testIndexedValueForSearch() {
-        KeyedFlatObjectFieldType ft = createFieldType();
+        KeyedFlattenedFieldType ft = createFieldType();
 
         BytesRef keywordValue = ft.indexedValueForSearch("value");
         assertEquals(new BytesRef("key\0value"), keywordValue);
@@ -44,17 +44,15 @@ public class KeyedFlatObjectFieldTypeTests extends FieldTypeTestCase {
     }
 
     public void testTermQuery() {
-        KeyedFlatObjectFieldType ft = createFieldType();
+        KeyedFlattenedFieldType ft = createFieldType();
 
         Query expected = new TermQuery(new Term("field", "key\0value"));
         assertEquals(expected, ft.termQuery("value", null));
 
         expected = AutomatonQueries.caseInsensitiveTermQuery(new Term("field", "key\0value"));
         assertEquals(expected, ft.termQueryCaseInsensitive("value", null));
- 
-        
-        
-        KeyedFlatObjectFieldType unsearchable = new KeyedFlatObjectFieldType("field", false, true, "key",
+
+        KeyedFlattenedFieldType unsearchable = new KeyedFlattenedFieldType("field", false, true, "key",
             false, Collections.emptyMap());
         IllegalArgumentException e = expectThrows(IllegalArgumentException.class,
             () -> unsearchable.termQuery("field", null));
@@ -62,7 +60,7 @@ public class KeyedFlatObjectFieldTypeTests extends FieldTypeTestCase {
     }
 
     public void testTermsQuery() {
-        KeyedFlatObjectFieldType ft = createFieldType();
+        KeyedFlattenedFieldType ft = createFieldType();
 
         Query expected = new TermInSetQuery("field",
             new BytesRef("key\0value1"),
@@ -77,22 +75,21 @@ public class KeyedFlatObjectFieldTypeTests extends FieldTypeTestCase {
     }
 
     public void testExistsQuery() {
-        KeyedFlatObjectFieldType ft = createFieldType();
+        KeyedFlattenedFieldType ft = createFieldType();
 
         Query expected = new PrefixQuery(new Term("field", "key\0"));
         assertEquals(expected, ft.existsQuery(null));
     }
 
     public void testPrefixQuery() {
-        KeyedFlatObjectFieldType ft = createFieldType();
+        KeyedFlattenedFieldType ft = createFieldType();
 
         Query expected = new PrefixQuery(new Term("field", "key\0val"));
         assertEquals(expected, ft.prefixQuery("val", MultiTermQuery.CONSTANT_SCORE_REWRITE, false, MOCK_QSC));
 
         expected = AutomatonQueries.caseInsensitivePrefixQuery(new Term("field", "key\0vAl"));
         assertEquals(expected, ft.prefixQuery("vAl", MultiTermQuery.CONSTANT_SCORE_REWRITE, true, MOCK_QSC));
-        
-        
+
         ElasticsearchException ee = expectThrows(ElasticsearchException.class,
                 () -> ft.prefixQuery("val", MultiTermQuery.CONSTANT_SCORE_REWRITE, false, MOCK_QSC_DISALLOW_EXPENSIVE));
         assertEquals("[prefix] queries cannot be executed when 'search.allow_expensive_queries' is set to false. " +
@@ -100,7 +97,7 @@ public class KeyedFlatObjectFieldTypeTests extends FieldTypeTestCase {
     }
 
     public void testFuzzyQuery() {
-        KeyedFlatObjectFieldType ft = createFieldType();
+        KeyedFlattenedFieldType ft = createFieldType();
 
         UnsupportedOperationException e = expectThrows(UnsupportedOperationException.class,
             () -> ft.fuzzyQuery("value", Fuzziness.fromEdits(2), 1, 50, true, randomMockShardContext()));
@@ -108,7 +105,7 @@ public class KeyedFlatObjectFieldTypeTests extends FieldTypeTestCase {
     }
 
     public void testRangeQuery() {
-        KeyedFlatObjectFieldType ft = createFieldType();
+        KeyedFlattenedFieldType ft = createFieldType();
 
         TermRangeQuery expected = new TermRangeQuery("field",
             new BytesRef("key\0lower"),
@@ -137,7 +134,7 @@ public class KeyedFlatObjectFieldTypeTests extends FieldTypeTestCase {
     }
 
     public void testRegexpQuery() {
-        KeyedFlatObjectFieldType ft = createFieldType();
+        KeyedFlattenedFieldType ft = createFieldType();
 
         UnsupportedOperationException e = expectThrows(UnsupportedOperationException.class,
             () -> ft.regexpQuery("valu*", 0, 0, 10, null, randomMockShardContext()));
@@ -145,7 +142,7 @@ public class KeyedFlatObjectFieldTypeTests extends FieldTypeTestCase {
     }
 
     public void testWildcardQuery() {
-        KeyedFlatObjectFieldType ft = createFieldType();
+        KeyedFlattenedFieldType ft = createFieldType();
 
         UnsupportedOperationException e = expectThrows(UnsupportedOperationException.class,
             () -> ft.wildcardQuery("valu*", null, false, randomMockShardContext()));

x-pack/plugin/mapper-flattened/src/test/java/org/elasticsearch/xpack/flattened/mapper/KeyedFlatObjectLeafFieldDataTests.java → x-pack/plugin/mapper-flattened/src/test/java/org/elasticsearch/xpack/flattened/mapper/KeyedFlattenedLeafFieldDataTests.java

@@ -18,7 +18,7 @@ import java.io.IOException;
 
 import static org.apache.lucene.index.SortedSetDocValues.NO_MORE_ORDS;
 
-public class KeyedFlatObjectLeafFieldDataTests extends ESTestCase {
+public class KeyedFlattenedLeafFieldDataTests extends ESTestCase {
     private LeafOrdinalsFieldData delegate;
 
     @Before
@@ -53,7 +53,7 @@ public class KeyedFlatObjectLeafFieldDataTests extends ESTestCase {
     }
 
     private BytesRef prefixedValue(String key, String value) {
-        String term = FlatObjectFieldParser.createKeyedValue(key, value);
+        String term = FlattenedFieldParser.createKeyedValue(key, value);
         return new BytesRef(term);
     }
 
@@ -91,26 +91,26 @@ public class KeyedFlatObjectLeafFieldDataTests extends ESTestCase {
                                       long expectedMacOrd) throws IOException {
         BytesRef bytesKey = new BytesRef(key);
 
-        long actualMinOrd = KeyedFlatObjectLeafFieldData.findMinOrd(bytesKey, delegate.getOrdinalsValues());
+        long actualMinOrd = KeyedFlattenedLeafFieldData.findMinOrd(bytesKey, delegate.getOrdinalsValues());
         assertEquals(expectedMinOrd,  actualMinOrd);
 
-        long actualMaxOrd = KeyedFlatObjectLeafFieldData.findMaxOrd(bytesKey, delegate.getOrdinalsValues());
+        long actualMaxOrd = KeyedFlattenedLeafFieldData.findMaxOrd(bytesKey, delegate.getOrdinalsValues());
         assertEquals(expectedMacOrd, actualMaxOrd);
     }
 
     public void testAdvanceExact() throws IOException {
-        LeafOrdinalsFieldData avocadoFieldData = new KeyedFlatObjectLeafFieldData("avocado", delegate);
+        LeafOrdinalsFieldData avocadoFieldData = new KeyedFlattenedLeafFieldData("avocado", delegate);
         assertFalse(avocadoFieldData.getOrdinalsValues().advanceExact(0));
 
-        LeafOrdinalsFieldData bananaFieldData = new KeyedFlatObjectLeafFieldData("banana", delegate);
+        LeafOrdinalsFieldData bananaFieldData = new KeyedFlattenedLeafFieldData("banana", delegate);
         assertTrue(bananaFieldData.getOrdinalsValues().advanceExact(0));
 
-        LeafOrdinalsFieldData nonexistentFieldData = new KeyedFlatObjectLeafFieldData("berry", delegate);
+        LeafOrdinalsFieldData nonexistentFieldData = new KeyedFlattenedLeafFieldData("berry", delegate);
         assertFalse(nonexistentFieldData.getOrdinalsValues().advanceExact(0));
     }
 
     public void testNextOrd() throws IOException {
-        LeafOrdinalsFieldData fieldData = new KeyedFlatObjectLeafFieldData("banana", delegate);
+        LeafOrdinalsFieldData fieldData = new KeyedFlattenedLeafFieldData("banana", delegate);
         SortedSetDocValues docValues = fieldData.getOrdinalsValues();
         docValues.advanceExact(0);
 
@@ -128,15 +128,15 @@ public class KeyedFlatObjectLeafFieldDataTests extends ESTestCase {
     }
 
     public void testLookupOrd() throws IOException {
-        LeafOrdinalsFieldData appleFieldData = new KeyedFlatObjectLeafFieldData("apple", delegate);
+        LeafOrdinalsFieldData appleFieldData = new KeyedFlattenedLeafFieldData("apple", delegate);
         SortedSetDocValues appleDocValues = appleFieldData.getOrdinalsValues();
         assertEquals(new BytesRef("value0"), appleDocValues.lookupOrd(0));
 
-        LeafOrdinalsFieldData cantaloupeFieldData = new KeyedFlatObjectLeafFieldData("cantaloupe", delegate);
+        LeafOrdinalsFieldData cantaloupeFieldData = new KeyedFlattenedLeafFieldData("cantaloupe", delegate);
         SortedSetDocValues cantaloupeDocValues = cantaloupeFieldData.getOrdinalsValues();
         assertEquals(new BytesRef("value40"), cantaloupeDocValues.lookupOrd(0));
 
-        LeafOrdinalsFieldData cucumberFieldData = new KeyedFlatObjectLeafFieldData("cucumber", delegate);
+        LeafOrdinalsFieldData cucumberFieldData = new KeyedFlattenedLeafFieldData("cucumber", delegate);
         SortedSetDocValues cucumberDocValues = cucumberFieldData.getOrdinalsValues();
         assertEquals(new BytesRef("value41"), cucumberDocValues.lookupOrd(0));
     }

x-pack/plugin/mapper-flattened/src/test/java/org/elasticsearch/xpack/flattened/mapper/RootFlatObjectFieldTypeTests.java → x-pack/plugin/mapper-flattened/src/test/java/org/elasticsearch/xpack/flattened/mapper/RootFlattenedFieldTypeTests.java

@@ -20,21 +20,21 @@ import org.elasticsearch.common.lucene.search.AutomatonQueries;
 import org.elasticsearch.common.unit.Fuzziness;
 import org.elasticsearch.index.mapper.FieldNamesFieldMapper;
 import org.elasticsearch.index.mapper.FieldTypeTestCase;
-import org.elasticsearch.xpack.flattened.mapper.FlatObjectFieldMapper.RootFlatObjectFieldType;
+import org.elasticsearch.xpack.flattened.mapper.FlattenedFieldMapper.RootFlattenedFieldType;
 
 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
-public class RootFlatObjectFieldTypeTests extends FieldTypeTestCase {
+public class RootFlattenedFieldTypeTests extends FieldTypeTestCase {
 
-    private static RootFlatObjectFieldType createDefaultFieldType() {
-        return new RootFlatObjectFieldType("field", true, true, Collections.emptyMap(), false);
+    private static RootFlattenedFieldType createDefaultFieldType() {
+        return new RootFlattenedFieldType("field", true, true, Collections.emptyMap(), false);
     }
 
     public void testValueForDisplay() {
-        RootFlatObjectFieldType ft = createDefaultFieldType();
+        RootFlattenedFieldType ft = createDefaultFieldType();
 
         String fieldValue = "{ \"key\": \"value\" }";
         BytesRef storedValue = new BytesRef(fieldValue);
@@ -42,7 +42,7 @@ public class RootFlatObjectFieldTypeTests extends FieldTypeTestCase {
     }
 
     public void testTermQuery() {
-        RootFlatObjectFieldType ft = createDefaultFieldType();
+        RootFlattenedFieldType ft = createDefaultFieldType();
 
         Query expected = new TermQuery(new Term("field", "value"));
         assertEquals(expected, ft.termQuery("value", null));
@@ -51,7 +51,7 @@ public class RootFlatObjectFieldTypeTests extends FieldTypeTestCase {
         assertEquals(expected, ft.termQueryCaseInsensitive("Value", null));
 
 
-        RootFlatObjectFieldType unsearchable = new RootFlatObjectFieldType("field", false, true,
+        RootFlattenedFieldType unsearchable = new RootFlattenedFieldType("field", false, true,
             Collections.emptyMap(), false);
         IllegalArgumentException e = expectThrows(IllegalArgumentException.class,
             () -> unsearchable.termQuery("field", null));
@@ -59,17 +59,17 @@ public class RootFlatObjectFieldTypeTests extends FieldTypeTestCase {
     }
 
     public void testExistsQuery() {
-        RootFlatObjectFieldType ft = new RootFlatObjectFieldType("field", true, false, Collections.emptyMap(), false);
+        RootFlattenedFieldType ft = new RootFlattenedFieldType("field", true, false, Collections.emptyMap(), false);
         assertEquals(
             new TermQuery(new Term(FieldNamesFieldMapper.NAME, new BytesRef("field"))),
             ft.existsQuery(null));
 
-        RootFlatObjectFieldType withDv = new RootFlatObjectFieldType("field", true, true, Collections.emptyMap(), false);
+        RootFlattenedFieldType withDv = new RootFlattenedFieldType("field", true, true, Collections.emptyMap(), false);
         assertEquals(new DocValuesFieldExistsQuery("field"), withDv.existsQuery(null));
     }
 
     public void testFuzzyQuery() {
-        RootFlatObjectFieldType ft = createDefaultFieldType();
+        RootFlattenedFieldType ft = createDefaultFieldType();
 
         Query expected = new FuzzyQuery(new Term("field", "value"), 2, 1, 50, true);
         Query actual = ft.fuzzyQuery("value", Fuzziness.fromEdits(2), 1, 50, true, MOCK_QSC);
@@ -83,7 +83,7 @@ public class RootFlatObjectFieldTypeTests extends FieldTypeTestCase {
     }
 
     public void testRangeQuery() {
-        RootFlatObjectFieldType ft = createDefaultFieldType();
+        RootFlattenedFieldType ft = createDefaultFieldType();
 
         TermRangeQuery expected = new TermRangeQuery("field",
             new BytesRef("lower"),
@@ -102,7 +102,7 @@ public class RootFlatObjectFieldTypeTests extends FieldTypeTestCase {
     }
 
     public void testRegexpQuery() {
-        RootFlatObjectFieldType ft = createDefaultFieldType();
+        RootFlattenedFieldType ft = createDefaultFieldType();
 
         Query expected = new RegexpQuery(new Term("field", "val.*"));
         Query actual = ft.regexpQuery("val.*", 0, 0, 10, null, MOCK_QSC);
@@ -115,7 +115,7 @@ public class RootFlatObjectFieldTypeTests extends FieldTypeTestCase {
     }
 
     public void testWildcardQuery() {
-        RootFlatObjectFieldType ft = createDefaultFieldType();
+        RootFlattenedFieldType ft = createDefaultFieldType();
 
         Query expected = new WildcardQuery(new Term("field", new BytesRef("valu*")));
         assertEquals(expected, ft.wildcardQuery("valu*", null, MOCK_QSC));
@@ -128,7 +128,7 @@ public class RootFlatObjectFieldTypeTests extends FieldTypeTestCase {
 
     public void testFetchSourceValue() throws IOException {
         Map<String, Object> sourceValue = Map.of("key", "value");
-        RootFlatObjectFieldType ft = createDefaultFieldType();
+        RootFlattenedFieldType ft = createDefaultFieldType();
 
         assertEquals(List.of(sourceValue), fetchSourceValue(ft, sourceValue));
         assertEquals(List.of(), fetchSourceValue(ft, null));

x-pack/plugin/src/test/resources/rest-api-spec/test/flattened/10_basic.yml

@@ -2,52 +2,52 @@
 "Test exists query on flattened object field":
   - skip:
       version: " - 7.2.99"
-      reason: "Flat object fields were implemented in 7.3."
+      reason: "Flattened fields were implemented in 7.3."
 
   - do:
       indices.create:
-        index:  flat_object_test
+        index:  flattened_test
         body:
           mappings:
             properties:
-              flat_object:
+              flattened:
                 type: flattened
   - do:
       index:
-        index:  flat_object_test
+        index:  flattened_test
         id:     1
         body:
-          flat_object:
+          flattened:
             key: some_value
         refresh: true
 
   - do:
       search:
-        index: flat_object_test
+        index: flattened_test
         body:
           query:
             exists:
-              field: flat_object
+              field: flattened
 
   - match: { hits.total.value: 1 }
 
   - do:
       search:
-        index: flat_object_test
+        index: flattened_test
         body:
           query:
             exists:
-              field: flat_object.key
+              field: flattened.key
 
   - match: { hits.total.value: 1 }
 
   - do:
       search:
-        index: flat_object_test
+        index: flattened_test
         body:
           query:
             exists:
-              field: flat_object.nonexistent_key
+              field: flattened.nonexistent_key
 
   - match: { hits.total.value: 0 }
 
@@ -55,7 +55,7 @@
 "Test query string query on flattened object field":
   - skip:
       version: " - 7.2.99"
-      reason: "Flat object fields were implemented in 7.3."
+      reason: "Flattened fields were implemented in 7.3."
 
   - do:
       indices.create: