Commented out float features, everything pass either way expect a single bug arpung the exostence of COUNTER_FLOAT.

shmuelhanoch · shmuelhanoch · commit 2d1c02db075b · 2025-08-14T09:52:08.000+03:00
All test pass with the comments.
Without them ther obe which fail is in EsqlQueryRerponseTest.
diff --git a/x-pack/plugin/esql-core/src/main/java/org/elasticsearch/xpack/esql/core/type/DataType.java b/x-pack/plugin/esql-core/src/main/java/org/elasticsearch/xpack/esql/core/type/DataType.java
@@ -6,6 +6,7 @@
  */
 package org.elasticsearch.xpack.esql.core.type;
 
+import org.apache.logging.log4j.core.util.Booleans;
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
@@ -140,6 +141,7 @@
  * </ul>
  */
 public enum DataType {
+
     /**
      * Fields of this type are unsupported by any functions and are always
      * rendered as {@code null} in the response.
@@ -182,7 +184,15 @@ public enum DataType {
      * aggregation, and casting to their parent numeric type.
      */
     COUNTER_DOUBLE(builder().esType("counter_double").estimatedSize(Double.BYTES).docValues().counter()),
-
+    /**
+     * 32-bit floating point numbers labeled as metric counters in time-series indices.
+     * Although stored internally as numeric fields, they represent cumulative
+     * metrics and must not be treated as regular numeric fields. Therefore,
+     * we define them differently and separately from their parent numeric field.
+     * These fields are strictly for use in retrieval from indices, rate
+     * aggregation, and casting to their parent numeric type.
+     */
+    //COUNTER_FLOAT(builder().esType("counter_float").estimatedSize(Float.BYTES).docValues().counter()),
     /**
      * 64-bit signed numbers loaded as a java {@code long}.
      */
@@ -217,7 +227,7 @@ public enum DataType {
      * Values of this type never escape type resolution and functions,
      * operators, and results should never encounter one.
      */
-    FLOAT(builder().esType("float").estimatedSize(Float.BYTES).rationalNumber().docValues().widenSmallNumeric(DOUBLE)),
+    FLOAT(builder().esType("float").estimatedSize(Float.BYTES).rationalNumber().docValues()/*.counter(COUNTER_FLOAT)*/.widenSmallNumeric(DOUBLE)),
     /**
      * 16-bit floating point numbers widened on load to {@link #DOUBLE}.
      * Values of this type never escape type resolution and functions,
@@ -559,7 +569,7 @@ public static boolean isRepresentable(DataType t) {
     }
 
     public static boolean isCounter(DataType t) {
-        return t == COUNTER_DOUBLE || t == COUNTER_INTEGER || t == COUNTER_LONG;
+        return Set.of(COUNTER_DOUBLE, COUNTER_INTEGER, COUNTER_LONG).contains(t);
     }
 
     public static boolean isSpatialPoint(DataType t) {
@@ -654,7 +664,10 @@ public boolean isCounter() {
      * widen it into, otherwise this returns {@code this}.
      */
     public DataType widenSmallNumeric() {
-        return widenSmallNumeric == null ? this : widenSmallNumeric;
+        return switch (this) {
+            case FLOAT -> NATIVE_FLOATS_FEATURE_FLAG ? FLOAT : DOUBLE;
+            default -> widenSmallNumeric == null ? this : widenSmallNumeric;
+        };
     }
 
     /**
@@ -843,4 +856,5 @@ Builder counter(DataType counter) {
             return this;
         }
     }
+    public static final boolean NATIVE_FLOATS_FEATURE_FLAG = Booleans.parseBoolean(System.getProperty("esql_native_floats_enabled"), false);
 }
diff --git a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/EvaluatorImplementer.java b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/EvaluatorImplementer.java
@@ -44,6 +44,7 @@
 import static org.elasticsearch.compute.gen.Types.DRIVER_CONTEXT;
 import static org.elasticsearch.compute.gen.Types.EXPRESSION_EVALUATOR;
 import static org.elasticsearch.compute.gen.Types.EXPRESSION_EVALUATOR_FACTORY;
+import static org.elasticsearch.compute.gen.Types.FLOAT_BLOCK;
 import static org.elasticsearch.compute.gen.Types.INT_BLOCK;
 import static org.elasticsearch.compute.gen.Types.LONG_BLOCK;
 import static org.elasticsearch.compute.gen.Types.PAGE;
@@ -1091,6 +1092,8 @@ static boolean isBlockType(TypeName type) {
         return type.equals(INT_BLOCK)
             || type.equals(LONG_BLOCK)
             || type.equals(DOUBLE_BLOCK)
+            // TODO NATIVE FLOATS
+            // || type.equals(FLOAT_BLOCK)
             || type.equals(BOOLEAN_BLOCK)
             || type.equals(BYTES_REF_BLOCK);
     }
diff --git a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/Methods.java b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/Methods.java
@@ -39,6 +39,7 @@
 import static org.elasticsearch.compute.gen.Types.DOUBLE_VECTOR_BUILDER;
 import static org.elasticsearch.compute.gen.Types.DOUBLE_VECTOR_FIXED_BUILDER;
 import static org.elasticsearch.compute.gen.Types.FLOAT_BLOCK_BUILDER;
+import static org.elasticsearch.compute.gen.Types.FLOAT_VECTOR;
 import static org.elasticsearch.compute.gen.Types.FLOAT_VECTOR_BUILDER;
 import static org.elasticsearch.compute.gen.Types.FLOAT_VECTOR_FIXED_BUILDER;
 import static org.elasticsearch.compute.gen.Types.INT_BLOCK;
@@ -226,7 +227,7 @@ static String appendMethod(TypeName t) {
         if (t.equals(TypeName.DOUBLE) || t.equals(DOUBLE_BLOCK) || t.equals(DOUBLE_VECTOR)) {
             return "appendDouble";
         }
-        if (t.equals(TypeName.FLOAT) || t.equals(FLOAT_BLOCK_BUILDER)) {
+        if (t.equals(TypeName.FLOAT) || t.equals(FLOAT_BLOCK_BUILDER) /* TODO NATIVE FLOATS || t.equals(FLOAT_VECTOR) */ ) {
             return "appendFloat";
         }
         throw new IllegalArgumentException("unknown append method for [" + t + "]");
diff --git a/x-pack/plugin/esql/qa/server/single-node-native-float/build.gradle b/x-pack/plugin/esql/qa/server/single-node-native-float/build.gradle
@@ -0,0 +1,54 @@
+apply plugin: 'elasticsearch.internal-java-rest-test'
+apply plugin: 'elasticsearch.internal-yaml-rest-test'
+// Necessary to use tests in Serverless
+apply plugin: 'elasticsearch.internal-test-artifact'
+apply plugin: org.elasticsearch.gradle.internal.precommit.CheckstylePrecommitPlugin
+apply plugin: org.elasticsearch.gradle.internal.precommit.ForbiddenApisPrecommitPlugin
+apply plugin: org.elasticsearch.gradle.internal.precommit.ForbiddenPatternsPrecommitPlugin
+apply plugin: org.elasticsearch.gradle.internal.precommit.FilePermissionsPrecommitPlugin
+apply plugin: org.elasticsearch.gradle.internal.precommit.LoggerUsagePrecommitPlugin
+apply plugin: org.elasticsearch.gradle.internal.precommit.TestingConventionsPrecommitPlugin
+
+dependencies {
+  javaRestTestImplementation project(xpackModule('esql:qa:testFixtures'))
+  javaRestTestImplementation project(xpackModule('esql:qa:server'))
+  javaRestTestImplementation project(xpackModule('esql:tools'))
+  javaRestTestImplementation project(xpackModule('esql'))
+  yamlRestTestImplementation project(xpackModule('esql:qa:server'))
+
+  javaRestTestImplementation('org.apache.arrow:arrow-vector:18.3.0')
+  javaRestTestImplementation('org.apache.arrow:arrow-format:18.3.0')
+  javaRestTestImplementation('org.apache.arrow:arrow-memory-core:18.3.0')
+  javaRestTestImplementation('org.checkerframework:checker-qual:3.42.0')
+  javaRestTestImplementation('com.google.flatbuffers:flatbuffers-java:23.5.26')
+  javaRestTestImplementation("com.fasterxml.jackson.core:jackson-annotations:${versions.jackson}")
+  javaRestTestImplementation("com.fasterxml.jackson.core:jackson-core:${versions.jackson}")
+  javaRestTestImplementation("com.fasterxml.jackson.core:jackson-databind:${versions.jackson}")
+  javaRestTestImplementation("org.slf4j:slf4j-api:${versions.slf4j}")
+  javaRestTestImplementation("org.slf4j:slf4j-nop:${versions.slf4j}")
+  javaRestTestImplementation('org.apache.arrow:arrow-memory-unsafe:18.3.0')
+
+  clusterPlugins project(':plugins:mapper-size')
+  clusterPlugins project(':plugins:mapper-murmur3')
+  clusterPlugins project(':x-pack:plugin:inference:qa:test-service-plugin')
+}
+
+restResources {
+  restApi {
+    include '_common', 'bulk', 'get', 'indices', 'esql', 'xpack', 'enrich', 'cluster', 'capabilities', 'index'
+  }
+  restTests {
+    includeXpack 'esql'
+  }
+}
+
+tasks.named('javaRestTest') {
+  usesDefaultDistribution("to be triaged")
+  maxParallelForks = 1
+  jvmArgs('--add-opens=java.base/java.nio=ALL-UNNAMED', 'esql_native_floats_data_type=true')
+}
+
+tasks.named('yamlRestTest') {
+  usesDefaultDistribution("to be triaged")
+  maxParallelForks = 1
+}
diff --git a/x-pack/plugin/esql/qa/testFixtures/src/main/java/org/elasticsearch/xpack/esql/EsqlTestUtils.java b/x-pack/plugin/esql/qa/testFixtures/src/main/java/org/elasticsearch/xpack/esql/EsqlTestUtils.java
@@ -827,7 +827,7 @@ public static Literal randomLiteral(DataType type) {
             case DATETIME -> randomMillisUpToYear9999();
             case DATE_NANOS -> randomLongBetween(0, Long.MAX_VALUE);
             case DOUBLE, SCALED_FLOAT, COUNTER_DOUBLE -> randomDouble();
-            case FLOAT -> randomFloat();
+            case FLOAT /* TODO native floats ,COUNTER_FLOAT */ -> randomFloat();
             case HALF_FLOAT -> HalfFloatPoint.sortableShortToHalfFloat(HalfFloatPoint.halfFloatToSortableShort(randomFloat()));
             case KEYWORD -> new BytesRef(randomAlphaOfLength(5));
             case IP -> new BytesRef(InetAddressPoint.encode(randomIp(randomBoolean())));
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/PositionToXContent.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/PositionToXContent.java
@@ -84,6 +84,14 @@ protected XContentBuilder valueToXContent(XContentBuilder builder, ToXContent.Pa
                     return builder.value(((DoubleBlock) block).getDouble(valueIndex));
                 }
             };
+            /* TODO NATIVE FLOATS
+            case FLOAT, COUNTER_FLOAT -> new PositionToXContent(block) {
+                @Override
+                protected XContentBuilder valueToXContent(XContentBuilder builder, ToXContent.Params params, int valueIndex)
+                    throws IOException {
+                    return builder.value(((FloatBlock) block).getFloat(valueIndex));
+                }
+            }; */
             case UNSIGNED_LONG -> new PositionToXContent(block) {
                 @Override
                 protected XContentBuilder valueToXContent(XContentBuilder builder, ToXContent.Params params, int valueIndex)
@@ -190,8 +198,10 @@ protected XContentBuilder valueToXContent(XContentBuilder builder, ToXContent.Pa
                     return builder.value(((FloatBlock) block).getFloat(valueIndex));
                 }
             };
-            case DATE_PERIOD, TIME_DURATION, DOC_DATA_TYPE, TSID_DATA_TYPE, SHORT, BYTE, OBJECT, FLOAT, HALF_FLOAT, SCALED_FLOAT,
-                PARTIAL_AGG -> throw new IllegalArgumentException("can't convert values of type [" + columnInfo.type() + "]");
+            case DATE_PERIOD, TIME_DURATION, DOC_DATA_TYPE, TSID_DATA_TYPE, SHORT, BYTE, OBJECT, FLOAT,
+                /* TODO native floats COUNTER_FLOAT, */ HALF_FLOAT, SCALED_FLOAT, PARTIAL_AGG -> throw new IllegalArgumentException(
+                    "can't convert values of type [" + columnInfo.type() + "]"
+                );
         };
     }
 }
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/ResponseValueUtils.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/ResponseValueUtils.java
@@ -117,6 +117,8 @@ private static Object valueAt(DataType dataType, Block block, int offset, BytesR
             case LONG, COUNTER_LONG -> ((LongBlock) block).getLong(offset);
             case INTEGER, COUNTER_INTEGER -> ((IntBlock) block).getInt(offset);
             case DOUBLE, COUNTER_DOUBLE -> ((DoubleBlock) block).getDouble(offset);
+            // TODO NATIVE FLOATS
+            // case FLOAT, COUNTER_FLOAT -> ((FloatBlock) block).getFloat(offset);
             case KEYWORD, TEXT -> ((BytesRefBlock) block).getBytesRef(offset, scratch).utf8ToString();
             case IP -> {
                 BytesRef val = ((BytesRefBlock) block).getBytesRef(offset, scratch);
@@ -149,8 +151,8 @@ private static Object valueAt(DataType dataType, Block block, int offset, BytesR
                 }
             }
             case DENSE_VECTOR -> ((FloatBlock) block).getFloat(offset);
-            case SHORT, BYTE, FLOAT, HALF_FLOAT, SCALED_FLOAT, OBJECT, DATE_PERIOD, TIME_DURATION, DOC_DATA_TYPE, TSID_DATA_TYPE, NULL,
-                PARTIAL_AGG -> throw EsqlIllegalArgumentException.illegalDataType(dataType);
+            case SHORT, BYTE, FLOAT, /* TODO native floats COUNTER_FLOAT, */ HALF_FLOAT, SCALED_FLOAT, OBJECT, DATE_PERIOD, TIME_DURATION,
+                DOC_DATA_TYPE, TSID_DATA_TYPE, NULL, PARTIAL_AGG -> throw EsqlIllegalArgumentException.illegalDataType(dataType);
         };
     }
 }
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/fulltext/Match.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/fulltext/Match.java
@@ -96,6 +96,8 @@ public class Match extends FullTextFunction implements OptionalArgument, PostAna
         DATETIME,
         DATE_NANOS,
         DOUBLE,
