only serialize index options if not default

Author: markjhoy

server/src/main/java/org/elasticsearch/index/mapper/vectors/SparseVectorFieldMapper.java

@@ -101,10 +101,22 @@ public static class Builder extends FieldMapper.Builder {
             () -> null,
             (n, c, o) -> parseIndexOptions(c, o),
             m -> toType(m).fieldType().indexOptions,
-            XContentBuilder::field,
+            this::serializeIndexOptions,
+            // XContentBuilder::field,
             Objects::toString
         ).acceptsNull();
 
+        private void serializeIndexOptions(XContentBuilder builder, String name, IndexOptions value) throws IOException {
+            if (value instanceof IndexOptions serializeIndexOptions) {
+                if (IndexOptions.isDefaultOptions(serializeIndexOptions)) {
+                    // do not emit anything if it's the default options
+                    return;
+                }
+            }
+
+            builder.field(name, value);
+        }
+
         private final MappingParserContext mappingParserContext;
 
         public Builder(String name) {
@@ -541,6 +553,15 @@ public static class IndexOptions implements ToXContent {
             this.pruningConfig = pruningConfig;
         }
 
+        public static boolean isDefaultOptions(IndexOptions indexOptions) {
+            if (indexOptions == null || indexOptions.prune == null || indexOptions.prune == false || indexOptions.pruningConfig == null) {
+                return false;
+            }
+
+            return (indexOptions.pruningConfig.getTokensFreqRatioThreshold() == TokenPruningConfig.DEFAULT_TOKENS_FREQ_RATIO_THRESHOLD
+                && indexOptions.pruningConfig.getTokensWeightThreshold() == TokenPruningConfig.DEFAULT_TOKENS_WEIGHT_THRESHOLD);
+        }
+
         public Boolean getPrune() {
             return prune;
         }

server/src/test/java/org/elasticsearch/index/mapper/vectors/SparseVectorFieldMapperTests.java

@@ -87,14 +87,52 @@ protected void minimalMappingWithExplicitIndexOptions(XContentBuilder b) throws
             b.field("prune", true);
             b.startObject("pruning_config");
             {
-                b.field("tokens_freq_ratio_threshold", TokenPruningConfig.DEFAULT_TOKENS_FREQ_RATIO_THRESHOLD);
+                b.field("tokens_freq_ratio_threshold", 3.0f);
+                b.field("tokens_weight_threshold", 0.5f);
+            }
+            b.endObject();
+        }
+        b.endObject();
+    }
+
+    protected void serializedMappingWithSomeIndexOptions(XContentBuilder b) throws IOException {
+        b.field("type", "sparse_vector");
+        b.startObject("index_options");
+        {
+            b.field("prune", true);
+            b.startObject("pruning_config");
+            {
+                b.field("tokens_freq_ratio_threshold", 3.0f);
                 b.field("tokens_weight_threshold", TokenPruningConfig.DEFAULT_TOKENS_WEIGHT_THRESHOLD);
             }
             b.endObject();
         }
         b.endObject();
     }
 
+    protected void minimalMappingWithSomeExplicitIndexOptions(XContentBuilder b) throws IOException {
+        b.field("type", "sparse_vector");
+        b.startObject("index_options");
+        {
+            b.field("prune", true);
+            b.startObject("pruning_config");
+            {
+                b.field("tokens_freq_ratio_threshold", 3.0f);
+            }
+            b.endObject();
+        }
+        b.endObject();
+    }
+
+    protected void mappingWithIndexOptionsOnlyPruneTrue(XContentBuilder b) throws IOException {
+        b.field("type", "sparse_vector");
+        b.startObject("index_options");
+        {
+            b.field("prune", true);
+        }
+        b.endObject();
+    }
+
     protected void mappingWithIndexOptionsPruneFalse(XContentBuilder b) throws IOException {
         b.field("type", "sparse_vector");
         b.startObject("index_options");
@@ -133,7 +171,7 @@ private static int getFrequency(TokenStream tk) throws IOException {
 
     public void testDefaults() throws Exception {
         DocumentMapper mapper = createDocumentMapper(fieldMapping(this::minimalMapping));
-        assertEquals(Strings.toString(fieldMapping(this::minimalMappingWithExplicitIndexOptions)), mapper.mappingSource().toString());
+        assertEquals(Strings.toString(fieldMapping(this::minimalMapping)), mapper.mappingSource().toString());
 
         ParsedDocument doc1 = mapper.parse(source(this::writeField));
 
@@ -159,7 +197,7 @@ public void testDefaults() throws Exception {
 
     public void testMappingWithoutIndexOptionsUsesDefaults() throws Exception {
         DocumentMapper mapper = createDocumentMapper(fieldMapping(this::minimalMapping));
-        assertEquals(Strings.toString(fieldMapping(this::minimalMappingWithExplicitIndexOptions)), mapper.mappingSource().toString());
+        assertEquals(Strings.toString(fieldMapping(this::minimalMapping)), mapper.mappingSource().toString());
 
         IndexVersion preIndexOptionsVersion = IndexVersionUtils.randomVersionBetween(
             random(),
@@ -170,6 +208,20 @@ public void testMappingWithoutIndexOptionsUsesDefaults() throws Exception {
         assertEquals(Strings.toString(fieldMapping(this::minimalMapping)), previousMapper.mappingSource().toString());
     }
 
+    public void testMappingWithExplicitIndexOptions() throws Exception {
+        DocumentMapper mapper = createDocumentMapper(fieldMapping(this::minimalMappingWithExplicitIndexOptions));
+        assertEquals(Strings.toString(fieldMapping(this::minimalMappingWithExplicitIndexOptions)), mapper.mappingSource().toString());
+
+        mapper = createDocumentMapper(fieldMapping(this::mappingWithIndexOptionsPruneFalse));
+        assertEquals(Strings.toString(fieldMapping(this::mappingWithIndexOptionsPruneFalse)), mapper.mappingSource().toString());
+
+        mapper = createDocumentMapper(fieldMapping(this::minimalMappingWithSomeExplicitIndexOptions));
+        assertEquals(Strings.toString(fieldMapping(this::serializedMappingWithSomeIndexOptions)), mapper.mappingSource().toString());
+
+        mapper = createDocumentMapper(fieldMapping(this::mappingWithIndexOptionsOnlyPruneTrue));
+        assertEquals(Strings.toString(fieldMapping(this::mappingWithIndexOptionsOnlyPruneTrue)), mapper.mappingSource().toString());
+   }
+
     public void testDotInFieldName() throws Exception {
         DocumentMapper mapper = createDocumentMapper(fieldMapping(this::minimalMapping));
         ParsedDocument parsedDocument = mapper.parse(source(b -> b.field("field", Map.of("foo.bar", 10, "foobar", 20))));