Use docvalue skippers on dimension fields

modules/mapper-extras/src/main/java/org/elasticsearch/index/mapper/extras/ScaledFloatFieldMapper.java

@@ -722,7 +722,13 @@ protected void parseCreateField(DocumentParserContext context) throws IOExceptio
         }
         long scaledValue = encode(doubleValue, scalingFactor);
 
-        NumberFieldMapper.NumberType.LONG.addFields(context.doc(), fieldType().name(), scaledValue, indexed, hasDocValues, stored);
+        NumberFieldMapper.NumberType.LONG.addFields(
+            context.doc(),
+            fieldType().name(),
+            scaledValue,
+            IndexType.points(indexed, hasDocValues),
+            stored
+        );
 
         if (shouldStoreOffsets) {
             context.getOffSetContext().recordOffset(offsetsFieldName, scaledValue);

modules/mapper-extras/src/main/java/org/elasticsearch/index/mapper/extras/TokenCountFieldMapper.java

@@ -164,7 +164,13 @@ protected void parseCreateField(DocumentParserContext context) throws IOExceptio
             tokenCount = countPositions(analyzer, fullPath(), value, enablePositionIncrements);
         }
 
-        NumberFieldMapper.NumberType.INTEGER.addFields(context.doc(), fieldType().name(), tokenCount, index, hasDocValues, store);
+        NumberFieldMapper.NumberType.INTEGER.addFields(
+            context.doc(),
+            fieldType().name(),
+            tokenCount,
+            IndexType.points(index, hasDocValues),
+            store
+        );
     }
 
     /**

server/src/main/java/org/elasticsearch/index/IndexVersions.java

@@ -192,6 +192,7 @@ private static Version parseUnchecked(String version) {
     public static final IndexVersion REENABLED_TIMESTAMP_DOC_VALUES_SPARSE_INDEX = def(9_042_0_00, Version.LUCENE_10_3_1);
     public static final IndexVersion SKIPPERS_ENABLED_BY_DEFAULT = def(9_043_0_00, Version.LUCENE_10_3_1);
     public static final IndexVersion TIME_SERIES_USE_SYNTHETIC_ID = def(9_044_0_00, Version.LUCENE_10_3_1);
+    public static final IndexVersion TIME_SERIES_DIMENSIONS_USE_SKIPPERS = def(9_045_0_00, Version.LUCENE_10_3_1);
 
     /*
      * STOP! READ THIS FIRST! No, really,

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

@@ -79,7 +79,7 @@ private static BooleanFieldMapper toType(FieldMapper in) {
     public static final class Builder extends FieldMapper.DimensionBuilder {
 
         private final Parameter<Boolean> docValues = Parameter.docValuesParam(m -> toType(m).hasDocValues, true);
-        private final Parameter<Boolean> indexed = Parameter.indexParam(m -> toType(m).indexed, true);
+        private final Parameter<Boolean> indexed;
         private final Parameter<Boolean> stored = Parameter.storeParam(m -> toType(m).stored, false);
         private final Parameter<Explicit<Boolean>> ignoreMalformed;
         private final Parameter<Boolean> nullValue = new Parameter<>(
@@ -117,20 +117,9 @@ public Builder(String name, ScriptCompiler scriptCompiler, IndexSettings indexSe
                 IGNORE_MALFORMED_SETTING.get(indexSettings.getSettings())
             );
             this.script.precludesParameters(ignoreMalformed, nullValue);
+            this.dimension = TimeSeriesParams.dimensionParam(m -> toType(m).fieldType().isDimension(), docValues::get);
+            this.indexed = Parameter.indexParam(m -> toType(m).indexed, indexSettings, dimension);
             addScriptValidation(script, indexed, docValues);
-            this.dimension = TimeSeriesParams.dimensionParam(m -> toType(m).fieldType().isDimension()).addValidator(v -> {
-                if (v && (indexed.getValue() == false || docValues.getValue() == false)) {
-                    throw new IllegalArgumentException(
-                        "Field ["
-                            + TimeSeriesParams.TIME_SERIES_DIMENSION_PARAM
-                            + "] requires that ["
-                            + indexed.name
-                            + "] and ["
-                            + docValues.name
-                            + "] are true"
-                    );
-                }
-            });
         }
 
         public Builder dimension(boolean dimension) {
@@ -152,16 +141,30 @@ protected Parameter<?>[] getParameters() {
                 dimension };
         }
 
+        private IndexType indexType() {
+            if (indexed.get() && indexSettings.getIndexVersionCreated().isLegacyIndexVersion() == false) {
+                return IndexType.terms(true, docValues.getValue());
+            }
+            if (docValues.get() == false) {
+                return IndexType.NONE;
+            }
+            if (dimension.get()
+                && indexSettings.useDocValuesSkipper()
+                && indexSettings.getIndexVersionCreated().onOrAfter(IndexVersions.TIME_SERIES_DIMENSIONS_USE_SKIPPERS)) {
+                return IndexType.skippers();
+            }
+            return IndexType.docValuesOnly();
+        }
+
         @Override
         public BooleanFieldMapper build(MapperBuilderContext context) {
             if (inheritDimensionParameterFromParentObject(context)) {
                 dimension(true);
             }
             MappedFieldType ft = new BooleanFieldType(
                 context.buildFullName(leafName()),
-                indexed.getValue() && indexSettings.getIndexVersionCreated().isLegacyIndexVersion() == false,
+                indexType(),
                 stored.getValue(),
-                docValues.getValue(),
                 nullValue.getValue(),
                 scriptValues(),
                 meta.getValue(),
@@ -215,32 +218,27 @@ public static final class BooleanFieldType extends TermBasedFieldType {
 
         public BooleanFieldType(
             String name,
-            boolean isIndexed,
+            IndexType indexType,
             boolean isStored,
-            boolean hasDocValues,
             Boolean nullValue,
             FieldValues<Boolean> scriptValues,
             Map<String, String> meta,
             boolean isDimension,
             boolean isSyntheticSource
         ) {
-            super(name, IndexType.terms(isIndexed, hasDocValues), isStored, TextSearchInfo.SIMPLE_MATCH_ONLY, meta);
+            super(name, indexType, isStored, TextSearchInfo.SIMPLE_MATCH_ONLY, meta);
             this.nullValue = nullValue;
             this.scriptValues = scriptValues;
             this.isDimension = isDimension;
             this.isSyntheticSource = isSyntheticSource;
         }
 
         public BooleanFieldType(String name) {
-            this(name, true);
-        }
-
-        public BooleanFieldType(String name, boolean isIndexed) {
-            this(name, isIndexed, true);
+            this(name, IndexType.terms(true, true));
         }
 
-        public BooleanFieldType(String name, boolean isIndexed, boolean hasDocValues) {
-            this(name, isIndexed, isIndexed, hasDocValues, false, null, Collections.emptyMap(), false, false);
+        public BooleanFieldType(String name, IndexType indexType) {
+            this(name, indexType, true, false, null, Collections.emptyMap(), false, false);
         }
 
         @Override
@@ -601,7 +599,11 @@ private void indexValue(DocumentParserContext context, Boolean value) {
             context.doc().add(new StoredField(fieldType().name(), value ? "T" : "F"));
         }
         if (hasDocValues) {
-            context.doc().add(new SortedNumericDocValuesField(fieldType().name(), value ? 1 : 0));
+            if (fieldType().indexType.hasDocValuesSkipper()) {
+                context.doc().add(SortedNumericDocValuesField.indexedField(fieldType().name(), value ? 1 : 0));
+            } else {
+                context.doc().add(new SortedNumericDocValuesField(fieldType().name(), value ? 1 : 0));
+            }
         } else {
             context.addToFieldNames(fieldType().name());
         }

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

@@ -1314,6 +1314,21 @@ public static Parameter<Boolean> indexParam(Function<FieldMapper, Boolean> initi
             return Parameter.boolParam("index", false, initializer, defaultValue);
         }
 
+        public static Parameter<Boolean> indexParam(
+            Function<FieldMapper, Boolean> initializer,
+            IndexSettings indexSettings,
+            Supplier<Boolean> isDimension
+        ) {
+            return Parameter.boolParam(
+                "index",
+                false,
+                initializer,
+                () -> isDimension.get() == false
+                    || indexSettings.useDocValuesSkipper() == false
+                    || indexSettings.getIndexVersionCreated().before(IndexVersions.TIME_SERIES_DIMENSIONS_USE_SKIPPERS)
+            );
+        }
+
         public static Parameter<Boolean> storeParam(Function<FieldMapper, Boolean> initializer, boolean defaultValue) {
             return Parameter.boolParam("store", false, initializer, defaultValue);
         }

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

@@ -143,7 +143,7 @@ public Builder(String name, ScriptCompiler scriptCompiler, IndexSettings indexSe
                 }
             });
             // We allow `time_series_dimension` parameter to be parsed, but only allow it to be `false`
-            this.dimension = TimeSeriesParams.dimensionParam(m -> false).addValidator(v -> {
+            this.dimension = TimeSeriesParams.dimensionParam(m -> false, () -> true).addValidator(v -> {
                 if (v) {
                     throw new IllegalArgumentException(
                         "Parameter [" + TimeSeriesParams.TIME_SERIES_DIMENSION_PARAM + "] cannot be set to geo_point"

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

@@ -9,6 +9,11 @@
 
 package org.elasticsearch.index.mapper;
 
+import org.apache.lucene.document.FieldType;
+import org.apache.lucene.index.DocValuesSkipIndexType;
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.IndexOptions;
+
 import java.util.Objects;
 
 /**
@@ -118,6 +123,25 @@ public static IndexType terms(boolean isIndexed, boolean hasDocValues) {
         return new IndexType(isIndexed, false, false, false, hasDocValues, false);
     }
 
+    /**
+     * @return a terms-based IndexType from a lucene FieldType
+     */
+    public static IndexType terms(FieldType fieldType) {
+        if (fieldType.indexOptions() == IndexOptions.NONE) {
+            if (fieldType.docValuesType() == DocValuesType.NONE) {
+                return NONE;
+            }
+            if (fieldType.docValuesSkipIndexType() == DocValuesSkipIndexType.NONE) {
+                return docValuesOnly();
+            }
+            return skippers();
+        }
+        if (fieldType.docValuesType() == DocValuesType.NONE) {
+            return terms(true, false);
+        }
+        return terms(true, true);
+    }
+
     /**
      * @return an IndexType with docValuesSkippers
      */

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

