diff --git a/docs/changelog/138548.yaml b/docs/changelog/138548.yaml
new file mode 100644
index 0000000000000..f7787059385b4
--- /dev/null
+++ b/docs/changelog/138548.yaml
@@ -0,0 +1,5 @@
+pr: 138548
+summary: Store high-cardinality keyword fields in binary doc values
+area: Mapping
+type: feature
+issues: []
diff --git a/modules/percolator/src/test/java/org/elasticsearch/percolator/QueryBuilderStoreTests.java b/modules/percolator/src/test/java/org/elasticsearch/percolator/QueryBuilderStoreTests.java
index 67527a4d27436..c98e70131b554 100644
--- a/modules/percolator/src/test/java/org/elasticsearch/percolator/QueryBuilderStoreTests.java
+++ b/modules/percolator/src/test/java/org/elasticsearch/percolator/QueryBuilderStoreTests.java
@@ -32,6 +32,7 @@
 import org.elasticsearch.index.mapper.TestDocumentParserContext;
 import org.elasticsearch.index.query.SearchExecutionContext;
 import org.elasticsearch.index.query.TermQueryBuilder;
+import org.elasticsearch.script.field.BinaryDocValuesField;
 import org.elasticsearch.search.SearchModule;
 import org.elasticsearch.search.aggregations.support.CoreValuesSourceType;
 import org.elasticsearch.test.ESTestCase;
