ESQL: Most remaining block loads from MV_MIN and MV_MAX

server/src/main/java/module-info.java

@@ -500,6 +500,7 @@
     exports org.elasticsearch.index.codec.vectors.cluster to org.elasticsearch.test.knn;
     exports org.elasticsearch.index.codec.vectors.es93 to org.elasticsearch.test.knn;
     exports org.elasticsearch.search.crossproject;
-    exports org.elasticsearch.index.mapper.blockloader.docvalues;
     exports org.elasticsearch.index.mapper.blockloader;
+    exports org.elasticsearch.index.mapper.blockloader.docvalues;
+    exports org.elasticsearch.index.mapper.blockloader.docvalues.fn;
 }

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

@@ -61,7 +61,7 @@
 import org.elasticsearch.index.fielddata.plain.SortedSetOrdinalsIndexFieldData;
 import org.elasticsearch.index.mapper.blockloader.BlockLoaderFunctionConfig;
 import org.elasticsearch.index.mapper.blockloader.docvalues.BytesRefsFromOrdsBlockLoader;
-import org.elasticsearch.index.mapper.blockloader.docvalues.Utf8CodePointsFromOrdsBlockLoader;
+import org.elasticsearch.index.mapper.blockloader.docvalues.fn.Utf8CodePointsFromOrdsBlockLoader;
 import org.elasticsearch.index.query.AutomatonQueryWithDescription;
 import org.elasticsearch.index.query.SearchExecutionContext;
 import org.elasticsearch.index.similarity.SimilarityProvider;

server/src/main/java/org/elasticsearch/index/mapper/blockloader/docvalues/AbstractBooleansBlockLoader.java

@@ -0,0 +1,153 @@
+/*
+ * 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.mapper.blockloader.docvalues;
+
+import org.apache.lucene.index.DocValues;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.NumericDocValues;
+import org.apache.lucene.index.SortedNumericDocValues;
+
+import java.io.IOException;
+
+/**
+ * Loads {@code boolean}s from doc values.
+ */
+public abstract class AbstractBooleansBlockLoader extends BlockDocValuesReader.DocValuesBlockLoader {
+    protected final String fieldName;
+
+    public AbstractBooleansBlockLoader(String fieldName) {
+        this.fieldName = fieldName;
+    }
+
+    @Override
+    public final BooleanBuilder builder(BlockFactory factory, int expectedCount) {
+        return factory.booleans(expectedCount);
+    }
+
+    @Override
+    public AllReader reader(LeafReaderContext context) throws IOException {
+        SortedNumericDocValues docValues = context.reader().getSortedNumericDocValues(fieldName);
+        if (docValues != null) {
+            NumericDocValues singleton = DocValues.unwrapSingleton(docValues);
+            if (singleton != null) {
+                return singletonReader(singleton);
+            }
+            return sortedReader(docValues);
+        }
+        NumericDocValues singleton = context.reader().getNumericDocValues(fieldName);
+        if (singleton != null) {
+            return singletonReader(singleton);
+        }
+        return new ConstantNullsReader();
+    }
+
+    protected abstract AllReader singletonReader(NumericDocValues docValues);
+
+    protected abstract AllReader sortedReader(SortedNumericDocValues docValues);
+
+    public static class Singleton extends BlockDocValuesReader {
+        private final NumericDocValues numericDocValues;
+
+        public Singleton(NumericDocValues numericDocValues) {
+            this.numericDocValues = numericDocValues;
+        }
+
+        @Override
+        public Block read(BlockFactory factory, Docs docs, int offset, boolean nullsFiltered) throws IOException {
+            try (BooleanBuilder builder = factory.booleansFromDocValues(docs.count() - offset)) {
+                int lastDoc = -1;
+                for (int i = offset; i < docs.count(); i++) {
+                    int doc = docs.get(i);
+                    if (doc < lastDoc) {
+                        throw new IllegalStateException("docs within same block must be in order");
+                    }
+                    if (numericDocValues.advanceExact(doc)) {
+                        builder.appendBoolean(numericDocValues.longValue() != 0);
+                    } else {
+                        builder.appendNull();
+                    }
+                    lastDoc = doc;
+                }
+                return builder.build();
+            }
+        }
+
+        @Override
+        public void read(int docId, StoredFields storedFields, Builder builder) throws IOException {
+            BooleanBuilder blockBuilder = (BooleanBuilder) builder;
+            if (numericDocValues.advanceExact(docId)) {
+                blockBuilder.appendBoolean(numericDocValues.longValue() != 0);
+            } else {
+                blockBuilder.appendNull();
+            }
+        }
+
+        @Override
+        public int docId() {
+            return numericDocValues.docID();
+        }
+
+        @Override
+        public String toString() {
+            return "BooleansFromDocValues.Singleton";
+        }
+    }
+
+    static class Sorted extends BlockDocValuesReader {
+        private final SortedNumericDocValues numericDocValues;
+
+        Sorted(SortedNumericDocValues numericDocValues) {
+            this.numericDocValues = numericDocValues;
+        }
+
+        @Override
+        public Block read(BlockFactory factory, Docs docs, int offset, boolean nullsFiltered) throws IOException {
+            try (BooleanBuilder builder = factory.booleansFromDocValues(docs.count() - offset)) {
+                for (int i = offset; i < docs.count(); i++) {
+                    int doc = docs.get(i);
+                    read(doc, builder);
+                }
+                return builder.build();
+            }
+        }
+
+        @Override
+        public void read(int docId, StoredFields storedFields, Builder builder) throws IOException {
+            read(docId, (BooleanBuilder) builder);
+        }
+
+        private void read(int doc, BooleanBuilder builder) throws IOException {
+            if (false == numericDocValues.advanceExact(doc)) {
+                builder.appendNull();
+                return;
+            }
+            int count = numericDocValues.docValueCount();
+            if (count == 1) {
+                builder.appendBoolean(numericDocValues.nextValue() != 0);
+                return;
+            }
+            builder.beginPositionEntry();
+            for (int v = 0; v < count; v++) {
+                builder.appendBoolean(numericDocValues.nextValue() != 0);
+            }
+            builder.endPositionEntry();
+        }
+
+        @Override
+        public int docId() {
+            return numericDocValues.docID();
+        }
+
+        @Override
+        public String toString() {
+            return "BooleansFromDocValues.Sorted";
+        }
+    }
+}