@@ -74,7 +74,7 @@ private static IpFieldMapper toType(FieldMapper in) {
 
     public static final class Builder extends FieldMapper.DimensionBuilder {
 
-        private final Parameter<Boolean> indexed = Parameter.indexParam(m -> toType(m).indexed, true);
+        private final Parameter<Boolean> indexed;
         private final Parameter<Boolean> hasDocValues = Parameter.docValuesParam(m -> toType(m).hasDocValues, true);
         private final Parameter<Boolean> stored = Parameter.storeParam(m -> toType(m).stored, false);
 
@@ -105,20 +105,9 @@ public Builder(String name, ScriptCompiler scriptCompiler, IndexSettings indexSe
                 IGNORE_MALFORMED_SETTING.get(indexSettings.getSettings())
             );
             this.script.precludesParameters(nullValue, ignoreMalformed);
+            this.dimension = TimeSeriesParams.dimensionParam(m -> toType(m).dimension, hasDocValues::get);
+            this.indexed = Parameter.indexParam(m -> toType(m).indexed, indexSettings, dimension);
             addScriptValidation(script, indexed, hasDocValues);
-            this.dimension = TimeSeriesParams.dimensionParam(m -> toType(m).dimension).addValidator(v -> {
-                if (v && (indexed.getValue() == false || hasDocValues.getValue() == false)) {
-                    throw new IllegalArgumentException(
-                        "Field ["
-                            + TimeSeriesParams.TIME_SERIES_DIMENSION_PARAM
-                            + "] requires that ["
-                            + indexed.name
-                            + "] and ["
-                            + hasDocValues.name
-                            + "] are true"
-                    );
-                }
-            });
         }
 
         Builder nullValue(String nullValue) {
@@ -186,6 +175,11 @@ private IndexType indexType() {
             if (indexSettings.getIndexVersionCreated().isLegacyIndexVersion()) {
                 return hasDocValues.get() ? IndexType.archivedPoints() : IndexType.NONE;
             }
+            if (dimension.get()
+                && indexSettings.useDocValuesSkipper()
+                && indexSettings.getIndexVersionCreated().onOrAfter(IndexVersions.TIME_SERIES_DIMENSIONS_USE_SKIPPERS)) {
+                return IndexType.skippers();
+            }
             return IndexType.points(indexed.get(), hasDocValues.get());
         }
 
@@ -650,7 +644,11 @@ private void indexValue(DocumentParserContext context, ESInetAddressPoint addres
             doc.add(address);
         }
         if (hasDocValues) {
-            doc.add(new SortedSetDocValuesField(fieldType().name(), address.binaryValue()));
+            if (indexed == false) {
+                doc.add(SortedSetDocValuesField.indexedField(fieldType().name(), address.binaryValue()));
+            } else {
+                doc.add(new SortedSetDocValuesField(fieldType().name(), address.binaryValue()));
+            }
         } else if (stored || indexed) {
             context.addToFieldNames(fieldType().name());
         }