Use optional subobjects instead of explicit

Author: gmarouli

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

@@ -621,6 +621,8 @@ static MergeResult build(ObjectMapper existing, ObjectMapper mergeWithObject, Ma
             if (mergeWithObject.subobjects.isPresent()) {
                 if (reason == MergeReason.INDEX_TEMPLATE) {
                     subObjects = mergeWithObject.subobjects;
+                } else if (mergeWithObject instanceof PassThroughObjectMapper && existing.subobjects.isEmpty()) {
+                    subObjects = mergeWithObject.subobjects;
                 } else if (existing.subobjects() != mergeWithObject.subobjects()) {
                     throw new MapperException(
                         "the [subobjects] parameter can't be updated for the object mapping [" + existing.fullPath() + "]"

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

@@ -200,8 +200,8 @@ public PassThroughObjectMapper merge(Mapper mergeWith, MapperMergeContext parent
     static boolean isEligibleForMerge(ObjectMapper objectMapper) {
         return objectMapper.isRoot() == false
             && (objectMapper.subobjects == null
-                || objectMapper.subobjects.explicit() == false
-                || objectMapper.subobjects.value().equals(Subobjects.DISABLED));
+                || objectMapper.subobjects.isEmpty()
+                || objectMapper.subobjects.get().equals(Subobjects.DISABLED));
     }
 
     @Override

server/src/test/java/org/elasticsearch/index/mapper/ObjectMapperMergeTests.java

@@ -355,10 +355,10 @@ public void testConflictingDynamicUpdate() {
 
     public void testMergingWithPassThrough() {
         boolean isSourceSynthetic = randomBoolean();
-        var objectMapper = new RootObjectMapper.Builder("_doc").add(
-            new ObjectMapper.Builder("metrics").add(new KeywordFieldMapper.Builder("cpu_usage", IndexVersion.current()))
+        var objectMapper = new RootObjectMapper.Builder("_doc", Optional.empty()).add(
+            new ObjectMapper.Builder("metrics", Optional.empty()).add(new KeywordFieldMapper.Builder("cpu_usage", IndexVersion.current()))
         ).build(MapperBuilderContext.root(isSourceSynthetic, true));
-        var passThroughMapper = new RootObjectMapper.Builder("_doc").add(
+        var passThroughMapper = new RootObjectMapper.Builder("_doc", Optional.empty()).add(
             new PassThroughObjectMapper.Builder("metrics").setPriority(10)
                 .add(new KeywordFieldMapper.Builder("memory_usage", IndexVersion.current()))
         ).build(MapperBuilderContext.root(isSourceSynthetic, true));
@@ -371,19 +371,16 @@ public void testMergingWithPassThrough() {
         assertThat(metrics.getMapper("cpu_usage"), instanceOf(KeywordFieldMapper.class));
         assertThat(metrics.getMapper("memory_usage"), instanceOf(KeywordFieldMapper.class));
 
-        var subobjectsTrueMapper = new RootObjectMapper.Builder("_doc").add(
-            new ObjectMapper.Builder("metrics", Explicit.of(ObjectMapper.Subobjects.ENABLED)).add(
+        var subobjectsTrueMapper = new RootObjectMapper.Builder("_doc", Optional.empty()).add(
+            new ObjectMapper.Builder("metrics", Optional.of(ObjectMapper.Subobjects.ENABLED)).add(
                 new KeywordFieldMapper.Builder("cpu_usage", IndexVersion.current())
             )
         ).build(MapperBuilderContext.root(isSourceSynthetic, true));
-        IllegalArgumentException e = expectThrows(
-            IllegalArgumentException.class,
+        MapperException e = expectThrows(
+            MapperException.class,
             () -> subobjectsTrueMapper.merge(passThroughMapper, MapperMergeContext.root(false, false, MAPPING_UPDATE, Long.MAX_VALUE))
         );
-        assertThat(
-            e.getMessage(),
-            equalTo("can't merge a passthrough mapping [metrics] with an object mapping that is either root or has subobjects enabled")
-        );
+        assertThat(e.getMessage(), equalTo("the [subobjects] parameter can't be updated for the object mapping [metrics]"));
     }
 
     private static RootObjectMapper createRootSubobjectFalseLeafWithDots() {

server/src/test/java/org/elasticsearch/index/mapper/PassThroughObjectMapperTests.java

@@ -187,10 +187,11 @@ public void testCheckForDuplicatePrioritiesEmpty() throws IOException {
 
     public void testMergingWithPassThrough() {
         boolean isSourceSynthetic = randomBoolean();
-        var passThroughMapper = new RootObjectMapper.Builder("_doc").add(new PassThroughObjectMapper.Builder("metrics").setPriority(10))
-            .build(MapperBuilderContext.root(isSourceSynthetic, true));
-        var objectMapper = new RootObjectMapper.Builder("_doc").add(
-            new ObjectMapper.Builder("metrics").add(new KeywordFieldMapper.Builder("cpu_usage", IndexVersion.current()))
+        var passThroughMapper = new RootObjectMapper.Builder("_doc", Optional.empty()).add(
+            new PassThroughObjectMapper.Builder("metrics").setPriority(10)
+        ).build(MapperBuilderContext.root(isSourceSynthetic, true));
+        var objectMapper = new RootObjectMapper.Builder("_doc", Optional.empty()).add(
+            new ObjectMapper.Builder("metrics", Optional.empty()).add(new KeywordFieldMapper.Builder("cpu_usage", IndexVersion.current()))
         ).build(MapperBuilderContext.root(isSourceSynthetic, true));
 
         RootObjectMapper merged = passThroughMapper.merge(
@@ -199,8 +200,8 @@ public void testMergingWithPassThrough() {
         );
         assertThat(merged.getMapper("metrics"), instanceOf(PassThroughObjectMapper.class));
 
-        var objectMapperWithSubObjectTrue = new RootObjectMapper.Builder("_doc").add(
-            new ObjectMapper.Builder("metrics", Explicit.of(ObjectMapper.Subobjects.ENABLED)).add(
+        var objectMapperWithSubObjectTrue = new RootObjectMapper.Builder("_doc", Optional.empty()).add(
+            new ObjectMapper.Builder("metrics", Optional.of(ObjectMapper.Subobjects.ENABLED)).add(
                 new KeywordFieldMapper.Builder("cpu_usage", IndexVersion.current())
             )
         ).build(MapperBuilderContext.root(isSourceSynthetic, true));
@@ -217,7 +218,7 @@ public void testMergingWithPassThrough() {
             equalTo("can't merge a passthrough mapping [metrics] with an object mapping that is either root or has subobjects enabled")
         );
 
-        var rootObjectMapper = new RootObjectMapper.Builder("metrics").add(
+        var rootObjectMapper = new RootObjectMapper.Builder("metrics", Optional.empty()).add(
             new KeywordFieldMapper.Builder("cpu_usage", IndexVersion.current())
         ).build(MapperBuilderContext.root(isSourceSynthetic, true));