avoid buffer

Author: dnhatn

server/src/main/java/org/elasticsearch/index/codec/tsdb/es819/ES819TSDBDocValuesProducer.java

@@ -1404,8 +1404,8 @@ public BlockLoader.Block tryRead(
                     boolean nullsFiltered,
                     BlockDocValuesReader.ToDouble toDouble
                 ) throws IOException {
-                    try (var longs = singletonLongs(factory, toDouble, docs.count() - offset)) {
-                        return tryRead(longs, docs, offset);
+                    try (var singletonLongBuilder = singletonLongBuilder(factory, toDouble, docs.count() - offset)) {
+                        return tryRead(singletonLongBuilder, docs, offset);
                     }
                 }
 
@@ -1566,7 +1566,7 @@ public BlockLoader.Block tryRead(
                             assert disi.index() == firstIndex + i : "unexpected disi index " + (firstIndex + i) + "!=" + disi.index();
                         }
                     }
-                    try (var longs = singletonLongs(factory, toDouble, valueCount)) {
+                    try (var singletonLongBuilder = singletonLongBuilder(factory, toDouble, valueCount)) {
                         for (int i = 0; i < valueCount;) {
                             final int index = firstIndex + i;
                             final int blockIndex = index >>> ES819TSDBDocValuesFormat.NUMERIC_BLOCK_SHIFT;
@@ -1580,10 +1580,10 @@ public BlockLoader.Block tryRead(
                                 decoder.decode(valuesData, currentBlock);
                             }
                             final int count = Math.min(ES819TSDBDocValuesFormat.NUMERIC_BLOCK_SIZE - blockStartIndex, valueCount - i);
-                            longs.appendLongs(currentBlock, blockStartIndex, count);
+                            singletonLongBuilder.appendLongs(currentBlock, blockStartIndex, count);
                             i += count;
                         }
-                        return longs.build();
+                        return singletonLongBuilder.build();
                     }
                 }
             };
@@ -1881,7 +1881,7 @@ public BlockLoader.Builder endPositionEntry() {
         public void close() {}
     }
 