@@ -88,7 +89,7 @@ public void testStoringQueryBuilders() throws IOException {
             when(searchExecutionContext.getWriteableRegistry()).thenReturn(writableRegistry());
             when(searchExecutionContext.getParserConfig()).thenReturn(parserConfig());
             when(searchExecutionContext.getForField(fieldMapper.fieldType(), fielddataOperation)).thenReturn(
-                new BytesBinaryIndexFieldData(fieldMapper.fullPath(), CoreValuesSourceType.KEYWORD)
+                new BytesBinaryIndexFieldData(fieldMapper.fullPath(), CoreValuesSourceType.KEYWORD, BinaryDocValuesField::new)
             );
             when(searchExecutionContext.getFieldType(Mockito.anyString())).thenAnswer(invocation -> {
                 final String fieldName = (String) invocation.getArguments()[0];
diff --git a/rest-api-spec/src/yamlRestTest/resources/rest-api-spec/test/search/395_binary_doc_values_search.yml b/rest-api-spec/src/yamlRestTest/resources/rest-api-spec/test/search/395_binary_doc_values_search.yml
new file mode 100644
index 0000000000000..8f98e460d583f
--- /dev/null
+++ b/rest-api-spec/src/yamlRestTest/resources/rest-api-spec/test/search/395_binary_doc_values_search.yml
@@ -0,0 +1,115 @@
+---
+setup:
+  - requires:
+      cluster_features: ["mapper.keyword.store_high_cardinality_in_binary_doc_values"]
+      reason: "testing binary doc values search"
+
+  - do:
+      indices.create:
+        index:  test
+        body:
+          mappings:
+            dynamic: false
+            properties:
+              keyword:
+                type: keyword
+                index: false
+                doc_values:
+                  cardinality: high
+
+  - do:
+      index:
+        index: test
+        id: "1"
+        body:
+          keyword: "key1"
+
+  - do:
+      index:
+        index: test
+        id: "2"
+        body:
+          keyword: "key2"
+  - do:
+      indices.refresh: {}
+
+---
+"Test match query on keyword field where only binary doc values are enabled":
+
+  - do:
+      search:
+        index: test
+        body: { query: { match: { keyword: { query: "key1" } } } }
+  - length:   { hits.hits: 1  }
+
+---
+"Test terms query on keyword field where only binary doc values are enabled":
+
+  - do:
+      search:
+        index: test
+        body: { query: { terms: { keyword: [ "key1", "key2" ] } } }
+  - length:   { hits.hits: 2  }
+
+---
+"Test range query on keyword field where only binary doc values are enabled":
+
+  - do:
+      search:
+        index: test
+        body: { query: { range: { keyword: { gte: "key1" } } } }
+  - length:   { hits.hits: 2  }
+
+---
+"Test fuzzy query on keyword field where only binary doc values are enabled":
+
+  - do:
+      search:
+        index: test
+        body: { query: { fuzzy: { keyword: { value: "kay1", fuzziness: 1 } } } }
+  - length:   { hits.hits: 1  }
+
+---
+"Test prefix query on keyword field where only binary doc values are enabled":
+
+  - do:
+      search:
+        index: test
+        body: { query: { prefix: { keyword: { value: "key" } } } }
+  - length:   { hits.hits: 2  }
+
+---
+"Test case insensitive term query on keyword field where only binary doc values are enabled":
+
+  - do:
+      search:
+        index: test
+        body: { query: { term: { keyword: { value: "KeY1", case_insensitive: true } } } }
+  - length:   { hits.hits: 1  }
+
+---
+"Test wildcard query on keyword field where only binary doc values are enabled":
+
+  - do:
+      search:
+        index: test
+        body: { query: { wildcard: { keyword: { value: "k*1" } } } }
+  - length:   { hits.hits: 1  }
+
+---
+"Test case insensitive wildcard query on keyword field where only binary doc values are enabled":
+
+  - do:
+      search:
+        index: test
+        body: { query: { wildcard: { keyword: { value: "K*1", case_insensitive: true } } } }
+  - length:   { hits.hits: 1  }
+
+---
+"Test regexp query on keyword field where only binary doc values are enabled":
+
+  - do:
+      search:
+        index: test
+        body: { query: { regexp: { keyword: { value: "k.*1" } } } }
+  - length:   { hits.hits: 1  }
diff --git a/server/src/main/java/org/elasticsearch/index/fielddata/MultiValuedSortedBinaryDocValues.java b/server/src/main/java/org/elasticsearch/index/fielddata/MultiValuedSortedBinaryDocValues.java
new file mode 100644
index 0000000000000..2b6293b584bb5
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/index/fielddata/MultiValuedSortedBinaryDocValues.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+package org.elasticsearch.index.fielddata;
+
+import org.apache.lucene.index.BinaryDocValues;
+import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.common.io.stream.ByteArrayStreamInput;
+
+import java.io.IOException;
+
+/**
+ * Wrapper around {@link BinaryDocValues} to decode the typical multivalued encoding used by
+ * {@link org.elasticsearch.index.mapper.BinaryFieldMapper.CustomBinaryDocValuesField}.
+ */
+public class MultiValuedSortedBinaryDocValues extends SortedBinaryDocValues {
+
+    BinaryDocValues values;
+    int count;
+    final ByteArrayStreamInput in = new ByteArrayStreamInput();
+    final BytesRef scratch = new BytesRef();
+
+    public MultiValuedSortedBinaryDocValues(BinaryDocValues values) {
+        this.values = values;
+    }
+
+    @Override
+    public boolean advanceExact(int doc) throws IOException {
+        if (values.advanceExact(doc)) {
+            final BytesRef bytes = values.binaryValue();
+            assert bytes.length > 0;
+            in.reset(bytes.bytes, bytes.offset, bytes.length);
+            count = in.readVInt();
+            scratch.bytes = bytes.bytes;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public int docValueCount() {
+        return count;
+    }
+
+    @Override
+    public BytesRef nextValue() throws IOException {
+        scratch.length = in.readVInt();
+        scratch.offset = in.getPosition();
+        in.setPosition(scratch.offset + scratch.length);
+        return scratch;
+    }
+}
diff --git a/server/src/main/java/org/elasticsearch/index/fielddata/plain/AbstractBinaryDVLeafFieldData.java b/server/src/main/java/org/elasticsearch/index/fielddata/plain/AbstractBinaryDVLeafFieldData.java
deleted file mode 100644
index 63fa0e21c6cb6..0000000000000
--- a/server/src/main/java/org/elasticsearch/index/fielddata/plain/AbstractBinaryDVLeafFieldData.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
- * or more contributor license agreements. Licensed under the "Elastic License
- * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
- * Public License v 1"; you may not use this file except in compliance with, at
- * your election, the "Elastic License 2.0", the "GNU Affero General Public
- * License v3.0 only", or the "Server Side Public License, v 1".
- */
-
-package org.elasticsearch.index.fielddata.plain;
-
-import org.apache.lucene.index.BinaryDocValues;
-import org.apache.lucene.util.BytesRef;
-import org.elasticsearch.common.io.stream.ByteArrayStreamInput;
-import org.elasticsearch.index.fielddata.LeafFieldData;
-import org.elasticsearch.index.fielddata.SortedBinaryDocValues;
-
-import java.io.IOException;
-
-abstract class AbstractBinaryDVLeafFieldData implements LeafFieldData {
-    private final BinaryDocValues values;
-
-    AbstractBinaryDVLeafFieldData(BinaryDocValues values) {
-        super();
-        this.values = values;
-    }
-
-    @Override
-    public long ramBytesUsed() {
-        return 0; // not exposed by Lucene
-    }
-
-    @Override
-    public SortedBinaryDocValues getBytesValues() {
-        return new SortedBinaryDocValues() {
-
-            int count;
-            final ByteArrayStreamInput in = new ByteArrayStreamInput();
-            final BytesRef scratch = new BytesRef();
-
-            @Override
-            public boolean advanceExact(int doc) throws IOException {
-                if (values.advanceExact(doc)) {
-                    final BytesRef bytes = values.binaryValue();
-                    assert bytes.length > 0;
-                    in.reset(bytes.bytes, bytes.offset, bytes.length);
-                    count = in.readVInt();
-                    scratch.bytes = bytes.bytes;
-                    return true;
-                } else {
-                    return false;
-                }
-            }
-
-            @Override
-            public int docValueCount() {
-                return count;
-            }
-
-            @Override
-            public BytesRef nextValue() throws IOException {
-                scratch.length = in.readVInt();
-                scratch.offset = in.getPosition();
-                in.setPosition(scratch.offset + scratch.length);
-                return scratch;
-            }
-
-        };
-    }
-
-}
diff --git a/server/src/main/java/org/elasticsearch/index/fielddata/plain/BytesBinaryDVLeafFieldData.java b/server/src/main/java/org/elasticsearch/index/fielddata/plain/BytesBinaryDVLeafFieldData.java
deleted file mode 100644
index 9bb6062fb08c9..0000000000000
--- a/server/src/main/java/org/elasticsearch/index/fielddata/plain/BytesBinaryDVLeafFieldData.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
- * or more contributor license agreements. Licensed under the "Elastic License
- * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
- * Public License v 1"; you may not use this file except in compliance with, at
- * your election, the "Elastic License 2.0", the "GNU Affero General Public
- * License v3.0 only", or the "Server Side Public License, v 1".
- */
-
-package org.elasticsearch.index.fielddata.plain;
-
-import org.apache.lucene.index.BinaryDocValues;
-import org.elasticsearch.script.field.BinaryDocValuesField;
-import org.elasticsearch.script.field.DocValuesScriptFieldFactory;
-
-final class BytesBinaryDVLeafFieldData extends AbstractBinaryDVLeafFieldData {
-    BytesBinaryDVLeafFieldData(BinaryDocValues values) {
-        super(values);
-    }
-
-    @Override
-    public DocValuesScriptFieldFactory getScriptFieldFactory(String name) {
-        return new BinaryDocValuesField(getBytesValues(), name);
-    }
-}
diff --git a/server/src/main/java/org/elasticsearch/index/fielddata/plain/BytesBinaryIndexFieldData.java b/server/src/main/java/org/elasticsearch/index/fielddata/plain/BytesBinaryIndexFieldData.java
index f5d4bf837f062..043857ae0a0fc 100644
--- a/server/src/main/java/org/elasticsearch/index/fielddata/plain/BytesBinaryIndexFieldData.java
+++ b/server/src/main/java/org/elasticsearch/index/fielddata/plain/BytesBinaryIndexFieldData.java
@@ -17,7 +17,9 @@
 import org.elasticsearch.index.fielddata.IndexFieldData;
 import org.elasticsearch.index.fielddata.IndexFieldData.XFieldComparatorSource.Nested;
 import org.elasticsearch.index.fielddata.IndexFieldDataCache;
+import org.elasticsearch.index.fielddata.SortedBinaryDocValues;
 import org.elasticsearch.indices.breaker.CircuitBreakerService;
+import org.elasticsearch.script.field.ToScriptFieldFactory;
 import org.elasticsearch.search.DocValueFormat;
 import org.elasticsearch.search.MultiValueMode;
 import org.elasticsearch.search.aggregations.support.ValuesSourceType;
@@ -26,14 +28,20 @@
 
 import java.io.IOException;
 
-public class BytesBinaryIndexFieldData implements IndexFieldData<BytesBinaryDVLeafFieldData> {
+public class BytesBinaryIndexFieldData implements IndexFieldData<MultiValuedBinaryDVLeafFieldData> {
 
     protected final String fieldName;
     protected final ValuesSourceType valuesSourceType;
+    protected final ToScriptFieldFactory<SortedBinaryDocValues> toScriptFieldFactory;
 
-    public BytesBinaryIndexFieldData(String fieldName, ValuesSourceType valuesSourceType) {
+    public BytesBinaryIndexFieldData(
+        String fieldName,
+        ValuesSourceType valuesSourceType,
+        ToScriptFieldFactory<SortedBinaryDocValues> toScriptFieldFactory
+    ) {
         this.fieldName = fieldName;
         this.valuesSourceType = valuesSourceType;
+        this.toScriptFieldFactory = toScriptFieldFactory;
     }
 
     @Override
@@ -66,32 +74,34 @@ public BucketedSort newBucketedSort(
     }
 
     @Override
-    public BytesBinaryDVLeafFieldData load(LeafReaderContext context) {
+    public MultiValuedBinaryDVLeafFieldData load(LeafReaderContext context) {
         try {
-            return new BytesBinaryDVLeafFieldData(DocValues.getBinary(context.reader(), fieldName));
+            return new MultiValuedBinaryDVLeafFieldData(DocValues.getBinary(context.reader(), fieldName), toScriptFieldFactory);
         } catch (IOException e) {
             throw new IllegalStateException("Cannot load doc values", e);
         }
     }
 
     @Override
-    public BytesBinaryDVLeafFieldData loadDirect(LeafReaderContext context) {
+    public MultiValuedBinaryDVLeafFieldData loadDirect(LeafReaderContext context) {
         return load(context);
     }
 
     public static class Builder implements IndexFieldData.Builder {
         private final String name;
+        private final ToScriptFieldFactory<SortedBinaryDocValues> toScriptFieldFactory;
         private final ValuesSourceType valuesSourceType;
 
-        public Builder(String name, ValuesSourceType valuesSourceType) {
+        public Builder(String name, ValuesSourceType valuesSourceType, ToScriptFieldFactory<SortedBinaryDocValues> toScriptFieldFactory) {
             this.name = name;
             this.valuesSourceType = valuesSourceType;
+            this.toScriptFieldFactory = toScriptFieldFactory;
         }
 
         @Override
         public IndexFieldData<?> build(IndexFieldDataCache cache, CircuitBreakerService breakerService) {
             // Ignore breaker
-            return new BytesBinaryIndexFieldData(name, valuesSourceType);
+            return new BytesBinaryIndexFieldData(name, valuesSourceType, toScriptFieldFactory);
         }
     }
 }
diff --git a/server/src/main/java/org/elasticsearch/index/fielddata/plain/StringBinaryDVLeafFieldData.java b/server/src/main/java/org/elasticsearch/index/fielddata/plain/MultiValuedBinaryDVLeafFieldData.java
similarity index 57%
rename from server/src/main/java/org/elasticsearch/index/fielddata/plain/StringBinaryDVLeafFieldData.java
rename to server/src/main/java/org/elasticsearch/index/fielddata/plain/MultiValuedBinaryDVLeafFieldData.java
index 032ea2a022b25..eb73e423c1c42 100644
--- a/server/src/main/java/org/elasticsearch/index/fielddata/plain/StringBinaryDVLeafFieldData.java
+++ b/server/src/main/java/org/elasticsearch/index/fielddata/plain/MultiValuedBinaryDVLeafFieldData.java
@@ -10,22 +10,35 @@
 package org.elasticsearch.index.fielddata.plain;
 
 import org.apache.lucene.index.BinaryDocValues;
+import org.elasticsearch.index.fielddata.LeafFieldData;
+import org.elasticsearch.index.fielddata.MultiValuedSortedBinaryDocValues;
 import org.elasticsearch.index.fielddata.SortedBinaryDocValues;
 import org.elasticsearch.script.field.DocValuesScriptFieldFactory;
 import org.elasticsearch.script.field.ToScriptFieldFactory;
 
-final class StringBinaryDVLeafFieldData extends AbstractBinaryDVLeafFieldData {
+public final class MultiValuedBinaryDVLeafFieldData implements LeafFieldData {
+    private final BinaryDocValues values;
+    private final ToScriptFieldFactory<SortedBinaryDocValues> toScriptFieldFactory;
 
-    protected final ToScriptFieldFactory<SortedBinaryDocValues> toScriptFieldFactory;
+    MultiValuedBinaryDVLeafFieldData(BinaryDocValues values, ToScriptFieldFactory<SortedBinaryDocValues> toScriptFieldFactory) {
+        super();
+        this.values = values;
+        this.toScriptFieldFactory = toScriptFieldFactory;
+    }
 
-    StringBinaryDVLeafFieldData(BinaryDocValues values, ToScriptFieldFactory<SortedBinaryDocValues> toScriptFieldFactory) {
-        super(values);
+    @Override
+    public long ramBytesUsed() {
+        return 0; // not exposed by Lucene
+    }
 
-        this.toScriptFieldFactory = toScriptFieldFactory;
+    @Override
+    public SortedBinaryDocValues getBytesValues() {
+        return new MultiValuedSortedBinaryDocValues(values);
     }
 
     @Override
     public DocValuesScriptFieldFactory getScriptFieldFactory(String name) {
         return toScriptFieldFactory.getScriptFieldFactory(getBytesValues(), name);
     }
+
 }
diff --git a/server/src/main/java/org/elasticsearch/index/fielddata/plain/StringBinaryIndexFieldData.java b/server/src/main/java/org/elasticsearch/index/fielddata/plain/StringBinaryIndexFieldData.java
index 7c8b058cb01f1..012697e750227 100644
--- a/server/src/main/java/org/elasticsearch/index/fielddata/plain/StringBinaryIndexFieldData.java
+++ b/server/src/main/java/org/elasticsearch/index/fielddata/plain/StringBinaryIndexFieldData.java
@@ -26,7 +26,7 @@
 
 import java.io.IOException;
 
-public class StringBinaryIndexFieldData implements IndexFieldData<StringBinaryDVLeafFieldData> {
+public class StringBinaryIndexFieldData implements IndexFieldData<MultiValuedBinaryDVLeafFieldData> {
 
     protected final String fieldName;
     protected final ValuesSourceType valuesSourceType;
@@ -59,9 +59,9 @@ public SortField sortField(Object missingValue, MultiValueMode sortMode, Nested
     }
 
     @Override
-    public StringBinaryDVLeafFieldData load(LeafReaderContext context) {
+    public MultiValuedBinaryDVLeafFieldData load(LeafReaderContext context) {
         try {
-            return new StringBinaryDVLeafFieldData(DocValues.getBinary(context.reader(), fieldName), toScriptFieldFactory);
+            return new MultiValuedBinaryDVLeafFieldData(DocValues.getBinary(context.reader(), fieldName), toScriptFieldFactory);
         } catch (IOException e) {
             throw new IllegalStateException("Cannot load doc values", e);
         }
@@ -82,7 +82,7 @@ public BucketedSort newBucketedSort(
     }
 
     @Override
-    public StringBinaryDVLeafFieldData loadDirect(LeafReaderContext context) {
+    public MultiValuedBinaryDVLeafFieldData loadDirect(LeafReaderContext context) {
         return load(context);
     }
 }
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/BinaryDocValuesSyntheticFieldLoaderLayer.java b/server/src/main/java/org/elasticsearch/index/mapper/BinaryDocValuesSyntheticFieldLoaderLayer.java
index 1f0c0be1f9555..ac0f102094146 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/BinaryDocValuesSyntheticFieldLoaderLayer.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/BinaryDocValuesSyntheticFieldLoaderLayer.java
@@ -9,76 +9,64 @@
 
 package org.elasticsearch.index.mapper;
 
-import org.apache.lucene.index.BinaryDocValues;
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.util.BytesRef;
-import org.elasticsearch.common.io.stream.ByteArrayStreamInput;
+import org.elasticsearch.index.fielddata.MultiValuedSortedBinaryDocValues;
+import org.elasticsearch.index.fielddata.SortedBinaryDocValues;
 import org.elasticsearch.xcontent.XContentBuilder;
 
 import java.io.IOException;
 
 public final class BinaryDocValuesSyntheticFieldLoaderLayer implements CompositeSyntheticFieldLoader.DocValuesLayer {
 
-    private final String fieldName;
+    private final String name;
+    private SortedBinaryDocValues bytesValues;
+    private boolean hasValue;
 
-    // the binary doc values for a document are all encoded in a single binary array, which this stream knows how to read
-    // the doc values in the array take the form of [doc value count][length of value 1][value 1][length of value 2][value 2]...
-    private final ByteArrayStreamInput stream;
-    private int valueCount;
+    public BinaryDocValuesSyntheticFieldLoaderLayer(String name) {
+        this.name = name;
+    }
 
-    public BinaryDocValuesSyntheticFieldLoaderLayer(String fieldName) {
-        this.fieldName = fieldName;
-        this.stream = new ByteArrayStreamInput();
+    @Override
+    public long valueCount() {
+        return bytesValues == null ? 0 : bytesValues.docValueCount();
     }
 
     @Override
     public DocValuesLoader docValuesLoader(LeafReader leafReader, int[] docIdsInLeaf) throws IOException {
-        BinaryDocValues docValues = leafReader.getBinaryDocValues(fieldName);
-
-        // there are no values associated with this field
+        var docValues = leafReader.getBinaryDocValues(name);
         if (docValues == null) {
-            valueCount = 0;
+            bytesValues = null;
             return null;
         }
 
-        return docId -> {
-            // there are no more documents to process
-            if (docValues.advanceExact(docId) == false) {
-                valueCount = 0;
-                return false;
-            }
+        bytesValues = new MultiValuedSortedBinaryDocValues(docValues);
 
-            // otherwise, extract the doc values into a stream to later read from
-            BytesRef docValuesBytes = docValues.binaryValue();
-            stream.reset(docValuesBytes.bytes, docValuesBytes.offset, docValuesBytes.length);
-            valueCount = stream.readVInt();
-
-            return hasValue();
+        return docId -> {
+            hasValue = bytesValues.advanceExact(docId);
+            return hasValue;
         };
     }
 
-    @Override
-    public void write(XContentBuilder b) throws IOException {
-        for (int i = 0; i < valueCount; i++) {
-            // this function already knows how to decode the underlying bytes array, so no need to explicitly call VInt()
-            BytesRef valueBytes = stream.readBytesRef();
-            b.value(valueBytes.utf8ToString());
-        }
-    }
-
     @Override
     public boolean hasValue() {
-        return valueCount > 0;
+        return hasValue;
     }
 
     @Override
-    public long valueCount() {
-        return valueCount;
+    public void write(XContentBuilder b) throws IOException {
+        if (hasValue == false) {
+            return;
+        }
+
+        for (int i = 0; i < bytesValues.docValueCount(); ++i) {
+            BytesRef value = bytesValues.nextValue();
+            b.utf8Value(value.bytes, value.offset, value.length);
+        }
     }
 
     @Override
     public String fieldName() {
-        return fieldName;
+        return name;
     }
-
 }
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/BinaryFieldMapper.java b/server/src/main/java/org/elasticsearch/index/mapper/BinaryFieldMapper.java
index 01daf1bf6d392..6db6a5b00755c 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/BinaryFieldMapper.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/BinaryFieldMapper.java
@@ -22,6 +22,7 @@
 import org.elasticsearch.index.fielddata.IndexFieldData;
 import org.elasticsearch.index.fielddata.plain.BytesBinaryIndexFieldData;
 import org.elasticsearch.index.query.SearchExecutionContext;
+import org.elasticsearch.script.field.BinaryDocValuesField;
 import org.elasticsearch.search.DocValueFormat;
 import org.elasticsearch.search.aggregations.support.CoreValuesSourceType;
 import org.elasticsearch.xcontent.XContentBuilder;
@@ -127,7 +128,7 @@ public BytesReference valueForDisplay(Object value) {
         @Override
         public IndexFieldData.Builder fielddataBuilder(FieldDataContext fieldDataContext) {
             failIfNoDocValues();
-            return new BytesBinaryIndexFieldData.Builder(name(), CoreValuesSourceType.KEYWORD);
+            return new BytesBinaryIndexFieldData.Builder(name(), CoreValuesSourceType.KEYWORD, BinaryDocValuesField::new);
         }
 
         @Override
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/FieldMapper.java b/server/src/main/java/org/elasticsearch/index/mapper/FieldMapper.java
index 14c1232696976..b235f837b6970 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/FieldMapper.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/FieldMapper.java
@@ -617,7 +617,7 @@ public Builder add(FieldMapper.Builder builder) {
 
                 if (builder instanceof KeywordFieldMapper.Builder kwd) {
                     if ((kwd.hasNormalizer() == false || kwd.isNormalizerSkipStoreOriginalValue())
-                        && (kwd.hasDocValues() || kwd.isStored())) {
+                        && (kwd.docValuesParameters().enabled || kwd.isStored())) {
                         hasSyntheticSourceCompatibleKeywordField = true;
                     }
                 }
@@ -778,7 +778,7 @@ public interface SerializerCheck<T> {
      * A configurable parameter for a field mapper
      * @param <T> the type of the value the parameter holds
      */
-    public static final class Parameter<T> implements Supplier<T> {
+    public static class Parameter<T> implements Supplier<T> {
 
         public final String name;
         private List<String> deprecatedNames = List.of();
@@ -1405,6 +1405,84 @@ public static Parameter<OnScriptError> onScriptErrorParam(
         }
     }
 
+    public static final class DocValuesParameter extends Parameter<DocValuesParameter.Values> {
+        public static final String PARAMETER_NAME = "doc_values";
+
+        public record Values(boolean enabled, Cardinality cardinality) {
+            public enum Cardinality {
+                LOW,
+                HIGH;
+
+                @Override
+                public String toString() {
+                    return name().toLowerCase(Locale.ROOT);
+                }
+            }
+
+            public static Values DISABLED = new Values(false, Cardinality.LOW);
+        }
+
+        public final Parameter<Values.Cardinality> cardinalityParameter;
+
+        public DocValuesParameter(Values defaultValue, Function<FieldMapper, Values> initializer) {
+            super(PARAMETER_NAME, false, () -> defaultValue, null, initializer, null, Values::toString);
+
+            cardinalityParameter = Parameter.enumParam(
+                "cardinality",
+                false,
+                m -> initializer.apply(m).cardinality,
+                defaultValue.cardinality,
+                Values.Cardinality.class
+            );
+        }
+
+        @Override
+        public void parse(String field, MappingParserContext context, Object value) {
+            if (value instanceof Boolean valueBool) {
+                if (valueBool) {
+                    setValue(getDefaultValue());
+                } else {
+                    setValue(Values.DISABLED);
+                }
+            } else if (value instanceof String) {
+                if (value.equals("true")) {
+                    setValue(getDefaultValue());
+                } else if (value.equals("false")) {
+                    setValue(Values.DISABLED);
+                } else {
+                    throw new IllegalArgumentException("Illegal value [" + value + "] for parameter [" + name + "]");
+                }
+            } else if (value instanceof Map) {
+                @SuppressWarnings("unchecked")
+                Map<String, Object> valueMap = (Map<String, Object>) value;
+                cardinalityParameter.parse(field, context, valueMap.get(cardinalityParameter.name));
+
+                setValue(new Values(true, cardinalityParameter.getValue()));
+            } else {
+                throw new IllegalArgumentException("Illegal value [" + value + "] for parameter [" + name + "]");
+            }
+        }
+
+        @Override
+        public void setValue(Values value) {
+            super.setValue(value);
+            cardinalityParameter.setValue(value.cardinality);
+        }
+
+        protected void toXContent(XContentBuilder builder, boolean includeDefaults) throws IOException {
+            Values value = getValue();
+            if (includeDefaults || isConfigured()) {
+                if (value.enabled == false) {
+                    builder.field(name, false);
+                } else {
+                    builder.startObject(name);
+                    builder.field(cardinalityParameter.name, value.cardinality);
+                    builder.endObject();
+                }
+            }
+        }
+    }
+
     public static final class Conflicts {
 
         private final String mapperName;
@@ -1499,11 +1577,7 @@ protected final void validate() {
         @Override
         public abstract FieldMapper build(MapperBuilderContext context);
 
-        protected void addScriptValidation(
-            Parameter<Script> scriptParam,
-            Parameter<Boolean> indexParam,
-            Parameter<Boolean> docValuesParam
-        ) {
+        protected void addScriptValidation(Parameter<Script> scriptParam, Parameter<Boolean> indexParam, Supplier<Boolean> docValuesParam) {
             scriptParam.addValidator(s -> {
                 if (s != null && indexParam.get() == false && docValuesParam.get() == false) {
                     throw new MapperParsingException("Cannot define script on field with index:false and doc_values:false");
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/KeywordFieldMapper.java b/server/src/main/java/org/elasticsearch/index/mapper/KeywordFieldMapper.java
index 2b558d12b9e83..f7f37e8727def 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/KeywordFieldMapper.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/KeywordFieldMapper.java
@@ -60,8 +60,10 @@
 import org.elasticsearch.index.fielddata.IndexFieldData;
 import org.elasticsearch.index.fielddata.SourceValueFetcherSortedBinaryIndexFieldData;
 import org.elasticsearch.index.fielddata.StoredFieldSortedBinaryIndexFieldData;
+import org.elasticsearch.index.fielddata.plain.BytesBinaryIndexFieldData;
 import org.elasticsearch.index.fielddata.plain.SortedSetOrdinalsIndexFieldData;
 import org.elasticsearch.index.mapper.blockloader.BlockLoaderFunctionConfig;
+import org.elasticsearch.index.mapper.blockloader.docvalues.BytesRefsFromCustomBinaryBlockLoader;
 import org.elasticsearch.index.mapper.blockloader.docvalues.BytesRefsFromOrdsBlockLoader;
 import org.elasticsearch.index.mapper.blockloader.docvalues.fn.MvMaxBytesRefsFromOrdsBlockLoader;
 import org.elasticsearch.index.mapper.blockloader.docvalues.fn.MvMinBytesRefsFromOrdsBlockLoader;
@@ -71,14 +73,19 @@
 import org.elasticsearch.index.similarity.SimilarityProvider;
 import org.elasticsearch.script.Script;
 import org.elasticsearch.script.ScriptCompiler;
+import org.elasticsearch.script.SortedBinaryDocValuesStringFieldScript;
 import org.elasticsearch.script.SortedSetDocValuesStringFieldScript;
 import org.elasticsearch.script.StringFieldScript;
 import org.elasticsearch.script.field.KeywordDocValuesField;
 import org.elasticsearch.search.aggregations.support.CoreValuesSourceType;
 import org.elasticsearch.search.lookup.FieldValues;
 import org.elasticsearch.search.lookup.SearchLookup;
+import org.elasticsearch.search.runtime.StringScriptFieldFuzzyQuery;
 import org.elasticsearch.search.runtime.StringScriptFieldPrefixQuery;
+import org.elasticsearch.search.runtime.StringScriptFieldRangeQuery;
+import org.elasticsearch.search.runtime.StringScriptFieldRegexpQuery;
 import org.elasticsearch.search.runtime.StringScriptFieldTermQuery;
+import org.elasticsearch.search.runtime.StringScriptFieldTermsQuery;
 import org.elasticsearch.search.runtime.StringScriptFieldWildcardQuery;
 import org.elasticsearch.xcontent.Text;
 import org.elasticsearch.xcontent.XContentBuilder;
@@ -97,7 +104,9 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.TreeSet;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
 
 import static org.apache.lucene.index.IndexWriter.MAX_TERM_LENGTH;
 import static org.elasticsearch.core.Strings.format;
@@ -115,6 +124,11 @@ public final class KeywordFieldMapper extends FieldMapper {
     public static final String CONTENT_TYPE = "keyword";
     private static final String HOST_NAME = "host.name";
 
+    public static final DocValuesParameter.Values DEFAULT_DOC_VALUES_PARAMS = new DocValuesParameter.Values(
+        true,
+        DocValuesParameter.Values.Cardinality.LOW
+    );
+
     public static class Defaults {
         public static final FieldType FIELD_TYPE;
         public static final FieldType FIELD_TYPE_WITH_SKIP_DOC_VALUES;
@@ -178,7 +192,10 @@ private static KeywordFieldMapper toType(FieldMapper in) {
     public static final class Builder extends FieldMapper.DimensionBuilder {
 
         private final Parameter<Boolean> indexed;
-        private final Parameter<Boolean> hasDocValues = Parameter.docValuesParam(m -> toType(m).hasDocValues, true);
+        private final DocValuesParameter docValuesParameters = new DocValuesParameter(
+            DEFAULT_DOC_VALUES_PARAMS,
+            m -> toType(m).docValuesParameters()
+        );
         private final Parameter<Boolean> stored = Parameter.storeParam(m -> toType(m).fieldType.stored(), false);
 
         private final Parameter<String> nullValue = Parameter.stringParam("null_value", false, m -> toType(m).fieldType().nullValue, null)
@@ -262,10 +279,12 @@ public Builder(
 
             this.script.precludesParameters(nullValue);
 
-            this.dimension = TimeSeriesParams.dimensionParam(m -> toType(m).fieldType().isDimension(), hasDocValues::get)
-                .precludesParameters(normalizer);
+            this.dimension = TimeSeriesParams.dimensionParam(
+                m -> toType(m).fieldType().isDimension(),
+                () -> docValuesParameters.getValue().enabled()
+            ).precludesParameters(normalizer);
             this.indexed = Parameter.indexParam(m -> toType(m).indexed, indexSettings, dimension);
-            addScriptValidation(script, indexed, hasDocValues);
+            addScriptValidation(script, indexed, () -> docValuesParameters.getValue().enabled());
 
             this.ignoreAbove = Parameter.ignoreAboveParam(
                 m -> toType(m).fieldType().ignoreAbove().get(),
@@ -311,13 +330,14 @@ Builder nullValue(String nullValue) {
             return this;
         }
 
+        @Deprecated()
         public Builder docValues(boolean hasDocValues) {
-            this.hasDocValues.setValue(hasDocValues);
+            this.docValuesParameters.setValue(hasDocValues ? DEFAULT_DOC_VALUES_PARAMS : DocValuesParameter.Values.DISABLED);
             return this;
         }
 
-        public boolean hasDocValues() {
-            return this.hasDocValues.get();
+        public DocValuesParameter.Values docValuesParameters() {
+            return docValuesParameters.getValue();
         }
 
         public SimilarityProvider similarity() {
@@ -359,7 +379,7 @@ private FieldValues<String> scriptValues() {
         protected Parameter<?>[] getParameters() {
             return new Parameter<?>[] {
                 indexed,
-                hasDocValues,
+                docValuesParameters,
                 stored,
                 nullValue,
                 eagerGlobalOrdinals,
@@ -376,6 +396,15 @@ protected Parameter<?>[] getParameters() {
                 dimension };
         }
 
+        private IndexType buildIndexType(FieldType fieldType) {
+            var docValuesParameters = docValuesParameters();
+            if (docValuesParameters.enabled() && docValuesParameters.cardinality() == DocValuesParameter.Values.Cardinality.HIGH) {
+                return IndexType.terms(fieldType.indexOptions() != IndexOptions.NONE, true);
+            }
+
+            return IndexType.terms(fieldType);
+        }
+
         private KeywordFieldType buildFieldType(MapperBuilderContext context, FieldType fieldType) {
             NamedAnalyzer normalizer = Lucene.KEYWORD_ANALYZER;
             NamedAnalyzer searchAnalyzer = Lucene.KEYWORD_ANALYZER;
@@ -406,7 +435,7 @@ private KeywordFieldType buildFieldType(MapperBuilderContext context, FieldType
             }
             return new KeywordFieldType(
                 context.buildFullName(leafName()),
-                IndexType.terms(fieldType),
+                buildIndexType(fieldType),
                 new TextSearchInfo(fieldType, similarity.get(), searchAnalyzer, quoteAnalyzer),
                 normalizer,
                 this,
@@ -423,7 +452,7 @@ public KeywordFieldMapper build(MapperBuilderContext context) {
             String offsetsFieldName = getOffsetsFieldName(
                 context,
                 indexSettings.sourceKeepMode(),
-                hasDocValues.getValue(),
+                fieldtype.docValuesType() == DocValuesType.SORTED_SET,
                 stored.getValue(),
                 this,
                 indexCreatedVersion,
@@ -446,7 +475,14 @@ private FieldType resolveFieldType(final boolean forceDocValuesSkipper, final St
             }
             fieldtype.setOmitNorms(this.hasNorms.getValue() == false);
             fieldtype.setStored(this.stored.getValue());
-            fieldtype.setDocValuesType(this.hasDocValues.getValue() ? DocValuesType.SORTED_SET : DocValuesType.NONE);
+
+            DocValuesParameter.Values docValuesParameters = this.docValuesParameters.get();
+            if (docValuesParameters.enabled() && docValuesParameters.cardinality() == DocValuesParameter.Values.Cardinality.LOW) {
+                fieldtype.setDocValuesType(DocValuesType.SORTED_SET);
+            } else {
+                fieldtype.setDocValuesType(DocValuesType.NONE);
+            }
+
             if (fieldtype.equals(Defaults.FIELD_TYPE_WITH_SKIP_DOC_VALUES) == false) {
                 // NOTE: override index options only if we are not using a sparse doc values index (and we use an inverted index)
                 fieldtype.setIndexOptions(TextParams.toIndexOptions(this.indexed.getValue(), this.indexOptions.getValue()));
@@ -462,11 +498,13 @@ private FieldType resolveFieldType(final boolean forceDocValuesSkipper, final St
         }
 
         private boolean shouldUseTimeSeriesSkipper() {
-            return hasDocValues.get() && indexed.get() == false && useTimeSeriesDocValuesSkippers(indexSettings, dimension.get());
+            return docValuesParameters.getValue().enabled()
+                && indexed.get() == false
+                && useTimeSeriesDocValuesSkippers(indexSettings, dimension.get());
         }
 
         private boolean shouldUseHostnameSkipper(final String fullFieldName) {
-            return hasDocValues.get()
+            return docValuesParameters.getValue().enabled()
                 && IndexSettings.USE_DOC_VALUES_SKIPPER.get(indexSettings.getSettings())
                 && indexSettings.getIndexVersionCreated().onOrAfter(IndexVersions.SKIPPERS_ENABLED_BY_DEFAULT)
                 && IndexMode.LOGSDB.equals(indexSettings.getMode())
@@ -491,6 +529,7 @@ public static final class KeywordFieldType extends TextFamilyFieldType {
         private final boolean eagerGlobalOrdinals;
         private final FieldValues<String> scriptValues;
         private final boolean isDimension;
+        private final DocValuesParameter.Values docValuesParameters;
 
         public KeywordFieldType(
             String name,
@@ -519,6 +558,7 @@ public KeywordFieldType(
             this.nullValue = builder.nullValue.getValue();
             this.scriptValues = builder.scriptValues();
             this.isDimension = builder.dimension.getValue();
+            this.docValuesParameters = builder.docValuesParameters();
         }
 
         public KeywordFieldType(String name) {
@@ -533,6 +573,7 @@ public KeywordFieldType(String name, boolean isIndexed, boolean hasDocValues, Ma
             this.eagerGlobalOrdinals = false;
             this.scriptValues = null;
             this.isDimension = false;
+            this.docValuesParameters = DEFAULT_DOC_VALUES_PARAMS;
         }
 
         public KeywordFieldType(String name, FieldType fieldType, boolean isSyntheticSource) {
@@ -551,6 +592,7 @@ public KeywordFieldType(String name, FieldType fieldType, boolean isSyntheticSou
             this.eagerGlobalOrdinals = false;
             this.scriptValues = null;
             this.isDimension = false;
+            this.docValuesParameters = DEFAULT_DOC_VALUES_PARAMS;
         }
 
         public KeywordFieldType(String name, NamedAnalyzer analyzer) {
@@ -569,6 +611,7 @@ public KeywordFieldType(String name, NamedAnalyzer analyzer) {
             this.eagerGlobalOrdinals = false;
             this.scriptValues = null;
             this.isDimension = false;
+            this.docValuesParameters = DEFAULT_DOC_VALUES_PARAMS;
         }
 
         @Override
@@ -581,6 +624,14 @@ public Query termQuery(Object value, SearchExecutionContext context) {
             failIfNotIndexedNorDocValuesFallback(context);
             if (indexType.hasTerms()) {
                 return super.termQuery(value, context);
+            } else if (storedInBinaryDocValues()) {
+                return new StringScriptFieldTermQuery(
+                    new Script(""),
+                    ctx -> new SortedBinaryDocValuesStringFieldScript(binaryDocValuesName(), context.lookup(), ctx),
+                    name(),
+                    indexedValueForSearch(value).utf8ToString(),
+                    false
+                );
             } else {
                 return SortedSetDocValuesField.newSlowExactQuery(name(), indexedValueForSearch(value));
             }
@@ -591,6 +642,13 @@ public Query termsQuery(Collection<?> values, SearchExecutionContext context) {
             failIfNotIndexedNorDocValuesFallback(context);
             if (indexType.hasTerms()) {
                 return super.termsQuery(values, context);
+            } else if (storedInBinaryDocValues()) {
+                return new StringScriptFieldTermsQuery(
+                    new Script(""),
+                    ctx -> new SortedBinaryDocValuesStringFieldScript(binaryDocValuesName(), context.lookup(), ctx),
+                    name(),
+                    values.stream().map(this::indexedValueForSearch).map(BytesRef::utf8ToString).collect(Collectors.toSet())
+                );
             } else {
                 Collection<BytesRef> bytesRefs = values.stream().map(this::indexedValueForSearch).toList();
                 return SortedSetDocValuesField.newSlowSetQuery(name(), bytesRefs);
@@ -608,6 +666,16 @@ public Query rangeQuery(
             failIfNotIndexedNorDocValuesFallback(context);
             if (indexType.hasTerms()) {
                 return super.rangeQuery(lowerTerm, upperTerm, includeLower, includeUpper, context);
+            } else if (storedInBinaryDocValues()) {
+                return new StringScriptFieldRangeQuery(
+                    new Script(""),
+                    ctx -> new SortedBinaryDocValuesStringFieldScript(binaryDocValuesName(), context.lookup(), ctx),
+                    name(),
+                    lowerTerm == null ? null : indexedValueForSearch(lowerTerm).utf8ToString(),
+                    upperTerm == null ? null : indexedValueForSearch(upperTerm).utf8ToString(),
+                    includeLower,
+                    includeUpper
+                );
             } else {
                 return SortedSetDocValuesField.newSlowRangeQuery(
                     name(),
@@ -632,6 +700,16 @@ public Query fuzzyQuery(
             failIfNotIndexedNorDocValuesFallback(context);
             if (indexType.hasTerms()) {
                 return super.fuzzyQuery(value, fuzziness, prefixLength, maxExpansions, transpositions, context, rewriteMethod);
+            } else if (storedInBinaryDocValues()) {
+                return StringScriptFieldFuzzyQuery.build(
+                    new Script(""),
+                    ctx -> new SortedBinaryDocValuesStringFieldScript(binaryDocValuesName(), context.lookup(), ctx),
+                    name(),
+                    indexedValueForSearch(value).utf8ToString(),
+                    fuzziness.asDistance(BytesRefs.toString(value)),
+                    prefixLength,
+                    transpositions
+                );
             } else {
                 return new FuzzyQuery(
                     new Term(name(), indexedValueForSearch(value)),
@@ -654,6 +732,14 @@ public Query prefixQuery(
             failIfNotIndexedNorDocValuesFallback(context);
             if (indexType.hasTerms()) {
                 return super.prefixQuery(value, method, caseInsensitive, context);
+            } else if (storedInBinaryDocValues()) {
+                return new StringScriptFieldPrefixQuery(
+                    new Script(""),
+                    ctx -> new SortedBinaryDocValuesStringFieldScript(binaryDocValuesName(), context.lookup(), ctx),
+                    name(),
+                    indexedValueForSearch(value).utf8ToString(),
+                    caseInsensitive
+                );
             } else {
                 if (caseInsensitive == false) {
                     Term prefix = new Term(name(), indexedValueForSearch(value));
@@ -674,6 +760,14 @@ public Query termQueryCaseInsensitive(Object value, SearchExecutionContext conte
             failIfNotIndexedNorDocValuesFallback(context);
             if (indexType.hasTerms()) {
                 return super.termQueryCaseInsensitive(value, context);
+            } else if (storedInBinaryDocValues()) {
+                return new StringScriptFieldTermQuery(
+                    new Script(""),
+                    ctx -> new SortedBinaryDocValuesStringFieldScript(binaryDocValuesName(), context.lookup(), ctx),
+                    name(),
+                    indexedValueForSearch(value).utf8ToString(),
+                    true
+                );
             } else {
                 return new StringScriptFieldTermQuery(
                     new Script(""),
@@ -691,7 +785,11 @@ public TermsEnum getTerms(IndexReader reader, String prefix, boolean caseInsensi
             if (indexType.hasTerms()) {
                 terms = MultiTerms.getTerms(reader, name());
             } else if (hasDocValues()) {
-                terms = SortedSetDocValuesTerms.getTerms(reader, name());
+                if (storedInBinaryDocValues()) {
+                    throw new UnsupportedOperationException("TODO");
+                } else {
+                    terms = SortedSetDocValuesTerms.getTerms(reader, name());
+                }
             }
             if (terms == null) {
                 // Field does not exist on this shard.
@@ -721,6 +819,14 @@ public String typeName() {
             return CONTENT_TYPE;
         }
 
+        public boolean storedInBinaryDocValues() {
+            return docValuesParameters.enabled() && docValuesParameters.cardinality() == DocValuesParameter.Values.Cardinality.HIGH;
+        }
+
+        public String binaryDocValuesName() {
+            return name() + "._dv";
+        }
+
         @Override
         public boolean eagerGlobalOrdinals() {
             return eagerGlobalOrdinals;
@@ -734,6 +840,12 @@ NamedAnalyzer normalizer() {
         public BlockLoader blockLoader(BlockLoaderContext blContext) {
             if (hasDocValues() && (blContext.fieldExtractPreference() != FieldExtractPreference.STORED || isSyntheticSourceEnabled())) {
                 BlockLoaderFunctionConfig cfg = blContext.blockLoaderFunctionConfig();
+
+                if (storedInBinaryDocValues()) {
+                    // TODO: Support the function-specific optimizations
+                    return new BytesRefsFromCustomBinaryBlockLoader(binaryDocValuesName());
+                }
+
                 if (cfg == null) {
                     return new BytesRefsFromOrdsBlockLoader(name());
                 }
@@ -743,7 +855,6 @@ public BlockLoader blockLoader(BlockLoaderContext blContext) {
                     case MV_MIN -> new MvMinBytesRefsFromOrdsBlockLoader(name());
                     default -> throw new UnsupportedOperationException("unknown fusion config [" + cfg.function() + "]");
                 };
-
             }
             if (blContext.blockLoaderFunctionConfig() != null) {
                 throw new UnsupportedOperationException("function fusing only supported for doc values");
@@ -871,12 +982,19 @@ protected BytesRef storedToBytesRef(Object stored) {
             );
         }
 
-        private SortedSetOrdinalsIndexFieldData.Builder fieldDataFromDocValues() {
-            return new SortedSetOrdinalsIndexFieldData.Builder(
-                name(),
-                CoreValuesSourceType.KEYWORD,
-                (dv, n) -> new KeywordDocValuesField(FieldData.toString(dv), n)
-            );
+        private IndexFieldData.Builder fieldDataFromDocValues() {
+            return switch (docValuesParameters.cardinality()) {
+                case LOW -> new SortedSetOrdinalsIndexFieldData.Builder(
+                    name(),
+                    CoreValuesSourceType.KEYWORD,
+                    (dv, n) -> new KeywordDocValuesField(FieldData.toString(dv), n)
+                );
+                case HIGH -> new BytesBinaryIndexFieldData.Builder(
+                    binaryDocValuesName(),
+                    CoreValuesSourceType.KEYWORD,
+                    KeywordDocValuesField::new
+                );
+            };
         }
 
         @Override
@@ -957,17 +1075,17 @@ public Query wildcardQuery(
                 } else {
                     value = indexedValueForSearch(value).utf8ToString();
                 }
-                if (caseInsensitive == false) {
+
+                if (caseInsensitive == false && docValuesParameters.cardinality() == DocValuesParameter.Values.Cardinality.LOW) {
                     Term term = new Term(name(), value);
                     return new WildcardQuery(term, Operations.DEFAULT_DETERMINIZE_WORK_LIMIT, MultiTermQuery.DOC_VALUES_REWRITE);
                 }
-                return new StringScriptFieldWildcardQuery(
-                    new Script(""),
-                    ctx -> new SortedSetDocValuesStringFieldScript(name(), context.lookup(), ctx),
-                    name(),
-                    value,
-                    caseInsensitive
-                );
+
+                StringFieldScript.LeafFactory leafFactory = docValuesParameters.cardinality() == DocValuesParameter.Values.Cardinality.LOW
+                    ? ctx -> new SortedSetDocValuesStringFieldScript(name(), context.lookup(), ctx)
+                    : ctx -> new SortedBinaryDocValuesStringFieldScript(binaryDocValuesName(), context.lookup(), ctx);
+
+                return new StringScriptFieldWildcardQuery(new Script(""), leafFactory, name(), value, caseInsensitive);
             }
         }
 
@@ -982,8 +1100,19 @@ public Query normalizedWildcardQuery(String value, MultiTermQuery.RewriteMethod
                 } else {
                     value = indexedValueForSearch(value).utf8ToString();
                 }
-                Term term = new Term(name(), value);
-                return new WildcardQuery(term, Operations.DEFAULT_DETERMINIZE_WORK_LIMIT, MultiTermQuery.DOC_VALUES_REWRITE);
+
+                if (storedInBinaryDocValues()) {
+                    return new StringScriptFieldWildcardQuery(
+                        new Script(""),
+                        ctx -> new SortedBinaryDocValuesStringFieldScript(binaryDocValuesName(), context.lookup(), ctx),
+                        name(),
+                        value,
+                        false
+                    );
+                } else {
+                    Term term = new Term(name(), value);
+                    return new WildcardQuery(term, Operations.DEFAULT_DETERMINIZE_WORK_LIMIT, MultiTermQuery.DOC_VALUES_REWRITE);
+                }
             }
         }
 
@@ -1003,14 +1132,27 @@ public Query regexpQuery(
                 if (matchFlags != 0) {
                     throw new IllegalArgumentException("Match flags not yet implemented [" + matchFlags + "]");
                 }
-                return new RegexpQuery(
-                    new Term(name(), indexedValueForSearch(value)),
-                    syntaxFlags,
-                    matchFlags,
-                    RegexpQuery.DEFAULT_PROVIDER,
-                    maxDeterminizedStates,
-                    MultiTermQuery.DOC_VALUES_REWRITE
-                );
+
+                if (storedInBinaryDocValues()) {
+                    return new StringScriptFieldRegexpQuery(
+                        new Script(""),
+                        ctx -> new SortedBinaryDocValuesStringFieldScript(binaryDocValuesName(), context.lookup(), ctx),
+                        name(),
+                        value,
+                        syntaxFlags,
+                        matchFlags,
+                        maxDeterminizedStates
+                    );
+                } else {
+                    return new RegexpQuery(
+                        new Term(name(), indexedValueForSearch(value)),
+                        syntaxFlags,
+                        matchFlags,
+                        RegexpQuery.DEFAULT_PROVIDER,
+                        maxDeterminizedStates,
+                        MultiTermQuery.DOC_VALUES_REWRITE
+                    );
+                }
             }
         }
 
@@ -1052,7 +1194,7 @@ public Query automatonQuery(
     }
 
     private final boolean indexed;
-    private final boolean hasDocValues;
+    private final DocValuesParameter.Values docValuesParameters;
     private final String indexOptions;
     private final FieldType fieldType;
     private final String normalizerName;
@@ -1077,7 +1219,7 @@ private KeywordFieldMapper(
         super(simpleName, mappedFieldType, builderParams);
         assert fieldType.indexOptions().compareTo(IndexOptions.DOCS_AND_FREQS) <= 0;
         this.indexed = builder.indexed.getValue();
-        this.hasDocValues = builder.hasDocValues.getValue();
+        this.docValuesParameters = builder.docValuesParameters.getValue();
         this.indexOptions = builder.indexOptions.getValue();
         this.fieldType = freezeAndDeduplicateFieldType(fieldType);
         this.normalizerName = builder.normalizer.getValue();
@@ -1105,6 +1247,10 @@ public boolean isNormalizerSkipStoreOriginalValue() {
         return normalizerSkipStoreOriginalValue;
     }
 
+    public DocValuesParameter.Values docValuesParameters() {
+        return docValuesParameters;
+    }
+
     protected void parseCreateField(DocumentParserContext context) throws IOException {
         var value = context.parser().optimizedTextOrNull();
 
@@ -1168,7 +1314,7 @@ private boolean indexValue(DocumentParserContext context, XContentString value)
                 // store the value in a binary doc values field, create one if it doesn't exist
                 MultiValuedBinaryDocValuesField field = (MultiValuedBinaryDocValuesField) context.doc().getByKey(fieldName);
                 if (field == null) {
-                    field = new MultiValuedBinaryDocValuesField(fieldName);
+                    field = new MultiValuedBinaryDocValuesField(fieldName, MultiValuedBinaryDocValuesField.Ordering.INSERTION);
                     context.doc().addWithKey(fieldName, field);
                 }
                 field.add(bytesRef);
@@ -1208,8 +1354,25 @@ private boolean indexValue(DocumentParserContext context, XContentString value)
             throw new IllegalArgumentException(msg);
         }
 
-        Field field = buildKeywordField(binaryValue);
-        context.doc().add(field);
+        if (fieldType().storedInBinaryDocValues()) {
+            assert fieldType.docValuesType() == DocValuesType.NONE;
+            MultiValuedBinaryDocValuesField field = (MultiValuedBinaryDocValuesField) context.doc()
+                .getField(fieldType().binaryDocValuesName());
+            if (field == null) {
+                field = new MultiValuedBinaryDocValuesField(
+                    fieldType().binaryDocValuesName(),
+                    MultiValuedBinaryDocValuesField.Ordering.NATURAL
+                );
+                context.doc().addWithKey(fieldType().binaryDocValuesName(), field);
+            }
+            field.add(binaryValue);
+        }
+
+        // Skip adding the field if we're using binary doc values (cardinality is high) and the field is neither indexed nor stored.
+        if (fieldType.indexOptions() != IndexOptions.NONE || fieldType.docValuesType() != DocValuesType.NONE || fieldType.stored()) {
+            Field field = buildKeywordField(binaryValue);
+            context.doc().add(field);
+        }
 
         if (fieldType().hasDocValues() == false && fieldType.omitNorms()) {
             context.addToFieldNames(fieldType().name());
@@ -1291,7 +1454,9 @@ protected SyntheticSourceSupport syntheticSourceSupport() {
             return SyntheticSourceSupport.FALLBACK;
         }
 
-        if (fieldType.stored() || hasDocValues) {
+        if (fieldType.stored()
+            || offsetsFieldName != null
+            || (indexSettings.sourceKeepMode() == SourceKeepMode.NONE && fieldType.docValuesType() != DocValuesType.NONE)) {
             return new SyntheticSourceSupport.Native(() -> syntheticFieldLoader(fullPath(), leafName()));
         }
 
@@ -1299,7 +1464,7 @@ protected SyntheticSourceSupport syntheticSourceSupport() {
     }
 
     public CompositeSyntheticFieldLoader syntheticFieldLoader(String fullFieldName, String leafFieldName) {
-        assert fieldType.stored() || hasDocValues;
+        assert fieldType.stored() || docValuesParameters.enabled();
 
         var layers = new ArrayList<CompositeSyntheticFieldLoader.Layer>(2);
         if (fieldType.stored()) {
@@ -1310,23 +1475,29 @@ protected void writeValue(Object value, XContentBuilder b) throws IOException {
                     b.utf8Value(ref.bytes, ref.offset, ref.length);
                 }
             });
-        } else if (hasDocValues) {
-            if (offsetsFieldName != null) {
-                layers.add(new SortedSetWithOffsetsDocValuesSyntheticFieldLoaderLayer(fullPath(), offsetsFieldName));
+        } else if (docValuesParameters.enabled()) {
+            if (docValuesParameters.cardinality() == DocValuesParameter.Values.Cardinality.LOW) {
+                if (offsetsFieldName != null) {
+                    layers.add(new SortedSetWithOffsetsDocValuesSyntheticFieldLoaderLayer(fullPath(), offsetsFieldName));
+                } else {
+                    layers.add(new SortedSetDocValuesSyntheticFieldLoaderLayer(fullPath()) {
+
+                        @Override
+                        protected BytesRef convert(BytesRef value) {
+                            return value;
+                        }
+
+                        @Override
+                        protected BytesRef preserve(BytesRef value) {
+                            // Preserve must make a deep copy because convert gets a shallow copy from the iterator
+                            return BytesRef.deepCopyOf(value);
+                        }
+                    });
+                }
             } else {
-                layers.add(new SortedSetDocValuesSyntheticFieldLoaderLayer(fullPath()) {
-
-                    @Override
-                    protected BytesRef convert(BytesRef value) {
-                        return value;
-                    }
-
-                    @Override
-                    protected BytesRef preserve(BytesRef value) {
-                        // Preserve must make a deep copy because convert gets a shallow copy from the iterator
-                        return BytesRef.deepCopyOf(value);
-                    }
-                });
+                assert offsetsFieldName == null;
+                assert indexSettings.sourceKeepMode() == SourceKeepMode.NONE;
+                layers.add(new BinaryDocValuesSyntheticFieldLoaderLayer(fieldType().binaryDocValuesName()));
             }
         }
 
@@ -1344,18 +1515,25 @@ protected BytesRef preserve(BytesRef value) {
      * A custom implementation of {@link org.apache.lucene.index.BinaryDocValues} that uses a {@link Set} to maintain a collection of unique
      * binary doc values for fields with multiple values per document.
      */
-    private static final class MultiValuedBinaryDocValuesField extends CustomDocValuesField {
+    private static class MultiValuedBinaryDocValuesField extends CustomDocValuesField {
+        enum Ordering {
+            INSERTION,
+            NATURAL
+        }
 
         private final Set<BytesRef> uniqueValues;
         private int docValuesByteCount = 0;
 
-        MultiValuedBinaryDocValuesField(String name) {
+        MultiValuedBinaryDocValuesField(String name, Ordering ordering) {
             super(name);
-            // linked hash set to maintain insertion order of elements
-            uniqueValues = new LinkedHashSet<>();
+
+            uniqueValues = switch (ordering) {
+                case INSERTION -> new LinkedHashSet<>();
+                case NATURAL -> new TreeSet<>();
+            };
         }
 
-        public void add(final BytesRef value) {
+        public void add(BytesRef value) {
             if (uniqueValues.add(value)) {
                 // might as well track these on the go as opposed to having to loop through all entries later
                 docValuesByteCount += value.length;
@@ -1384,6 +1562,5 @@ public BytesRef binaryValue() {
                 throw new ElasticsearchException("Failed to get binary value", e);
             }
         }
-
     }
 }
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/MapperFeatures.java b/server/src/main/java/org/elasticsearch/index/mapper/MapperFeatures.java
index 7b96b1b7cc835..1788a00e00e34 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/MapperFeatures.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/MapperFeatures.java
@@ -65,6 +65,9 @@ public class MapperFeatures implements FeatureSpecification {
     public static final NodeFeature FIX_DENSE_VECTOR_WRONG_FIELDS = new NodeFeature("mapper.fix_dense_vector_wrong_fields");
     static final NodeFeature BBQ_DISK_STATS_SUPPORT = new NodeFeature("mapper.bbq_disk_stats_support");
     static final NodeFeature STORED_FIELDS_SPEC_MERGE_BUG = new NodeFeature("mapper.stored_fields_spec_merge_bug");
+    static final NodeFeature STORE_HIGH_CARDINALITY_KEYWORDS_IN_BINARY_DOC_VALUES = new NodeFeature(
+        "mapper.keyword.store_high_cardinality_in_binary_doc_values"
+    );
 
     @Override
     public Set<NodeFeature> getTestFeatures() {
@@ -110,7 +113,8 @@ public Set<NodeFeature> getTestFeatures() {
             BASE64_DENSE_VECTORS,
             FIX_DENSE_VECTOR_WRONG_FIELDS,
             BBQ_DISK_STATS_SUPPORT,
-            STORED_FIELDS_SPEC_MERGE_BUG
+            STORED_FIELDS_SPEC_MERGE_BUG,
+            STORE_HIGH_CARDINALITY_KEYWORDS_IN_BINARY_DOC_VALUES
         );
         if (ES93GenericFlatVectorsFormat.GENERIC_VECTOR_FORMAT.isEnabled()) {
             features = new HashSet<>(features);
diff --git a/server/src/main/java/org/elasticsearch/script/SortedBinaryDocValuesStringFieldScript.java b/server/src/main/java/org/elasticsearch/script/SortedBinaryDocValuesStringFieldScript.java
new file mode 100644
index 0000000000000..b0b44e4e3884d
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/script/SortedBinaryDocValuesStringFieldScript.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+package org.elasticsearch.script;
+
+import org.apache.lucene.index.DocValues;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.index.fielddata.MultiValuedSortedBinaryDocValues;
+import org.elasticsearch.index.fielddata.SortedBinaryDocValues;
+import org.elasticsearch.index.mapper.OnScriptError;
+import org.elasticsearch.search.lookup.SearchLookup;
+
+import java.io.IOException;
+import java.util.Map;
+
+public class SortedBinaryDocValuesStringFieldScript extends StringFieldScript {
+    private final SortedBinaryDocValues sortedBinaryDocValues;
+    boolean hasValue = false;
+
+    public SortedBinaryDocValuesStringFieldScript(String fieldName, SearchLookup searchLookup, LeafReaderContext ctx) {
+        super(fieldName, Map.of(), searchLookup, OnScriptError.FAIL, ctx);
+        try {
+            var binaryDocValues = DocValues.getBinary(ctx.reader(), fieldName);
+            sortedBinaryDocValues = new MultiValuedSortedBinaryDocValues(binaryDocValues);
+        } catch (IOException e) {
+            throw new IllegalStateException("Cannot load doc values", e);
+        }
+    }
+
+    @Override
+    public void setDocument(int docID) {
+        try {
+            hasValue = sortedBinaryDocValues.advanceExact(docID);
+        } catch (IOException e) {
+            throw new IllegalStateException("Cannot load doc values", e);
+        }
+    }
+
+    @Override
+    public void execute() {
+        try {
+            if (hasValue) {
+                for (int i = 0; i < sortedBinaryDocValues.docValueCount(); i++) {
+                    BytesRef bytesRef = sortedBinaryDocValues.nextValue();
+                    emit(bytesRef.utf8ToString());
+                }
+            }
+        } catch (IOException e) {
+            throw new IllegalStateException("Cannot load doc values", e);
+        }
+    }
+}
diff --git a/server/src/test/java/org/elasticsearch/index/mapper/KeywordFieldMapperTests.java b/server/src/test/java/org/elasticsearch/index/mapper/KeywordFieldMapperTests.java
index 1744cc1b69611..57516ac168617 100644
--- a/server/src/test/java/org/elasticsearch/index/mapper/KeywordFieldMapperTests.java
+++ b/server/src/test/java/org/elasticsearch/index/mapper/KeywordFieldMapperTests.java
@@ -938,6 +938,30 @@ public void testDocValuesLoadedFromStoredSynthetic() throws IOException {
         assertScriptDocValues(mapper, "foo", equalTo(List.of("foo")));
     }
 
+    public void testDocValuesLowCardinality() throws IOException {
+        MapperService mapperService = createMapperService(
+            fieldMapping(b -> b.field("type", "keyword").startObject("doc_values").field("cardinality", "low").endObject())
+        );
+        KeywordFieldMapper mapper = (KeywordFieldMapper) mapperService.documentMapper().mappers().getMapper("field");
+        assertThat(
+            mapper.docValuesParameters(),
+            equalTo(new FieldMapper.DocValuesParameter.Values(true, FieldMapper.DocValuesParameter.Values.Cardinality.LOW))
+        );
+        assertScriptDocValues(mapperService, List.of("bar", "foo"), equalTo(List.of("bar", "foo")));
+    }
+
+    public void testDocValuesHighCardinality() throws IOException {
+        MapperService mapperService = createMapperService(
+            fieldMapping(b -> b.field("type", "keyword").startObject("doc_values").field("cardinality", "high").endObject())
+        );
+        KeywordFieldMapper mapper = (KeywordFieldMapper) mapperService.documentMapper().mappers().getMapper("field");
+        assertThat(
+            mapper.docValuesParameters(),
+            equalTo(new FieldMapper.DocValuesParameter.Values(true, FieldMapper.DocValuesParameter.Values.Cardinality.HIGH))
+        );
+        assertScriptDocValues(mapperService, List.of("bar", "foo"), equalTo(List.of("bar", "foo")));
+    }
+
     public void testFieldTypeWithSkipDocValues_LogsDbModeDisabledSetting() throws IOException {
         final MapperService mapperService = createMapperService(
             Settings.builder()
diff --git a/test/framework/src/main/java/org/elasticsearch/datageneration/datasource/DefaultMappingParametersHandler.java b/test/framework/src/main/java/org/elasticsearch/datageneration/datasource/DefaultMappingParametersHandler.java
index 3fb817f6af681..97c161ac5a7d1 100644
--- a/test/framework/src/main/java/org/elasticsearch/datageneration/datasource/DefaultMappingParametersHandler.java
+++ b/test/framework/src/main/java/org/elasticsearch/datageneration/datasource/DefaultMappingParametersHandler.java
@@ -83,7 +83,15 @@ private Supplier<Map<String, Object>> numberMapping(FieldType fieldType) {
 
     private Supplier<Map<String, Object>> keywordMapping(DataSourceRequest.LeafMappingParametersGenerator request) {
         return () -> {
-            var mapping = commonMappingParameters();
+            var mapping = new HashMap<String, Object>();
+            mapping.put("store", ESTestCase.randomBoolean());
+            mapping.put("index", ESTestCase.randomBoolean());
+
+            if (ESTestCase.randomBoolean()) {
+                mapping.put(Mapper.SYNTHETIC_SOURCE_KEEP_PARAM, randomFrom("none", "arrays", "all"));
+            }
+
+            mapping.put("doc_values", extendedDocValuesParams());
 
             // Inject copy_to sometimes but reflect that it is not widely used in reality.
             // We only add copy_to to keywords because we get into trouble with numeric fields that are copied to dynamic fields.
@@ -271,6 +279,16 @@ public static HashMap<String, Object> commonMappingParameters() {
         return map;
     }
 
+    public static Object extendedDocValuesParams() {
+        return switch (ESTestCase.randomInt(3)) {
+            case 0 -> false;
+            case 1 -> Map.of("cardinality", "low");
+            case 2 -> Map.of("cardinality", "high");
+            case 3 -> true;
+            default -> throw new IllegalStateException();
+        };
+    }
+
     @Override
     public DataSourceResponse.ObjectMappingParametersGenerator handle(DataSourceRequest.ObjectMappingParametersGenerator request) {
         if (request.isNested()) {
diff --git a/test/framework/src/main/java/org/elasticsearch/datageneration/queries/LeafQueryGenerator.java b/test/framework/src/main/java/org/elasticsearch/datageneration/queries/LeafQueryGenerator.java
index cb102e185c9b5..6a47d2af336bf 100644
--- a/test/framework/src/main/java/org/elasticsearch/datageneration/queries/LeafQueryGenerator.java
+++ b/test/framework/src/main/java/org/elasticsearch/datageneration/queries/LeafQueryGenerator.java
@@ -42,11 +42,22 @@ static LeafQueryGenerator buildForType(String type, MappingPredicates mappingPre
         };
     }
 
+    private static boolean extendedDocValuesEnabled(Map<String, Object> fieldMapping) {
+        Object configuredValue = fieldMapping.getOrDefault("doc_values", true);
+        if (configuredValue instanceof Boolean b) {
+            return b;
+        } else if (configuredValue instanceof Map) {
+            return true;
+        } else {
+            throw new IllegalArgumentException("Unexpected value [" + configuredValue + "] for mapping parameter [doc_values]");
+        }
+    }
+
     class KeywordQueryGenerator implements LeafQueryGenerator {
         public List<QueryBuilder> generate(Map<String, Object> fieldMapping, String path, Object value) {
             if (fieldMapping != null) {
                 boolean isIndexed = (Boolean) fieldMapping.getOrDefault("index", true);
-                boolean hasDocValues = (Boolean) fieldMapping.getOrDefault("doc_values", true);
+                boolean hasDocValues = LeafQueryGenerator.extendedDocValuesEnabled(fieldMapping);
                 if (isIndexed == false && hasDocValues == false) {
                     return List.of();
                 }
diff --git a/test/framework/src/main/java/org/elasticsearch/index/mapper/BlockLoaderTestCase.java b/test/framework/src/main/java/org/elasticsearch/index/mapper/BlockLoaderTestCase.java
index 3b6c4ec5e0123..421133db82c18 100644
--- a/test/framework/src/main/java/org/elasticsearch/index/mapper/BlockLoaderTestCase.java
+++ b/test/framework/src/main/java/org/elasticsearch/index/mapper/BlockLoaderTestCase.java
@@ -275,6 +275,13 @@ private void processLevel(Map<String, Object> level, String field, ArrayList<Obj
     }
 
     public static boolean hasDocValues(Map<String, Object> fieldMapping, boolean defaultValue) {
-        return (boolean) fieldMapping.getOrDefault("doc_values", defaultValue);
+        Object value = fieldMapping.getOrDefault("doc_values", defaultValue);
+        if (value instanceof Boolean b) {
+            return b;
+        } else if (value instanceof Map) {
+            return true;
+        } else {
+            throw new IllegalArgumentException("Unexpected value [" + value + "] for mapping parameter [doc_values]");
+        }
     }
 }
diff --git a/test/framework/src/main/java/org/elasticsearch/index/mapper/KeywordFieldSyntheticSourceSupport.java b/test/framework/src/main/java/org/elasticsearch/index/mapper/KeywordFieldSyntheticSourceSupport.java
index 770b4dffbae27..2b600d961d62c 100644
--- a/test/framework/src/main/java/org/elasticsearch/index/mapper/KeywordFieldSyntheticSourceSupport.java
+++ b/test/framework/src/main/java/org/elasticsearch/index/mapper/KeywordFieldSyntheticSourceSupport.java
@@ -24,15 +24,23 @@ public class KeywordFieldSyntheticSourceSupport implements MapperTestCase.Synthe
     private final Integer ignoreAbove;
     private final boolean allIgnored;
     private final boolean store;
-    private final boolean docValues;
+    private final FieldMapper.DocValuesParameter.Values docValues;
     private final String nullValue;
+    private final boolean allowIgnoredSource;
 
-    KeywordFieldSyntheticSourceSupport(Integer ignoreAbove, boolean store, String nullValue, boolean useFallbackSyntheticSource) {
+    KeywordFieldSyntheticSourceSupport(Integer ignoreAbove, boolean store, String nullValue, boolean allowIgnoredSource) {
         this.ignoreAbove = ignoreAbove;
         this.allIgnored = ignoreAbove != null && LuceneTestCase.rarely();
         this.store = store;
         this.nullValue = nullValue;
-        this.docValues = useFallbackSyntheticSource == false || ESTestCase.randomBoolean();
+        this.allowIgnoredSource = allowIgnoredSource;
+
+        this.docValues = switch (ESTestCase.randomInt(allowIgnoredSource ? 2 : 1)) {
+            case 0 -> new FieldMapper.DocValuesParameter.Values(true, FieldMapper.DocValuesParameter.Values.Cardinality.LOW);
+            case 1 -> new FieldMapper.DocValuesParameter.Values(true, FieldMapper.DocValuesParameter.Values.Cardinality.HIGH);
+            case 2 -> FieldMapper.DocValuesParameter.Values.DISABLED;
+            default -> throw new IllegalStateException();
+        };
     }
 
     @Override
@@ -44,7 +52,9 @@ public boolean ignoreAbove() {
     public boolean preservesExactSource() {
         // We opt in into fallback synthetic source implementation
         // if there is nothing else to use, and it preserves exact source data.
-        return store == false && docValues == false;
+        return allowIgnoredSource
+            && store == false
+            && (docValues.enabled() == false || docValues.cardinality() == FieldMapper.DocValuesParameter.Values.Cardinality.HIGH);
     }
 
     @Override
@@ -111,8 +121,13 @@ private void mapping(XContentBuilder b) throws IOException {
         if (store) {
             b.field("store", true);
         }
-        if (docValues == false) {
+
+        if (docValues.enabled() == false) {
             b.field("doc_values", false);
+        } else {
+            b.startObject("doc_values");
+            b.field("cardinality", docValues.cardinality().toString());
+            b.endObject();
         }
     }