+        // TODO NATIVE FLOATS
+        // FLOAT,
         INTEGER,
         IP,
         LONG,
@@ -108,6 +110,8 @@ public class Match extends FullTextFunction implements OptionalArgument, PostAna
         DATETIME,
         DATE_NANOS,
         DOUBLE,
+        // TODO NATIVE FLOATS
+        // FLOAT,
         INTEGER,
         IP,
         LONG,
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/nulls/Coalesce.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/nulls/Coalesce.java
@@ -209,8 +209,9 @@ public ExpressionEvaluator.Factory toEvaluator(ToEvaluator toEvaluator) {
             case KEYWORD, TEXT, CARTESIAN_POINT, CARTESIAN_SHAPE, GEO_POINT, GEO_SHAPE, IP, VERSION -> CoalesceBytesRefEvaluator
                 .toEvaluator(toEvaluator, children());
             case NULL -> EvalOperator.CONSTANT_NULL_FACTORY;
-            case UNSUPPORTED, SHORT, BYTE, DATE_PERIOD, OBJECT, DOC_DATA_TYPE, SOURCE, TIME_DURATION, FLOAT, HALF_FLOAT, TSID_DATA_TYPE,
-                SCALED_FLOAT, PARTIAL_AGG, AGGREGATE_METRIC_DOUBLE, DENSE_VECTOR -> throw new UnsupportedOperationException(
+            case UNSUPPORTED, SHORT, BYTE, DATE_PERIOD, OBJECT, DOC_DATA_TYPE, SOURCE, TIME_DURATION, FLOAT,
+                HALF_FLOAT, /* TODO native floats COUNTER_FLOAT, */
+                TSID_DATA_TYPE, SCALED_FLOAT, PARTIAL_AGG, AGGREGATE_METRIC_DOUBLE, DENSE_VECTOR -> throw new UnsupportedOperationException(
                     dataType() + " can’t be coalesced"
                 );
         };
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/planner/LocalExecutionPlanner.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/planner/LocalExecutionPlanner.java
@@ -490,8 +490,9 @@ private PhysicalOperation planTopN(TopNExec topNExec, LocalExecutionPlannerConte
                 case VERSION -> TopNEncoder.VERSION;
                 case BOOLEAN, NULL, BYTE, SHORT, INTEGER, LONG, DOUBLE, FLOAT, HALF_FLOAT, DATETIME, DATE_NANOS, DATE_PERIOD, TIME_DURATION,
                     OBJECT, SCALED_FLOAT, UNSIGNED_LONG, DOC_DATA_TYPE, TSID_DATA_TYPE -> TopNEncoder.DEFAULT_SORTABLE;
-                case GEO_POINT, CARTESIAN_POINT, GEO_SHAPE, CARTESIAN_SHAPE, COUNTER_LONG, COUNTER_INTEGER, COUNTER_DOUBLE, SOURCE,
-                    AGGREGATE_METRIC_DOUBLE, DENSE_VECTOR -> TopNEncoder.DEFAULT_UNSORTABLE;
+                case GEO_POINT, CARTESIAN_POINT, GEO_SHAPE, CARTESIAN_SHAPE, COUNTER_LONG, COUNTER_INTEGER,
+                    COUNTER_DOUBLE, /* TODO native floats COUNTER_FLOAT, */
+                    SOURCE, AGGREGATE_METRIC_DOUBLE, DENSE_VECTOR -> TopNEncoder.DEFAULT_UNSORTABLE;
                 // unsupported fields are encoded as BytesRef, we'll use the same encoder; all values should be null at this point
                 case PARTIAL_AGG, UNSUPPORTED -> TopNEncoder.UNSUPPORTED;
             };
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/planner/PlannerUtils.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/planner/PlannerUtils.java
@@ -320,6 +320,8 @@ public static ElementType toElementType(DataType dataType, MappedFieldType.Field
             case LONG, DATETIME, DATE_NANOS, UNSIGNED_LONG, COUNTER_LONG -> ElementType.LONG;
             case INTEGER, COUNTER_INTEGER -> ElementType.INT;
             case DOUBLE, COUNTER_DOUBLE -> ElementType.DOUBLE;
+            // TODO native floats
+            // case COUNTER_FLOAT -> ElementType.FLOAT;
             // unsupported fields are passed through as a BytesRef
             case KEYWORD, TEXT, IP, SOURCE, VERSION, UNSUPPORTED -> ElementType.BYTES_REF;
             case NULL -> ElementType.NULL;
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/action/EsqlQueryResponseTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/action/EsqlQueryResponseTests.java
@@ -213,6 +213,8 @@ private Page randomPage(List<ColumnInfoImpl> columns) {
                 case UNSIGNED_LONG, LONG, COUNTER_LONG -> ((LongBlock.Builder) builder).appendLong(randomLong());
                 case INTEGER, COUNTER_INTEGER -> ((IntBlock.Builder) builder).appendInt(randomInt());
                 case DOUBLE, COUNTER_DOUBLE -> ((DoubleBlock.Builder) builder).appendDouble(randomDouble());
+                // TODO NATIVE FLOATS
+                // case FLOAT, COUNTER_FLOAT -> ((FloatBlock.Builder) builder).appendFloat(randomFloat());
                 case KEYWORD -> ((BytesRefBlock.Builder) builder).appendBytesRef(new BytesRef(randomAlphaOfLength(10)));
                 case TEXT -> ((BytesRefBlock.Builder) builder).appendBytesRef(new BytesRef(randomAlphaOfLength(10000)));
                 case IP -> ((BytesRefBlock.Builder) builder).appendBytesRef(
@@ -1175,6 +1177,8 @@ static Page valuesToPage(BlockFactory blockFactory, List<ColumnInfoImpl> columns
                     case LONG, COUNTER_LONG -> ((LongBlock.Builder) builder).appendLong(((Number) value).longValue());
                     case INTEGER, COUNTER_INTEGER -> ((IntBlock.Builder) builder).appendInt(((Number) value).intValue());
                     case DOUBLE, COUNTER_DOUBLE -> ((DoubleBlock.Builder) builder).appendDouble(((Number) value).doubleValue());
+                    // TODO NATIVE FLOATS
+                    // case FLOAT -> ((FloatBlock.Builder) builder).appendFloat(((Number) value).floatValue());
                     case KEYWORD, TEXT -> ((BytesRefBlock.Builder) builder).appendBytesRef(new BytesRef(value.toString()));
                     case UNSUPPORTED -> ((BytesRefBlock.Builder) builder).appendNull();
                     case IP -> ((BytesRefBlock.Builder) builder).appendBytesRef(stringToIP(value.toString()));
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/LocalPhysicalPlanOptimizerTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/LocalPhysicalPlanOptimizerTests.java
@@ -161,6 +161,8 @@ public class LocalPhysicalPlanOptimizerTests extends MapperServiceTestCase {
         DataType.INTEGER,
         DataType.LONG,
         DataType.DOUBLE,
+        // TODO NATIVE FLOATS
+        // DataType.FLOAT,
         DataType.KEYWORD,
         DataType.TEXT
     );
@@ -1252,6 +1254,8 @@ private static Object randomQueryValue(DataType dataType) {
             case DATE_NANOS -> EsqlDataTypeConverter.nanoTimeToString(randomMillisUpToYear9999());
             case DATETIME -> EsqlDataTypeConverter.dateTimeToString(randomMillisUpToYear9999());
             case DOUBLE -> randomDouble();
+            // TODO NATIVE FLOATS
+            // case FLOAT -> randomFloat();
             case KEYWORD -> randomAlphaOfLength(5);
             case IP -> NetworkAddress.format(randomIp(randomBoolean()));
             case TEXT -> randomAlphaOfLength(50);

Original file line number	Diff line number	Diff line change
`@@ -117,6 +117,8 @@ private static Object valueAt(DataType dataType, Block block, int offset, BytesR`
`117`	`117`	`case LONG, COUNTER_LONG -> ((LongBlock) block).getLong(offset);`
`118`	`118`	`case INTEGER, COUNTER_INTEGER -> ((IntBlock) block).getInt(offset);`
`119`	`119`	`case DOUBLE, COUNTER_DOUBLE -> ((DoubleBlock) block).getDouble(offset);`
	`120`	`+ // TODO NATIVE FLOATS`
	`121`	`+ // case FLOAT, COUNTER_FLOAT -> ((FloatBlock) block).getFloat(offset);`
`120`	`122`	`case KEYWORD, TEXT -> ((BytesRefBlock) block).getBytesRef(offset, scratch).utf8ToString();`
`121`	`123`	`case IP -> {`
`122`	`124`	`BytesRef val = ((BytesRefBlock) block).getBytesRef(offset, scratch);`
`@@ -149,8 +151,8 @@ private static Object valueAt(DataType dataType, Block block, int offset, BytesR`
`149`	`151`	`}`
`150`	`152`	`}`
`151`	`153`	`case DENSE_VECTOR -> ((FloatBlock) block).getFloat(offset);`
`152`		`- case SHORT, BYTE, FLOAT, HALF_FLOAT, SCALED_FLOAT, OBJECT, DATE_PERIOD, TIME_DURATION, DOC_DATA_TYPE, TSID_DATA_TYPE, NULL,`
`153`		`- PARTIAL_AGG -> throw EsqlIllegalArgumentException.illegalDataType(dataType);`
	`154`	`+ case SHORT, BYTE, FLOAT, /* TODO native floats COUNTER_FLOAT, */ HALF_FLOAT, SCALED_FLOAT, OBJECT, DATE_PERIOD, TIME_DURATION,`
	`155`	`+ DOC_DATA_TYPE, TSID_DATA_TYPE, NULL, PARTIAL_AGG -> throw EsqlIllegalArgumentException.illegalDataType(dataType);`
`154`	`156`	`};`
`155`	`157`	`}`
`156`	`158`	`}`