-    static BlockLoader.SingletonLongBuilder singletonLongs(
+    static BlockLoader.SingletonLongBuilder singletonLongBuilder(
         BlockLoader.BlockFactory factory,
         BlockDocValuesReader.ToDouble toDouble,
         int valueCount
@@ -1897,7 +1897,6 @@ static BlockLoader.SingletonLongBuilder singletonLongs(
     static final class SingletonLongToDoubleDelegate implements BlockLoader.SingletonLongBuilder {
         private final BlockLoader.SingletonDoubleBuilder doubleBuilder;
         private final BlockDocValuesReader.ToDouble toDouble;
-        private final double[] buffer = new double[ES819TSDBDocValuesFormat.NUMERIC_BLOCK_SIZE];
 
         // The passed builder is used to store the converted double values and produce the final block containing them.
         SingletonLongToDoubleDelegate(BlockLoader.SingletonDoubleBuilder doubleBuilder, BlockDocValuesReader.ToDouble toDouble) {
@@ -1912,11 +1911,7 @@ public BlockLoader.SingletonLongBuilder appendLong(long value) {
 
         @Override
         public BlockLoader.SingletonLongBuilder appendLongs(long[] values, int from, int length) {
-            assert length <= buffer.length : "length " + length + " > " + buffer.length;
-            for (int i = 0; i < length; i++) {
-                buffer[i] = toDouble.convert(values[from + i]);
-            }
-            doubleBuilder.appendDoubles(buffer, 0, length);
+            doubleBuilder.appendLongs(toDouble, values, from, length);
             return this;
         }
 

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

@@ -407,11 +407,6 @@ interface BlockFactory {
          */
         DoubleBuilder doubles(int expectedCount);
 
-        /**
-         * Creates a block from an array of doubles
-         */
-        Block doubles(double[] values, int expectedCount);
-
         /**
          * Build a builder to load dense vectors without any loading constraints.
          */
@@ -575,6 +570,8 @@ interface SingletonDoubleBuilder extends Builder {
         SingletonDoubleBuilder appendDouble(double value);
 
         SingletonDoubleBuilder appendDoubles(double[] values, int from, int length);
+
+        SingletonDoubleBuilder appendLongs(BlockDocValuesReader.ToDouble toDouble, long[] values, int from, int length);
     }
 
     interface LongBuilder extends Builder {

test/framework/src/main/java/org/elasticsearch/index/mapper/TestBlock.java

@@ -120,16 +120,6 @@ public DoublesBuilder appendDouble(double value) {
                 return new DoublesBuilder();
             }
 
-            @Override
-            public BlockLoader.Block doubles(double[] values, int expectedCount) {
-                try (BlockLoader.DoubleBuilder builder = doubles(expectedCount)) {
-                    for (double value : values) {
-                        builder.appendDouble(value);
-                    }
-                    return builder.build();
-                }
-            }
-
             @Override
             public BlockLoader.FloatBuilder denseVectors(int expectedCount, int dimensions) {
                 class FloatsBuilder extends TestBlock.Builder implements BlockLoader.FloatBuilder {
@@ -286,6 +276,20 @@ public BlockLoader.SingletonDoubleBuilder appendDouble(double value) {
                         return this;
                     }
 
+                    @Override
+                    public BlockLoader.SingletonDoubleBuilder appendLongs(
+                        BlockDocValuesReader.ToDouble toDouble,
+                        long[] longValues,
+                        int from,
+                        int length
+                    ) {
+                        for (int i = 0; i < length; i++) {
+                            values[count + i] = toDouble.convert(longValues[from + i]);
+                        }
+                        this.count += length;
+                        return this;
+                    }
+
                     @Override
                     public BlockLoader.Builder appendNull() {
                         throw new UnsupportedOperationException();

x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/lucene/read/DelegatingBlockLoaderFactory.java

@@ -78,11 +78,6 @@ public BlockLoader.DoubleBuilder doubles(int expectedCount) {
         return factory.newDoubleBlockBuilder(expectedCount);
     }
 
-    @Override
-    public BlockLoader.Block doubles(double[] values, int expectedCount) {
-        return factory.newDoubleArrayVector(values, expectedCount).asBlock();
-    }
-
     @Override
     public BlockLoader.FloatBuilder denseVectors(int expectedVectorsCount, int dimensions) {
         return factory.newFloatBlockBuilder(expectedVectorsCount * dimensions);

x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/lucene/read/SingletonDoubleBuilder.java

@@ -10,6 +10,7 @@
 import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.core.Releasable;
+import org.elasticsearch.index.mapper.BlockDocValuesReader;
 import org.elasticsearch.index.mapper.BlockLoader;
 
 /**
@@ -84,6 +85,15 @@ public BlockLoader.SingletonDoubleBuilder appendDoubles(double[] values, int fro
         return this;
     }
 
+    @Override
+    public BlockLoader.SingletonDoubleBuilder appendLongs(BlockDocValuesReader.ToDouble toDouble, long[] longValues, int from, int length) {
+        for (int i = 0; i < length; i++) {
+            values[count + i] = toDouble.convert(longValues[from + i]);
+        }
+        this.count += length;
+        return this;
+    }
+
     @Override
     public void close() {
         blockFactory.adjustBreaker(-valuesSize(values.length));

x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/lucene/read/SingletonDoubleBuilderTests.java

@@ -72,6 +72,8 @@ private void testRead(BlockFactory factory) throws IOException {
                             double value = Double.longBitsToDouble(docValues.longValue());
                             if (randomBoolean()) {
                                 builder.appendDoubles(new double[] { value }, 0, 1);
+                            } else if (randomBoolean()) {
+                                builder.appendLongs(Double::longBitsToDouble, new long[] { docValues.longValue() }, 0, 1);
                             } else {
                                 builder.appendDouble(value);
                             }