server/src/main/java/org/elasticsearch/index/mapper/blockloader/docvalues/AbstractBytesRefsFromOrdsBlockLoader.java

@@ -20,10 +20,10 @@
 /**
  * Loads {@code keyword} style fields that are stored as a lookup table.
  */
-abstract class AbstractBytesRefsFromOrdsBlockLoader extends BlockDocValuesReader.DocValuesBlockLoader {
+public abstract class AbstractBytesRefsFromOrdsBlockLoader extends BlockDocValuesReader.DocValuesBlockLoader {
     protected final String fieldName;
 
-    AbstractBytesRefsFromOrdsBlockLoader(String fieldName) {
+    public AbstractBytesRefsFromOrdsBlockLoader(String fieldName) {
         this.fieldName = fieldName;
     }
 
@@ -56,7 +56,7 @@ public final AllReader reader(LeafReaderContext context) throws IOException {
     protected static class Singleton extends BlockDocValuesReader {
         private final SortedDocValues ordinals;
 
-        Singleton(SortedDocValues ordinals) {
+        public Singleton(SortedDocValues ordinals) {
             this.ordinals = ordinals;
         }
 

server/src/main/java/org/elasticsearch/index/mapper/blockloader/docvalues/AbstractDoublesFromDocValuesBlockLoader.java

@@ -0,0 +1,165 @@
+/*
+ * 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.mapper.blockloader.docvalues;
+
+import org.apache.lucene.index.DocValues;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.NumericDocValues;
+import org.apache.lucene.index.SortedNumericDocValues;
+
+import java.io.IOException;
+
+/**
+ * Loads {@code double}s from doc values.
+ */
+public abstract class AbstractDoublesFromDocValuesBlockLoader extends BlockDocValuesReader.DocValuesBlockLoader {
+    protected final String fieldName;
+    private final BlockDocValuesReader.ToDouble toDouble;
+
+    public AbstractDoublesFromDocValuesBlockLoader(String fieldName, BlockDocValuesReader.ToDouble toDouble) {
+        this.fieldName = fieldName;
+        this.toDouble = toDouble;
+    }
+
+    @Override
+    public final Builder builder(BlockFactory factory, int expectedCount) {
+        return factory.doubles(expectedCount);
+    }
+
+    @Override
+    public final AllReader reader(LeafReaderContext context) throws IOException {
+        SortedNumericDocValues docValues = context.reader().getSortedNumericDocValues(fieldName);
+        if (docValues != null) {
+            NumericDocValues singleton = DocValues.unwrapSingleton(docValues);
+            if (singleton != null) {
+                return singletonReader(singleton, toDouble);
+            }
+            return sortedReader(docValues, toDouble);
+        }
+        NumericDocValues singleton = context.reader().getNumericDocValues(fieldName);
+        if (singleton != null) {
+            return singletonReader(singleton, toDouble);
+        }
+        return new ConstantNullsReader();
+    }
+
+    protected abstract AllReader singletonReader(NumericDocValues docValues, BlockDocValuesReader.ToDouble toDouble);
+
+    protected abstract AllReader sortedReader(SortedNumericDocValues docValues, BlockDocValuesReader.ToDouble toDouble);
+
+    public static class Singleton extends BlockDocValuesReader implements BlockDocValuesReader.NumericDocValuesAccessor {
+        private final NumericDocValues docValues;
+        private final ToDouble toDouble;
+
+        public Singleton(NumericDocValues docValues, ToDouble toDouble) {
+            this.docValues = docValues;
+            this.toDouble = toDouble;
+        }
+
+        @Override
+        public Block read(BlockFactory factory, Docs docs, int offset, boolean nullsFiltered) throws IOException {
+            if (docValues instanceof OptionalColumnAtATimeReader direct) {
+                Block result = direct.tryRead(factory, docs, offset, nullsFiltered, toDouble, false);
+                if (result != null) {
+                    return result;
+                }
+            }
+            try (DoubleBuilder builder = factory.doublesFromDocValues(docs.count() - offset)) {
+                for (int i = offset; i < docs.count(); i++) {
+                    int doc = docs.get(i);
+                    if (docValues.advanceExact(doc)) {
+                        builder.appendDouble(toDouble.convert(docValues.longValue()));
+                    } else {
+                        builder.appendNull();
+                    }
+                }
+                return builder.build();
+            }
+        }
+
+        @Override
+        public void read(int docId, StoredFields storedFields, Builder builder) throws IOException {
+            DoubleBuilder blockBuilder = (DoubleBuilder) builder;
+            if (docValues.advanceExact(docId)) {
+                blockBuilder.appendDouble(toDouble.convert(docValues.longValue()));
+            } else {
+                blockBuilder.appendNull();
+            }
+        }
+
+        @Override
+        public int docId() {
+            return docValues.docID();
+        }
+
+        @Override
+        public String toString() {
+            return "DoublesFromDocValues.Singleton";
+        }
+
+        @Override
+        public NumericDocValues numericDocValues() {
+            return docValues;
+        }
+    }
+
+    public static class Sorted extends BlockDocValuesReader {
+        private final SortedNumericDocValues docValues;
+        private final ToDouble toDouble;
+
+        Sorted(SortedNumericDocValues docValues, ToDouble toDouble) {
+            this.docValues = docValues;
+            this.toDouble = toDouble;
+        }
+
+        @Override
+        public Block read(BlockFactory factory, Docs docs, int offset, boolean nullsFiltered) throws IOException {
+            try (DoubleBuilder builder = factory.doublesFromDocValues(docs.count() - offset)) {
+                for (int i = offset; i < docs.count(); i++) {
+                    int doc = docs.get(i);
+                    read(doc, builder);
+                }
+                return builder.build();
+            }
+        }
+
+        @Override
+        public void read(int docId, StoredFields storedFields, Builder builder) throws IOException {
+            read(docId, (DoubleBuilder) builder);
+        }
+
+        private void read(int doc, DoubleBuilder builder) throws IOException {
+            if (false == docValues.advanceExact(doc)) {
+                builder.appendNull();
+                return;
+            }
+            int count = docValues.docValueCount();
+            if (count == 1) {
+                builder.appendDouble(toDouble.convert(docValues.nextValue()));
+                return;
+            }
+            builder.beginPositionEntry();
+            for (int v = 0; v < count; v++) {
+                builder.appendDouble(toDouble.convert(docValues.nextValue()));
+            }
+            builder.endPositionEntry();
+        }
+
+        @Override
+        public int docId() {
+            return docValues.docID();
+        }
+
+        @Override
+        public String toString() {
+            return "DoublesFromDocValues.Sorted";
+        }
+    }
+}

server/src/main/java/org/elasticsearch/index/mapper/blockloader/docvalues/AbstractIntsFromDocValuesBlockLoader.java

@@ -22,7 +22,7 @@
 public abstract class AbstractIntsFromDocValuesBlockLoader extends BlockDocValuesReader.DocValuesBlockLoader {
     protected final String fieldName;
 
-    AbstractIntsFromDocValuesBlockLoader(String fieldName) {
+    protected AbstractIntsFromDocValuesBlockLoader(String fieldName) {
         this.fieldName = fieldName;
     }
 
@@ -55,7 +55,7 @@ public final AllReader reader(LeafReaderContext context) throws IOException {
     public static class Singleton extends BlockDocValuesReader implements BlockDocValuesReader.NumericDocValuesAccessor {
         private final NumericDocValues numericDocValues;
 
-        Singleton(NumericDocValues numericDocValues) {
+        public Singleton(NumericDocValues numericDocValues) {
             this.numericDocValues = numericDocValues;
         }