From 0ef8232da92adf513ad2542c7fad1791d10712a3 Mon Sep 17 00:00:00 2001
From: Mary Gouseti <mary.gouseti@elastic.co>
Date: Thu, 28 Sep 2023 11:45:32 +0300
Subject: [PATCH 01/32] Replace 200_logs_datastream_defaults.yml with java rest
 test (#99979)

---
 .../datastreams/LogsDataStreamIT.java         | 169 ++++++++++++++++++
 .../200_logs_datastream_defaults.yml          | 108 -----------
 2 files changed, 169 insertions(+), 108 deletions(-)
 create mode 100644 modules/data-streams/src/javaRestTest/java/org/elasticsearch/datastreams/LogsDataStreamIT.java
 delete mode 100644 modules/data-streams/src/yamlRestTest/resources/rest-api-spec/test/data_stream/200_logs_datastream_defaults.yml

diff --git a/modules/data-streams/src/javaRestTest/java/org/elasticsearch/datastreams/LogsDataStreamIT.java b/modules/data-streams/src/javaRestTest/java/org/elasticsearch/datastreams/LogsDataStreamIT.java
new file mode 100644
index 0000000000000..31d2f6a8e2171
--- /dev/null
+++ b/modules/data-streams/src/javaRestTest/java/org/elasticsearch/datastreams/LogsDataStreamIT.java
@@ -0,0 +1,169 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.datastreams;
+
+import org.elasticsearch.client.Request;
+import org.elasticsearch.client.ResponseException;
+import org.elasticsearch.client.RestClient;
+import org.junit.After;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+
+public class LogsDataStreamIT extends DisabledSecurityDataStreamTestCase {
+
+    @After
+    public void cleanUp() throws IOException {
+        adminClient().performRequest(new Request("DELETE", "_data_stream/*"));
+    }
+
+    @SuppressWarnings("unchecked")
+    public void testDefaultLogsSettingAndMapping() throws Exception {
+        RestClient client = client();
+        waitForLogs(client);
+
+        String dataStreamName = "logs-generic-default";
+        createDataStream(client, dataStreamName);
+        String backingIndex = getWriteBackingIndex(client, dataStreamName);
+
+        // Ensure correct settings
+        Map<String, Object> settings = getSettings(client, backingIndex);
+        assertThat(settings.get("index.mapping.ignore_malformed"), is("true"));
+
+        // Extend the mapping and verify
+        putMapping(client, backingIndex);
+        Map<String, Object> mappingProperties = getMappingProperties(client, backingIndex);
+        assertThat(((Map<String, Object>) mappingProperties.get("@timestamp")).get("ignore_malformed"), equalTo(false));
+        assertThat(((Map<String, Object>) mappingProperties.get("numeric_field")).get("type"), equalTo("integer"));
+
+        // Insert valid doc and verify successful indexing
+        {
+            indexDoc(client, dataStreamName, """
+                {
+                  "@timestamp": "2023-04-18",
+                  "message": "valid",
+                  "numeric_field": 42
+                }
+                """);
+            List<Object> results = searchDocs(client, dataStreamName, """
+                {
+                  "query": {
+                    "term": {
+                      "message": {
+                        "value": "valid"
+                      }
+                    }
+                  },
+                  "fields": ["numeric_field"]
+                }
+                """);
+            Map<String, Object> fields = ((Map<String, Map<String, Object>>) results.get(0)).get("fields");
+            assertThat(fields.get("numeric_field"), is(List.of(42)));
+        }
+
+        // Insert invalid doc and verify successful indexing
+        {
+            indexDoc(client, dataStreamName, """
+                {
+                  "@timestamp": "2023-04-18",
+                  "message": "invalid",
+                  "numeric_field": "forty-two"
+                }
+                """);
+            List<Object> results = searchDocs(client, dataStreamName, """
+                {
+                  "query": {
+                    "term": {
+                      "message": {
+                        "value": "invalid"
+                      }
+                    }
+                  },
+                  "fields": ["numeric_field"]
+                }
+                """);
+            List<String> ignored = ((Map<String, List<String>>) results.get(0)).get("_ignored");
+            assertThat(ignored, contains("numeric_field"));
+            Map<String, Object> ignoredFieldValues = ((Map<String, Map<String, Object>>) results.get(0)).get("ignored_field_values");
+            assertThat(ignoredFieldValues.get("numeric_field"), is(List.of("forty-two")));
+        }
+    }
+
+    private static void waitForLogs(RestClient client) throws Exception {
+        assertBusy(() -> {
+            try {
+                Request request = new Request("GET", "_index_template/logs");
+                assertOK(client.performRequest(request));
+            } catch (ResponseException e) {
+                fail(e.getMessage());
+            }
+        });
+    }
+
+    private static void createDataStream(RestClient client, String name) throws IOException {
+        Request request = new Request("PUT", "_data_stream/" + name);
+        assertOK(client.performRequest(request));
+    }
+
+    @SuppressWarnings("unchecked")
+    private static String getWriteBackingIndex(RestClient client, String name) throws IOException {
+        Request request = new Request("GET", "_data_stream/" + name);
+        List<Object> dataStreams = (List<Object>) entityAsMap(client.performRequest(request)).get("data_streams");
+        Map<String, Object> dataStream = (Map<String, Object>) dataStreams.get(0);
+        List<Map<String, String>> indices = (List<Map<String, String>>) dataStream.get("indices");
+        return indices.get(0).get("index_name");
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Map<String, Object> getSettings(RestClient client, String indexName) throws IOException {
+        Request request = new Request("GET", "/" + indexName + "/_settings?flat_settings");
+        return ((Map<String, Map<String, Object>>) entityAsMap(client.performRequest(request)).get(indexName)).get("settings");
+    }
+
+    private static void putMapping(RestClient client, String indexName) throws IOException {
+        Request request = new Request("PUT", "/" + indexName + "/_mapping");
+        request.setJsonEntity("""
+            {
+              "properties": {
+                "numeric_field": {
+                  "type": "integer"
+                }
+              }
+            }
+            """);
+        assertOK(client.performRequest(request));
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Map<String, Object> getMappingProperties(RestClient client, String indexName) throws IOException {
+        Request request = new Request("GET", "/" + indexName + "/_mapping");
+        Map<String, Object> map = (Map<String, Object>) entityAsMap(client.performRequest(request)).get(indexName);
+        Map<String, Object> mappings = (Map<String, Object>) map.get("mappings");
+        return (Map<String, Object>) mappings.get("properties");
+    }
+
+    private static void indexDoc(RestClient client, String dataStreamName, String doc) throws IOException {
+        Request request = new Request("POST", "/" + dataStreamName + "/_doc?refresh=true");
+        request.setJsonEntity(doc);
+        assertOK(client.performRequest(request));
+    }
+
+    @SuppressWarnings("unchecked")
+    private static List<Object> searchDocs(RestClient client, String dataStreamName, String query) throws IOException {
+        Request request = new Request("GET", "/" + dataStreamName + "/_search");
+        request.setJsonEntity(query);
+        Map<String, Object> hits = (Map<String, Object>) entityAsMap(client.performRequest(request)).get("hits");
+        return (List<Object>) hits.get("hits");
+    }
+}
diff --git a/modules/data-streams/src/yamlRestTest/resources/rest-api-spec/test/data_stream/200_logs_datastream_defaults.yml b/modules/data-streams/src/yamlRestTest/resources/rest-api-spec/test/data_stream/200_logs_datastream_defaults.yml
deleted file mode 100644
index eaaf0893c1a83..0000000000000
--- a/modules/data-streams/src/yamlRestTest/resources/rest-api-spec/test/data_stream/200_logs_datastream_defaults.yml
+++ /dev/null
@@ -1,108 +0,0 @@
----
-Verify default logs-*-* settings and mappings:
-  - do:
-      indices.create_data_stream:
-        name: logs-generic-default
-  - is_true: acknowledged
-
-  - do:
-      indices.get_data_stream:
-        name: logs-generic-default
-  - set: { data_streams.0.indices.0.index_name: idx0name }
-
-  # default backing index settings should be "ignore_malformed": true
-  - do:
-      indices.get_settings:
-        index: $idx0name
-  - match: { .$idx0name.settings.index.mapping.ignore_malformed: "true" }
-
-  # add test field mapping
-  - do:
-      indices.put_mapping:
-        index: $idx0name
-        body:
-          properties:
-            numeric_field:
-              type: integer
-  - is_true: acknowledged
-
-  # default backing index mapping should contain an exception for the @timestamp field - "ignore_malformed": false
-  - do:
-      indices.get_mapping:
-        index: $idx0name
-  - match: { .$idx0name.mappings.properties.@timestamp.ignore_malformed: false }
-  - match: { .$idx0name.mappings.properties.numeric_field.type: "integer" }
-
-  - do:
-      index:
-        index: logs-generic-default
-        refresh: true
-        body:
-          '@timestamp': '2023-04-18'
-          message: 'valid'
-          numeric_field: 42
-  - match: {result: "created"}
-
-  - do:
-      search:
-        index: logs-generic-default
-        body:
-          query:
-            term:
-              message:
-                value: 'valid'
-          fields:
-            - field: 'numeric_field'
-  - length: { hits.hits: 1 }
-  - length: { hits.hits.0.fields: 1 }
-  - match: { hits.hits.0.fields.numeric_field.0: 42 }
-
-  - do:
-      index:
-        index:  logs-generic-default
-        refresh: true
-        body:
-          '@timestamp': '2023-04-18'
-          message: 'number_as_string'
-          numeric_field: "42"
-  - match: {result: "created"}
-
-  - do:
-      search:
-        index: logs-generic-default
-        body:
-          query:
-            term:
-              message:
-                value: 'number_as_string'
-          fields:
-            - field: 'numeric_field'
-  - length: { hits.hits: 1 }
-  - length: { hits.hits.0.fields: 1 }
-  - match: { hits.hits.0.fields.numeric_field.0: 42 }
-
-  - do:
-      index:
-        index:  logs-generic-default
-        refresh: true
-        body:
-          '@timestamp': '2023-04-18'
-          message: 'invalid'
-          numeric_field: "forty-two"
-  - match: {result: "created"}
-
-  - do:
-      search:
-        index: logs-generic-default
-        body:
-          query:
-            term:
-              message:
-                value: 'invalid'
-          fields:
-            - field: 'numeric_field'
-  - length: { hits.hits: 1 }
-  - length: { hits.hits.0._ignored: 1 }
-  - match: { hits.hits.0._ignored.0: 'numeric_field' }
-  - length: { hits.hits.0.ignored_field_values.numeric_field: 1 }
-  - match: { hits.hits.0.ignored_field_values.numeric_field.0: 'forty-two' }

From d106fece41feb58c5f224c9eb52ec90f2de7755a Mon Sep 17 00:00:00 2001
From: Mary Gouseti <mary.gouseti@elastic.co>
Date: Thu, 28 Sep 2023 11:45:51 +0300
Subject: [PATCH 02/32] Replace the disabled stack templates yaml test with
 java rest test (#99978)

---
 .../xpack/core/StackTemplatesRestIT.java      | 59 +++++++++++++++++++
 .../rest-api-spec/test/stack/10_stack.yml     | 22 -------
 2 files changed, 59 insertions(+), 22 deletions(-)
 create mode 100644 x-pack/plugin/core/src/javaRestTest/java/org/elasticsearch/xpack/core/StackTemplatesRestIT.java
 delete mode 100644 x-pack/qa/core-rest-tests-with-security/src/yamlRestTest/resources/rest-api-spec/test/stack/10_stack.yml

diff --git a/x-pack/plugin/core/src/javaRestTest/java/org/elasticsearch/xpack/core/StackTemplatesRestIT.java b/x-pack/plugin/core/src/javaRestTest/java/org/elasticsearch/xpack/core/StackTemplatesRestIT.java
new file mode 100644
index 0000000000000..fcbf955c2b9ae
--- /dev/null
+++ b/x-pack/plugin/core/src/javaRestTest/java/org/elasticsearch/xpack/core/StackTemplatesRestIT.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; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+package org.elasticsearch.xpack.core;
+
+import org.elasticsearch.client.Request;
+import org.elasticsearch.client.ResponseException;
+import org.elasticsearch.client.RestClient;
+import org.elasticsearch.common.settings.SecureString;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.common.util.concurrent.ThreadContext;
+import org.elasticsearch.test.rest.ESRestTestCase;
+
+import static org.hamcrest.Matchers.is;
+
+public class StackTemplatesRestIT extends ESRestTestCase {
+
+    private static final String BASIC_AUTH_VALUE = basicAuthHeaderValue("x_pack_rest_user", new SecureString("x-pack-test-password"));
+
+    @Override
+    protected Settings restClientSettings() {
+        return Settings.builder().put(ThreadContext.PREFIX + ".Authorization", BASIC_AUTH_VALUE).build();
+    }
+
+    public void testTemplatesCanBeDisabled() throws Exception {
+        RestClient client = client();
+        // Ensure the logs template has been added
+        assertBusy(() -> {
+            try {
+                Request request = new Request("GET", "_index_template/logs");
+                assertOK(client.performRequest(request));
+            } catch (ResponseException e) {
+                fail(e.getMessage());
+            }
+        });
+        // Disable the stack templates
+        {
+            Request request = new Request("PUT", "_cluster/settings");
+            request.setJsonEntity("""
+                {
+                  "persistent": {
+                    "stack.templates.enabled": false
+                  }
+                }
+                """);
+            assertOK(client.performRequest(request));
+        }
+        Request getRequest = new Request("GET", "_index_template/logs");
+        assertOK(client.performRequest(getRequest));
+
+        Request deleteRequest = new Request("DELETE", "_index_template/logs");
+        assertOK(client.performRequest(deleteRequest));
+        ResponseException exception = expectThrows(ResponseException.class, () -> client.performRequest(deleteRequest));
+        assertThat(exception.getResponse().getStatusLine().getStatusCode(), is(404));
+    }
+}
diff --git a/x-pack/qa/core-rest-tests-with-security/src/yamlRestTest/resources/rest-api-spec/test/stack/10_stack.yml b/x-pack/qa/core-rest-tests-with-security/src/yamlRestTest/resources/rest-api-spec/test/stack/10_stack.yml
deleted file mode 100644
index 3346f5c8e58bd..0000000000000
--- a/x-pack/qa/core-rest-tests-with-security/src/yamlRestTest/resources/rest-api-spec/test/stack/10_stack.yml
+++ /dev/null
@@ -1,22 +0,0 @@
-"Stack templates can be disabled":
-  - skip:
-      version: all
-      reason: https://github.com/elastic/elasticsearch/issues/98163
-  - do:
-      cluster.put_settings:
-        body:
-          persistent:
-            stack.templates.enabled: false
-
-  - do:
-      indices.get_index_template:
-        name: logs
-
-  - do:
-      indices.delete_index_template:
-        name: logs
-
-  - do:
-      catch: missing
-      indices.get_index_template:
-        name: logs

From a698f4dce22f95ff234ff67ca04a3905fd9906a5 Mon Sep 17 00:00:00 2001
From: Jaime Pan <33685703+NEUpanning@users.noreply.github.com>
Date: Thu, 28 Sep 2023 16:54:55 +0800
Subject: [PATCH 03/32] Extract NodeInfoMetrics to top-level class (#99990)

---
 .../cluster/node/info/NodesInfoMetrics.java   | 75 +++++++++++++++++++
 .../cluster/node/info/NodesInfoRequest.java   | 66 +++++-----------
 .../node/info/NodesInfoRequestBuilder.java    | 22 +++---
 .../node/info/TransportNodesInfoAction.java   | 24 +++---
 .../remote/RemoteClusterNodesAction.java      |  3 +-
 .../ingest/PutPipelineTransportAction.java    |  3 +-
 .../admin/cluster/RestNodesInfoAction.java    |  3 +-
 .../rest/action/cat/RestNodeAttrsAction.java  |  3 +-
 .../rest/action/cat/RestNodesAction.java      |  9 ++-
 .../rest/action/cat/RestPluginsAction.java    |  3 +-
 .../rest/action/cat/RestThreadPoolAction.java |  3 +-
 .../node/info/NodesInfoRequestTests.java      | 12 +--
 .../remote/RemoteClusterNodesActionTests.java |  3 +-
 .../nodeinfo/AutoscalingNodeInfoService.java  |  3 +-
 .../TransportNodeEnrollmentAction.java        |  3 +-
 .../InternalEnrollmentTokenGenerator.java     |  5 +-
 16 files changed, 147 insertions(+), 93 deletions(-)
 create mode 100644 server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoMetrics.java

diff --git a/server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoMetrics.java b/server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoMetrics.java
new file mode 100644
index 0000000000000..3e632f9bdd212
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoMetrics.java
@@ -0,0 +1,75 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.action.admin.cluster.node.info;
+
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.common.io.stream.Writeable;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * This class is a container that encapsulates the necessary information needed to indicate which node information is requested.
+ */
+public class NodesInfoMetrics implements Writeable {
+    private Set<String> requestedMetrics = Metric.allMetrics();
+
+    public NodesInfoMetrics() {}
+
+    public NodesInfoMetrics(StreamInput in) throws IOException {
+        requestedMetrics.clear();
+        requestedMetrics.addAll(Arrays.asList(in.readStringArray()));
+    }
+
+    public Set<String> requestedMetrics() {
+        return requestedMetrics;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeStringArray(requestedMetrics.toArray(new String[0]));
+    }
+
+    /**
+     * An enumeration of the "core" sections of metrics that may be requested
+     * from the nodes information endpoint. Eventually this list will be
+     * pluggable.
+     */
+    public enum Metric {
+        SETTINGS("settings"),
+        OS("os"),
+        PROCESS("process"),
+        JVM("jvm"),
+        THREAD_POOL("thread_pool"),
+        TRANSPORT("transport"),
+        HTTP("http"),
+        REMOTE_CLUSTER_SERVER("remote_cluster_server"),
+        PLUGINS("plugins"),
+        INGEST("ingest"),
+        AGGREGATIONS("aggregations"),
+        INDICES("indices");
+
+        private final String metricName;
+
+        Metric(String name) {
+            this.metricName = name;
+        }
+
+        public String metricName() {
+            return this.metricName;
+        }
+
+        public static Set<String> allMetrics() {
+            return Arrays.stream(values()).map(Metric::metricName).collect(Collectors.toSet());
+        }
+    }
+}
diff --git a/server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoRequest.java b/server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoRequest.java
index 4e52116020be2..04b2a7d980678 100644
--- a/server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoRequest.java
+++ b/server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoRequest.java
@@ -13,18 +13,16 @@
 import org.elasticsearch.common.io.stream.StreamOutput;
 
 import java.io.IOException;
-import java.util.Arrays;
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
-import java.util.stream.Collectors;
 
 /**
  * A request to get node (cluster) level information.
  */
 public class NodesInfoRequest extends BaseNodesRequest<NodesInfoRequest> {
 
-    private Set<String> requestedMetrics = Metric.allMetrics();
+    private NodesInfoMetrics nodesInfoMetrics;
 
     /**
      * Create a new NodeInfoRequest from a {@link StreamInput} object.
@@ -34,8 +32,7 @@ public class NodesInfoRequest extends BaseNodesRequest<NodesInfoRequest> {
      */
     public NodesInfoRequest(StreamInput in) throws IOException {
         super(in);
-        requestedMetrics.clear();
-        requestedMetrics.addAll(Arrays.asList(in.readStringArray()));
+        nodesInfoMetrics = new NodesInfoMetrics(in);
     }
 
     /**
@@ -45,6 +42,7 @@ public NodesInfoRequest(StreamInput in) throws IOException {
     @SuppressWarnings("this-escape")
     public NodesInfoRequest(String... nodesIds) {
         super(nodesIds);
+        nodesInfoMetrics = new NodesInfoMetrics();
         all();
     }
 
@@ -52,7 +50,7 @@ public NodesInfoRequest(String... nodesIds) {
      * Clears all info flags.
      */
     public NodesInfoRequest clear() {
-        requestedMetrics.clear();
+        nodesInfoMetrics.requestedMetrics().clear();
         return this;
     }
 
@@ -60,7 +58,7 @@ public NodesInfoRequest clear() {
      * Sets to return all the data.
      */
     public NodesInfoRequest all() {
-        requestedMetrics.addAll(Metric.allMetrics());
+        nodesInfoMetrics.requestedMetrics().addAll(NodesInfoMetrics.Metric.allMetrics());
         return this;
     }
 
@@ -68,17 +66,17 @@ public NodesInfoRequest all() {
      * Get the names of requested metrics
      */
     public Set<String> requestedMetrics() {
-        return Set.copyOf(requestedMetrics);
+        return Set.copyOf(nodesInfoMetrics.requestedMetrics());
     }
 
     /**
      * Add metric
      */
     public NodesInfoRequest addMetric(String metric) {
-        if (Metric.allMetrics().contains(metric) == false) {
+        if (NodesInfoMetrics.Metric.allMetrics().contains(metric) == false) {
             throw new IllegalStateException("Used an illegal metric: " + metric);
         }
-        requestedMetrics.add(metric);
+        nodesInfoMetrics.requestedMetrics().add(metric);
         return this;
     }
 
@@ -87,12 +85,12 @@ public NodesInfoRequest addMetric(String metric) {
      */
     public NodesInfoRequest addMetrics(String... metrics) {
         SortedSet<String> metricsSet = new TreeSet<>(Set.of(metrics));
-        if (Metric.allMetrics().containsAll(metricsSet) == false) {
-            metricsSet.removeAll(Metric.allMetrics());
+        if (NodesInfoMetrics.Metric.allMetrics().containsAll(metricsSet) == false) {
+            metricsSet.removeAll(NodesInfoMetrics.Metric.allMetrics());
             String plural = metricsSet.size() == 1 ? "" : "s";
             throw new IllegalStateException("Used illegal metric" + plural + ": " + metricsSet);
         }
-        requestedMetrics.addAll(metricsSet);
+        nodesInfoMetrics.requestedMetrics().addAll(metricsSet);
         return this;
     }
 
@@ -100,17 +98,17 @@ public NodesInfoRequest addMetrics(String... metrics) {
      * Remove metric
      */
     public NodesInfoRequest removeMetric(String metric) {
-        if (Metric.allMetrics().contains(metric) == false) {
+        if (NodesInfoMetrics.Metric.allMetrics().contains(metric) == false) {
             throw new IllegalStateException("Used an illegal metric: " + metric);
         }
-        requestedMetrics.remove(metric);
+        nodesInfoMetrics.requestedMetrics().remove(metric);
         return this;
     }
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         super.writeTo(out);
-        out.writeStringCollection(requestedMetrics);
+        nodesInfoMetrics.writeTo(out);
     }
 
     /**
@@ -118,7 +116,7 @@ public void writeTo(StreamOutput out) throws IOException {
      * @param metrics the metrics to include in the request
      * @return
      */
-    public static NodesInfoRequest requestWithMetrics(Metric... metrics) {
+    public static NodesInfoRequest requestWithMetrics(NodesInfoMetrics.Metric... metrics) {
         NodesInfoRequest nodesInfoRequest = new NodesInfoRequest();
         nodesInfoRequest.clear();
         for (var metric : metrics) {
@@ -127,37 +125,7 @@ public static NodesInfoRequest requestWithMetrics(Metric... metrics) {
         return nodesInfoRequest;
     }
 
-    /**
-     * An enumeration of the "core" sections of metrics that may be requested
-     * from the nodes information endpoint. Eventually this list list will be
-     * pluggable.
-     */
-    public enum Metric {
-        SETTINGS("settings"),
-        OS("os"),
-        PROCESS("process"),
-        JVM("jvm"),
-        THREAD_POOL("thread_pool"),
-        TRANSPORT("transport"),
-        HTTP("http"),
-        REMOTE_CLUSTER_SERVER("remote_cluster_server"),
-        PLUGINS("plugins"),
-        INGEST("ingest"),
-        AGGREGATIONS("aggregations"),
-        INDICES("indices");
-
-        private final String metricName;
-
-        Metric(String name) {
-            this.metricName = name;
-        }
-
-        public String metricName() {
-            return this.metricName;
-        }
-
-        public static Set<String> allMetrics() {
-            return Arrays.stream(values()).map(Metric::metricName).collect(Collectors.toSet());
-        }
+    public NodesInfoMetrics getNodesInfoMetrics() {
+        return nodesInfoMetrics;
     }
 }
diff --git a/server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoRequestBuilder.java b/server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoRequestBuilder.java
index e839553021c3e..543804869eaa0 100644
--- a/server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoRequestBuilder.java
+++ b/server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoRequestBuilder.java
@@ -38,7 +38,7 @@ public NodesInfoRequestBuilder all() {
      * Should the node settings be returned.
      */
     public NodesInfoRequestBuilder setSettings(boolean settings) {
-        addOrRemoveMetric(settings, NodesInfoRequest.Metric.SETTINGS);
+        addOrRemoveMetric(settings, NodesInfoMetrics.Metric.SETTINGS);
         return this;
     }
 
@@ -46,7 +46,7 @@ public NodesInfoRequestBuilder setSettings(boolean settings) {
      * Should the node OS info be returned.
      */
     public NodesInfoRequestBuilder setOs(boolean os) {
-        addOrRemoveMetric(os, NodesInfoRequest.Metric.OS);
+        addOrRemoveMetric(os, NodesInfoMetrics.Metric.OS);
         return this;
     }
 
@@ -54,7 +54,7 @@ public NodesInfoRequestBuilder setOs(boolean os) {
      * Should the node OS process be returned.
      */
     public NodesInfoRequestBuilder setProcess(boolean process) {
-        addOrRemoveMetric(process, NodesInfoRequest.Metric.PROCESS);
+        addOrRemoveMetric(process, NodesInfoMetrics.Metric.PROCESS);
         return this;
     }
 
@@ -62,7 +62,7 @@ public NodesInfoRequestBuilder setProcess(boolean process) {
      * Should the node JVM info be returned.
      */
     public NodesInfoRequestBuilder setJvm(boolean jvm) {
-        addOrRemoveMetric(jvm, NodesInfoRequest.Metric.JVM);
+        addOrRemoveMetric(jvm, NodesInfoMetrics.Metric.JVM);
         return this;
     }
 
@@ -70,7 +70,7 @@ public NodesInfoRequestBuilder setJvm(boolean jvm) {
      * Should the node thread pool info be returned.
      */
     public NodesInfoRequestBuilder setThreadPool(boolean threadPool) {
-        addOrRemoveMetric(threadPool, NodesInfoRequest.Metric.THREAD_POOL);
+        addOrRemoveMetric(threadPool, NodesInfoMetrics.Metric.THREAD_POOL);
         return this;
     }
 
@@ -78,7 +78,7 @@ public NodesInfoRequestBuilder setThreadPool(boolean threadPool) {
      * Should the node Transport info be returned.
      */
     public NodesInfoRequestBuilder setTransport(boolean transport) {
-        addOrRemoveMetric(transport, NodesInfoRequest.Metric.TRANSPORT);
+        addOrRemoveMetric(transport, NodesInfoMetrics.Metric.TRANSPORT);
         return this;
     }
 
@@ -86,7 +86,7 @@ public NodesInfoRequestBuilder setTransport(boolean transport) {
      * Should the node HTTP info be returned.
      */
     public NodesInfoRequestBuilder setHttp(boolean http) {
-        addOrRemoveMetric(http, NodesInfoRequest.Metric.HTTP);
+        addOrRemoveMetric(http, NodesInfoMetrics.Metric.HTTP);
         return this;
     }
 
@@ -94,7 +94,7 @@ public NodesInfoRequestBuilder setHttp(boolean http) {
      * Should the node plugins info be returned.
      */
     public NodesInfoRequestBuilder setPlugins(boolean plugins) {
-        addOrRemoveMetric(plugins, NodesInfoRequest.Metric.PLUGINS);
+        addOrRemoveMetric(plugins, NodesInfoMetrics.Metric.PLUGINS);
         return this;
     }
 
@@ -102,7 +102,7 @@ public NodesInfoRequestBuilder setPlugins(boolean plugins) {
      * Should the node ingest info be returned.
      */
     public NodesInfoRequestBuilder setIngest(boolean ingest) {
-        addOrRemoveMetric(ingest, NodesInfoRequest.Metric.INGEST);
+        addOrRemoveMetric(ingest, NodesInfoMetrics.Metric.INGEST);
         return this;
     }
 
@@ -110,11 +110,11 @@ public NodesInfoRequestBuilder setIngest(boolean ingest) {
      * Should the node indices info be returned.
      */
     public NodesInfoRequestBuilder setIndices(boolean indices) {
-        addOrRemoveMetric(indices, NodesInfoRequest.Metric.INDICES);
+        addOrRemoveMetric(indices, NodesInfoMetrics.Metric.INDICES);
         return this;
     }
 
-    private void addOrRemoveMetric(boolean includeMetric, NodesInfoRequest.Metric metric) {
+    private void addOrRemoveMetric(boolean includeMetric, NodesInfoMetrics.Metric metric) {
         if (includeMetric) {
             request.addMetric(metric.metricName());
         } else {
diff --git a/server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/TransportNodesInfoAction.java b/server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
index ccd6ccde2dabd..14dffce86daa5 100644
--- a/server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
+++ b/server/src/main/java/org/elasticsearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
@@ -79,18 +79,18 @@ protected NodeInfo nodeOperation(NodeInfoRequest nodeRequest, Task task) {
         NodesInfoRequest request = nodeRequest.request;
         Set<String> metrics = request.requestedMetrics();
         return nodeService.info(
-            metrics.contains(NodesInfoRequest.Metric.SETTINGS.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.OS.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.PROCESS.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.JVM.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.THREAD_POOL.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.TRANSPORT.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.HTTP.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.REMOTE_CLUSTER_SERVER.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.PLUGINS.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.INGEST.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.AGGREGATIONS.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.INDICES.metricName())
+            metrics.contains(NodesInfoMetrics.Metric.SETTINGS.metricName()),
+            metrics.contains(NodesInfoMetrics.Metric.OS.metricName()),
+            metrics.contains(NodesInfoMetrics.Metric.PROCESS.metricName()),
+            metrics.contains(NodesInfoMetrics.Metric.JVM.metricName()),
+            metrics.contains(NodesInfoMetrics.Metric.THREAD_POOL.metricName()),
+            metrics.contains(NodesInfoMetrics.Metric.TRANSPORT.metricName()),
+            metrics.contains(NodesInfoMetrics.Metric.HTTP.metricName()),
+            metrics.contains(NodesInfoMetrics.Metric.REMOTE_CLUSTER_SERVER.metricName()),
+            metrics.contains(NodesInfoMetrics.Metric.PLUGINS.metricName()),
+            metrics.contains(NodesInfoMetrics.Metric.INGEST.metricName()),
+            metrics.contains(NodesInfoMetrics.Metric.AGGREGATIONS.metricName()),
+            metrics.contains(NodesInfoMetrics.Metric.INDICES.metricName())
         );
     }
 
diff --git a/server/src/main/java/org/elasticsearch/action/admin/cluster/remote/RemoteClusterNodesAction.java b/server/src/main/java/org/elasticsearch/action/admin/cluster/remote/RemoteClusterNodesAction.java
index 5898f258865d7..49d1dde59477b 100644
--- a/server/src/main/java/org/elasticsearch/action/admin/cluster/remote/RemoteClusterNodesAction.java
+++ b/server/src/main/java/org/elasticsearch/action/admin/cluster/remote/RemoteClusterNodesAction.java
@@ -15,6 +15,7 @@
 import org.elasticsearch.action.ActionResponse;
 import org.elasticsearch.action.ActionType;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoAction;
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoMetrics;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoResponse;
 import org.elasticsearch.action.support.ActionFilters;
@@ -108,7 +109,7 @@ protected void doExecute(Task task, Request request, ActionListener<Response> li
                 threadContext.markAsSystemContext();
                 if (request.remoteClusterServer) {
                     final NodesInfoRequest nodesInfoRequest = new NodesInfoRequest().clear()
-                        .addMetrics(NodesInfoRequest.Metric.REMOTE_CLUSTER_SERVER.metricName());
+                        .addMetrics(NodesInfoMetrics.Metric.REMOTE_CLUSTER_SERVER.metricName());
                     transportService.sendRequest(
                         transportService.getLocalNode(),
                         NodesInfoAction.NAME,
diff --git a/server/src/main/java/org/elasticsearch/action/ingest/PutPipelineTransportAction.java b/server/src/main/java/org/elasticsearch/action/ingest/PutPipelineTransportAction.java
index 65d5ad5807ecb..b1e2533d1038d 100644
--- a/server/src/main/java/org/elasticsearch/action/ingest/PutPipelineTransportAction.java
+++ b/server/src/main/java/org/elasticsearch/action/ingest/PutPipelineTransportAction.java
@@ -9,6 +9,7 @@
 package org.elasticsearch.action.ingest;
 
 import org.elasticsearch.action.ActionListener;
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoMetrics;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.elasticsearch.action.support.ActionFilters;
 import org.elasticsearch.action.support.master.AcknowledgedResponse;
@@ -66,7 +67,7 @@ protected void masterOperation(Task task, PutPipelineRequest request, ClusterSta
         ingestService.putPipeline(request, listener, (nodeListener) -> {
             NodesInfoRequest nodesInfoRequest = new NodesInfoRequest();
             nodesInfoRequest.clear();
-            nodesInfoRequest.addMetric(NodesInfoRequest.Metric.INGEST.metricName());
+            nodesInfoRequest.addMetric(NodesInfoMetrics.Metric.INGEST.metricName());
             client.admin().cluster().nodesInfo(nodesInfoRequest, nodeListener);
         });
     }
diff --git a/server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestNodesInfoAction.java b/server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestNodesInfoAction.java
index ad591c07ffec0..fc04374411536 100644
--- a/server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestNodesInfoAction.java
+++ b/server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestNodesInfoAction.java
@@ -8,6 +8,7 @@
 
 package org.elasticsearch.rest.action.admin.cluster;
 
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoMetrics;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.elasticsearch.client.internal.node.NodeClient;
 import org.elasticsearch.common.Strings;
@@ -28,7 +29,7 @@
 
 @ServerlessScope(Scope.INTERNAL)
 public class RestNodesInfoAction extends BaseRestHandler {
-    static final Set<String> ALLOWED_METRICS = NodesInfoRequest.Metric.allMetrics();
+    static final Set<String> ALLOWED_METRICS = NodesInfoMetrics.Metric.allMetrics();
 
     private final SettingsFilter settingsFilter;
 
diff --git a/server/src/main/java/org/elasticsearch/rest/action/cat/RestNodeAttrsAction.java b/server/src/main/java/org/elasticsearch/rest/action/cat/RestNodeAttrsAction.java
index a9a1a09a4f01c..9a032ce064cf6 100644
--- a/server/src/main/java/org/elasticsearch/rest/action/cat/RestNodeAttrsAction.java
+++ b/server/src/main/java/org/elasticsearch/rest/action/cat/RestNodeAttrsAction.java
@@ -9,6 +9,7 @@
 package org.elasticsearch.rest.action.cat;
 
 import org.elasticsearch.action.admin.cluster.node.info.NodeInfo;
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoMetrics;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoResponse;
 import org.elasticsearch.action.admin.cluster.state.ClusterStateRequest;
@@ -60,7 +61,7 @@ public RestChannelConsumer doCatRequest(final RestRequest request, final NodeCli
             @Override
             public void processResponse(final ClusterStateResponse clusterStateResponse) {
                 NodesInfoRequest nodesInfoRequest = new NodesInfoRequest();
-                nodesInfoRequest.clear().addMetric(NodesInfoRequest.Metric.PROCESS.metricName());
+                nodesInfoRequest.clear().addMetric(NodesInfoMetrics.Metric.PROCESS.metricName());
                 client.admin().cluster().nodesInfo(nodesInfoRequest, new RestResponseListener<NodesInfoResponse>(channel) {
                     @Override
                     public RestResponse buildResponse(NodesInfoResponse nodesInfoResponse) throws Exception {
diff --git a/server/src/main/java/org/elasticsearch/rest/action/cat/RestNodesAction.java b/server/src/main/java/org/elasticsearch/rest/action/cat/RestNodesAction.java
index 296daeeedb7d1..1c4d5f7d8fdbd 100644
--- a/server/src/main/java/org/elasticsearch/rest/action/cat/RestNodesAction.java
+++ b/server/src/main/java/org/elasticsearch/rest/action/cat/RestNodesAction.java
@@ -9,6 +9,7 @@
 package org.elasticsearch.rest.action.cat;
 
 import org.elasticsearch.action.admin.cluster.node.info.NodeInfo;
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoMetrics;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoResponse;
 import org.elasticsearch.action.admin.cluster.node.stats.NodeStats;
@@ -90,10 +91,10 @@ public void processResponse(final ClusterStateResponse clusterStateResponse) {
                 NodesInfoRequest nodesInfoRequest = new NodesInfoRequest();
                 nodesInfoRequest.clear()
                     .addMetrics(
-                        NodesInfoRequest.Metric.JVM.metricName(),
-                        NodesInfoRequest.Metric.OS.metricName(),
-                        NodesInfoRequest.Metric.PROCESS.metricName(),
-                        NodesInfoRequest.Metric.HTTP.metricName()
+                        NodesInfoMetrics.Metric.JVM.metricName(),
+                        NodesInfoMetrics.Metric.OS.metricName(),
+                        NodesInfoMetrics.Metric.PROCESS.metricName(),
+                        NodesInfoMetrics.Metric.HTTP.metricName()
                     );
                 client.admin().cluster().nodesInfo(nodesInfoRequest, new RestActionListener<NodesInfoResponse>(channel) {
                     @Override
diff --git a/server/src/main/java/org/elasticsearch/rest/action/cat/RestPluginsAction.java b/server/src/main/java/org/elasticsearch/rest/action/cat/RestPluginsAction.java
index 16ad6b4c289e4..7aba2c8e38a6d 100644
--- a/server/src/main/java/org/elasticsearch/rest/action/cat/RestPluginsAction.java
+++ b/server/src/main/java/org/elasticsearch/rest/action/cat/RestPluginsAction.java
@@ -9,6 +9,7 @@
 package org.elasticsearch.rest.action.cat;
 
 import org.elasticsearch.action.admin.cluster.node.info.NodeInfo;
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoMetrics;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoResponse;
 import org.elasticsearch.action.admin.cluster.node.info.PluginsAndModules;
@@ -61,7 +62,7 @@ public RestChannelConsumer doCatRequest(final RestRequest request, final NodeCli
             @Override
             public void processResponse(final ClusterStateResponse clusterStateResponse) throws Exception {
                 NodesInfoRequest nodesInfoRequest = new NodesInfoRequest();
-                nodesInfoRequest.clear().addMetric(NodesInfoRequest.Metric.PLUGINS.metricName());
+                nodesInfoRequest.clear().addMetric(NodesInfoMetrics.Metric.PLUGINS.metricName());
                 client.admin().cluster().nodesInfo(nodesInfoRequest, new RestResponseListener<NodesInfoResponse>(channel) {
                     @Override
                     public RestResponse buildResponse(final NodesInfoResponse nodesInfoResponse) throws Exception {
diff --git a/server/src/main/java/org/elasticsearch/rest/action/cat/RestThreadPoolAction.java b/server/src/main/java/org/elasticsearch/rest/action/cat/RestThreadPoolAction.java
index 727bd361e5def..c94f40b83856e 100644
--- a/server/src/main/java/org/elasticsearch/rest/action/cat/RestThreadPoolAction.java
+++ b/server/src/main/java/org/elasticsearch/rest/action/cat/RestThreadPoolAction.java
@@ -9,6 +9,7 @@
 package org.elasticsearch.rest.action.cat;
 
 import org.elasticsearch.action.admin.cluster.node.info.NodeInfo;
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoMetrics;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoResponse;
 import org.elasticsearch.action.admin.cluster.node.stats.NodeStats;
@@ -77,7 +78,7 @@ public RestChannelConsumer doCatRequest(final RestRequest request, final NodeCli
             public void processResponse(final ClusterStateResponse clusterStateResponse) {
                 NodesInfoRequest nodesInfoRequest = new NodesInfoRequest();
                 nodesInfoRequest.clear()
-                    .addMetrics(NodesInfoRequest.Metric.PROCESS.metricName(), NodesInfoRequest.Metric.THREAD_POOL.metricName());
+                    .addMetrics(NodesInfoMetrics.Metric.PROCESS.metricName(), NodesInfoMetrics.Metric.THREAD_POOL.metricName());
                 client.admin().cluster().nodesInfo(nodesInfoRequest, new RestActionListener<NodesInfoResponse>(channel) {
                     @Override
                     public void processResponse(final NodesInfoResponse nodesInfoResponse) {
diff --git a/server/src/test/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoRequestTests.java b/server/src/test/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoRequestTests.java
index a572625fb9f9c..16c0ed251aa3d 100644
--- a/server/src/test/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoRequestTests.java
+++ b/server/src/test/java/org/elasticsearch/action/admin/cluster/node/info/NodesInfoRequestTests.java
@@ -32,7 +32,7 @@ public class NodesInfoRequestTests extends ESTestCase {
      */
     public void testAddMetricsSet() throws Exception {
         NodesInfoRequest request = new NodesInfoRequest(randomAlphaOfLength(8));
-        randomSubsetOf(NodesInfoRequest.Metric.allMetrics()).forEach(request::addMetric);
+        randomSubsetOf(NodesInfoMetrics.Metric.allMetrics()).forEach(request::addMetric);
         NodesInfoRequest deserializedRequest = roundTripRequest(request);
         assertThat(request.requestedMetrics(), equalTo(deserializedRequest.requestedMetrics()));
     }
@@ -42,7 +42,7 @@ public void testAddMetricsSet() throws Exception {
      */
     public void testAddSingleMetric() throws Exception {
         NodesInfoRequest request = new NodesInfoRequest(randomAlphaOfLength(8));
-        request.addMetric(randomFrom(NodesInfoRequest.Metric.allMetrics()));
+        request.addMetric(randomFrom(NodesInfoMetrics.Metric.allMetrics()));
         NodesInfoRequest deserializedRequest = roundTripRequest(request);
         assertThat(request.requestedMetrics(), equalTo(deserializedRequest.requestedMetrics()));
     }
@@ -53,7 +53,7 @@ public void testAddSingleMetric() throws Exception {
     public void testRemoveSingleMetric() throws Exception {
         NodesInfoRequest request = new NodesInfoRequest(randomAlphaOfLength(8));
         request.all();
-        String metric = randomFrom(NodesInfoRequest.Metric.allMetrics());
+        String metric = randomFrom(NodesInfoMetrics.Metric.allMetrics());
         request.removeMetric(metric);
 
         NodesInfoRequest deserializedRequest = roundTripRequest(request);
@@ -63,7 +63,7 @@ public void testRemoveSingleMetric() throws Exception {
 
     /**
      * Test that a newly constructed NodesInfoRequestObject requests all of the
-     * possible metrics defined in {@link NodesInfoRequest.Metric}.
+     * possible metrics defined in {@link NodesInfoMetrics.Metric}.
      */
     public void testNodesInfoRequestDefaults() {
         NodesInfoRequest defaultNodesInfoRequest = new NodesInfoRequest(randomAlphaOfLength(8));
@@ -80,7 +80,7 @@ public void testNodesInfoRequestAll() throws Exception {
         NodesInfoRequest request = new NodesInfoRequest("node");
         request.all();
 
-        assertThat(request.requestedMetrics(), equalTo(NodesInfoRequest.Metric.allMetrics()));
+        assertThat(request.requestedMetrics(), equalTo(NodesInfoMetrics.Metric.allMetrics()));
     }
 
     /**
@@ -101,7 +101,7 @@ public void testUnknownMetricsRejected() {
         String unknownMetric2 = "unknown_metric2";
         Set<String> unknownMetrics = new HashSet<>();
         unknownMetrics.add(unknownMetric1);
-        unknownMetrics.addAll(randomSubsetOf(NodesInfoRequest.Metric.allMetrics()));
+        unknownMetrics.addAll(randomSubsetOf(NodesInfoMetrics.Metric.allMetrics()));
 
         NodesInfoRequest request = new NodesInfoRequest();
 
diff --git a/server/src/test/java/org/elasticsearch/action/admin/cluster/remote/RemoteClusterNodesActionTests.java b/server/src/test/java/org/elasticsearch/action/admin/cluster/remote/RemoteClusterNodesActionTests.java
index 7c6c1ffdcf98b..18c586a4a51ae 100644
--- a/server/src/test/java/org/elasticsearch/action/admin/cluster/remote/RemoteClusterNodesActionTests.java
+++ b/server/src/test/java/org/elasticsearch/action/admin/cluster/remote/RemoteClusterNodesActionTests.java
@@ -13,6 +13,7 @@
 import org.elasticsearch.action.ActionListenerResponseHandler;
 import org.elasticsearch.action.admin.cluster.node.info.NodeInfo;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoAction;
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoMetrics;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoResponse;
 import org.elasticsearch.action.support.ActionFilters;
@@ -108,7 +109,7 @@ public void testDoExecuteForRemoteServerNodes() {
 
         doAnswer(invocation -> {
             final NodesInfoRequest nodesInfoRequest = invocation.getArgument(2);
-            assertThat(nodesInfoRequest.requestedMetrics(), containsInAnyOrder(NodesInfoRequest.Metric.REMOTE_CLUSTER_SERVER.metricName()));
+            assertThat(nodesInfoRequest.requestedMetrics(), containsInAnyOrder(NodesInfoMetrics.Metric.REMOTE_CLUSTER_SERVER.metricName()));
             final ActionListenerResponseHandler<NodesInfoResponse> handler = invocation.getArgument(3);
             handler.handleResponse(nodesInfoResponse);
             return null;
diff --git a/x-pack/plugin/autoscaling/src/main/java/org/elasticsearch/xpack/autoscaling/capacity/nodeinfo/AutoscalingNodeInfoService.java b/x-pack/plugin/autoscaling/src/main/java/org/elasticsearch/xpack/autoscaling/capacity/nodeinfo/AutoscalingNodeInfoService.java
index 118cd19d01b79..578689828de6b 100644
--- a/x-pack/plugin/autoscaling/src/main/java/org/elasticsearch/xpack/autoscaling/capacity/nodeinfo/AutoscalingNodeInfoService.java
+++ b/x-pack/plugin/autoscaling/src/main/java/org/elasticsearch/xpack/autoscaling/capacity/nodeinfo/AutoscalingNodeInfoService.java
@@ -11,6 +11,7 @@
 import org.apache.logging.log4j.Logger;
 import org.elasticsearch.action.ActionListener;
 import org.elasticsearch.action.FailedNodeException;
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoMetrics;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.elasticsearch.action.admin.cluster.node.stats.NodesStatsRequest;
 import org.elasticsearch.action.support.nodes.BaseNodeResponse;
@@ -138,7 +139,7 @@ private void sendToMissingNodes(Function<String, DiscoveryNode> nodeLookup, Set<
                                     .map(BaseNodeResponse::getNode)
                                     .map(DiscoveryNode::getId)
                                     .toArray(String[]::new)
-                            ).clear().addMetric(NodesInfoRequest.Metric.OS.metricName()).timeout(fetchTimeout),
+                            ).clear().addMetric(NodesInfoMetrics.Metric.OS.metricName()).timeout(fetchTimeout),
                             ActionListener.wrap(nodesInfoResponse -> {
                                 final Map<String, AutoscalingNodeInfo.Builder> builderBuilder = Maps.newHashMapWithExpectedSize(
                                     nodesStatsResponse.getNodes().size()
diff --git a/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/action/enrollment/TransportNodeEnrollmentAction.java b/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/action/enrollment/TransportNodeEnrollmentAction.java
index 65747c94590b5..152c6aeaf14e7 100644
--- a/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/action/enrollment/TransportNodeEnrollmentAction.java
+++ b/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/action/enrollment/TransportNodeEnrollmentAction.java
@@ -11,6 +11,7 @@
 import org.elasticsearch.action.ActionListener;
 import org.elasticsearch.action.admin.cluster.node.info.NodeInfo;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoAction;
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoMetrics;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.elasticsearch.action.support.ActionFilters;
 import org.elasticsearch.action.support.HandledTransportAction;
@@ -142,7 +143,7 @@ protected void doExecute(Task task, NodeEnrollmentRequest request, ActionListene
         }
 
         final List<String> nodeList = new ArrayList<>();
-        final NodesInfoRequest nodesInfoRequest = new NodesInfoRequest().addMetric(NodesInfoRequest.Metric.TRANSPORT.metricName());
+        final NodesInfoRequest nodesInfoRequest = new NodesInfoRequest().addMetric(NodesInfoMetrics.Metric.TRANSPORT.metricName());
         executeAsyncWithOrigin(client, SECURITY_ORIGIN, NodesInfoAction.INSTANCE, nodesInfoRequest, ActionListener.wrap(response -> {
             for (NodeInfo nodeInfo : response.getNodes()) {
                 nodeList.add(nodeInfo.getInfo(TransportInfo.class).getAddress().publishAddress().toString());
diff --git a/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/enrollment/InternalEnrollmentTokenGenerator.java b/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/enrollment/InternalEnrollmentTokenGenerator.java
index 1e874dead9956..d0acc61570853 100644
--- a/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/enrollment/InternalEnrollmentTokenGenerator.java
+++ b/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/enrollment/InternalEnrollmentTokenGenerator.java
@@ -13,6 +13,7 @@
 import org.elasticsearch.action.ActionListener;
 import org.elasticsearch.action.admin.cluster.node.info.NodeInfo;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoAction;
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoMetrics;
 import org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.elasticsearch.action.support.WriteRequest;
 import org.elasticsearch.client.internal.Client;
@@ -65,7 +66,7 @@ public InternalEnrollmentTokenGenerator(Environment environment, SSLService sslS
     public void maybeCreateNodeEnrollmentToken(Consumer<String> consumer, Iterator<TimeValue> backoff) {
         // the enrollment token can only be used against the node that generated it
         final NodesInfoRequest nodesInfoRequest = new NodesInfoRequest().nodesIds("_local")
-            .addMetrics(NodesInfoRequest.Metric.HTTP.metricName(), NodesInfoRequest.Metric.TRANSPORT.metricName());
+            .addMetrics(NodesInfoMetrics.Metric.HTTP.metricName(), NodesInfoMetrics.Metric.TRANSPORT.metricName());
 
         client.execute(NodesInfoAction.INSTANCE, nodesInfoRequest, ActionListener.wrap(response -> {
             assert response.getNodes().size() == 1;
@@ -133,7 +134,7 @@ public void maybeCreateNodeEnrollmentToken(Consumer<String> consumer, Iterator<T
     public void createKibanaEnrollmentToken(Consumer<EnrollmentToken> consumer, Iterator<TimeValue> backoff) {
         // the enrollment token can only be used against the node that generated it
         final NodesInfoRequest nodesInfoRequest = new NodesInfoRequest().nodesIds("_local")
-            .addMetric(NodesInfoRequest.Metric.HTTP.metricName());
+            .addMetric(NodesInfoMetrics.Metric.HTTP.metricName());
         client.execute(NodesInfoAction.INSTANCE, nodesInfoRequest, ActionListener.wrap(response -> {
             assert response.getNodes().size() == 1;
             NodeInfo nodeInfo = response.getNodes().get(0);

From 075e7c68bd3f80b20eac28383234462791e972e8 Mon Sep 17 00:00:00 2001
From: Panagiotis Bailis <pmpailis@gmail.com>
Date: Thu, 28 Sep 2023 13:23:53 +0300
Subject: [PATCH 04/32] Muting failing test MixedClusterClientYamlTestSuiteIT
 test {p0=search.vectors/90_sparse_vector/Sparse vector in 7.x}  (#100009)

---
 .../rest-api-spec/test/search.vectors/90_sparse_vector.yml    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rest-api-spec/src/yamlRestTest/resources/rest-api-spec/test/search.vectors/90_sparse_vector.yml b/rest-api-spec/src/yamlRestTest/resources/rest-api-spec/test/search.vectors/90_sparse_vector.yml
index 3644e93d12bbd..27aa0e6e9a20b 100644
--- a/rest-api-spec/src/yamlRestTest/resources/rest-api-spec/test/search.vectors/90_sparse_vector.yml
+++ b/rest-api-spec/src/yamlRestTest/resources/rest-api-spec/test/search.vectors/90_sparse_vector.yml
@@ -145,8 +145,8 @@
 "Sparse vector in 7.x":
   - skip:
       features: allowed_warnings
-      version: "8.0.0 - "
-      reason: "sparse_vector field type supported in 7.x"
+      version: "all"
+      reason: "AwaitsFix https://github.com/elastic/elasticsearch/issues/100003"
   - do:
       allowed_warnings:
         - "The [sparse_vector] field type is deprecated and will be removed in 8.0."

From a0b0e25e091d79537634300e7ac94d3a2be8f6ac Mon Sep 17 00:00:00 2001
From: Armin Braun <me@obrown.io>
Date: Thu, 28 Sep 2023 12:55:45 +0200
Subject: [PATCH 05/32] Simplify FieldCaps Transport Messages Code (#100010)

This removes the intermediate GroupBy record and a few list allocations
to reduce the memory and runtime overhead of large responses when there
isn't as much deduplication.

This should help visibly with the not-as-much-deduplication case
already, but more importantly it sets up a massive improvement in a
follow-up that I'd open right after this is merged! We can assume that
the `IndexFieldCapabilities` instances (now a record to make this
obvious) will be duplicated across entries massively. So we can
deduplicate them when writing through a lookup table, massively
shrinking the size of these responses and making operations on the
coordinating node much faster as well.
---
 .../FieldCapabilitiesIndexResponse.java       |  75 +++++-----
 .../fieldcaps/IndexFieldCapabilities.java     | 138 +++++-------------
 .../action/fieldcaps/ResponseRewriter.java    |  10 +-
 .../TransportFieldCapabilitiesAction.java     |   7 +-
 .../FieldCapabilitiesNodeResponseTests.java   |   4 +-
 .../FieldCapabilitiesResponseTests.java       |   4 +-
 6 files changed, 83 insertions(+), 155 deletions(-)

diff --git a/server/src/main/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesIndexResponse.java b/server/src/main/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesIndexResponse.java
index aac322c4a1de7..b1f844ed66215 100644
--- a/server/src/main/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesIndexResponse.java
+++ b/server/src/main/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesIndexResponse.java
@@ -16,12 +16,11 @@
 import org.elasticsearch.core.Nullable;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 final class FieldCapabilitiesIndexResponse implements Writeable {
     private static final TransportVersion MAPPING_HASH_VERSION = TransportVersions.V_8_2_0;
@@ -48,7 +47,7 @@ final class FieldCapabilitiesIndexResponse implements Writeable {
 
     FieldCapabilitiesIndexResponse(StreamInput in) throws IOException {
         this.indexName = in.readString();
-        this.responseMap = in.readMap(IndexFieldCapabilities::new);
+        this.responseMap = in.readMap(IndexFieldCapabilities::readFrom);
         this.canMatch = in.readBoolean();
         this.originVersion = in.getTransportVersion();
         if (in.getTransportVersion().onOrAfter(MAPPING_HASH_VERSION)) {
@@ -68,32 +67,25 @@ public void writeTo(StreamOutput out) throws IOException {
         }
     }
 
-    private record GroupByMappingHash(List<String> indices, String indexMappingHash, Map<String, IndexFieldCapabilities> responseMap)
-        implements
-            Writeable {
-        GroupByMappingHash(StreamInput in) throws IOException {
-            this(in.readStringCollectionAsList(), in.readString(), in.readMap(IndexFieldCapabilities::new));
-        }
-
-        @Override
-        public void writeTo(StreamOutput out) throws IOException {
-            out.writeStringCollection(indices);
-            out.writeString(indexMappingHash);
-            out.writeMap(responseMap, StreamOutput::writeWriteable);
-        }
-
-        Stream<FieldCapabilitiesIndexResponse> getResponses() {
-            return indices.stream().map(index -> new FieldCapabilitiesIndexResponse(index, indexMappingHash, responseMap, true));
-        }
-    }
-
     static List<FieldCapabilitiesIndexResponse> readList(StreamInput input) throws IOException {
         if (input.getTransportVersion().before(MAPPING_HASH_VERSION)) {
             return input.readCollectionAsList(FieldCapabilitiesIndexResponse::new);
         }
-        final List<FieldCapabilitiesIndexResponse> ungroupedList = input.readCollectionAsList(FieldCapabilitiesIndexResponse::new);
-        final List<GroupByMappingHash> groups = input.readCollectionAsList(GroupByMappingHash::new);
-        return Stream.concat(ungroupedList.stream(), groups.stream().flatMap(GroupByMappingHash::getResponses)).toList();
+        final int ungrouped = input.readVInt();
+        final ArrayList<FieldCapabilitiesIndexResponse> responses = new ArrayList<>(ungrouped);
+        for (int i = 0; i < ungrouped; i++) {
+            responses.add(new FieldCapabilitiesIndexResponse(input));
+        }
+        final int groups = input.readVInt();
+        for (int i = 0; i < groups; i++) {
+            final List<String> indices = input.readStringCollectionAsList();
+            final String mappingHash = input.readString();
+            final Map<String, IndexFieldCapabilities> ifc = input.readMap(IndexFieldCapabilities::readFrom);
+            for (String index : indices) {
+                responses.add(new FieldCapabilitiesIndexResponse(index, mappingHash, ifc, true));
+            }
+        }
+        return responses;
     }
 
     static void writeList(StreamOutput output, List<FieldCapabilitiesIndexResponse> responses) throws IOException {
@@ -101,22 +93,23 @@ static void writeList(StreamOutput output, List<FieldCapabilitiesIndexResponse>
             output.writeCollection(responses);
             return;
         }
-        final Predicate<FieldCapabilitiesIndexResponse> canGroup = r -> r.canMatch && r.indexMappingHash != null;
-        final List<FieldCapabilitiesIndexResponse> ungroupedResponses = responses.stream().filter(r -> canGroup.test(r) == false).toList();
-        final List<GroupByMappingHash> groupedResponses = responses.stream()
-            .filter(canGroup)
-            .collect(Collectors.groupingBy(r -> r.indexMappingHash))
-            .values()
-            .stream()
-            .map(rs -> {
-                final String indexMappingHash = rs.get(0).indexMappingHash;
-                final Map<String, IndexFieldCapabilities> responseMap = rs.get(0).responseMap;
-                final List<String> indices = rs.stream().map(r -> r.indexName).toList();
-                return new GroupByMappingHash(indices, indexMappingHash, responseMap);
-            })
-            .toList();
+
+        Map<String, List<FieldCapabilitiesIndexResponse>> groupedResponsesMap = new HashMap<>();
+        final List<FieldCapabilitiesIndexResponse> ungroupedResponses = new ArrayList<>();
+        for (FieldCapabilitiesIndexResponse r : responses) {
+            if (r.canMatch && r.indexMappingHash != null) {
+                groupedResponsesMap.computeIfAbsent(r.indexMappingHash, k -> new ArrayList<>()).add(r);
+            } else {
+                ungroupedResponses.add(r);
+            }
+        }
         output.writeCollection(ungroupedResponses);
-        output.writeCollection(groupedResponses);
+        output.writeCollection(groupedResponsesMap.values(), (o, fieldCapabilitiesIndexResponses) -> {
+            o.writeCollection(fieldCapabilitiesIndexResponses, (oo, r) -> oo.writeString(r.indexName));
+            var first = fieldCapabilitiesIndexResponses.get(0);
+            o.writeString(first.indexMappingHash);
+            o.writeMap(first.responseMap, StreamOutput::writeWriteable);
+        });
     }
 
     /**
diff --git a/server/src/main/java/org/elasticsearch/action/fieldcaps/IndexFieldCapabilities.java b/server/src/main/java/org/elasticsearch/action/fieldcaps/IndexFieldCapabilities.java
index 57a9dd049d26c..ef609a06cb8be 100644
--- a/server/src/main/java/org/elasticsearch/action/fieldcaps/IndexFieldCapabilities.java
+++ b/server/src/main/java/org/elasticsearch/action/fieldcaps/IndexFieldCapabilities.java
@@ -17,65 +17,54 @@
 
 import java.io.IOException;
 import java.util.Map;
-import java.util.Objects;
 
 /**
  * Describes the capabilities of a field in a single index.
+ * @param name           The name of the field.
+ * @param type           The type associated with the field.
+ * @param isSearchable   Whether this field is indexed for search.
+ * @param isAggregatable Whether this field can be aggregated on.
+ * @param meta           Metadata about the field.
  */
-public class IndexFieldCapabilities implements Writeable {
 
-    private static final StringLiteralDeduplicator typeStringDeduplicator = new StringLiteralDeduplicator();
-
-    private final String name;
-    private final String type;
-    private final boolean isMetadatafield;
-    private final boolean isSearchable;
-    private final boolean isAggregatable;
-    private final boolean isDimension;
-    private final TimeSeriesParams.MetricType metricType;
-    private final Map<String, String> meta;
+public record IndexFieldCapabilities(
+    String name,
+    String type,
+    boolean isMetadatafield,
+    boolean isSearchable,
+    boolean isAggregatable,
+    boolean isDimension,
+    TimeSeriesParams.MetricType metricType,
+    Map<String, String> meta
+) implements Writeable {
 
-    /**
-     * @param name The name of the field.
-     * @param type The type associated with the field.
-     * @param isSearchable Whether this field is indexed for search.
-     * @param isAggregatable Whether this field can be aggregated on.
-     * @param meta Metadata about the field.
-     */
-    IndexFieldCapabilities(
-        String name,
-        String type,
-        boolean isMetadatafield,
-        boolean isSearchable,
-        boolean isAggregatable,
-        boolean isDimension,
-        TimeSeriesParams.MetricType metricType,
-        Map<String, String> meta
-    ) {
-        this.name = name;
-        this.type = type;
-        this.isMetadatafield = isMetadatafield;
-        this.isSearchable = isSearchable;
-        this.isAggregatable = isAggregatable;
-        this.isDimension = isDimension;
-        this.metricType = metricType;
-        this.meta = meta;
-    }
+    private static final StringLiteralDeduplicator typeStringDeduplicator = new StringLiteralDeduplicator();
 
-    IndexFieldCapabilities(StreamInput in) throws IOException {
-        this.name = in.readString();
-        this.type = typeStringDeduplicator.deduplicate(in.readString());
-        this.isMetadatafield = in.readBoolean();
-        this.isSearchable = in.readBoolean();
-        this.isAggregatable = in.readBoolean();
+    public static IndexFieldCapabilities readFrom(StreamInput in) throws IOException {
+        String name = in.readString();
+        String type = typeStringDeduplicator.deduplicate(in.readString());
+        boolean isMetadatafield = in.readBoolean();
+        boolean isSearchable = in.readBoolean();
+        boolean isAggregatable = in.readBoolean();
+        boolean isDimension;
+        TimeSeriesParams.MetricType metricType;
         if (in.getTransportVersion().onOrAfter(TransportVersions.V_8_0_0)) {
-            this.isDimension = in.readBoolean();
-            this.metricType = in.readOptionalEnum(TimeSeriesParams.MetricType.class);
+            isDimension = in.readBoolean();
+            metricType = in.readOptionalEnum(TimeSeriesParams.MetricType.class);
         } else {
-            this.isDimension = false;
-            this.metricType = null;
+            isDimension = false;
+            metricType = null;
         }
-        this.meta = in.readMap(StreamInput::readString);
+        return new IndexFieldCapabilities(
+            name,
+            type,
+            isMetadatafield,
+            isSearchable,
+            isAggregatable,
+            isDimension,
+            metricType,
+            in.readMap(StreamInput::readString)
+        );
     }
 
     @Override
@@ -92,55 +81,4 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeMap(meta, StreamOutput::writeString);
     }
 
-    public String getName() {
-        return name;
-    }
-
-    public String getType() {
-        return type;
-    }
-
-    public boolean isMetadatafield() {
-        return isMetadatafield;
-    }
-
-    public boolean isAggregatable() {
-        return isAggregatable;
-    }
-
-    public boolean isSearchable() {
-        return isSearchable;
-    }
-
-    public boolean isDimension() {
-        return isDimension;
-    }
-
-    public TimeSeriesParams.MetricType getMetricType() {
-        return metricType;
-    }
-
-    public Map<String, String> meta() {
-        return meta;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        IndexFieldCapabilities that = (IndexFieldCapabilities) o;
-        return isMetadatafield == that.isMetadatafield
-            && isSearchable == that.isSearchable
-            && isAggregatable == that.isAggregatable
-            && isDimension == that.isDimension
-            && Objects.equals(metricType, that.metricType)
-            && Objects.equals(name, that.name)
-            && Objects.equals(type, that.type)
-            && Objects.equals(meta, that.meta);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(name, type, isMetadatafield, isSearchable, isAggregatable, isDimension, metricType, meta);
-    }
 }
diff --git a/server/src/main/java/org/elasticsearch/action/fieldcaps/ResponseRewriter.java b/server/src/main/java/org/elasticsearch/action/fieldcaps/ResponseRewriter.java
index 37313c435319c..d39dd28b32611 100644
--- a/server/src/main/java/org/elasticsearch/action/fieldcaps/ResponseRewriter.java
+++ b/server/src/main/java/org/elasticsearch/action/fieldcaps/ResponseRewriter.java
@@ -54,11 +54,11 @@ private static Function<IndexFieldCapabilities, IndexFieldCapabilities> buildTra
         Set<String> nestedObjects = null;
         if (allowedTypes.length > 0) {
             Set<String> at = Set.of(allowedTypes);
-            test = test.and(ifc -> at.contains(ifc.getType()));
+            test = test.and(ifc -> at.contains(ifc.type()));
         }
         for (String filter : filters) {
             if ("-parent".equals(filter)) {
-                test = test.and(fc -> fc.getType().equals("nested") == false && fc.getType().equals("object") == false);
+                test = test.and(fc -> fc.type().equals("nested") == false && fc.type().equals("object") == false);
             }
             if ("-metadata".equals(filter)) {
                 test = test.and(fc -> fc.isMetadatafield() == false);
@@ -71,7 +71,7 @@ private static Function<IndexFieldCapabilities, IndexFieldCapabilities> buildTra
                     nestedObjects = findTypes("nested", input);
                 }
                 Set<String> no = nestedObjects;
-                test = test.and(fc -> isNestedField(fc.getName(), no) == false);
+                test = test.and(fc -> isNestedField(fc.name(), no) == false);
             }
             if ("-multifield".equals(filter)) {
                 // immediate parent is not an object field
@@ -79,7 +79,7 @@ private static Function<IndexFieldCapabilities, IndexFieldCapabilities> buildTra
                     objects = findTypes("object", input);
                 }
                 Set<String> o = objects;
-                test = test.and(fc -> isNotMultifield(fc.getName(), o));
+                test = test.and(fc -> isNotMultifield(fc.name(), o));
             }
         }
         Predicate<IndexFieldCapabilities> finalTest = test;
@@ -94,7 +94,7 @@ private static Function<IndexFieldCapabilities, IndexFieldCapabilities> buildTra
     private static Set<String> findTypes(String type, Map<String, IndexFieldCapabilities> fieldCaps) {
         return fieldCaps.entrySet()
             .stream()
-            .filter(entry -> type.equals(entry.getValue().getType()))
+            .filter(entry -> type.equals(entry.getValue().type()))
             .map(Map.Entry::getKey)
             .collect(Collectors.toSet());
     }
diff --git a/server/src/main/java/org/elasticsearch/action/fieldcaps/TransportFieldCapabilitiesAction.java b/server/src/main/java/org/elasticsearch/action/fieldcaps/TransportFieldCapabilitiesAction.java
index 91c4f10956866..c9a44c14106ee 100644
--- a/server/src/main/java/org/elasticsearch/action/fieldcaps/TransportFieldCapabilitiesAction.java
+++ b/server/src/main/java/org/elasticsearch/action/fieldcaps/TransportFieldCapabilitiesAction.java
@@ -417,17 +417,14 @@ private static void innerMerge(
             final String field = entry.getKey();
             final IndexFieldCapabilities fieldCap = entry.getValue();
             Map<String, FieldCapabilities.Builder> typeMap = responseMapBuilder.computeIfAbsent(field, f -> new HashMap<>());
-            FieldCapabilities.Builder builder = typeMap.computeIfAbsent(
-                fieldCap.getType(),
-                key -> new FieldCapabilities.Builder(field, key)
-            );
+            FieldCapabilities.Builder builder = typeMap.computeIfAbsent(fieldCap.type(), key -> new FieldCapabilities.Builder(field, key));
             builder.add(
                 indices,
                 fieldCap.isMetadatafield(),
                 fieldCap.isSearchable(),
                 fieldCap.isAggregatable(),
                 fieldCap.isDimension(),
-                fieldCap.getMetricType(),
+                fieldCap.metricType(),
                 fieldCap.meta()
             );
         }
diff --git a/server/src/test/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesNodeResponseTests.java b/server/src/test/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesNodeResponseTests.java
index a95340e2fffd1..0802e498c43a7 100644
--- a/server/src/test/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesNodeResponseTests.java
+++ b/server/src/test/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesNodeResponseTests.java
@@ -161,8 +161,8 @@ public void testSerializeNodeResponseBetweenOldNodes() throws IOException {
                 // Exclude metric types which was introduced in 8.0
                 assertThat(outCap.keySet(), equalTo(inCap.keySet()));
                 for (String field : outCap.keySet()) {
-                    assertThat(outCap.get(field).getName(), equalTo(inCap.get(field).getName()));
-                    assertThat(outCap.get(field).getType(), equalTo(inCap.get(field).getType()));
+                    assertThat(outCap.get(field).name(), equalTo(inCap.get(field).name()));
+                    assertThat(outCap.get(field).type(), equalTo(inCap.get(field).type()));
                     assertThat(outCap.get(field).isSearchable(), equalTo(inCap.get(field).isSearchable()));
                     assertThat(outCap.get(field).isAggregatable(), equalTo(inCap.get(field).isAggregatable()));
                     assertThat(outCap.get(field).meta(), equalTo(inCap.get(field).meta()));
diff --git a/server/src/test/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesResponseTests.java b/server/src/test/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesResponseTests.java
index cc7c76553ef99..461000fc22b02 100644
--- a/server/src/test/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesResponseTests.java
+++ b/server/src/test/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesResponseTests.java
@@ -235,8 +235,8 @@ public void testSerializeCCSResponseBetweenOldClusters() throws IOException {
                 // Exclude metric types which was introduced in 8.0
                 assertThat(outCap.keySet(), equalTo(inCap.keySet()));
                 for (String field : outCap.keySet()) {
-                    assertThat(outCap.get(field).getName(), equalTo(inCap.get(field).getName()));
-                    assertThat(outCap.get(field).getType(), equalTo(inCap.get(field).getType()));
+                    assertThat(outCap.get(field).name(), equalTo(inCap.get(field).name()));
+                    assertThat(outCap.get(field).type(), equalTo(inCap.get(field).type()));
                     assertThat(outCap.get(field).isSearchable(), equalTo(inCap.get(field).isSearchable()));
                     assertThat(outCap.get(field).isAggregatable(), equalTo(inCap.get(field).isAggregatable()));
                     assertThat(outCap.get(field).meta(), equalTo(inCap.get(field).meta()));

From 84350c65f553f0f4cc9bd852bbe4d272dea111b4 Mon Sep 17 00:00:00 2001
From: Luca Cavanna <javanna@apache.org>
Date: Thu, 28 Sep 2023 13:34:17 +0200
Subject: [PATCH 06/32] Adjust executor queue size in AggregatorTestCase
 (#100011)

The queue size needs to be unbounded like the search workers thread pool, to prevent rejections. Rather than setting the queue size to a negative number, we can reuse the search workers executor that is already part of the created thread pool instance.
---
 .../search/aggregations/AggregatorTestCase.java      | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/test/framework/src/main/java/org/elasticsearch/search/aggregations/AggregatorTestCase.java b/test/framework/src/main/java/org/elasticsearch/search/aggregations/AggregatorTestCase.java
index d19fd4ecf08a3..5a28bd8b0ea6d 100644
--- a/test/framework/src/main/java/org/elasticsearch/search/aggregations/AggregatorTestCase.java
+++ b/test/framework/src/main/java/org/elasticsearch/search/aggregations/AggregatorTestCase.java
@@ -59,8 +59,6 @@
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.common.util.MockBigArrays;
 import org.elasticsearch.common.util.MockPageCacheRecycler;
-import org.elasticsearch.common.util.concurrent.EsExecutors;
-import org.elasticsearch.common.util.concurrent.EsExecutors.TaskTrackingConfig;
 import org.elasticsearch.core.CheckedConsumer;
 import org.elasticsearch.core.Releasable;
 import org.elasticsearch.core.Releasables;
@@ -201,16 +199,8 @@ public abstract class AggregatorTestCase extends ESTestCase {
 
     @Before
     public final void initPlugins() {
-        int numThreads = randomIntBetween(2, 4);
         threadPool = new TestThreadPool(AggregatorTestCase.class.getName());
-        threadPoolExecutor = EsExecutors.newFixed(
-            "test",
-            numThreads,
-            10,
-            EsExecutors.daemonThreadFactory("test"),
-            threadPool.getThreadContext(),
-            randomFrom(TaskTrackingConfig.DEFAULT, TaskTrackingConfig.DO_NOT_TRACK)
-        );
+        threadPoolExecutor = (ThreadPoolExecutor) threadPool.executor(ThreadPool.Names.SEARCH_WORKER);
         List<SearchPlugin> plugins = new ArrayList<>(getSearchPlugins());
         plugins.add(new AggCardinalityUpperBoundPlugin());
         SearchModule searchModule = new SearchModule(Settings.EMPTY, plugins);

From d6526f8d4b48de145c893dc39bcb9ccf02a5ae04 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Yulia=20=C4=8Cech?=
 <6585477+yuliacech@users.noreply.github.com>
Date: Thu, 28 Sep 2023 13:41:53 +0200
Subject: [PATCH 07/32] [Index Management] Update docs screenshots with for the
 new index details page (#99973)

---
 .../index-mgmt/management_index_details.png   | Bin 339652 -> 422199 bytes
 docs/reference/indices/index-mgmt.asciidoc    |   6 +++---
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/reference/images/index-mgmt/management_index_details.png b/docs/reference/images/index-mgmt/management_index_details.png
index edf1a6517f6a2dc7ad7746456f22ea313a85ae77..a975b9952ca88762f7db2d91929a9f309aacd22c 100644
GIT binary patch
literal 422199
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%0A!STcD+1B7+}
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

literal 339652
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

diff --git a/docs/reference/indices/index-mgmt.asciidoc b/docs/reference/indices/index-mgmt.asciidoc
index 571f1c813fbfa..b89d2ec957af9 100644
--- a/docs/reference/indices/index-mgmt.asciidoc
+++ b/docs/reference/indices/index-mgmt.asciidoc
@@ -49,11 +49,11 @@ Badges indicate if an index is a <<ccr-put-follow,follower index>>, a
 Clicking a badge narrows the list to only indices of that type.
 You can also filter indices using the search bar.
 
-You can drill down into each index to investigate the index
+By clicking the index name, you can open an index details page to investigate the index
 <<index-modules-settings,settings>>, <<mapping,mapping>>, and statistics.
-From this view, you can also edit the index settings. 
+On this page, you can also edit the index settings.
 
-To view and explore the documents within an index, click the compass icon image:compassicon.png[width=3%] next to the index name to open {kibana-ref}/discover.html[Discover].
+To view and explore the documents within an index, click the *Discover index* button to open {kibana-ref}/discover.html[Discover].
 
 [role="screenshot"]
 image::images/index-mgmt/management_index_details.png[Index Management UI]

From 787bca43deea01170f469ef4615ad697130aff27 Mon Sep 17 00:00:00 2001
From: Matteo Piergiovanni <134913285+piergm@users.noreply.github.com>
Date: Thu, 28 Sep 2023 13:50:59 +0200
Subject: [PATCH 08/32] Mute SearchResponseTests#testSerialization (#100005)
 (#100015)

---
 .../org/elasticsearch/action/search/SearchResponseTests.java     | 1 +
 1 file changed, 1 insertion(+)

diff --git a/server/src/test/java/org/elasticsearch/action/search/SearchResponseTests.java b/server/src/test/java/org/elasticsearch/action/search/SearchResponseTests.java
index befea803e6fa0..9acb63db2cc90 100644
--- a/server/src/test/java/org/elasticsearch/action/search/SearchResponseTests.java
+++ b/server/src/test/java/org/elasticsearch/action/search/SearchResponseTests.java
@@ -590,6 +590,7 @@ public void testToXContent() throws IOException {
         }
     }
 
+    @AwaitsFix(bugUrl = "https://github.com/elastic/elasticsearch/issues/100005")
     public void testSerialization() throws IOException {
         SearchResponse searchResponse = createTestItem(false);
         SearchResponse deserialized = copyWriteable(

From 2499f6c7b0a4d7d20fd223bfb220951779c881d2 Mon Sep 17 00:00:00 2001
From: David Roberts <dave.roberts@elastic.co>
Date: Thu, 28 Sep 2023 13:53:21 +0100
Subject: [PATCH 09/32] [ML] Use TransportVersion for remote cluster age check
 (#100013)

Previously the code was using MlConfigVersion for a
remote cluster version check, which is inappropriate
as the communications with the remote cluster are
transport, not config.
---
 .../common/validation/SourceDestValidator.java   |  3 ---
 .../xpack/core/ml/MlConfigVersion.java           |  3 ++-
 .../xpack/core/ml/datafeed/DatafeedConfig.java   |  7 ++++---
 .../ml/action/TransportStartDatafeedAction.java  | 16 ++++++++--------
 .../TransportStartDatafeedActionTests.java       | 13 +++++++------
 5 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/common/validation/SourceDestValidator.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/common/validation/SourceDestValidator.java
index 49bdf60ad0b18..9962f14ec3736 100644
--- a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/common/validation/SourceDestValidator.java
+++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/common/validation/SourceDestValidator.java
@@ -73,9 +73,6 @@ public final class SourceDestValidator {
     public static final String REMOTE_CLUSTERS_TRANSPORT_TOO_OLD =
         "remote clusters are expected to run at least transport version [{0}] (reason: [{1}]),"
             + " but the following clusters were too old: [{2}]";
-    public static final String REMOTE_CLUSTERS_CONFIG_TOO_OLD =
-        "remote clusters are expected to run at least config version [{0}] (reason: [{1}]),"
-            + " but the following clusters were too old: [{2}]";
     public static final String PIPELINE_MISSING = "Pipeline with id [{0}] could not be found";
 
     private final IndexNameExpressionResolver indexNameExpressionResolver;
diff --git a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/MlConfigVersion.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/MlConfigVersion.java
index 75370db1d766f..e631e3efe5cb6 100644
--- a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/MlConfigVersion.java
+++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/MlConfigVersion.java
@@ -268,7 +268,8 @@ public static MlConfigVersion max(MlConfigVersion version1, MlConfigVersion vers
         return version1.id > version2.id ? version1 : version2;
     }
 
-    public static MlConfigVersion fromVersion(Version version) {
+    // Visible only for testing
+    static MlConfigVersion fromVersion(Version version) {
         if (version.equals(Version.V_8_10_0)) {
             return V_10;
         }
diff --git a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/datafeed/DatafeedConfig.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/datafeed/DatafeedConfig.java
index 7f5de886222ba..cacc4a6a33196 100644
--- a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/datafeed/DatafeedConfig.java
+++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/datafeed/DatafeedConfig.java
@@ -9,6 +9,8 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.elasticsearch.ElasticsearchException;
+import org.elasticsearch.TransportVersion;
+import org.elasticsearch.TransportVersions;
 import org.elasticsearch.action.search.SearchRequest;
 import org.elasticsearch.action.support.IndicesOptions;
 import org.elasticsearch.cluster.SimpleDiffable;
@@ -36,7 +38,6 @@
 import org.elasticsearch.xcontent.XContentBuilder;
 import org.elasticsearch.xcontent.XContentParser;
 import org.elasticsearch.xpack.core.common.time.TimeUtils;
-import org.elasticsearch.xpack.core.ml.MlConfigVersion;
 import org.elasticsearch.xpack.core.ml.datafeed.extractor.ExtractorUtils;
 import org.elasticsearch.xpack.core.ml.utils.ExceptionsHelper;
 import org.elasticsearch.xpack.core.ml.utils.MlStrings;
@@ -86,7 +87,7 @@
  */
 public class DatafeedConfig implements SimpleDiffable<DatafeedConfig>, ToXContentObject {
 
-    private static final MlConfigVersion RUNTIME_MAPPINGS_INTRODUCED = MlConfigVersion.V_7_11_0;
+    private static final TransportVersion RUNTIME_MAPPINGS_INTRODUCED = TransportVersions.V_7_11_0;
 
     public static final int DEFAULT_SCROLL_SIZE = 1000;
 
@@ -340,7 +341,7 @@ public Integer getScrollSize() {
         return scrollSize;
     }
 
-    public Optional<Tuple<MlConfigVersion, String>> minRequiredConfigVersion() {
+    public Optional<Tuple<TransportVersion, String>> minRequiredTransportVersion() {
         return runtimeMappings.isEmpty()
             ? Optional.empty()
             : Optional.of(Tuple.tuple(RUNTIME_MAPPINGS_INTRODUCED, SearchSourceBuilder.RUNTIME_MAPPINGS_FIELD.getPreferredName()));
diff --git a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TransportStartDatafeedAction.java b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TransportStartDatafeedAction.java
index 38b827b120bf6..475ca4ef2a7ce 100644
--- a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TransportStartDatafeedAction.java
+++ b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TransportStartDatafeedAction.java
@@ -10,6 +10,7 @@
 import org.apache.logging.log4j.Logger;
 import org.elasticsearch.ElasticsearchStatusException;
 import org.elasticsearch.ResourceAlreadyExistsException;
+import org.elasticsearch.TransportVersion;
 import org.elasticsearch.action.ActionListener;
 import org.elasticsearch.action.support.ActionFilters;
 import org.elasticsearch.action.support.master.TransportMasterNodeAction;
@@ -45,7 +46,6 @@
 import org.elasticsearch.xcontent.NamedXContentRegistry;
 import org.elasticsearch.xpack.core.XPackField;
 import org.elasticsearch.xpack.core.ml.MachineLearningField;
-import org.elasticsearch.xpack.core.ml.MlConfigVersion;
 import org.elasticsearch.xpack.core.ml.MlTasks;
 import org.elasticsearch.xpack.core.ml.action.GetDatafeedRunningStateAction;
 import org.elasticsearch.xpack.core.ml.action.NodeAcknowledgedResponse;
@@ -80,7 +80,7 @@
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
-import static org.elasticsearch.xpack.core.common.validation.SourceDestValidator.REMOTE_CLUSTERS_CONFIG_TOO_OLD;
+import static org.elasticsearch.xpack.core.common.validation.SourceDestValidator.REMOTE_CLUSTERS_TRANSPORT_TOO_OLD;
 
 /* This class extends from TransportMasterNodeAction for cluster state observing purposes.
  The stop datafeed api also redirect the elected master node.
@@ -249,7 +249,7 @@ public void onFailure(Exception e) {
                             checkRemoteConfigVersions(
                                 datafeedConfigHolder.get(),
                                 remoteAliases,
-                                (cn) -> MlConfigVersion.fromVersion(remoteClusterService.getConnection(cn).getVersion())
+                                (cn) -> remoteClusterService.getConnection(cn).getTransportVersion()
                             );
                             createDataExtractor(task, job, datafeedConfigHolder.get(), params, waitForTaskListener);
                         }
@@ -299,17 +299,17 @@ public void onFailure(Exception e) {
     static void checkRemoteConfigVersions(
         DatafeedConfig config,
         List<String> remoteClusters,
-        Function<String, MlConfigVersion> configVersionSupplier
+        Function<String, TransportVersion> transportVersionSupplier
     ) {
-        Optional<Tuple<MlConfigVersion, String>> minVersionAndReason = config.minRequiredConfigVersion();
+        Optional<Tuple<TransportVersion, String>> minVersionAndReason = config.minRequiredTransportVersion();
         if (minVersionAndReason.isPresent() == false) {
             return;
         }
         final String reason = minVersionAndReason.get().v2();
-        final MlConfigVersion minVersion = minVersionAndReason.get().v1();
+        final TransportVersion minVersion = minVersionAndReason.get().v1();
 
         List<String> clustersTooOld = remoteClusters.stream()
-            .filter(cn -> configVersionSupplier.apply(cn).before(minVersion))
+            .filter(cn -> transportVersionSupplier.apply(cn).before(minVersion))
             .collect(Collectors.toList());
         if (clustersTooOld.isEmpty()) {
             return;
@@ -317,7 +317,7 @@ static void checkRemoteConfigVersions(
 
         throw ExceptionsHelper.badRequestException(
             Messages.getMessage(
-                REMOTE_CLUSTERS_CONFIG_TOO_OLD,
+                REMOTE_CLUSTERS_TRANSPORT_TOO_OLD,
                 minVersion.toString(),
                 reason,
                 Strings.collectionToCommaDelimitedString(clustersTooOld)
diff --git a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/action/TransportStartDatafeedActionTests.java b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/action/TransportStartDatafeedActionTests.java
index 4a66a2836273e..a2d5003118536 100644
--- a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/action/TransportStartDatafeedActionTests.java
+++ b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/action/TransportStartDatafeedActionTests.java
@@ -8,13 +8,14 @@
 package org.elasticsearch.xpack.ml.action;
 
 import org.elasticsearch.ElasticsearchStatusException;
+import org.elasticsearch.TransportVersion;
+import org.elasticsearch.TransportVersions;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.persistent.PersistentTasksCustomMetadata;
 import org.elasticsearch.search.SearchModule;
 import org.elasticsearch.tasks.TaskId;
 import org.elasticsearch.test.ESTestCase;
 import org.elasticsearch.xcontent.NamedXContentRegistry;
-import org.elasticsearch.xpack.core.ml.MlConfigVersion;
 import org.elasticsearch.xpack.core.ml.action.StartDatafeedAction;
 import org.elasticsearch.xpack.core.ml.datafeed.DatafeedConfig;
 import org.elasticsearch.xpack.core.ml.datafeed.DatafeedConfigTests;
@@ -112,13 +113,13 @@ public void testNoDeprecationsLogged() {
     }
 
     public void testRemoteClusterVersionCheck() {
-        Map<String, MlConfigVersion> clusterVersions = Map.of(
+        Map<String, TransportVersion> clusterVersions = Map.of(
             "modern_cluster_1",
-            MlConfigVersion.CURRENT,
+            TransportVersion.current(),
             "modern_cluster_2",
-            MlConfigVersion.CURRENT,
+            TransportVersion.current(),
             "old_cluster_1",
-            MlConfigVersion.V_7_0_0
+            TransportVersions.V_7_0_0
         );
 
         Map<String, Object> field = Map.of("runtime_field_foo", Map.of("type", "keyword", "script", ""));
@@ -137,7 +138,7 @@ public void testRemoteClusterVersionCheck() {
         assertThat(
             ex.getMessage(),
             containsString(
-                "remote clusters are expected to run at least config version [7.11.0] (reason: [runtime_mappings]), "
+                "remote clusters are expected to run at least transport version [7110099] (reason: [runtime_mappings]), "
                     + "but the following clusters were too old: [old_cluster_1]"
             )
         );

From c6f4cb49143729128c05b104fa383e07b3884061 Mon Sep 17 00:00:00 2001
From: Mary Gouseti <mary.gouseti@elastic.co>
Date: Thu, 28 Sep 2023 15:55:39 +0300
Subject: [PATCH 10/32] Inactive replica of new primary shard is green (#99995)

When we have a new initialisation of a primary shard we consider the
this indicator `green` based on the idea that this are unexceptional
events in the cluster's lifecycle. However, when we have a replica of
this shard that is inactive we turn to `yellow`.

With this PR, we change this behaviour to signal that if the primary is
inactive and that is `green`, then an inactive replica of this shard is
also `green`.

Fixes #99951
---
 docs/changelog/99995.yaml                        |  6 ++++++
 ...ShardsAvailabilityHealthIndicatorService.java | 16 +++++++++++++---
 ...sAvailabilityHealthIndicatorServiceTests.java | 13 +++++++++----
 3 files changed, 28 insertions(+), 7 deletions(-)
 create mode 100644 docs/changelog/99995.yaml

diff --git a/docs/changelog/99995.yaml b/docs/changelog/99995.yaml
new file mode 100644
index 0000000000000..d67cbdaec1f37
--- /dev/null
+++ b/docs/changelog/99995.yaml
@@ -0,0 +1,6 @@
+pr: 99995
+summary: When a primary is inactive but this is considered expected, the same applies for the replica of this shard.
+area: Health
+type: enhancement
+issues:
+ - 99951
diff --git a/server/src/main/java/org/elasticsearch/cluster/routing/allocation/ShardsAvailabilityHealthIndicatorService.java b/server/src/main/java/org/elasticsearch/cluster/routing/allocation/ShardsAvailabilityHealthIndicatorService.java
index e04e8a47349b6..9d41dd86d2ceb 100644
--- a/server/src/main/java/org/elasticsearch/cluster/routing/allocation/ShardsAvailabilityHealthIndicatorService.java
+++ b/server/src/main/java/org/elasticsearch/cluster/routing/allocation/ShardsAvailabilityHealthIndicatorService.java
@@ -402,7 +402,7 @@ private class ShardAllocationCounts {
         private final Map<Diagnosis.Definition, Set<String>> diagnosisDefinitions = new HashMap<>();
 
         public void increment(ShardRouting routing, ClusterState state, NodesShutdownMetadata shutdowns, boolean verbose) {
-            boolean isNew = isUnassignedDueToNewInitialization(routing);
+            boolean isNew = isUnassignedDueToNewInitialization(routing, state);
             boolean isRestarting = isUnassignedDueToTimelyRestart(routing, shutdowns);
             available &= routing.active() || isRestarting || isNew;
             if ((routing.active() || isRestarting || isNew) == false) {
@@ -454,8 +454,14 @@ private static boolean isUnassignedDueToTimelyRestart(ShardRouting routing, Node
         return now - restartingAllocationDelayExpiration <= 0;
     }
 
-    private static boolean isUnassignedDueToNewInitialization(ShardRouting routing) {
-        return routing.primary() && routing.active() == false && getInactivePrimaryHealth(routing) == ClusterHealthStatus.YELLOW;
+    private static boolean isUnassignedDueToNewInitialization(ShardRouting routing, ClusterState state) {
+        if (routing.active()) {
+            return false;
+        }
+        // If the primary is inactive for unexceptional events in the cluster lifecycle, both the primary and the
+        // replica are considered new initializations.
+        ShardRouting primary = routing.primary() ? routing : state.routingTable().shardRoutingTable(routing.shardId()).primaryShard();
+        return primary.active() == false && getInactivePrimaryHealth(primary) == ClusterHealthStatus.YELLOW;
     }
 
     /**
@@ -815,6 +821,7 @@ public String getSymptom() {
                 || primaries.unassigned_new > 0
                 || primaries.unassigned_restarting > 0
                 || replicas.unassigned > 0
+                || replicas.unassigned_new > 0
                 || replicas.unassigned_restarting > 0
                 || primaries.initializing > 0
                 || replicas.initializing > 0) {
@@ -822,6 +829,7 @@ public String getSymptom() {
                     Stream.of(
                         createMessage(primaries.unassigned, "unavailable primary shard", "unavailable primary shards"),
                         createMessage(primaries.unassigned_new, "creating primary shard", "creating primary shards"),
+                        createMessage(replicas.unassigned_new, "creating replica shard", "creating replica shards"),
                         createMessage(primaries.unassigned_restarting, "restarting primary shard", "restarting primary shards"),
                         createMessage(replicas.unassigned, "unavailable replica shard", "unavailable replica shards"),
                         createMessage(primaries.initializing, "initializing primary shard", "initializing primary shards"),
@@ -861,6 +869,8 @@ public HealthIndicatorDetails getDetails(boolean verbose) {
                         replicas.unassigned,
                         "initializing_replicas",
                         replicas.initializing,
+                        "creating_replicas",
+                        replicas.unassigned_new,
                         "restarting_replicas",
                         replicas.unassigned_restarting,
                         "started_replicas",
diff --git a/server/src/test/java/org/elasticsearch/cluster/routing/allocation/ShardsAvailabilityHealthIndicatorServiceTests.java b/server/src/test/java/org/elasticsearch/cluster/routing/allocation/ShardsAvailabilityHealthIndicatorServiceTests.java
index e6da007b085a3..708a3125590fd 100644
--- a/server/src/test/java/org/elasticsearch/cluster/routing/allocation/ShardsAvailabilityHealthIndicatorServiceTests.java
+++ b/server/src/test/java/org/elasticsearch/cluster/routing/allocation/ShardsAvailabilityHealthIndicatorServiceTests.java
@@ -533,8 +533,11 @@ public void testShouldBeYellowWhenRestartingReplicasReachedAllocationDelay() {
         );
     }
 
-    public void testShouldBeGreenWhenThereAreInitializingPrimaries() {
-        var clusterState = createClusterStateWith(List.of(index("restarting-index", new ShardAllocation("node-0", CREATING))), List.of());
+    public void testShouldBeGreenWhenThereAreInitializingPrimariesAndReplicas() {
+        var clusterState = createClusterStateWith(
+            List.of(index("restarting-index", new ShardAllocation("node-0", CREATING), new ShardAllocation("node-1", CREATING))),
+            List.of()
+        );
         var service = createShardsAvailabilityIndicatorService(clusterState);
 
         assertThat(
@@ -542,8 +545,8 @@ public void testShouldBeGreenWhenThereAreInitializingPrimaries() {
             equalTo(
                 createExpectedResult(
                     GREEN,
-                    "This cluster has 1 creating primary shard.",
-                    Map.of("creating_primaries", 1),
+                    "This cluster has 1 creating primary shard, 1 creating replica shard.",
+                    Map.of("creating_primaries", 1, "creating_replicas", 1),
                     emptyList(),
                     emptyList()
                 )
@@ -1765,6 +1768,8 @@ private static Map<String, Object> addDefaults(Map<String, Object> override) {
             override.getOrDefault("started_primaries", 0),
             "unassigned_replicas",
             override.getOrDefault("unassigned_replicas", 0),
+            "creating_replicas",
+            override.getOrDefault("creating_replicas", 0),
             "initializing_replicas",
             override.getOrDefault("initializing_replicas", 0),
             "restarting_replicas",

From e951d0efd02aa07cf8a1e9495b2fd045f01bd1ce Mon Sep 17 00:00:00 2001
From: Kostas Krikellas <131142368+kkrik-es@users.noreply.github.com>
Date: Thu, 28 Sep 2023 17:19:00 +0300
Subject: [PATCH 11/32] [TEST] Test that aggregate_metric_double is unsupported
 in ESQL (#99952)

* Test that aggregate_metric_double is unsupported in ESQL

* Add from-clause test
---
 .../resources/rest-api-spec/test/40_tsdb.yml  | 56 +++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/x-pack/plugin/esql/qa/server/single-node/src/yamlRestTest/resources/rest-api-spec/test/40_tsdb.yml b/x-pack/plugin/esql/qa/server/single-node/src/yamlRestTest/resources/rest-api-spec/test/40_tsdb.yml
index d72d09644a128..2e8c43379d690 100644
--- a/x-pack/plugin/esql/qa/server/single-node/src/yamlRestTest/resources/rest-api-spec/test/40_tsdb.yml
+++ b/x-pack/plugin/esql/qa/server/single-node/src/yamlRestTest/resources/rest-api-spec/test/40_tsdb.yml
@@ -60,6 +60,39 @@ setup:
           - '{"index": {}}'
           - '{"@timestamp": "2021-04-28T18:51:03.142Z", "metricset": "pod", "k8s": {"pod": {"name": "dog", "uid":"df3145b3-0563-4d3b-a0f7-897eb2876ea9", "ip": "10.10.55.3", "network": {"tx": 1434595272, "rx": 530605511}}}}'
 
+  - do:
+      indices.create:
+        index: test2
+        body:
+          settings:
+            index:
+              mode: time_series
+              routing_path: [ dim ]
+              time_series:
+                start_time: 2021-04-28T00:00:00Z
+                end_time: 2021-04-29T00:00:00Z
+          mappings:
+            properties:
+              "@timestamp":
+                type: date
+              dim:
+                type: keyword
+                time_series_dimension: true
+              agg_metric:
+                type: aggregate_metric_double
+                metrics:
+                  - max
+                default_metric: max
+  - do:
+      bulk:
+        refresh: true
+        index: test
+        body:
+          - '{"index": {}}'
+          - '{"@timestamp": "2021-04-28T18:50:04.467Z", "dim": "A", "agg_metric": {"max": 10}}'
+          - '{"index": {}}'
+          - '{"@timestamp": "2021-04-28T18:50:24.467Z", "dim": "B", "agg_metric": {"max": 20}}'
+
 ---
 load everything:
   - do:
@@ -109,3 +142,26 @@ filter on counter:
       esql.query:
         body:
           query: 'from test | where k8s.pod.network.tx == 1434577921'
+
+---
+from doc with aggregate_metric_double:
+  - do:
+      esql.query:
+        body:
+          query: 'from test2'
+
+  - match: {columns.0.name: "@timestamp"}
+  - match: {columns.0.type: "date"}
+  - match: {columns.1.name: "agg_metric"}
+  - match: {columns.1.type: "unsupported"}
+  - match: {columns.2.name: "dim"}
+  - match: {columns.2.type: "keyword"}
+  - length: {values: 0}
+
+---
+stats on aggregate_metric_double:
+  - do:
+      catch: /Cannot use field \[agg_metric\] with unsupported type \[aggregate_metric_double\]/
+      esql.query:
+        body:
+          query: 'FROM test2 | STATS max(agg_metric) BY dim '

From ddd95d568a1057402c6ef9d479667ad1c1736c83 Mon Sep 17 00:00:00 2001
From: David Roberts <dave.roberts@elastic.co>
Date: Thu, 28 Sep 2023 16:16:05 +0100
Subject: [PATCH 12/32] [Transform] Hide the fromVersion method of
 TransformConfigVersion (#100008)

This method wasn't used anywhere, but we don't want to allow
anyone to use it in the future.
---
 .../xpack/core/transform/TransformConfigVersion.java           | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/transform/TransformConfigVersion.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/transform/TransformConfigVersion.java
index acc10008cd40f..3d6a1aef8477a 100644
--- a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/transform/TransformConfigVersion.java
+++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/transform/TransformConfigVersion.java
@@ -302,7 +302,8 @@ public static TransformConfigVersion max(TransformConfigVersion version1, Transf
         return version1.id > version2.id ? version1 : version2;
     }
 
-    public static TransformConfigVersion fromVersion(Version version) {
+    // Visible only for testing
+    static TransformConfigVersion fromVersion(Version version) {
         if (version.equals(Version.V_8_10_0)) {
             return V_10;
         }

From 517a5425c569c5b0c2b5c0be6b6a3810c21f63ff Mon Sep 17 00:00:00 2001
From: Armin Braun <me@obrown.io>
Date: Thu, 28 Sep 2023 17:55:00 +0200
Subject: [PATCH 13/32] Deduplicate fields in FieldCaps intra-cluster messages
 (#100022)

We have a stable equality check for individual fields capabilities.
Even in the dynamic mapping case where mappings vary across indices, we
tend to have a lot of overlap across mappings. By dedplicating the
individual field capabilities instances when serializing we can reduce
the size of the field caps messages massively in many cases.

A repeated field takes up only an extra ~4 bytes in the transport
message which compared to tens of MB in the general case.
Even if deduplication were to never apply this change should reduce
response sizes though as it only adds about ~4 bytes in overhead for a
never deduplicated field but saves the redundant double writing of field
names we used to do (we wrote them both in the map key and in the value)
and it seems safe to assume that almost all field names are longer than
4 bytes.
---
 .../org/elasticsearch/TransportVersions.java  |  2 +
 .../FieldCapabilitiesIndexResponse.java       | 67 ++++++++++++++++++-
 2 files changed, 68 insertions(+), 1 deletion(-)

diff --git a/server/src/main/java/org/elasticsearch/TransportVersions.java b/server/src/main/java/org/elasticsearch/TransportVersions.java
index 926cc4801dddc..5f120134acb04 100644
--- a/server/src/main/java/org/elasticsearch/TransportVersions.java
+++ b/server/src/main/java/org/elasticsearch/TransportVersions.java
@@ -145,6 +145,8 @@ static TransportVersion def(int id) {
     public static final TransportVersion WAIT_FOR_CLUSTER_STATE_IN_RECOVERY_ADDED = def(8_502_00_0);
     public static final TransportVersion RECOVERY_COMMIT_TOO_NEW_EXCEPTION_ADDED = def(8_503_00_0);
     public static final TransportVersion NODE_INFO_COMPONENT_VERSIONS_ADDED = def(8_504_00_0);
+
+    public static final TransportVersion COMPACT_FIELD_CAPS_ADDED = def(8_505_00_0);
     /*
      * STOP! READ THIS FIRST! No, really,
      *        ____ _____ ___  ____  _        ____  _____    _    ____    _____ _   _ ___ ____    _____ ___ ____  ____ _____ _
diff --git a/server/src/main/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesIndexResponse.java b/server/src/main/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesIndexResponse.java
index b1f844ed66215..e9e3a05169afc 100644
--- a/server/src/main/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesIndexResponse.java
+++ b/server/src/main/java/org/elasticsearch/action/fieldcaps/FieldCapabilitiesIndexResponse.java
@@ -13,11 +13,13 @@
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.common.io.stream.Writeable;
+import org.elasticsearch.common.util.Maps;
 import org.elasticsearch.core.Nullable;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -67,6 +69,8 @@ public void writeTo(StreamOutput out) throws IOException {
         }
     }
 
+    private record CompressedGroup(String[] indices, String mappingHash, int[] fields) {}
+
     static List<FieldCapabilitiesIndexResponse> readList(StreamInput input) throws IOException {
         if (input.getTransportVersion().before(MAPPING_HASH_VERSION)) {
             return input.readCollectionAsList(FieldCapabilitiesIndexResponse::new);
@@ -77,6 +81,37 @@ static List<FieldCapabilitiesIndexResponse> readList(StreamInput input) throws I
             responses.add(new FieldCapabilitiesIndexResponse(input));
         }
         final int groups = input.readVInt();
+        if (input.getTransportVersion().onOrAfter(TransportVersions.COMPACT_FIELD_CAPS_ADDED)) {
+            collectCompressedResponses(input, groups, responses);
+        } else {
+            collectResponsesLegacyFormat(input, groups, responses);
+        }
+        return responses;
+    }
+
+    private static void collectCompressedResponses(StreamInput input, int groups, ArrayList<FieldCapabilitiesIndexResponse> responses)
+        throws IOException {
+        final CompressedGroup[] compressedGroups = new CompressedGroup[groups];
+        for (int i = 0; i < groups; i++) {
+            final String[] indices = input.readStringArray();
+            final String mappingHash = input.readString();
+            compressedGroups[i] = new CompressedGroup(indices, mappingHash, input.readIntArray());
+        }
+        final IndexFieldCapabilities[] ifcLookup = input.readArray(IndexFieldCapabilities::readFrom, IndexFieldCapabilities[]::new);
+        for (CompressedGroup compressedGroup : compressedGroups) {
+            final Map<String, IndexFieldCapabilities> ifc = Maps.newMapWithExpectedSize(compressedGroup.fields.length);
+            for (int i : compressedGroup.fields) {
+                var val = ifcLookup[i];
+                ifc.put(val.name(), val);
+            }
+            for (String index : compressedGroup.indices) {
+                responses.add(new FieldCapabilitiesIndexResponse(index, compressedGroup.mappingHash, ifc, true));
+            }
+        }
+    }
+
+    private static void collectResponsesLegacyFormat(StreamInput input, int groups, ArrayList<FieldCapabilitiesIndexResponse> responses)
+        throws IOException {
         for (int i = 0; i < groups; i++) {
             final List<String> indices = input.readStringCollectionAsList();
             final String mappingHash = input.readString();
@@ -85,7 +120,6 @@ static List<FieldCapabilitiesIndexResponse> readList(StreamInput input) throws I
                 responses.add(new FieldCapabilitiesIndexResponse(index, mappingHash, ifc, true));
             }
         }
-        return responses;
     }
 
     static void writeList(StreamOutput output, List<FieldCapabilitiesIndexResponse> responses) throws IOException {
@@ -103,7 +137,19 @@ static void writeList(StreamOutput output, List<FieldCapabilitiesIndexResponse>
                 ungroupedResponses.add(r);
             }
         }
+
         output.writeCollection(ungroupedResponses);
+        if (output.getTransportVersion().onOrAfter(TransportVersions.COMPACT_FIELD_CAPS_ADDED)) {
+            writeCompressedResponses(output, groupedResponsesMap);
+        } else {
+            writeResponsesLegacyFormat(output, groupedResponsesMap);
+        }
+    }
+
+    private static void writeResponsesLegacyFormat(
+        StreamOutput output,
+        Map<String, List<FieldCapabilitiesIndexResponse>> groupedResponsesMap
+    ) throws IOException {
         output.writeCollection(groupedResponsesMap.values(), (o, fieldCapabilitiesIndexResponses) -> {
             o.writeCollection(fieldCapabilitiesIndexResponses, (oo, r) -> oo.writeString(r.indexName));
             var first = fieldCapabilitiesIndexResponses.get(0);
@@ -112,6 +158,25 @@ static void writeList(StreamOutput output, List<FieldCapabilitiesIndexResponse>
         });
     }
 
+    private static void writeCompressedResponses(StreamOutput output, Map<String, List<FieldCapabilitiesIndexResponse>> groupedResponsesMap)
+        throws IOException {
+        final Map<IndexFieldCapabilities, Integer> fieldDedupMap = new LinkedHashMap<>();
+        output.writeCollection(groupedResponsesMap.values(), (o, fieldCapabilitiesIndexResponses) -> {
+            o.writeCollection(fieldCapabilitiesIndexResponses, (oo, r) -> oo.writeString(r.indexName));
+            var first = fieldCapabilitiesIndexResponses.get(0);
+            o.writeString(first.indexMappingHash);
+            o.writeVInt(first.responseMap.size());
+            for (IndexFieldCapabilities ifc : first.responseMap.values()) {
+                Integer offset = fieldDedupMap.size();
+                final Integer found = fieldDedupMap.putIfAbsent(ifc, offset);
+                o.writeInt(found == null ? offset : found);
+            }
+        });
+        // this is a linked hash map so the key-set is written in insertion order, so we can just write it out in order and then read it
+        // back as an array of FieldCapabilitiesIndexResponse in #collectCompressedResponses to use as a lookup
+        output.writeCollection(fieldDedupMap.keySet());
+    }
+
     /**
      * Get the index name
      */

From 246e8324c8531e3821d3498e15477160874fe99a Mon Sep 17 00:00:00 2001
From: David Kyle <david.kyle@elastic.co>
Date: Thu, 28 Sep 2023 17:34:26 +0100
Subject: [PATCH 14/32] [ML] Handle malformed inference result  (#100023)

Improved logging and best attempt at handling what is
expected to be a rare edge case
---
 .../process/PyTorchResultProcessor.java       | 38 +++++++++++++++----
 .../process/PyTorchResultProcessorTests.java  | 17 +++++++++
 2 files changed, 47 insertions(+), 8 deletions(-)

diff --git a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/pytorch/process/PyTorchResultProcessor.java b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/pytorch/process/PyTorchResultProcessor.java
index 6b92a9349c4ea..4b925464d985b 100644
--- a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/pytorch/process/PyTorchResultProcessor.java
+++ b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/pytorch/process/PyTorchResultProcessor.java
@@ -107,17 +107,19 @@ public void process(PyTorchProcess process) {
 
                 if (result.inferenceResult() != null) {
                     processInferenceResult(result);
-                }
-                ThreadSettings threadSettings = result.threadSettings();
-                if (threadSettings != null) {
-                    threadSettingsConsumer.accept(threadSettings);
+                } else if (result.threadSettings() != null) {
+                    threadSettingsConsumer.accept(result.threadSettings());
                     processThreadSettings(result);
-                }
-                if (result.ackResult() != null) {
+                } else if (result.ackResult() != null) {
                     processAcknowledgement(result);
-                }
-                if (result.errorResult() != null) {
+                } else if (result.errorResult() != null) {
                     processErrorResult(result);
+                } else {
+                    // will should only get here if the native process
+                    // has produced a partially valid result, one that
+                    // is accepted by the parser but does not have any
+                    // content
+                    handleUnknownResultType(result);
                 }
             }
         } catch (Exception e) {
@@ -208,6 +210,26 @@ void processErrorResult(PyTorchResult result) {
         }
     }
 
+    void handleUnknownResultType(PyTorchResult result) {
+        if (result.requestId() != null) {
+            PendingResult pendingResult = pendingResults.remove(result.requestId());
+            if (pendingResult == null) {
+                logger.error(() -> format("[%s] no pending result listener for unknown result type [%s]", modelId, result));
+            } else {
+                String msg = format("[%s] pending result listener cannot handle unknown result type [%s]", modelId, result);
+                logger.error(msg);
+                var errorResult = new ErrorResult(msg);
+                pendingResult.listener.onResponse(new PyTorchResult(result.requestId(), null, null, null, null, null, errorResult));
+            }
+        } else {
+            // Cannot look up the listener without a request id
+            // all that can be done in this case is log a message.
+            // The result parser requires a request id so this
+            // code should not be hit.
+            logger.error(() -> format("[%s] cannot process unknown result type [%s]", modelId, result));
+        }
+    }
+
     public synchronized ResultStats getResultStats() {
         long currentMs = currentTimeMsSupplier.getAsLong();
         long currentPeriodStartTimeMs = startTime + Intervals.alignToFloor(currentMs - startTime, REPORTING_PERIOD_MS);
diff --git a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/pytorch/process/PyTorchResultProcessorTests.java b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/pytorch/process/PyTorchResultProcessorTests.java
index e172f4ffb528c..860da3140f4fe 100644
--- a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/pytorch/process/PyTorchResultProcessorTests.java
+++ b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/pytorch/process/PyTorchResultProcessorTests.java
@@ -153,6 +153,23 @@ public void testPendingRequestAreCalledAtShutdown() {
         }
     }
 
+    public void testsHandleUnknownResult() {
+        var processor = new PyTorchResultProcessor("deployment-foo", settings -> {});
+        var listener = new AssertingResultListener(
+            r -> assertThat(
+                r.errorResult().error(),
+                containsString("[deployment-foo] pending result listener cannot handle unknown result type")
+            )
+        );
+
+        processor.registerRequest("no-result-content", listener);
+
+        processor.process(
+            mockNativeProcess(List.of(new PyTorchResult("no-result-content", null, null, null, null, null, null)).iterator())
+        );
+        assertTrue(listener.hasResponse);
+    }
+
     private static class AssertingResultListener implements ActionListener<PyTorchResult> {
         boolean hasResponse;
         final Consumer<PyTorchResult> responseAsserter;

From 0e219307f2d63bcbfc4357c75bf7c4b510801e21 Mon Sep 17 00:00:00 2001
From: Nik Everett <nik9000@gmail.com>
Date: Thu, 28 Sep 2023 13:17:08 -0400
Subject: [PATCH 15/32] ESQL: Track blocks (#100025)

This tracks blocks from topn and a few other places. We're going to try
and track blocks all the places.
---
 .../compute/operator/TopNBenchmark.java       |   2 +
 .../org/elasticsearch/core/Releasables.java   |   2 +-
 .../common/util/BytesRefArray.java            |   9 +-
 .../common/util/MockBigArrays.java            |   8 +-
 .../indices/CrankyCircuitBreakerService.java  |  15 +-
 .../compute/data/BooleanArrayBlock.java       |   1 +
 .../compute/data/BooleanBlockBuilder.java     |  16 +-
 .../compute/data/BooleanVectorBuilder.java    |  13 +-
 .../data/BooleanVectorFixedBuilder.java       |   8 +
 .../compute/data/BytesRefArrayBlock.java      |   3 +-
 .../compute/data/BytesRefArrayVector.java     |   2 +-
 .../compute/data/BytesRefBlockBuilder.java    |  29 +++-
 .../compute/data/BytesRefVectorBuilder.java   |  30 +++-
 .../compute/data/DoubleArrayBlock.java        |   1 +
 .../compute/data/DoubleBlockBuilder.java      |  16 +-
 .../compute/data/DoubleVectorBuilder.java     |  13 +-
 .../data/DoubleVectorFixedBuilder.java        |   8 +
 .../compute/data/IntArrayBlock.java           |   1 +
 .../compute/data/IntBlockBuilder.java         |  16 +-
 .../compute/data/IntVectorBuilder.java        |  13 +-
 .../compute/data/IntVectorFixedBuilder.java   |   8 +
 .../compute/data/LongArrayBlock.java          |   1 +
 .../compute/data/LongBlockBuilder.java        |  16 +-
 .../compute/data/LongVectorBuilder.java       |  13 +-
 .../compute/data/LongVectorFixedBuilder.java  |   8 +
 .../topn/ResultBuilderForBoolean.java         |  10 +-
 .../topn/ResultBuilderForBytesRef.java        |  10 +-
 .../operator/topn/ResultBuilderForDouble.java |  10 +-
 .../operator/topn/ResultBuilderForInt.java    |  10 +-
 .../operator/topn/ResultBuilderForLong.java   |  10 +-
 .../compute/data/AbstractBlockBuilder.java    |  34 ++++
 .../compute/data/AbstractVectorBuilder.java   |  41 ++++-
 .../org/elasticsearch/compute/data/Block.java |   6 +-
 .../compute/data/BlockFactory.java            |   4 +-
 .../compute/data/BlockUtils.java              |   2 +-
 .../compute/data/ConstantNullBlock.java       |  14 ++
 .../elasticsearch/compute/data/DocBlock.java  |  17 +-
 .../compute/data/ElementType.java             |  25 ++-
 .../elasticsearch/compute/data/Vector.java    |   6 +-
 .../compute/data/X-ArrayBlock.java.st         |   3 +-
 .../compute/data/X-ArrayVector.java.st        |   2 +-
 .../compute/data/X-BlockBuilder.java.st       |  55 +++++-
 .../compute/data/X-VectorBuilder.java.st      |  48 +++++-
 .../compute/data/X-VectorFixedBuilder.java.st |   8 +
 .../compute/operator/Driver.java              |   8 +-
 .../exchange/ExchangeSinkOperator.java        |   4 -
 .../compute/operator/topn/ResultBuilder.java  |  26 ++-
 .../operator/topn/ResultBuilderForDoc.java    |  16 +-
 .../operator/topn/ResultBuilderForNull.java   |  13 +-
 .../compute/operator/topn/TopNOperator.java   |  67 ++++++--
 .../operator/topn/X-ResultBuilder.java.st     |  10 +-
 .../elasticsearch/compute/OperatorTests.java  |   2 +-
 .../AggregatorFunctionTestCase.java           |   8 +-
 .../CountAggregatorFunctionTests.java         |   5 +-
 ...istinctBooleanAggregatorFunctionTests.java |   3 +-
 ...ooleanGroupingAggregatorFunctionTests.java |   3 +-
 ...stinctBytesRefAggregatorFunctionTests.java |   3 +-
 ...tesRefGroupingAggregatorFunctionTests.java |   3 +-
 ...DistinctDoubleAggregatorFunctionTests.java |   3 +-
 ...DoubleGroupingAggregatorFunctionTests.java |   3 +-
 ...untDistinctIntAggregatorFunctionTests.java |   2 +-
 ...nctIntGroupingAggregatorFunctionTests.java |   3 +-
 ...ntDistinctLongAggregatorFunctionTests.java |   4 +-
 ...ctLongGroupingAggregatorFunctionTests.java |   4 +-
 .../CountGroupingAggregatorFunctionTests.java |   4 +-
 .../GroupingAggregatorFunctionTestCase.java   |  28 +--
 .../MaxDoubleAggregatorFunctionTests.java     |   3 +-
 ...DoubleGroupingAggregatorFunctionTests.java |   3 +-
 .../MaxIntAggregatorFunctionTests.java        |   3 +-
 ...MaxIntGroupingAggregatorFunctionTests.java |   3 +-
 .../MaxLongAggregatorFunctionTests.java       |   5 +-
 ...axLongGroupingAggregatorFunctionTests.java |   8 +-
 ...eviationDoubleAggregatorFunctionTests.java |   3 +-
 ...DoubleGroupingAggregatorFunctionTests.java |   3 +-
 ...teDeviationIntAggregatorFunctionTests.java |   3 +-
 ...ionIntGroupingAggregatorFunctionTests.java |   3 +-
 ...eDeviationLongAggregatorFunctionTests.java |   5 +-
 ...onLongGroupingAggregatorFunctionTests.java |   5 +-
 .../MinDoubleAggregatorFunctionTests.java     |   3 +-
 ...DoubleGroupingAggregatorFunctionTests.java |   3 +-
 .../MinIntAggregatorFunctionTests.java        |   3 +-
 ...MinIntGroupingAggregatorFunctionTests.java |   3 +-
 .../MinLongAggregatorFunctionTests.java       |   5 +-
 ...inLongGroupingAggregatorFunctionTests.java |   8 +-
 ...rcentileDoubleAggregatorFunctionTests.java |   3 +-
 ...DoubleGroupingAggregatorFunctionTests.java |   3 +-
 .../PercentileIntAggregatorFunctionTests.java |   3 +-
 ...ileIntGroupingAggregatorFunctionTests.java |   3 +-
 ...PercentileLongAggregatorFunctionTests.java |   5 +-
 ...leLongGroupingAggregatorFunctionTests.java |   4 +-
 .../SumDoubleAggregatorFunctionTests.java     |   3 +-
 ...DoubleGroupingAggregatorFunctionTests.java |   3 +-
 .../SumIntAggregatorFunctionTests.java        |   2 +-
 ...SumIntGroupingAggregatorFunctionTests.java |   3 +-
 .../SumLongAggregatorFunctionTests.java       |   6 +-
 ...umLongGroupingAggregatorFunctionTests.java |   4 +-
 .../compute/data/BlockBuilderTests.java       | 146 +++++++++++++---
 .../compute/data/BlockFactoryTests.java       |  28 ++-
 .../compute/data/BlockTestUtils.java          |   1 +
 .../data/BytesRefBlockEqualityTests.java      |  37 ++--
 .../compute/data/DocVectorTests.java          |  57 ++++---
 .../data/DoubleBlockEqualityTests.java        |  37 ++--
 .../compute/data/IntBlockEqualityTests.java   |  37 ++--
 .../compute/data/LongBlockEqualityTests.java  |  39 +++--
 .../compute/data/TestBlockBuilder.java        |  25 +++
 .../compute/data/VectorBuilderTests.java      | 153 +++++++++++++++++
 .../compute/data/VectorFixedBuilderTests.java |  39 +++--
 .../ValuesSourceReaderOperatorTests.java      |  30 +++-
 .../operator/AggregationOperatorTests.java    |   5 +-
 .../compute/operator/AnyOperatorTestCase.java |   2 +-
 .../operator/CannedSourceOperator.java        |  25 ++-
 .../operator/ColumnExtractOperatorTests.java  |   3 +-
 .../compute/operator/EvalOperatorTests.java   |   5 +-
 .../compute/operator/FilterOperatorTests.java |   5 +-
 .../operator/ForkingOperatorTestCase.java     |  12 +-
 .../HashAggregationOperatorTests.java         |   8 +-
 .../compute/operator/LimitOperatorTests.java  |   5 +-
 .../operator/MvExpandOperatorTests.java       |   3 +-
 .../compute/operator/OperatorTestCase.java    |  50 ++++--
 .../operator/ProjectOperatorTests.java        |   2 +-
 .../SequenceLongBlockSourceOperator.java      |  18 +-
 .../operator/StringExtractOperatorTests.java  |   3 +-
 .../operator/TupleBlockSourceOperator.java    |  12 +-
 .../compute/operator/topn/ExtractorTests.java |  17 +-
 .../operator/topn/TopNOperatorTests.java      | 160 +++++++++++++++---
 .../rest-api-spec/test/50_index_patterns.yml  |  59 +++----
 .../metadata-ignoreCsvTests.csv-spec          |   3 +-
 .../xpack/esql/action/EsqlActionIT.java       | 145 ++++++++--------
 .../xpack/esql/action/EsqlDisruptionIT.java   |   4 +
 129 files changed, 1592 insertions(+), 486 deletions(-)
 create mode 100644 x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/VectorBuilderTests.java

diff --git a/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/TopNBenchmark.java b/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/TopNBenchmark.java
index 9ef4eef2a6924..84f7cec47b737 100644
--- a/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/TopNBenchmark.java
+++ b/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/TopNBenchmark.java
@@ -13,6 +13,7 @@
 import org.elasticsearch.common.settings.ClusterSettings;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.BooleanBlock;
 import org.elasticsearch.compute.data.BytesRefBlock;
 import org.elasticsearch.compute.data.DoubleBlock;
@@ -107,6 +108,7 @@ private static Operator operator(String data, int topCount) {
             ClusterSettings.createBuiltInClusterSettings()
         );
         return new TopNOperator(
+            BlockFactory.getNonBreakingInstance(),
             breakerService.getBreaker(CircuitBreaker.REQUEST),
             topCount,
             elementTypes,
diff --git a/libs/core/src/main/java/org/elasticsearch/core/Releasables.java b/libs/core/src/main/java/org/elasticsearch/core/Releasables.java
index b8d1a9a542779..c2b48c4706573 100644
--- a/libs/core/src/main/java/org/elasticsearch/core/Releasables.java
+++ b/libs/core/src/main/java/org/elasticsearch/core/Releasables.java
@@ -89,7 +89,7 @@ private static void close(boolean success, Releasable... releasables) {
      *  // the resources will be released when reaching here
      *  </pre>
      */
-    public static Releasable wrap(final Iterable<Releasable> releasables) {
+    public static Releasable wrap(final Iterable<? extends Releasable> releasables) {
         return new Releasable() {
             @Override
             public void close() {
diff --git a/server/src/main/java/org/elasticsearch/common/util/BytesRefArray.java b/server/src/main/java/org/elasticsearch/common/util/BytesRefArray.java
index de061c7f314d6..91dbfc30123fe 100644
--- a/server/src/main/java/org/elasticsearch/common/util/BytesRefArray.java
+++ b/server/src/main/java/org/elasticsearch/common/util/BytesRefArray.java
@@ -160,7 +160,14 @@ public void writeTo(StreamOutput out) throws IOException {
 
     @Override
     public long ramBytesUsed() {
-        return BASE_RAM_BYTES_USED + startOffsets.ramBytesUsed() + bytes.ramBytesUsed();
+        return BASE_RAM_BYTES_USED + bigArraysRamBytesUsed();
+    }
+
+    /**
+     * Memory used by the {@link BigArrays} portion of this {@link BytesRefArray}.
+     */
+    public long bigArraysRamBytesUsed() {
+        return startOffsets.ramBytesUsed() + bytes.ramBytesUsed();
     }
 
 }
diff --git a/test/framework/src/main/java/org/elasticsearch/common/util/MockBigArrays.java b/test/framework/src/main/java/org/elasticsearch/common/util/MockBigArrays.java
index 02e8cfd7f16fc..0a0592b5a01f2 100644
--- a/test/framework/src/main/java/org/elasticsearch/common/util/MockBigArrays.java
+++ b/test/framework/src/main/java/org/elasticsearch/common/util/MockBigArrays.java
@@ -678,6 +678,9 @@ public void addEstimateBytesAndMaybeBreak(long bytes, String label) throws Circu
             while (true) {
                 long old = used.get();
                 long total = old + bytes;
+                if (total < 0) {
+                    throw new AssertionError("total must be >= 0 but was [" + total + "]");
+                }
                 if (total > max.getBytes()) {
                     throw new CircuitBreakingException(ERROR_MESSAGE, bytes, max.getBytes(), Durability.TRANSIENT);
                 }
@@ -689,7 +692,10 @@ public void addEstimateBytesAndMaybeBreak(long bytes, String label) throws Circu
 
         @Override
         public void addWithoutBreaking(long bytes) {
-            used.addAndGet(bytes);
+            long total = used.addAndGet(bytes);
+            if (total < 0) {
+                throw new AssertionError("total must be >= 0 but was [" + total + "]");
+            }
         }
 
         @Override
diff --git a/test/framework/src/main/java/org/elasticsearch/indices/CrankyCircuitBreakerService.java b/test/framework/src/main/java/org/elasticsearch/indices/CrankyCircuitBreakerService.java
index 15ffa52569d00..bd5f974a5f800 100644
--- a/test/framework/src/main/java/org/elasticsearch/indices/CrankyCircuitBreakerService.java
+++ b/test/framework/src/main/java/org/elasticsearch/indices/CrankyCircuitBreakerService.java
@@ -15,6 +15,8 @@
 import org.elasticsearch.indices.breaker.CircuitBreakerStats;
 import org.elasticsearch.test.ESTestCase;
 
+import java.util.concurrent.atomic.AtomicLong;
+
 /**
  * {@link CircuitBreakerService} that fails one twentieth of the time when you
  * add bytes. This is useful to make sure code responds sensibly to circuit
@@ -27,31 +29,32 @@ public class CrankyCircuitBreakerService extends CircuitBreakerService {
     public static final String ERROR_MESSAGE = "cranky breaker";
 
     private final CircuitBreaker breaker = new CircuitBreaker() {
-        @Override
-        public void circuitBreak(String fieldName, long bytesNeeded) {
+        private final AtomicLong used = new AtomicLong();
 
-        }
+        @Override
+        public void circuitBreak(String fieldName, long bytesNeeded) {}
 
         @Override
         public void addEstimateBytesAndMaybeBreak(long bytes, String label) throws CircuitBreakingException {
             if (ESTestCase.random().nextInt(20) == 0) {
                 throw new CircuitBreakingException(ERROR_MESSAGE, Durability.PERMANENT);
             }
+            used.addAndGet(bytes);
         }
 
         @Override
         public void addWithoutBreaking(long bytes) {
-
+            used.addAndGet(bytes);
         }
 
         @Override
         public long getUsed() {
-            return 0;
+            return used.get();
         }
 
         @Override
         public long getLimit() {
-            return 0;
+            return Long.MAX_VALUE;
         }
 
         @Override
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanArrayBlock.java
index d8a5e471aaf84..b6e36e698355b 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanArrayBlock.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanArrayBlock.java
@@ -75,6 +75,7 @@ public BooleanBlock expand() {
     public static long ramBytesEstimated(boolean[] values, int[] firstValueIndexes, BitSet nullsMask) {
         return BASE_RAM_BYTES_USED + RamUsageEstimator.sizeOf(values) + BlockRamUsageEstimator.sizeOf(firstValueIndexes)
             + BlockRamUsageEstimator.sizeOfBitSet(nullsMask) + RamUsageEstimator.shallowSizeOfInstance(MvOrdering.class);
+        // TODO mvordering is shared
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanBlockBuilder.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanBlockBuilder.java
index a7d397fcfb98e..98b9fdb948bc0 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanBlockBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanBlockBuilder.java
@@ -7,6 +7,8 @@
 
 package org.elasticsearch.compute.data;
 
+import org.apache.lucene.util.RamUsageEstimator;
+
 import java.util.Arrays;
 
 /**
@@ -20,7 +22,7 @@ final class BooleanBlockBuilder extends AbstractBlockBuilder implements BooleanB
     BooleanBlockBuilder(int estimatedSize, BlockFactory blockFactory) {
         super(blockFactory);
         int initialSize = Math.max(estimatedSize, 2);
-        adjustBreaker(initialSize);
+        adjustBreaker(RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + initialSize * elementSize());
         values = new boolean[initialSize];
     }
 
@@ -192,8 +194,16 @@ public BooleanBlock build() {
                 block = new BooleanArrayBlock(values, positionCount, firstValueIndexes, nullsMask, mvOrdering, blockFactory);
             }
         }
-        // update the breaker with the actual bytes used.
-        blockFactory.adjustBreaker(block.ramBytesUsed() - estimatedBytes, true);
+        /*
+         * Update the breaker with the actual bytes used.
+         * We pass false below even though we've used the bytes. That's weird,
+         * but if we break here we will throw away the used memory, letting
+         * it be deallocated. The exception will bubble up and the builder will
+         * still technically be open, meaning the calling code should close it
+         * which will return all used memory to the breaker.
+         */
+        blockFactory.adjustBreaker(block.ramBytesUsed() - estimatedBytes, false);
+        built();
         return block;
     }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanVectorBuilder.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanVectorBuilder.java
index 45c74ee6e06d4..3792e39275f82 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanVectorBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanVectorBuilder.java
@@ -49,6 +49,7 @@ protected void growValuesArray(int newSize) {
 
     @Override
     public BooleanVector build() {
+        finish();
         BooleanVector vector;
         if (valueCount == 1) {
             vector = new ConstantBooleanVector(values[0], 1, blockFactory);
@@ -58,8 +59,16 @@ public BooleanVector build() {
             }
             vector = new BooleanArrayVector(values, valueCount, blockFactory);
         }
-        // update the breaker with the actual bytes used.
-        blockFactory.adjustBreaker(vector.ramBytesUsed() - estimatedBytes, true);
+        /*
+         * Update the breaker with the actual bytes used.
+         * We pass false below even though we've used the bytes. That's weird,
+         * but if we break here we will throw away the used memory, letting
+         * it be deallocated. The exception will bubble up and the builder will
+         * still technically be open, meaning the calling code should close it
+         * which will return all used memory to the breaker.
+         */
+        blockFactory.adjustBreaker(vector.ramBytesUsed() - estimatedBytes, false);
+        built();
         return vector;
     }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanVectorFixedBuilder.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanVectorFixedBuilder.java
index 30146d4e55c02..1428a1a221fa3 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanVectorFixedBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanVectorFixedBuilder.java
@@ -58,4 +58,12 @@ public BooleanVector build() {
         }
         return new BooleanArrayVector(values, values.length, blockFactory);
     }
+
+    @Override
+    public void close() {
+        if (nextIndex >= 0) {
+            // If nextIndex < 0 we've already built the vector
+            blockFactory.adjustBreaker(-ramBytesUsed(values.length), false);
+        }
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayBlock.java
index e4ee70cd27a47..db5b5d3fcf804 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayBlock.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayBlock.java
@@ -77,6 +77,7 @@ public BytesRefBlock expand() {
     public static long ramBytesEstimated(BytesRefArray values, int[] firstValueIndexes, BitSet nullsMask) {
         return BASE_RAM_BYTES_USED + RamUsageEstimator.sizeOf(values) + BlockRamUsageEstimator.sizeOf(firstValueIndexes)
             + BlockRamUsageEstimator.sizeOfBitSet(nullsMask) + RamUsageEstimator.shallowSizeOfInstance(MvOrdering.class);
+        // TODO mvordering is shared
     }
 
     @Override
@@ -115,7 +116,7 @@ public void close() {
             throw new IllegalStateException("can't release already released block [" + this + "]");
         }
         released = true;
-        blockFactory.adjustBreaker(-(ramBytesUsed() - values.ramBytesUsed()), true);
+        blockFactory.adjustBreaker(-ramBytesUsed() + values.bigArraysRamBytesUsed(), true);
         Releasables.closeExpectNoException(values);
     }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayVector.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayVector.java
index c8f5276a99db5..1692bfc59358a 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayVector.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayVector.java
@@ -85,7 +85,7 @@ public String toString() {
 
     @Override
     public void close() {
-        blockFactory.adjustBreaker(-BASE_RAM_BYTES_USED, true);
+        blockFactory.adjustBreaker(-ramBytesUsed() + values.bigArraysRamBytesUsed(), true);
         Releasables.closeExpectNoException(values);
     }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefBlockBuilder.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefBlockBuilder.java
index 23c18d2a9ca6e..a60b26667eb79 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefBlockBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefBlockBuilder.java
@@ -193,19 +193,42 @@ public BytesRefBlockBuilder mvOrdering(Block.MvOrdering mvOrdering) {
     public BytesRefBlock build() {
         finish();
         BytesRefBlock block;
+        assert estimatedBytes == 0 || firstValueIndexes != null;
         if (hasNonNullValue && positionCount == 1 && valueCount == 1) {
             block = new ConstantBytesRefVector(BytesRef.deepCopyOf(values.get(0, new BytesRef())), 1, blockFactory).asBlock();
+            /*
+             * Update the breaker with the actual bytes used.
+             * We pass false below even though we've used the bytes. That's weird,
+             * but if we break here we will throw away the used memory, letting
+             * it be deallocated. The exception will bubble up and the builder will
+             * still technically be open, meaning the calling code should close it
+             * which will return all used memory to the breaker.
+             */
+            blockFactory.adjustBreaker(block.ramBytesUsed() - estimatedBytes, false);
             Releasables.closeExpectNoException(values);
         } else {
-            estimatedBytes += values.ramBytesUsed();
             if (isDense() && singleValued()) {
                 block = new BytesRefArrayVector(values, positionCount, blockFactory).asBlock();
             } else {
                 block = new BytesRefArrayBlock(values, positionCount, firstValueIndexes, nullsMask, mvOrdering, blockFactory);
             }
+            /*
+             * Update the breaker with the actual bytes used.
+             * We pass false below even though we've used the bytes. That's weird,
+             * but if we break here we will throw away the used memory, letting
+             * it be deallocated. The exception will bubble up and the builder will
+             * still technically be open, meaning the calling code should close it
+             * which will return all used memory to the breaker.
+             */
+            blockFactory.adjustBreaker(block.ramBytesUsed() - estimatedBytes - values.bigArraysRamBytesUsed(), false);
         }
-        // update the breaker with the actual bytes used.
-        blockFactory.adjustBreaker(block.ramBytesUsed() - estimatedBytes, true);
+        values = null;
+        built();
         return block;
     }
+
+    @Override
+    public void extraClose() {
+        Releasables.closeExpectNoException(values);
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefVectorBuilder.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefVectorBuilder.java
index f37ffb2a7e28a..5ea9a2b7d0184 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefVectorBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefVectorBuilder.java
@@ -54,16 +54,40 @@ protected void growValuesArray(int newSize) {
 
     @Override
     public BytesRefVector build() {
+        finish();
         BytesRefVector vector;
+        assert estimatedBytes == 0;
         if (valueCount == 1) {
             vector = new ConstantBytesRefVector(BytesRef.deepCopyOf(values.get(0, new BytesRef())), 1, blockFactory);
+            /*
+             * Update the breaker with the actual bytes used.
+             * We pass false below even though we've used the bytes. That's weird,
+             * but if we break here we will throw away the used memory, letting
+             * it be deallocated. The exception will bubble up and the builder will
+             * still technically be open, meaning the calling code should close it
+             * which will return all used memory to the breaker.
+             */
+            blockFactory.adjustBreaker(vector.ramBytesUsed(), false);
             Releasables.closeExpectNoException(values);
         } else {
-            estimatedBytes = values.ramBytesUsed();
             vector = new BytesRefArrayVector(values, valueCount, blockFactory);
+            /*
+             * Update the breaker with the actual bytes used.
+             * We pass false below even though we've used the bytes. That's weird,
+             * but if we break here we will throw away the used memory, letting
+             * it be deallocated. The exception will bubble up and the builder will
+             * still technically be open, meaning the calling code should close it
+             * which will return all used memory to the breaker.
+             */
+            blockFactory.adjustBreaker(vector.ramBytesUsed() - values.bigArraysRamBytesUsed(), false);
         }
-        // update the breaker with the actual bytes used.
-        blockFactory.adjustBreaker(vector.ramBytesUsed() - estimatedBytes, true);
+        values = null;
+        built();
         return vector;
     }
+
+    @Override
+    public void extraClose() {
+        Releasables.closeExpectNoException(values);
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleArrayBlock.java
index b0de974a85c24..675952a8d6a85 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleArrayBlock.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleArrayBlock.java
@@ -75,6 +75,7 @@ public DoubleBlock expand() {
     public static long ramBytesEstimated(double[] values, int[] firstValueIndexes, BitSet nullsMask) {
         return BASE_RAM_BYTES_USED + RamUsageEstimator.sizeOf(values) + BlockRamUsageEstimator.sizeOf(firstValueIndexes)
             + BlockRamUsageEstimator.sizeOfBitSet(nullsMask) + RamUsageEstimator.shallowSizeOfInstance(MvOrdering.class);
+        // TODO mvordering is shared
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleBlockBuilder.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleBlockBuilder.java
index a97f58f3924b1..dca8fe2d0d2e6 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleBlockBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleBlockBuilder.java
@@ -7,6 +7,8 @@
 
 package org.elasticsearch.compute.data;
 
+import org.apache.lucene.util.RamUsageEstimator;
+
 import java.util.Arrays;
 
 /**
@@ -20,7 +22,7 @@ final class DoubleBlockBuilder extends AbstractBlockBuilder implements DoubleBlo
     DoubleBlockBuilder(int estimatedSize, BlockFactory blockFactory) {
         super(blockFactory);
         int initialSize = Math.max(estimatedSize, 2);
-        adjustBreaker(initialSize);
+        adjustBreaker(RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + initialSize * elementSize());
         values = new double[initialSize];
     }
 
@@ -192,8 +194,16 @@ public DoubleBlock build() {
                 block = new DoubleArrayBlock(values, positionCount, firstValueIndexes, nullsMask, mvOrdering, blockFactory);
             }
         }
-        // update the breaker with the actual bytes used.
-        blockFactory.adjustBreaker(block.ramBytesUsed() - estimatedBytes, true);
+        /*
+         * Update the breaker with the actual bytes used.
+         * We pass false below even though we've used the bytes. That's weird,
+         * but if we break here we will throw away the used memory, letting
+         * it be deallocated. The exception will bubble up and the builder will
+         * still technically be open, meaning the calling code should close it
+         * which will return all used memory to the breaker.
+         */
+        blockFactory.adjustBreaker(block.ramBytesUsed() - estimatedBytes, false);
+        built();
         return block;
     }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleVectorBuilder.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleVectorBuilder.java
index f92ec67aec012..12fa06a944fbc 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleVectorBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleVectorBuilder.java
@@ -49,6 +49,7 @@ protected void growValuesArray(int newSize) {
 
     @Override
     public DoubleVector build() {
+        finish();
         DoubleVector vector;
         if (valueCount == 1) {
             vector = new ConstantDoubleVector(values[0], 1, blockFactory);
@@ -58,8 +59,16 @@ public DoubleVector build() {
             }
             vector = new DoubleArrayVector(values, valueCount, blockFactory);
         }
-        // update the breaker with the actual bytes used.
-        blockFactory.adjustBreaker(vector.ramBytesUsed() - estimatedBytes, true);
+        /*
+         * Update the breaker with the actual bytes used.
+         * We pass false below even though we've used the bytes. That's weird,
+         * but if we break here we will throw away the used memory, letting
+         * it be deallocated. The exception will bubble up and the builder will
+         * still technically be open, meaning the calling code should close it
+         * which will return all used memory to the breaker.
+         */
+        blockFactory.adjustBreaker(vector.ramBytesUsed() - estimatedBytes, false);
+        built();
         return vector;
     }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleVectorFixedBuilder.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleVectorFixedBuilder.java
index 83992ed71b720..b636d9eb19756 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleVectorFixedBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleVectorFixedBuilder.java
@@ -58,4 +58,12 @@ public DoubleVector build() {
         }
         return new DoubleArrayVector(values, values.length, blockFactory);
     }
+
+    @Override
+    public void close() {
+        if (nextIndex >= 0) {
+            // If nextIndex < 0 we've already built the vector
+            blockFactory.adjustBreaker(-ramBytesUsed(values.length), false);
+        }
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntArrayBlock.java
index 7a345941df019..4170009b89ab2 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntArrayBlock.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntArrayBlock.java
@@ -75,6 +75,7 @@ public IntBlock expand() {
     public static long ramBytesEstimated(int[] values, int[] firstValueIndexes, BitSet nullsMask) {
         return BASE_RAM_BYTES_USED + RamUsageEstimator.sizeOf(values) + BlockRamUsageEstimator.sizeOf(firstValueIndexes)
             + BlockRamUsageEstimator.sizeOfBitSet(nullsMask) + RamUsageEstimator.shallowSizeOfInstance(MvOrdering.class);
+        // TODO mvordering is shared
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntBlockBuilder.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntBlockBuilder.java
index 53d379d715c9b..ba96f85e73197 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntBlockBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntBlockBuilder.java
@@ -7,6 +7,8 @@
 
 package org.elasticsearch.compute.data;
 
+import org.apache.lucene.util.RamUsageEstimator;
+
 import java.util.Arrays;
 
 /**
@@ -20,7 +22,7 @@ final class IntBlockBuilder extends AbstractBlockBuilder implements IntBlock.Bui
     IntBlockBuilder(int estimatedSize, BlockFactory blockFactory) {
         super(blockFactory);
         int initialSize = Math.max(estimatedSize, 2);
-        adjustBreaker(initialSize);
+        adjustBreaker(RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + initialSize * elementSize());
         values = new int[initialSize];
     }
 
@@ -192,8 +194,16 @@ public IntBlock build() {
                 block = new IntArrayBlock(values, positionCount, firstValueIndexes, nullsMask, mvOrdering, blockFactory);
             }
         }
-        // update the breaker with the actual bytes used.
-        blockFactory.adjustBreaker(block.ramBytesUsed() - estimatedBytes, true);
+        /*
+         * Update the breaker with the actual bytes used.
+         * We pass false below even though we've used the bytes. That's weird,
+         * but if we break here we will throw away the used memory, letting
+         * it be deallocated. The exception will bubble up and the builder will
+         * still technically be open, meaning the calling code should close it
+         * which will return all used memory to the breaker.
+         */
+        blockFactory.adjustBreaker(block.ramBytesUsed() - estimatedBytes, false);
+        built();
         return block;
     }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntVectorBuilder.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntVectorBuilder.java
index 0533d5463a4e7..155adfec02b9f 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntVectorBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntVectorBuilder.java
@@ -49,6 +49,7 @@ protected void growValuesArray(int newSize) {
 
     @Override
     public IntVector build() {
+        finish();
         IntVector vector;
         if (valueCount == 1) {
             vector = new ConstantIntVector(values[0], 1, blockFactory);
@@ -58,8 +59,16 @@ public IntVector build() {
             }
             vector = new IntArrayVector(values, valueCount, blockFactory);
         }
-        // update the breaker with the actual bytes used.
-        blockFactory.adjustBreaker(vector.ramBytesUsed() - estimatedBytes, true);
+        /*
+         * Update the breaker with the actual bytes used.
+         * We pass false below even though we've used the bytes. That's weird,
+         * but if we break here we will throw away the used memory, letting
+         * it be deallocated. The exception will bubble up and the builder will
+         * still technically be open, meaning the calling code should close it
+         * which will return all used memory to the breaker.
+         */
+        blockFactory.adjustBreaker(vector.ramBytesUsed() - estimatedBytes, false);
+        built();
         return vector;
     }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntVectorFixedBuilder.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntVectorFixedBuilder.java
index 19303b4024869..03a15fb10a800 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntVectorFixedBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntVectorFixedBuilder.java
@@ -58,4 +58,12 @@ public IntVector build() {
         }
         return new IntArrayVector(values, values.length, blockFactory);
     }
+
+    @Override
+    public void close() {
+        if (nextIndex >= 0) {
+            // If nextIndex < 0 we've already built the vector
+            blockFactory.adjustBreaker(-ramBytesUsed(values.length), false);
+        }
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongArrayBlock.java
index 21c6b445cd37d..778ec4294180c 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongArrayBlock.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongArrayBlock.java
@@ -75,6 +75,7 @@ public LongBlock expand() {
     public static long ramBytesEstimated(long[] values, int[] firstValueIndexes, BitSet nullsMask) {
         return BASE_RAM_BYTES_USED + RamUsageEstimator.sizeOf(values) + BlockRamUsageEstimator.sizeOf(firstValueIndexes)
             + BlockRamUsageEstimator.sizeOfBitSet(nullsMask) + RamUsageEstimator.shallowSizeOfInstance(MvOrdering.class);
+        // TODO mvordering is shared
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongBlockBuilder.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongBlockBuilder.java
index a378b382ce31e..09d858e7c9b03 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongBlockBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongBlockBuilder.java
@@ -7,6 +7,8 @@
 
 package org.elasticsearch.compute.data;
 
+import org.apache.lucene.util.RamUsageEstimator;
+
 import java.util.Arrays;
 
 /**
@@ -20,7 +22,7 @@ final class LongBlockBuilder extends AbstractBlockBuilder implements LongBlock.B
     LongBlockBuilder(int estimatedSize, BlockFactory blockFactory) {
         super(blockFactory);
         int initialSize = Math.max(estimatedSize, 2);
-        adjustBreaker(initialSize);
+        adjustBreaker(RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + initialSize * elementSize());
         values = new long[initialSize];
     }
 
@@ -192,8 +194,16 @@ public LongBlock build() {
                 block = new LongArrayBlock(values, positionCount, firstValueIndexes, nullsMask, mvOrdering, blockFactory);
             }
         }
-        // update the breaker with the actual bytes used.
-        blockFactory.adjustBreaker(block.ramBytesUsed() - estimatedBytes, true);
+        /*
+         * Update the breaker with the actual bytes used.
+         * We pass false below even though we've used the bytes. That's weird,
+         * but if we break here we will throw away the used memory, letting
+         * it be deallocated. The exception will bubble up and the builder will
+         * still technically be open, meaning the calling code should close it
+         * which will return all used memory to the breaker.
+         */
+        blockFactory.adjustBreaker(block.ramBytesUsed() - estimatedBytes, false);
+        built();
         return block;
     }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongVectorBuilder.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongVectorBuilder.java
index 6b2e9f1de7d51..3b8bbf4219d00 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongVectorBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongVectorBuilder.java
@@ -49,6 +49,7 @@ protected void growValuesArray(int newSize) {
 
     @Override
     public LongVector build() {
+        finish();
         LongVector vector;
         if (valueCount == 1) {
             vector = new ConstantLongVector(values[0], 1, blockFactory);
@@ -58,8 +59,16 @@ public LongVector build() {
             }
             vector = new LongArrayVector(values, valueCount, blockFactory);
         }
-        // update the breaker with the actual bytes used.
-        blockFactory.adjustBreaker(vector.ramBytesUsed() - estimatedBytes, true);
+        /*
+         * Update the breaker with the actual bytes used.
+         * We pass false below even though we've used the bytes. That's weird,
+         * but if we break here we will throw away the used memory, letting
+         * it be deallocated. The exception will bubble up and the builder will
+         * still technically be open, meaning the calling code should close it
+         * which will return all used memory to the breaker.
+         */
+        blockFactory.adjustBreaker(vector.ramBytesUsed() - estimatedBytes, false);
+        built();
         return vector;
     }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongVectorFixedBuilder.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongVectorFixedBuilder.java
index 5414b7669f588..0960d607d9c0d 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongVectorFixedBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongVectorFixedBuilder.java
@@ -58,4 +58,12 @@ public LongVector build() {
         }
         return new LongArrayVector(values, values.length, blockFactory);
     }
+
+    @Override
+    public void close() {
+        if (nextIndex >= 0) {
+            // If nextIndex < 0 we've already built the vector
+            blockFactory.adjustBreaker(-ramBytesUsed(values.length), false);
+        }
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForBoolean.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForBoolean.java
index 50cef0417dd45..3d568adc2b5ea 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForBoolean.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForBoolean.java
@@ -8,6 +8,7 @@
 package org.elasticsearch.compute.operator.topn;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.BooleanBlock;
 
 class ResultBuilderForBoolean implements ResultBuilder {
@@ -20,10 +21,10 @@ class ResultBuilderForBoolean implements ResultBuilder {
      */
     private boolean key;
 
-    ResultBuilderForBoolean(TopNEncoder encoder, boolean inKey, int initialSize) {
+    ResultBuilderForBoolean(BlockFactory blockFactory, TopNEncoder encoder, boolean inKey, int initialSize) {
         assert encoder == TopNEncoder.DEFAULT_UNSORTABLE : encoder.toString();
         this.inKey = inKey;
-        this.builder = BooleanBlock.newBlockBuilder(initialSize);
+        this.builder = BooleanBlock.newBlockBuilder(initialSize, blockFactory);
     }
 
     @Override
@@ -63,4 +64,9 @@ public BooleanBlock build() {
     public String toString() {
         return "ResultBuilderForBoolean[inKey=" + inKey + "]";
     }
+
+    @Override
+    public void close() {
+        builder.close();
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForBytesRef.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForBytesRef.java
index 55f324c931b67..e37f82f3363a9 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForBytesRef.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForBytesRef.java
@@ -8,6 +8,7 @@
 package org.elasticsearch.compute.operator.topn;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.BytesRefBlock;
 
 class ResultBuilderForBytesRef implements ResultBuilder {
@@ -24,10 +25,10 @@ class ResultBuilderForBytesRef implements ResultBuilder {
      */
     private BytesRef key;
 
-    ResultBuilderForBytesRef(TopNEncoder encoder, boolean inKey, int initialSize) {
+    ResultBuilderForBytesRef(BlockFactory blockFactory, TopNEncoder encoder, boolean inKey, int initialSize) {
         this.encoder = encoder;
         this.inKey = inKey;
-        this.builder = BytesRefBlock.newBlockBuilder(initialSize);
+        this.builder = BytesRefBlock.newBlockBuilder(initialSize, blockFactory);
     }
 
     @Override
@@ -67,4 +68,9 @@ public BytesRefBlock build() {
     public String toString() {
         return "ResultBuilderForBytesRef[inKey=" + inKey + "]";
     }
+
+    @Override
+    public void close() {
+        builder.close();
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForDouble.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForDouble.java
index ed4a9b45d90dc..77c976c6e0085 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForDouble.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForDouble.java
@@ -8,6 +8,7 @@
 package org.elasticsearch.compute.operator.topn;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 
 class ResultBuilderForDouble implements ResultBuilder {
@@ -20,10 +21,10 @@ class ResultBuilderForDouble implements ResultBuilder {
      */
     private double key;
 
-    ResultBuilderForDouble(TopNEncoder encoder, boolean inKey, int initialSize) {
+    ResultBuilderForDouble(BlockFactory blockFactory, TopNEncoder encoder, boolean inKey, int initialSize) {
         assert encoder == TopNEncoder.DEFAULT_UNSORTABLE : encoder.toString();
         this.inKey = inKey;
-        this.builder = DoubleBlock.newBlockBuilder(initialSize);
+        this.builder = DoubleBlock.newBlockBuilder(initialSize, blockFactory);
     }
 
     @Override
@@ -63,4 +64,9 @@ public DoubleBlock build() {
     public String toString() {
         return "ResultBuilderForDouble[inKey=" + inKey + "]";
     }
+
+    @Override
+    public void close() {
+        builder.close();
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForInt.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForInt.java
index 2bcfc81107445..389ed3bc2e3c3 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForInt.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForInt.java
@@ -8,6 +8,7 @@
 package org.elasticsearch.compute.operator.topn;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.IntBlock;
 
 class ResultBuilderForInt implements ResultBuilder {
@@ -20,10 +21,10 @@ class ResultBuilderForInt implements ResultBuilder {
      */
     private int key;
 
-    ResultBuilderForInt(TopNEncoder encoder, boolean inKey, int initialSize) {
+    ResultBuilderForInt(BlockFactory blockFactory, TopNEncoder encoder, boolean inKey, int initialSize) {
         assert encoder == TopNEncoder.DEFAULT_UNSORTABLE : encoder.toString();
         this.inKey = inKey;
-        this.builder = IntBlock.newBlockBuilder(initialSize);
+        this.builder = IntBlock.newBlockBuilder(initialSize, blockFactory);
     }
 
     @Override
@@ -63,4 +64,9 @@ public IntBlock build() {
     public String toString() {
         return "ResultBuilderForInt[inKey=" + inKey + "]";
     }
+
+    @Override
+    public void close() {
+        builder.close();
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForLong.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForLong.java
index 3ada85bf9d5c9..63ee9d35c59e5 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForLong.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/ResultBuilderForLong.java
@@ -8,6 +8,7 @@
 package org.elasticsearch.compute.operator.topn;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 
 class ResultBuilderForLong implements ResultBuilder {
@@ -20,10 +21,10 @@ class ResultBuilderForLong implements ResultBuilder {
      */
     private long key;
 
-    ResultBuilderForLong(TopNEncoder encoder, boolean inKey, int initialSize) {
+    ResultBuilderForLong(BlockFactory blockFactory, TopNEncoder encoder, boolean inKey, int initialSize) {
         assert encoder == TopNEncoder.DEFAULT_UNSORTABLE : encoder.toString();
         this.inKey = inKey;
-        this.builder = LongBlock.newBlockBuilder(initialSize);
+        this.builder = LongBlock.newBlockBuilder(initialSize, blockFactory);
     }
 
     @Override
@@ -63,4 +64,9 @@ public LongBlock build() {
     public String toString() {
         return "ResultBuilderForLong[inKey=" + inKey + "]";
     }
+
+    @Override
+    public void close() {
+        builder.close();
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractBlockBuilder.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractBlockBuilder.java
index a6ad5d1299543..3d06eba398513 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractBlockBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractBlockBuilder.java
@@ -33,6 +33,8 @@ abstract class AbstractBlockBuilder implements Block.Builder {
     /** The number of bytes currently estimated with the breaker. */
     protected long estimatedBytes;
 
+    private boolean closed = false;
+
     protected AbstractBlockBuilder(BlockFactory blockFactory) {
         this.blockFactory = blockFactory;
     }
@@ -101,7 +103,14 @@ protected final void updatePosition() {
         }
     }
 
+    /**
+     * Called during implementations of {@link Block.Builder#build} as a first step
+     * to check if the block is still open and to finish the last position.
+     */
     protected final void finish() {
+        if (closed) {
+            throw new IllegalStateException("already closed");
+        }
         if (positionEntryIsOpen) {
             endPositionEntry();
         }
@@ -110,6 +119,16 @@ protected final void finish() {
         }
     }
 
+    /**
+     * Called during implementations of {@link Block.Builder#build} as a last step
+     * to mark the Builder as closed and make sure that further closes don't double
+     * free memory.
+     */
+    protected final void built() {
+        closed = true;
+        estimatedBytes = 0;
+    }
+
     protected abstract void growValuesArray(int newSize);
 
     /** The number of bytes used to represent each value element. */
@@ -125,6 +144,20 @@ protected final void ensureCapacity() {
         growValuesArray(newSize);
     }
 
+    @Override
+    public final void close() {
+        if (closed == false) {
+            closed = true;
+            adjustBreaker(-estimatedBytes);
+            extraClose();
+        }
+    }
+
+    /**
+     * Called when first {@link #close() closed}.
+     */
+    protected void extraClose() {}
+
     static int calculateNewArraySize(int currentSize) {
         // trivially, grows array by 50%
         return currentSize + (currentSize >> 1);
@@ -133,6 +166,7 @@ static int calculateNewArraySize(int currentSize) {
     protected void adjustBreaker(long deltaBytes) {
         blockFactory.adjustBreaker(deltaBytes, false);
         estimatedBytes += deltaBytes;
+        assert estimatedBytes >= 0;
     }
 
     private void setFirstValue(int position, int value) {
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVectorBuilder.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVectorBuilder.java
index 49ce276074735..274e88cd8d8b6 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVectorBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVectorBuilder.java
@@ -7,9 +7,14 @@
 
 package org.elasticsearch.compute.data;
 
-abstract class AbstractVectorBuilder {
+abstract class AbstractVectorBuilder implements Vector.Builder {
     protected int valueCount;
 
+    /**
+     * Has this builder been closed already?
+     */
+    private boolean closed = false;
+
     protected final BlockFactory blockFactory;
 
     /** The number of bytes currently estimated with the breaker. */
@@ -46,4 +51,38 @@ protected void adjustBreaker(long deltaBytes) {
         blockFactory.adjustBreaker(deltaBytes, false);
         estimatedBytes += deltaBytes;
     }
+
+    /**
+     * Called during implementations of {@link Block.Builder#build} as a first step
+     * to check if the block is still open and to finish the last position.
+     */
+    protected final void finish() {
+        if (closed) {
+            throw new IllegalStateException("already closed");
+        }
+    }
+
+    /**
+     * Called during implementations of {@link Block.Builder#build} as a last step
+     * to mark the Builder as closed and make sure that further closes don't double
+     * free memory.
+     */
+    protected final void built() {
+        closed = true;
+        estimatedBytes = 0;
+    }
+
+    @Override
+    public final void close() {
+        if (closed == false) {
+            closed = true;
+            adjustBreaker(-estimatedBytes);
+            extraClose();
+        }
+    }
+
+    /**
+     * Called when first {@link #close() closed}.
+     */
+    protected void extraClose() {}
 }
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Block.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Block.java
index 5b10a3a510de0..ca0721ebbe4f8 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Block.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Block.java
@@ -133,7 +133,11 @@ static Block constantNullBlock(int positions, BlockFactory blockFactory) {
         return blockFactory.newConstantNullBlock(positions);
     }
 
-    interface Builder {
+    /**
+     * Builds {@link Block}s. Typically, you use one of it's direct supinterfaces like {@link IntBlock.Builder}.
+     * This is {@link Releasable} and should be released after building the block or if building the block fails.
+     */
+    interface Builder extends Releasable {
 
         /**
          * Appends a null value to the block.
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/BlockFactory.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/BlockFactory.java
index 2afea228a4a78..63de604c49b18 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/BlockFactory.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/BlockFactory.java
@@ -305,7 +305,7 @@ public BytesRefBlock newBytesRefArrayBlock(
         MvOrdering mvOrdering
     ) {
         var b = new BytesRefArrayBlock(values, positionCount, firstValueIndexes, nulls, mvOrdering, this);
-        adjustBreaker(b.ramBytesUsed() - values.ramBytesUsed(), true);
+        adjustBreaker(b.ramBytesUsed() - values.bigArraysRamBytesUsed(), true);
         return b;
     }
 
@@ -315,7 +315,7 @@ public BytesRefVector.Builder newBytesRefVectorBuilder(int estimatedSize) {
 
     public BytesRefVector newBytesRefArrayVector(BytesRefArray values, int positionCount) {
         var b = new BytesRefArrayVector(values, positionCount, this);
-        adjustBreaker(b.ramBytesUsed() - values.ramBytesUsed(), true);
+        adjustBreaker(b.ramBytesUsed() - values.bigArraysRamBytesUsed(), true);
         return b;
     }
 
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/BlockUtils.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/BlockUtils.java
index 2ebbb771b5df1..0d09f7bb480e0 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/BlockUtils.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/BlockUtils.java
@@ -210,7 +210,7 @@ public static Object toJavaObject(Block block, int position) {
     private static Object valueAtOffset(Block block, int offset) {
         return switch (block.elementType()) {
             case BOOLEAN -> ((BooleanBlock) block).getBoolean(offset);
-            case BYTES_REF -> ((BytesRefBlock) block).getBytesRef(offset, new BytesRef());
+            case BYTES_REF -> BytesRef.deepCopyOf(((BytesRefBlock) block).getBytesRef(offset, new BytesRef()));
             case DOUBLE -> ((DoubleBlock) block).getDouble(offset);
             case INT -> ((IntBlock) block).getInt(offset);
             case LONG -> ((LongBlock) block).getLong(offset);
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/ConstantNullBlock.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/ConstantNullBlock.java
index 2da9cfeba09f0..01994af1cfc96 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/ConstantNullBlock.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/ConstantNullBlock.java
@@ -136,6 +136,11 @@ public void close() {
     static class Builder implements Block.Builder {
         private int positionCount;
 
+        /**
+         * Has this builder been closed already?
+         */
+        private boolean closed = false;
+
         @Override
         public Builder appendNull() {
             positionCount++;
@@ -174,7 +179,16 @@ public Block.Builder mvOrdering(MvOrdering mvOrdering) {
 
         @Override
         public Block build() {
+            if (closed) {
+                throw new IllegalStateException("already closed");
+            }
+            close();
             return new ConstantNullBlock(positionCount);
         }
+
+        @Override
+        public void close() {
+            closed = true;
+        }
     }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/DocBlock.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/DocBlock.java
index b21a956980f6a..6bcf913ce6240 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/DocBlock.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/DocBlock.java
@@ -82,8 +82,8 @@ public void close() {
     /**
      * A builder the for {@link DocBlock}.
      */
-    public static Builder newBlockBuilder(int estimatedSize) {
-        return new Builder(estimatedSize);
+    public static Builder newBlockBuilder(int estimatedSize, BlockFactory blockFactory) {
+        return new Builder(estimatedSize, blockFactory);
     }
 
     public static class Builder implements Block.Builder {
@@ -91,10 +91,10 @@ public static class Builder implements Block.Builder {
         private final IntVector.Builder segments;
         private final IntVector.Builder docs;
 
-        private Builder(int estimatedSize) {
-            shards = IntVector.newVectorBuilder(estimatedSize);
-            segments = IntVector.newVectorBuilder(estimatedSize);
-            docs = IntVector.newVectorBuilder(estimatedSize);
+        private Builder(int estimatedSize, BlockFactory blockFactory) {
+            shards = IntVector.newVectorBuilder(estimatedSize, blockFactory);
+            segments = IntVector.newVectorBuilder(estimatedSize, blockFactory);
+            docs = IntVector.newVectorBuilder(estimatedSize, blockFactory);
         }
 
         public Builder appendShard(int shard) {
@@ -153,5 +153,10 @@ public DocBlock build() {
             // Pass null for singleSegmentNonDecreasing so we calculate it when we first need it.
             return new DocVector(shards.build(), segments.build(), docs.build(), null).asBlock();
         }
+
+        @Override
+        public void close() {
+            Releasables.closeExpectNoException(shards, segments, docs);
+        }
     }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/ElementType.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/ElementType.java
index 0c85d433018e0..4467766a9e0ef 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/ElementType.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/ElementType.java
@@ -9,8 +9,6 @@
 
 import org.apache.lucene.util.BytesRef;
 
-import java.util.function.IntFunction;
-
 /**
  * The type of elements in {@link Block} and {@link Vector}
  */
@@ -22,7 +20,7 @@ public enum ElementType {
     /**
      * Blocks containing only null values.
      */
-    NULL(estimatedSize -> new ConstantNullBlock.Builder()),
+    NULL((estimatedSize, blockFactory) -> new ConstantNullBlock.Builder()),
 
     BYTES_REF(BytesRefBlock::newBlockBuilder),
 
@@ -34,19 +32,32 @@ public enum ElementType {
     /**
      * Intermediate blocks which don't support retrieving elements.
      */
-    UNKNOWN(estimatedSize -> { throw new UnsupportedOperationException("can't build null blocks"); });
+    UNKNOWN((estimatedSize, blockFactory) -> { throw new UnsupportedOperationException("can't build null blocks"); });
+
+    interface BuilderSupplier {
+        Block.Builder newBlockBuilder(int estimatedSize, BlockFactory blockFactory);
+    }
 
-    private final IntFunction<Block.Builder> builder;
+    private final BuilderSupplier builder;
 
-    ElementType(IntFunction<Block.Builder> builder) {
+    ElementType(BuilderSupplier builder) {
         this.builder = builder;
     }
 
     /**
      * Create a new {@link Block.Builder} for blocks of this type.
+     * @deprecated use {@link #newBlockBuilder(int, BlockFactory)}
      */
+    @Deprecated
     public Block.Builder newBlockBuilder(int estimatedSize) {
-        return builder.apply(estimatedSize);
+        return builder.newBlockBuilder(estimatedSize, BlockFactory.getNonBreakingInstance());
+    }
+
+    /**
+     * Create a new {@link Block.Builder} for blocks of this type.
+     */
+    public Block.Builder newBlockBuilder(int estimatedSize, BlockFactory blockFactory) {
+        return builder.newBlockBuilder(estimatedSize, blockFactory);
     }
 
     public static ElementType fromJava(Class<?> type) {
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Vector.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Vector.java
index 171bdbd62f4d0..c9ecf1aa9e399 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Vector.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Vector.java
@@ -50,7 +50,11 @@ public interface Vector extends Accountable, Releasable {
     /** The block factory associated with this vector. */
     BlockFactory blockFactory();
 
-    interface Builder {
+    /**
+     * Builds {@link Vector}s. Typically, you use one of it's direct supinterfaces like {@link IntVector.Builder}.
+     * This is {@link Releasable} and should be released after building the vector or if building the vector fails.
+     */
+    interface Builder extends Releasable {
         /**
          * Builds the block. This method can be called multiple times.
          */
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayBlock.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayBlock.java.st
index 10ff868c09806..ddb0eced039be 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayBlock.java.st
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayBlock.java.st
@@ -93,6 +93,7 @@ $endif$
     public static long ramBytesEstimated($if(BytesRef)$BytesRefArray$else$$type$[]$endif$ values, int[] firstValueIndexes, BitSet nullsMask) {
         return BASE_RAM_BYTES_USED + RamUsageEstimator.sizeOf(values) + BlockRamUsageEstimator.sizeOf(firstValueIndexes)
             + BlockRamUsageEstimator.sizeOfBitSet(nullsMask) + RamUsageEstimator.shallowSizeOfInstance(MvOrdering.class);
+        // TODO mvordering is shared
     }
 
     @Override
@@ -137,7 +138,7 @@ $endif$
         }
         released = true;
     $if(BytesRef)$
-        blockFactory.adjustBreaker(-(ramBytesUsed() - values.ramBytesUsed()), true);
+        blockFactory.adjustBreaker(-ramBytesUsed() + values.bigArraysRamBytesUsed(), true);
         Releasables.closeExpectNoException(values);
     $else$
         blockFactory.adjustBreaker(-ramBytesUsed(), true);
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayVector.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayVector.java.st
index b6a8714f882ee..3e6ccc2286675 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayVector.java.st
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayVector.java.st
@@ -110,7 +110,7 @@ $endif$
 $if(BytesRef)$
     @Override
     public void close() {
-        blockFactory.adjustBreaker(-BASE_RAM_BYTES_USED, true);
+        blockFactory.adjustBreaker(-ramBytesUsed() + values.bigArraysRamBytesUsed(), true);
         Releasables.closeExpectNoException(values);
     }
 $endif$
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-BlockBuilder.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-BlockBuilder.java.st
index 4d43f25577cc5..0ccfc45f18664 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-BlockBuilder.java.st
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-BlockBuilder.java.st
@@ -14,6 +14,8 @@ import org.elasticsearch.common.util.BytesRefArray;
 import org.elasticsearch.core.Releasables;
 
 $else$
+import org.apache.lucene.util.RamUsageEstimator;
+
 import java.util.Arrays;
 $endif$
 
@@ -41,7 +43,7 @@ $else$
     $Type$BlockBuilder(int estimatedSize, BlockFactory blockFactory) {
         super(blockFactory);
         int initialSize = Math.max(estimatedSize, 2);
-        adjustBreaker(initialSize);
+        adjustBreaker(RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + initialSize * elementSize());
         values = new $type$[initialSize];
     }
 $endif$
@@ -246,27 +248,68 @@ $endif$
     public $Type$Block build() {
         finish();
         $Type$Block block;
-        if (hasNonNullValue && positionCount == 1 && valueCount == 1) {
 $if(BytesRef)$
+        assert estimatedBytes == 0 || firstValueIndexes != null;
+        if (hasNonNullValue && positionCount == 1 && valueCount == 1) {
             block = new ConstantBytesRefVector(BytesRef.deepCopyOf(values.get(0, new BytesRef())), 1, blockFactory).asBlock();
+            /*
+             * Update the breaker with the actual bytes used.
+             * We pass false below even though we've used the bytes. That's weird,
+             * but if we break here we will throw away the used memory, letting
+             * it be deallocated. The exception will bubble up and the builder will
+             * still technically be open, meaning the calling code should close it
+             * which will return all used memory to the breaker.
+             */
+            blockFactory.adjustBreaker(block.ramBytesUsed() - estimatedBytes, false);
             Releasables.closeExpectNoException(values);
         } else {
-            estimatedBytes += values.ramBytesUsed();
+            if (isDense() && singleValued()) {
+                block = new $Type$ArrayVector(values, positionCount, blockFactory).asBlock();
+            } else {
+                block = new $Type$ArrayBlock(values, positionCount, firstValueIndexes, nullsMask, mvOrdering, blockFactory);
+            }
+            /*
+             * Update the breaker with the actual bytes used.
+             * We pass false below even though we've used the bytes. That's weird,
+             * but if we break here we will throw away the used memory, letting
+             * it be deallocated. The exception will bubble up and the builder will
+             * still technically be open, meaning the calling code should close it
+             * which will return all used memory to the breaker.
+             */
+            blockFactory.adjustBreaker(block.ramBytesUsed() - estimatedBytes - values.bigArraysRamBytesUsed(), false);
+        }
+        values = null;
 $else$
+        if (hasNonNullValue && positionCount == 1 && valueCount == 1) {
             block = new Constant$Type$Vector(values[0], 1, blockFactory).asBlock();
         } else {
             if (values.length - valueCount > 1024 || valueCount < (values.length / 2)) {
                 values = Arrays.copyOf(values, valueCount);
             }
-$endif$
             if (isDense() && singleValued()) {
                 block = new $Type$ArrayVector(values, positionCount, blockFactory).asBlock();
             } else {
                 block = new $Type$ArrayBlock(values, positionCount, firstValueIndexes, nullsMask, mvOrdering, blockFactory);
             }
         }
-        // update the breaker with the actual bytes used.
-        blockFactory.adjustBreaker(block.ramBytesUsed() - estimatedBytes, true);
+        /*
+         * Update the breaker with the actual bytes used.
+         * We pass false below even though we've used the bytes. That's weird,
+         * but if we break here we will throw away the used memory, letting
+         * it be deallocated. The exception will bubble up and the builder will
+         * still technically be open, meaning the calling code should close it
+         * which will return all used memory to the breaker.
+         */
+        blockFactory.adjustBreaker(block.ramBytesUsed() - estimatedBytes, false);
+$endif$
+        built();
         return block;
     }
+$if(BytesRef)$
+
+    @Override
+    public void extraClose() {
+        Releasables.closeExpectNoException(values);
+    }
+$endif$
 }
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-VectorBuilder.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-VectorBuilder.java.st
index b813120b42e43..1e243c49b5d82 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-VectorBuilder.java.st
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-VectorBuilder.java.st
@@ -83,24 +83,62 @@ $endif$
 
     @Override
     public $Type$Vector build() {
+        finish();
         $Type$Vector vector;
-        if (valueCount == 1) {
 $if(BytesRef)$
+        assert estimatedBytes == 0;
+        if (valueCount == 1) {
             vector = new ConstantBytesRefVector(BytesRef.deepCopyOf(values.get(0, new BytesRef())), 1, blockFactory);
+            /*
+             * Update the breaker with the actual bytes used.
+             * We pass false below even though we've used the bytes. That's weird,
+             * but if we break here we will throw away the used memory, letting
+             * it be deallocated. The exception will bubble up and the builder will
+             * still technically be open, meaning the calling code should close it
+             * which will return all used memory to the breaker.
+             */
+            blockFactory.adjustBreaker(vector.ramBytesUsed(), false);
             Releasables.closeExpectNoException(values);
         } else {
-            estimatedBytes = values.ramBytesUsed();
+            vector = new $Type$ArrayVector(values, valueCount, blockFactory);
+            /*
+             * Update the breaker with the actual bytes used.
+             * We pass false below even though we've used the bytes. That's weird,
+             * but if we break here we will throw away the used memory, letting
+             * it be deallocated. The exception will bubble up and the builder will
+             * still technically be open, meaning the calling code should close it
+             * which will return all used memory to the breaker.
+             */
+            blockFactory.adjustBreaker(vector.ramBytesUsed() - values.bigArraysRamBytesUsed(), false);
+        }
+        values = null;
 $else$
+        if (valueCount == 1) {
             vector = new Constant$Type$Vector(values[0], 1, blockFactory);
         } else {
             if (values.length - valueCount > 1024 || valueCount < (values.length / 2)) {
                 values = Arrays.copyOf(values, valueCount);
             }
-$endif$
             vector = new $Type$ArrayVector(values, valueCount, blockFactory);
         }
-        // update the breaker with the actual bytes used.
-        blockFactory.adjustBreaker(vector.ramBytesUsed() - estimatedBytes, true);
+        /*
+         * Update the breaker with the actual bytes used.
+         * We pass false below even though we've used the bytes. That's weird,
+         * but if we break here we will throw away the used memory, letting
+         * it be deallocated. The exception will bubble up and the builder will
+         * still technically be open, meaning the calling code should close it
+         * which will return all used memory to the breaker.
+         */
+        blockFactory.adjustBreaker(vector.ramBytesUsed() - estimatedBytes, false);
+$endif$
+        built();
         return vector;
     }
+$if(BytesRef)$
+
+    @Override
+    public void extraClose() {
+        Releasables.closeExpectNoException(values);
+    }
+$endif$
 }
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-VectorFixedBuilder.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-VectorFixedBuilder.java.st
index 86bc6b0a095d6..d732c85db7467 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-VectorFixedBuilder.java.st
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-VectorFixedBuilder.java.st
@@ -58,4 +58,12 @@ final class $Type$VectorFixedBuilder implements $Type$Vector.FixedBuilder {
         }
         return new $Type$ArrayVector(values, values.length, blockFactory);
     }
+
+    @Override
+    public void close() {
+        if (nextIndex >= 0) {
+            // If nextIndex < 0 we've already built the vector
+            blockFactory.adjustBreaker(-ramBytesUsed(values.length), false);
+        }
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/Driver.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/Driver.java
index 281693a487255..1a1604406892c 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/Driver.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/Driver.java
@@ -181,7 +181,13 @@ private SubscribableListener<Void> runSingleLoopIteration() {
 
             if (op.isFinished() == false && nextOp.needsInput()) {
                 Page page = op.getOutput();
-                if (page != null && page.getPositionCount() != 0) {
+                if (page == null) {
+                    // No result, just move to the next iteration
+                } else if (page.getPositionCount() == 0) {
+                    // Empty result, release any memory it holds immediately and move to the next iteration
+                    page.releaseBlocks();
+                } else {
+                    // Non-empty result from the previous operation, move it to the next operation
                     nextOp.addInput(page);
                     movedPage = true;
                 }
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/exchange/ExchangeSinkOperator.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/exchange/ExchangeSinkOperator.java
index d52f25e9d8306..0fb6ec6f63d96 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/exchange/ExchangeSinkOperator.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/exchange/ExchangeSinkOperator.java
@@ -36,10 +36,6 @@ public record ExchangeSinkOperatorFactory(Supplier<ExchangeSink> exchangeSinks,
         implements
             SinkOperatorFactory {
 
-        public ExchangeSinkOperatorFactory(Supplier<ExchangeSink> exchangeSinks) {
-            this(exchangeSinks, Function.identity());
-        }
-
         @Override
         public SinkOperator get(DriverContext driverContext) {
             return new ExchangeSinkOperator(exchangeSinks.get(), transformer);
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/ResultBuilder.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/ResultBuilder.java
index b8a41a3ee343d..bd2027cade78f 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/ResultBuilder.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/ResultBuilder.java
@@ -9,12 +9,14 @@
 
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.ElementType;
+import org.elasticsearch.core.Releasable;
 
 /**
  * Builds {@link Block}s from keys and values encoded into {@link BytesRef}s.
  */
-interface ResultBuilder {
+interface ResultBuilder extends Releasable {
     /**
      * Called for each sort key before {@link #decodeValue} to consume the sort key and
      * store the value of the key for {@link #decodeValue} can use it to reconstruct
@@ -36,15 +38,21 @@ interface ResultBuilder {
      */
     Block build();
 
-    static ResultBuilder resultBuilderFor(ElementType elementType, TopNEncoder encoder, boolean inKey, int positions) {
+    static ResultBuilder resultBuilderFor(
+        BlockFactory blockFactory,
+        ElementType elementType,
+        TopNEncoder encoder,
+        boolean inKey,
+        int positions
+    ) {
         return switch (elementType) {
-            case BOOLEAN -> new ResultBuilderForBoolean(encoder, inKey, positions);
-            case BYTES_REF -> new ResultBuilderForBytesRef(encoder, inKey, positions);
-            case INT -> new ResultBuilderForInt(encoder, inKey, positions);
-            case LONG -> new ResultBuilderForLong(encoder, inKey, positions);
-            case DOUBLE -> new ResultBuilderForDouble(encoder, inKey, positions);
-            case NULL -> new ResultBuilderForNull();
-            case DOC -> new ResultBuilderForDoc(positions);
+            case BOOLEAN -> new ResultBuilderForBoolean(blockFactory, encoder, inKey, positions);
+            case BYTES_REF -> new ResultBuilderForBytesRef(blockFactory, encoder, inKey, positions);
+            case INT -> new ResultBuilderForInt(blockFactory, encoder, inKey, positions);
+            case LONG -> new ResultBuilderForLong(blockFactory, encoder, inKey, positions);
+            case DOUBLE -> new ResultBuilderForDouble(blockFactory, encoder, inKey, positions);
+            case NULL -> new ResultBuilderForNull(blockFactory);
+            case DOC -> new ResultBuilderForDoc(blockFactory, positions);
             default -> {
                 assert false : "Result builder for [" + elementType + "]";
                 throw new UnsupportedOperationException("Result builder for [" + elementType + "]");
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/ResultBuilderForDoc.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/ResultBuilderForDoc.java
index 166d5be83b474..7fb507ffdbead 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/ResultBuilderForDoc.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/ResultBuilderForDoc.java
@@ -13,12 +13,15 @@
 import org.elasticsearch.compute.data.DocVector;
 
 class ResultBuilderForDoc implements ResultBuilder {
+    private final BlockFactory blockFactory;
     private final int[] shards;
     private final int[] segments;
     private final int[] docs;
     private int position;
 
-    ResultBuilderForDoc(int positions) {
+    ResultBuilderForDoc(BlockFactory blockFactory, int positions) {
+        // TODO use fixed length builders
+        this.blockFactory = blockFactory;
         this.shards = new int[positions];
         this.segments = new int[positions];
         this.docs = new int[positions];
@@ -40,9 +43,9 @@ public void decodeValue(BytesRef values) {
     @Override
     public Block build() {
         return new DocVector(
-            BlockFactory.getNonBreakingInstance().newIntArrayVector(shards, position),
-            BlockFactory.getNonBreakingInstance().newIntArrayVector(segments, position),
-            BlockFactory.getNonBreakingInstance().newIntArrayVector(docs, position),
+            blockFactory.newIntArrayVector(shards, position),
+            blockFactory.newIntArrayVector(segments, position),
+            blockFactory.newIntArrayVector(docs, position),
             null
         ).asBlock();
     }
@@ -51,4 +54,9 @@ public Block build() {
     public String toString() {
         return "ValueExtractorForDoc";
     }
+
+    @Override
+    public void close() {
+        // TODO memory accounting
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/ResultBuilderForNull.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/ResultBuilderForNull.java
index 05b9ba2a07658..a45f16fc30910 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/ResultBuilderForNull.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/ResultBuilderForNull.java
@@ -9,10 +9,16 @@
 
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 
 public class ResultBuilderForNull implements ResultBuilder {
+    private final BlockFactory blockFactory;
     private int positions;
 
+    public ResultBuilderForNull(BlockFactory blockFactory) {
+        this.blockFactory = blockFactory;
+    }
+
     @Override
     public void decodeKey(BytesRef keys) {
         throw new AssertionError("somehow got a value for a null key");
@@ -29,11 +35,16 @@ public void decodeValue(BytesRef values) {
 
     @Override
     public Block build() {
-        return Block.constantNullBlock(positions);
+        return Block.constantNullBlock(positions, blockFactory);
     }
 
     @Override
     public String toString() {
         return "ValueExtractorForNull";
     }
+
+    @Override
+    public void close() {
+        // Nothing to close
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/TopNOperator.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/TopNOperator.java
index 86b3a18992db4..9657d60376763 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/TopNOperator.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/TopNOperator.java
@@ -12,7 +12,9 @@
 import org.apache.lucene.util.PriorityQueue;
 import org.apache.lucene.util.RamUsageEstimator;
 import org.elasticsearch.common.breaker.CircuitBreaker;
+import org.elasticsearch.common.collect.Iterators;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.ElementType;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.BreakingBytesRefBuilder;
@@ -205,7 +207,15 @@ public record TopNOperatorFactory(
 
         @Override
         public TopNOperator get(DriverContext driverContext) {
-            return new TopNOperator(driverContext.breaker(), topCount, elementTypes, encoders, sortOrders, maxPageSize);
+            return new TopNOperator(
+                driverContext.blockFactory(),
+                driverContext.breaker(),
+                topCount,
+                elementTypes,
+                encoders,
+                sortOrders,
+                maxPageSize
+            );
         }
 
         @Override
@@ -222,6 +232,7 @@ public String describe() {
         }
     }
 
+    private final BlockFactory blockFactory;
     private final CircuitBreaker breaker;
     private final Queue inputQueue;
 
@@ -231,9 +242,11 @@ public String describe() {
     private final List<TopNEncoder> encoders;
     private final List<SortOrder> sortOrders;
 
+    private Row spare;
     private Iterator<Page> output;
 
     public TopNOperator(
+        BlockFactory blockFactory,
         CircuitBreaker breaker,
         int topCount,
         List<ElementType> elementTypes,
@@ -241,6 +254,7 @@ public TopNOperator(
         List<SortOrder> sortOrders,
         int maxPageSize
     ) {
+        this.blockFactory = blockFactory;
         this.breaker = breaker;
         this.maxPageSize = maxPageSize;
         this.elementTypes = elementTypes;
@@ -301,21 +315,20 @@ public void addInput(Page page) {
          * and must be closed. That happens either because it's overflow from the
          * inputQueue or because we hit an allocation failure while building it.
          */
-        Row row = null;
         try {
             for (int i = 0; i < page.getPositionCount(); i++) {
-                if (row == null) {
-                    row = new Row(breaker);
+                if (spare == null) {
+                    spare = new Row(breaker);
                 } else {
-                    row.keys.clear();
-                    row.orderByCompositeKeyAscending.clear();
-                    row.values.clear();
+                    spare.keys.clear();
+                    spare.orderByCompositeKeyAscending.clear();
+                    spare.values.clear();
                 }
-                rowFiller.row(i, row);
-                row = inputQueue.insertWithOverflow(row);
+                rowFiller.row(i, spare);
+                spare = inputQueue.insertWithOverflow(spare);
             }
         } finally {
-            Releasables.close(row);
+            Releasables.close(() -> page.releaseBlocks());
         }
     }
 
@@ -327,18 +340,24 @@ public void finish() {
     }
 
     private Iterator<Page> toPages() {
+        if (spare != null) {
+            // Remove the spare, we're never going to use it again.
+            spare.close();
+            spare = null;
+        }
         if (inputQueue.size() == 0) {
             return Collections.emptyIterator();
         }
         List<Row> list = new ArrayList<>(inputQueue.size());
+        List<Page> result = new ArrayList<>();
+        ResultBuilder[] builders = null;
+        boolean success = false;
         try {
             while (inputQueue.size() > 0) {
                 list.add(inputQueue.pop());
             }
             Collections.reverse(list);
 
-            List<Page> result = new ArrayList<>();
-            ResultBuilder[] builders = null;
             int p = 0;
             int size = 0;
             for (int i = 0; i < list.size(); i++) {
@@ -347,6 +366,7 @@ private Iterator<Page> toPages() {
                     builders = new ResultBuilder[elementTypes.size()];
                     for (int b = 0; b < builders.length; b++) {
                         builders[b] = ResultBuilder.resultBuilderFor(
+                            blockFactory,
                             elementTypes.get(b),
                             encoders.get(b).toUnsortable(),
                             channelInKey(sortOrders, b),
@@ -386,14 +406,22 @@ private Iterator<Page> toPages() {
                 p++;
                 if (p == size) {
                     result.add(new Page(Arrays.stream(builders).map(ResultBuilder::build).toArray(Block[]::new)));
+                    Releasables.closeExpectNoException(builders);
                     builders = null;
                 }
-
             }
             assert builders == null;
+            success = true;
             return result.iterator();
         } finally {
-            Releasables.closeExpectNoException(() -> Releasables.close(list));
+            if (success == false) {
+                List<Releasable> close = new ArrayList<>(list);
+                for (Page p : result) {
+                    close.add(p::releaseBlocks);
+                }
+                Collections.addAll(close, builders);
+                Releasables.closeExpectNoException(Releasables.wrap(close));
+            }
         }
     }
 
@@ -422,10 +450,15 @@ public Page getOutput() {
     @Override
     public void close() {
         /*
-         * If everything went well we'll have drained inputQueue to this'll
-         * be a noop. But if inputQueue
+         * If we close before calling finish then spare and inputQueue will be live rows
+         * that need closing. If we close after calling finish then the output iterator
+         * will contain pages of results that have yet to be returned.
          */
-        Releasables.closeExpectNoException(() -> Releasables.close(inputQueue));
+        Releasables.closeExpectNoException(
+            spare,
+            inputQueue == null ? null : Releasables.wrap(inputQueue),
+            output == null ? null : Releasables.wrap(() -> Iterators.map(output, p -> p::releaseBlocks))
+        );
     }
 
     private static long SHALLOW_SIZE = RamUsageEstimator.shallowSizeOfInstance(TopNOperator.class) + RamUsageEstimator
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/X-ResultBuilder.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/X-ResultBuilder.java.st
index 5f9a35bd0ebd3..ebe62398c8504 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/X-ResultBuilder.java.st
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/X-ResultBuilder.java.st
@@ -8,6 +8,7 @@
 package org.elasticsearch.compute.operator.topn;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.$Type$Block;
 
 class ResultBuilderFor$Type$ implements ResultBuilder {
@@ -26,14 +27,14 @@ $endif$
      */
     private $type$ key;
 
-    ResultBuilderFor$Type$(TopNEncoder encoder, boolean inKey, int initialSize) {
+    ResultBuilderFor$Type$(BlockFactory blockFactory, TopNEncoder encoder, boolean inKey, int initialSize) {
 $if(BytesRef)$
         this.encoder = encoder;
 $else$
         assert encoder == TopNEncoder.DEFAULT_UNSORTABLE : encoder.toString();
 $endif$
         this.inKey = inKey;
-        this.builder = $Type$Block.newBlockBuilder(initialSize);
+        this.builder = $Type$Block.newBlockBuilder(initialSize, blockFactory);
     }
 
     @Override
@@ -81,4 +82,9 @@ $endif$
     public String toString() {
         return "ResultBuilderFor$Type$[inKey=" + inKey + "]";
     }
+
+    @Override
+    public void close() {
+        builder.close();
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/OperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/OperatorTests.java
index 04a966b399870..bdf696f460060 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/OperatorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/OperatorTests.java
@@ -287,7 +287,7 @@ public void testLimitOperator() {
         try (
             var driver = new Driver(
                 driverContext,
-                new SequenceLongBlockSourceOperator(values, 100),
+                new SequenceLongBlockSourceOperator(driverContext.blockFactory(), values, 100),
                 List.of((new LimitOperator.Factory(limit)).get(driverContext)),
                 new PageConsumerOperator(page -> {
                     LongBlock block = page.getBlock(0);
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/AggregatorFunctionTestCase.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/AggregatorFunctionTestCase.java
index a4b6c8b965962..22325039af124 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/AggregatorFunctionTestCase.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/AggregatorFunctionTestCase.java
@@ -91,8 +91,8 @@ protected final ByteSizeValue smallEnoughToCircuitBreak() {
     public final void testIgnoresNulls() {
         int end = between(1_000, 100_000);
         List<Page> results = new ArrayList<>();
-        List<Page> input = CannedSourceOperator.collectPages(simpleInput(end));
         DriverContext driverContext = driverContext();
+        List<Page> input = CannedSourceOperator.collectPages(simpleInput(driverContext.blockFactory(), end));
 
         try (
             Driver d = new Driver(
@@ -111,7 +111,9 @@ public final void testIgnoresNulls() {
     public final void testMultivalued() {
         int end = between(1_000, 100_000);
         DriverContext driverContext = driverContext();
-        List<Page> input = CannedSourceOperator.collectPages(new PositionMergingSourceOperator(simpleInput(end)));
+        List<Page> input = CannedSourceOperator.collectPages(
+            new PositionMergingSourceOperator(simpleInput(driverContext.blockFactory(), end))
+        );
         assertSimpleOutput(input, drive(simple(BigArrays.NON_RECYCLING_INSTANCE).get(driverContext), input.iterator()));
     }
 
@@ -119,7 +121,7 @@ public final void testMultivaluedWithNulls() {
         int end = between(1_000, 100_000);
         DriverContext driverContext = driverContext();
         List<Page> input = CannedSourceOperator.collectPages(
-            new NullInsertingSourceOperator(new PositionMergingSourceOperator(simpleInput(end)))
+            new NullInsertingSourceOperator(new PositionMergingSourceOperator(simpleInput(driverContext.blockFactory(), end)))
         );
         assertSimpleOutput(input, drive(simple(BigArrays.NON_RECYCLING_INSTANCE).get(driverContext), input.iterator()));
     }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountAggregatorFunctionTests.java
index 11241020a6709..623de7fdd1fff 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountAggregatorFunctionTests.java
@@ -10,6 +10,7 @@
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.BasicBlockTests;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.operator.SequenceLongBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -21,8 +22,8 @@
 
 public class CountAggregatorFunctionTests extends AggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
-        return new SequenceLongBlockSourceOperator(LongStream.range(0, size).map(l -> randomLong()));
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
+        return new SequenceLongBlockSourceOperator(blockFactory, LongStream.range(0, size).map(l -> randomLong()));
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBooleanAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBooleanAggregatorFunctionTests.java
index 74cd88feed3f4..febbb4d4a0615 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBooleanAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBooleanAggregatorFunctionTests.java
@@ -10,6 +10,7 @@
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.BasicBlockTests;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.operator.SequenceBooleanBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -21,7 +22,7 @@
 
 public class CountDistinctBooleanAggregatorFunctionTests extends AggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         return new SequenceBooleanBlockSourceOperator(LongStream.range(0, size).mapToObj(l -> randomBoolean()).toList());
     }
 
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBooleanGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBooleanGroupingAggregatorFunctionTests.java
index eab1b9cb2d8de..7360b101bf79d 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBooleanGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBooleanGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.LongBooleanTupleBlockSourceOperator;
@@ -33,7 +34,7 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         return new LongBooleanTupleBlockSourceOperator(
             LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomGroupId(size), randomBoolean()))
         );
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBytesRefAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBytesRefAggregatorFunctionTests.java
index 69ccc0a04c0f9..c495a6b9f196b 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBytesRefAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBytesRefAggregatorFunctionTests.java
@@ -11,6 +11,7 @@
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.BasicBlockTests;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.operator.BytesRefBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -23,7 +24,7 @@
 
 public class CountDistinctBytesRefAggregatorFunctionTests extends AggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         int max = between(1, Math.min(Integer.MAX_VALUE, Integer.MAX_VALUE / size));
         return new BytesRefBlockSourceOperator(
             LongStream.range(0, size).mapToObj(l -> new BytesRef(String.valueOf(between(-max, max)))).toList()
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBytesRefGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBytesRefGroupingAggregatorFunctionTests.java
index 919d06af430fd..eadbba9f91880 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBytesRefGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctBytesRefGroupingAggregatorFunctionTests.java
@@ -10,6 +10,7 @@
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.LongBytesRefTupleBlockSourceOperator;
@@ -35,7 +36,7 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         return new LongBytesRefTupleBlockSourceOperator(
             LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomGroupId(size), new BytesRef(String.valueOf(between(1, 10000)))))
         );
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctDoubleAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctDoubleAggregatorFunctionTests.java
index c0678441cdc74..ccfe7b426ebca 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctDoubleAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctDoubleAggregatorFunctionTests.java
@@ -10,6 +10,7 @@
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.BasicBlockTests;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.operator.SequenceDoubleBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -23,7 +24,7 @@
 
 public class CountDistinctDoubleAggregatorFunctionTests extends AggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         return new SequenceDoubleBlockSourceOperator(LongStream.range(0, size).mapToDouble(l -> ESTestCase.randomDouble()));
     }
 
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctDoubleGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctDoubleGroupingAggregatorFunctionTests.java
index 5a928f12d33b7..0c4d89da09b99 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctDoubleGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctDoubleGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.LongDoubleTupleBlockSourceOperator;
@@ -34,7 +35,7 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         return new LongDoubleTupleBlockSourceOperator(
             LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomGroupId(size), randomDoubleBetween(0, 100, true)))
         );
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctIntAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctIntAggregatorFunctionTests.java
index 3699a87431937..b67e4cdee7e97 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctIntAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctIntAggregatorFunctionTests.java
@@ -29,7 +29,7 @@
 
 public class CountDistinctIntAggregatorFunctionTests extends AggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         int max = between(1, Math.min(Integer.MAX_VALUE, Integer.MAX_VALUE / size));
         return new SequenceIntBlockSourceOperator(LongStream.range(0, size).mapToInt(l -> between(-max, max)));
     }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctIntGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctIntGroupingAggregatorFunctionTests.java
index f2a46e9f4c3af..678024c19d391 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctIntGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctIntGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.LongIntBlockSourceOperator;
@@ -34,7 +35,7 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         return new LongIntBlockSourceOperator(LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomGroupId(size), between(0, 10000))));
     }
 
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctLongAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctLongAggregatorFunctionTests.java
index 556f9d0ccc462..704b5c649f744 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctLongAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctLongAggregatorFunctionTests.java
@@ -30,9 +30,9 @@
 public class CountDistinctLongAggregatorFunctionTests extends AggregatorFunctionTestCase {
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         long max = randomLongBetween(1, Long.MAX_VALUE / size);
-        return new SequenceLongBlockSourceOperator(LongStream.range(0, size).map(l -> randomLongBetween(-max, max)));
+        return new SequenceLongBlockSourceOperator(blockFactory, LongStream.range(0, size).map(l -> randomLongBetween(-max, max)));
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctLongGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctLongGroupingAggregatorFunctionTests.java
index a5959471b8e15..4282adaba595e 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctLongGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountDistinctLongGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -33,8 +34,9 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         return new TupleBlockSourceOperator(
+            blockFactory,
             LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomGroupId(size), randomLongBetween(0, 100_000)))
         );
     }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountGroupingAggregatorFunctionTests.java
index 54a35fcc19cb2..945c68711bb4e 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/CountGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.LongDoubleTupleBlockSourceOperator;
@@ -33,9 +34,10 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         if (randomBoolean()) {
             return new TupleBlockSourceOperator(
+                blockFactory,
                 LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomLongBetween(0, 4), randomLong()))
             );
         }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/GroupingAggregatorFunctionTestCase.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/GroupingAggregatorFunctionTestCase.java
index eab6eb30261bd..4ae58fd8c6333 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/GroupingAggregatorFunctionTestCase.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/GroupingAggregatorFunctionTestCase.java
@@ -147,7 +147,9 @@ protected ByteSizeValue smallEnoughToCircuitBreak() {
     public final void testNullGroupsAndValues() {
         DriverContext driverContext = driverContext();
         int end = between(50, 60);
-        List<Page> input = CannedSourceOperator.collectPages(new NullInsertingSourceOperator(simpleInput(end)));
+        List<Page> input = CannedSourceOperator.collectPages(
+            new NullInsertingSourceOperator(simpleInput(driverContext.blockFactory(), end))
+        );
         List<Page> results = drive(simple(nonBreakingBigArrays().withCircuitBreaking()).get(driverContext), input.iterator());
         assertSimpleOutput(input, results);
     }
@@ -155,7 +157,7 @@ public final void testNullGroupsAndValues() {
     public final void testNullGroups() {
         DriverContext driverContext = driverContext();
         int end = between(50, 60);
-        List<Page> input = CannedSourceOperator.collectPages(nullGroups(simpleInput(end)));
+        List<Page> input = CannedSourceOperator.collectPages(nullGroups(simpleInput(driverContext.blockFactory(), end)));
         List<Page> results = drive(simple(nonBreakingBigArrays().withCircuitBreaking()).get(driverContext), input.iterator());
         assertSimpleOutput(input, results);
     }
@@ -184,7 +186,7 @@ protected void appendNull(ElementType elementType, Block.Builder builder, int bl
     public final void testNullValues() {
         DriverContext driverContext = driverContext();
         int end = between(50, 60);
-        List<Page> input = CannedSourceOperator.collectPages(nullValues(simpleInput(end)));
+        List<Page> input = CannedSourceOperator.collectPages(nullValues(simpleInput(driverContext.blockFactory(), end)));
         List<Page> results = drive(simple(nonBreakingBigArrays().withCircuitBreaking()).get(driverContext), input.iterator());
         assertSimpleOutput(input, results);
     }
@@ -192,7 +194,7 @@ public final void testNullValues() {
     public final void testNullValuesInitialIntermediateFinal() {
         DriverContext driverContext = driverContext();
         int end = between(50, 60);
-        List<Page> input = CannedSourceOperator.collectPages(nullValues(simpleInput(end)));
+        List<Page> input = CannedSourceOperator.collectPages(nullValues(simpleInput(driverContext.blockFactory(), end)));
         List<Page> results = drive(
             List.of(
                 simpleWithMode(nonBreakingBigArrays().withCircuitBreaking(), AggregatorMode.INITIAL).get(driverContext),
@@ -220,7 +222,7 @@ protected void appendNull(ElementType elementType, Block.Builder builder, int bl
     public final void testMultivalued() {
         DriverContext driverContext = driverContext();
         int end = between(1_000, 100_000);
-        List<Page> input = CannedSourceOperator.collectPages(mergeValues(simpleInput(end)));
+        List<Page> input = CannedSourceOperator.collectPages(mergeValues(simpleInput(driverContext.blockFactory(), end)));
         List<Page> results = drive(simple(nonBreakingBigArrays().withCircuitBreaking()).get(driverContext), input.iterator());
         assertSimpleOutput(input, results);
     }
@@ -228,7 +230,9 @@ public final void testMultivalued() {
     public final void testMulitvaluedNullGroupsAndValues() {
         DriverContext driverContext = driverContext();
         int end = between(50, 60);
-        List<Page> input = CannedSourceOperator.collectPages(new NullInsertingSourceOperator(mergeValues(simpleInput(end))));
+        List<Page> input = CannedSourceOperator.collectPages(
+            new NullInsertingSourceOperator(mergeValues(simpleInput(driverContext.blockFactory(), end)))
+        );
         List<Page> results = drive(simple(nonBreakingBigArrays().withCircuitBreaking()).get(driverContext), input.iterator());
         assertSimpleOutput(input, results);
     }
@@ -236,7 +240,7 @@ public final void testMulitvaluedNullGroupsAndValues() {
     public final void testMulitvaluedNullGroup() {
         DriverContext driverContext = driverContext();
         int end = between(50, 60);
-        List<Page> input = CannedSourceOperator.collectPages(nullGroups(mergeValues(simpleInput(end))));
+        List<Page> input = CannedSourceOperator.collectPages(nullGroups(mergeValues(simpleInput(driverContext.blockFactory(), end))));
         List<Page> results = drive(simple(nonBreakingBigArrays().withCircuitBreaking()).get(driverContext), input.iterator());
         assertSimpleOutput(input, results);
     }
@@ -244,7 +248,7 @@ public final void testMulitvaluedNullGroup() {
     public final void testMulitvaluedNullValues() {
         DriverContext driverContext = driverContext();
         int end = between(50, 60);
-        List<Page> input = CannedSourceOperator.collectPages(nullValues(mergeValues(simpleInput(end))));
+        List<Page> input = CannedSourceOperator.collectPages(nullValues(mergeValues(simpleInput(driverContext.blockFactory(), end))));
         List<Page> results = drive(simple(nonBreakingBigArrays().withCircuitBreaking()).get(driverContext), input.iterator());
         assertSimpleOutput(input, results);
     }
@@ -295,12 +299,13 @@ private void assertNullOnly(List<Operator> operators) {
 
     public final void testNullSome() {
         DriverContext driverContext = driverContext();
-        assertNullSome(List.of(simple(nonBreakingBigArrays().withCircuitBreaking()).get(driverContext)));
+        assertNullSome(driverContext, List.of(simple(nonBreakingBigArrays().withCircuitBreaking()).get(driverContext)));
     }
 
     public final void testNullSomeInitialFinal() {
         DriverContext driverContext = driverContext();
         assertNullSome(
+            driverContext,
             List.of(
                 simpleWithMode(nonBreakingBigArrays().withCircuitBreaking(), AggregatorMode.INITIAL).get(driverContext),
                 simpleWithMode(nonBreakingBigArrays().withCircuitBreaking(), AggregatorMode.FINAL).get(driverContext)
@@ -311,6 +316,7 @@ public final void testNullSomeInitialFinal() {
     public final void testNullSomeInitialIntermediateFinal() {
         DriverContext driverContext = driverContext();
         assertNullSome(
+            driverContext,
             List.of(
                 simpleWithMode(nonBreakingBigArrays().withCircuitBreaking(), AggregatorMode.INITIAL).get(driverContext),
                 simpleWithMode(nonBreakingBigArrays().withCircuitBreaking(), AggregatorMode.INTERMEDIATE).get(driverContext),
@@ -322,8 +328,8 @@ public final void testNullSomeInitialIntermediateFinal() {
     /**
      * Run the agg on some data where one group is always null.
      */
-    private void assertNullSome(List<Operator> operators) {
-        List<Page> inputData = CannedSourceOperator.collectPages(simpleInput(1000));
+    private void assertNullSome(DriverContext driverContext, List<Operator> operators) {
+        List<Page> inputData = CannedSourceOperator.collectPages(simpleInput(driverContext.blockFactory(), 1000));
         SeenGroups seenGroups = seenGroups(inputData);
 
         long nullGroup = randomFrom(seenGroups.nonNull);
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxDoubleAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxDoubleAggregatorFunctionTests.java
index b67220b4909b7..cfda483d029f6 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxDoubleAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxDoubleAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.operator.SequenceDoubleBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -21,7 +22,7 @@
 
 public class MaxDoubleAggregatorFunctionTests extends AggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         return new SequenceDoubleBlockSourceOperator(LongStream.range(0, size).mapToDouble(l -> ESTestCase.randomDouble()));
     }
 
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxDoubleGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxDoubleGroupingAggregatorFunctionTests.java
index 3750aec95f3a7..9a2c8bc17685d 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxDoubleGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxDoubleGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.LongDoubleTupleBlockSourceOperator;
@@ -24,7 +25,7 @@
 public class MaxDoubleGroupingAggregatorFunctionTests extends GroupingAggregatorFunctionTestCase {
 
     @Override
-    protected SourceOperator simpleInput(int end) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
         return new LongDoubleTupleBlockSourceOperator(
             LongStream.range(0, end).mapToObj(l -> Tuple.tuple(randomLongBetween(0, 4), randomDouble()))
         );
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxIntAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxIntAggregatorFunctionTests.java
index 72cfa06222b50..e76021b883120 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxIntAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxIntAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.operator.SequenceIntBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -20,7 +21,7 @@
 
 public class MaxIntAggregatorFunctionTests extends AggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         return new SequenceIntBlockSourceOperator(IntStream.range(0, size).map(l -> randomInt()));
     }
 
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxIntGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxIntGroupingAggregatorFunctionTests.java
index 9ffee498eeba2..313e10be39855 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxIntGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxIntGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.LongIntBlockSourceOperator;
@@ -33,7 +34,7 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         return new LongIntBlockSourceOperator(LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomLongBetween(0, 4), randomInt())));
     }
 
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxLongAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxLongAggregatorFunctionTests.java
index 4e84f2e672b97..a51aa98f7a5a8 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxLongAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxLongAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.operator.SequenceLongBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -20,9 +21,9 @@
 
 public class MaxLongAggregatorFunctionTests extends AggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         long max = randomLongBetween(1, Long.MAX_VALUE / size);
-        return new SequenceLongBlockSourceOperator(LongStream.range(0, size).map(l -> randomLongBetween(-max, max)));
+        return new SequenceLongBlockSourceOperator(blockFactory, LongStream.range(0, size).map(l -> randomLongBetween(-max, max)));
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxLongGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxLongGroupingAggregatorFunctionTests.java
index e284f2a6103d1..a1f44e128c2e1 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxLongGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MaxLongGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -33,8 +34,11 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
-        return new TupleBlockSourceOperator(LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomLongBetween(0, 4), randomLong())));
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
+        return new TupleBlockSourceOperator(
+            blockFactory,
+            LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomLongBetween(0, 4), randomLong()))
+        );
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleAggregatorFunctionTests.java
index 74bda421a545e..1c14a8e7855ce 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleAggregatorFunctionTests.java
@@ -10,6 +10,7 @@
 import org.elasticsearch.common.Randomness;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.operator.SequenceDoubleBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -22,7 +23,7 @@
 public class MedianAbsoluteDeviationDoubleAggregatorFunctionTests extends AggregatorFunctionTestCase {
 
     @Override
-    protected SourceOperator simpleInput(int end) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
         List<Double> values = Arrays.asList(1.2, 1.25, 2.0, 2.0, 4.3, 6.0, 9.0);
         Randomness.shuffle(values);
         return new SequenceDoubleBlockSourceOperator(values);
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleGroupingAggregatorFunctionTests.java
index 6751486453f30..06ddb2a734f8c 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleGroupingAggregatorFunctionTests.java
@@ -10,6 +10,7 @@
 import org.elasticsearch.common.Randomness;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.LongDoubleTupleBlockSourceOperator;
@@ -27,7 +28,7 @@
 public class MedianAbsoluteDeviationDoubleGroupingAggregatorFunctionTests extends GroupingAggregatorFunctionTestCase {
 
     @Override
-    protected SourceOperator simpleInput(int end) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
         double[][] samples = new double[][] {
             { 1.2, 1.25, 2.0, 2.0, 4.3, 6.0, 9.0 },
             { 0.1, 1.5, 2.0, 3.0, 4.0, 7.5, 100.0 },
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntAggregatorFunctionTests.java
index 20506cc5c8f93..40e422b6efc26 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntAggregatorFunctionTests.java
@@ -10,6 +10,7 @@
 import org.elasticsearch.common.Randomness;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.operator.SequenceIntBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -22,7 +23,7 @@
 public class MedianAbsoluteDeviationIntAggregatorFunctionTests extends AggregatorFunctionTestCase {
 
     @Override
-    protected SourceOperator simpleInput(int end) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
         List<Integer> values = Arrays.asList(12, 125, 20, 20, 43, 60, 90);
         Randomness.shuffle(values);
         return new SequenceIntBlockSourceOperator(values);
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntGroupingAggregatorFunctionTests.java
index 20f62c67a16cc..2f00764f6fe51 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntGroupingAggregatorFunctionTests.java
@@ -10,6 +10,7 @@
 import org.elasticsearch.common.Randomness;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.LongIntBlockSourceOperator;
@@ -27,7 +28,7 @@
 public class MedianAbsoluteDeviationIntGroupingAggregatorFunctionTests extends GroupingAggregatorFunctionTestCase {
 
     @Override
-    protected SourceOperator simpleInput(int end) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
         int[][] samples = new int[][] {
             { 12, 125, 20, 20, 43, 60, 90 },
             { 1, 15, 20, 30, 40, 75, 1000 },
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongAggregatorFunctionTests.java
index d80415f83daa2..465bb5800bbb6 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongAggregatorFunctionTests.java
@@ -10,6 +10,7 @@
 import org.elasticsearch.common.Randomness;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.operator.SequenceLongBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -22,10 +23,10 @@
 public class MedianAbsoluteDeviationLongAggregatorFunctionTests extends AggregatorFunctionTestCase {
 
     @Override
-    protected SourceOperator simpleInput(int end) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
         List<Long> values = Arrays.asList(12L, 125L, 20L, 20L, 43L, 60L, 90L);
         Randomness.shuffle(values);
-        return new SequenceLongBlockSourceOperator(values);
+        return new SequenceLongBlockSourceOperator(blockFactory, values);
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongGroupingAggregatorFunctionTests.java
index c3cebad8e0e0b..2c6bfc1204591 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongGroupingAggregatorFunctionTests.java
@@ -10,6 +10,7 @@
 import org.elasticsearch.common.Randomness;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -27,7 +28,7 @@
 public class MedianAbsoluteDeviationLongGroupingAggregatorFunctionTests extends GroupingAggregatorFunctionTestCase {
 
     @Override
-    protected SourceOperator simpleInput(int end) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
         long[][] samples = new long[][] {
             { 12, 125, 20, 20, 43, 60, 90 },
             { 1, 15, 20, 30, 40, 75, 1000 },
@@ -42,7 +43,7 @@ protected SourceOperator simpleInput(int end) {
                 values.add(Tuple.tuple((long) i, v));
             }
         }
-        return new TupleBlockSourceOperator(values);
+        return new TupleBlockSourceOperator(blockFactory, values);
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinDoubleAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinDoubleAggregatorFunctionTests.java
index 622302d549fd0..7e0b7241cf258 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinDoubleAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinDoubleAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.operator.SequenceDoubleBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -21,7 +22,7 @@
 
 public class MinDoubleAggregatorFunctionTests extends AggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         return new SequenceDoubleBlockSourceOperator(LongStream.range(0, size).mapToDouble(l -> ESTestCase.randomDouble()));
     }
 
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinDoubleGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinDoubleGroupingAggregatorFunctionTests.java
index 12c63e354547a..7c4141f4a7ad1 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinDoubleGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinDoubleGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.LongDoubleTupleBlockSourceOperator;
@@ -23,7 +24,7 @@
 
 public class MinDoubleGroupingAggregatorFunctionTests extends GroupingAggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int end) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
         return new LongDoubleTupleBlockSourceOperator(
             LongStream.range(0, end).mapToObj(l -> Tuple.tuple(randomLongBetween(0, 4), randomDouble()))
         );
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinIntAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinIntAggregatorFunctionTests.java
index 2dc0e893875ab..dc1ab1398fb90 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinIntAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinIntAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.operator.SequenceIntBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -20,7 +21,7 @@
 
 public class MinIntAggregatorFunctionTests extends AggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         return new SequenceIntBlockSourceOperator(IntStream.range(0, size).map(l -> randomInt()));
     }
 
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinIntGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinIntGroupingAggregatorFunctionTests.java
index 4ffbe9b1396d3..55cfc2d124e5f 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinIntGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinIntGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.LongIntBlockSourceOperator;
@@ -33,7 +34,7 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         return new LongIntBlockSourceOperator(LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomLongBetween(0, 4), randomInt())));
     }
 
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinLongAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinLongAggregatorFunctionTests.java
index 25a420237893e..91feb141ac74b 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinLongAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinLongAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.operator.SequenceLongBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -20,9 +21,9 @@
 
 public class MinLongAggregatorFunctionTests extends AggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         long max = randomLongBetween(1, Long.MAX_VALUE / size);
-        return new SequenceLongBlockSourceOperator(LongStream.range(0, size).map(l -> randomLongBetween(-max, max)));
+        return new SequenceLongBlockSourceOperator(blockFactory, LongStream.range(0, size).map(l -> randomLongBetween(-max, max)));
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinLongGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinLongGroupingAggregatorFunctionTests.java
index 311e7e41ed9ac..02dda3fe3c236 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinLongGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/MinLongGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -33,8 +34,11 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
-        return new TupleBlockSourceOperator(LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomLongBetween(0, 4), randomLong())));
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
+        return new TupleBlockSourceOperator(
+            blockFactory,
+            LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomLongBetween(0, 4), randomLong()))
+        );
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileDoubleAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileDoubleAggregatorFunctionTests.java
index 96e61d4782022..61f26cd0209b3 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileDoubleAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileDoubleAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.operator.SequenceDoubleBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -41,7 +42,7 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         return new SequenceDoubleBlockSourceOperator(LongStream.range(0, size).mapToDouble(l -> ESTestCase.randomDouble()));
     }
 
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileDoubleGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileDoubleGroupingAggregatorFunctionTests.java
index c0d6595e088eb..9495e78ec47ca 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileDoubleGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileDoubleGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.LongDoubleTupleBlockSourceOperator;
@@ -42,7 +43,7 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int end) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
         return new LongDoubleTupleBlockSourceOperator(
             LongStream.range(0, end).mapToObj(l -> Tuple.tuple(randomLongBetween(0, 4), randomDouble()))
         );
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileIntAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileIntAggregatorFunctionTests.java
index c34a01e608d1a..37d153f7bcae6 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileIntAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileIntAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.operator.SequenceIntBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -40,7 +41,7 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         int max = between(1, (int) Math.min(Integer.MAX_VALUE, Long.MAX_VALUE / size));
         return new SequenceIntBlockSourceOperator(LongStream.range(0, size).mapToInt(l -> between(0, max)));
     }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileIntGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileIntGroupingAggregatorFunctionTests.java
index a018fba96e897..948e156e52c85 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileIntGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileIntGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.LongIntBlockSourceOperator;
@@ -42,7 +43,7 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         int max = between(1, (int) Math.min(Integer.MAX_VALUE, Long.MAX_VALUE / size));
         return new LongIntBlockSourceOperator(
             LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomLongBetween(0, 4), between(-1, max)))
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileLongAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileLongAggregatorFunctionTests.java
index cf0b18840d91e..eb32dac18ea80 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileLongAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileLongAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.operator.SequenceLongBlockSourceOperator;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -40,9 +41,9 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         long max = randomLongBetween(1, 1_000_000);
-        return new SequenceLongBlockSourceOperator(LongStream.range(0, size).map(l -> randomLongBetween(0, max)));
+        return new SequenceLongBlockSourceOperator(blockFactory, LongStream.range(0, size).map(l -> randomLongBetween(0, max)));
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileLongGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileLongGroupingAggregatorFunctionTests.java
index 609526532b72e..6360be8595ff8 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileLongGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/PercentileLongGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -42,9 +43,10 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         long max = randomLongBetween(1, Long.MAX_VALUE / size / 5);
         return new TupleBlockSourceOperator(
+            blockFactory,
             LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomLongBetween(0, 4), randomLongBetween(-0, max)))
         );
     }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumDoubleAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumDoubleAggregatorFunctionTests.java
index 767f9a2d5c25b..d3dc262419008 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumDoubleAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumDoubleAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.Driver;
@@ -28,7 +29,7 @@
 
 public class SumDoubleAggregatorFunctionTests extends AggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         return new SequenceDoubleBlockSourceOperator(LongStream.range(0, size).mapToDouble(l -> ESTestCase.randomDouble()));
     }
 
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumDoubleGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumDoubleGroupingAggregatorFunctionTests.java
index 03a7269b84690..8b86d99653282 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumDoubleGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumDoubleGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.LongDoubleTupleBlockSourceOperator;
@@ -23,7 +24,7 @@
 
 public class SumDoubleGroupingAggregatorFunctionTests extends GroupingAggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int end) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
         return new LongDoubleTupleBlockSourceOperator(
             LongStream.range(0, end).mapToObj(l -> Tuple.tuple(randomLongBetween(0, 4), randomDouble()))
         );
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumIntAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumIntAggregatorFunctionTests.java
index e6fccf2d46f61..736386fae3dec 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumIntAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumIntAggregatorFunctionTests.java
@@ -27,7 +27,7 @@
 
 public class SumIntAggregatorFunctionTests extends AggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         int max = between(1, (int) Math.min(Integer.MAX_VALUE, Long.MAX_VALUE / size));
         return new SequenceIntBlockSourceOperator(LongStream.range(0, size).mapToInt(l -> between(-max, max)));
     }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumIntGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumIntGroupingAggregatorFunctionTests.java
index 71666024c819d..0b8678a0e3f05 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumIntGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumIntGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.LongIntBlockSourceOperator;
@@ -32,7 +33,7 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         int max = between(1, (int) Math.min(Integer.MAX_VALUE, Long.MAX_VALUE / size));
         return new LongIntBlockSourceOperator(
             LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomLongBetween(0, 4), between(-max, max)))
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumLongAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumLongAggregatorFunctionTests.java
index ae5aaa5b21965..e9523c5583cd4 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumLongAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumLongAggregatorFunctionTests.java
@@ -27,9 +27,9 @@
 
 public class SumLongAggregatorFunctionTests extends AggregatorFunctionTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         long max = randomLongBetween(1, Long.MAX_VALUE / size);
-        return new SequenceLongBlockSourceOperator(LongStream.range(0, size).map(l -> randomLongBetween(-max, max)));
+        return new SequenceLongBlockSourceOperator(blockFactory, LongStream.range(0, size).map(l -> randomLongBetween(-max, max)));
     }
 
     @Override
@@ -53,7 +53,7 @@ public void testOverflowFails() {
         try (
             Driver d = new Driver(
                 driverContext,
-                new SequenceLongBlockSourceOperator(LongStream.of(Long.MAX_VALUE - 1, 2)),
+                new SequenceLongBlockSourceOperator(driverContext.blockFactory(), LongStream.of(Long.MAX_VALUE - 1, 2)),
                 List.of(simple(nonBreakingBigArrays()).get(driverContext)),
                 new PageConsumerOperator(page -> fail("shouldn't have made it this far")),
                 () -> {}
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumLongGroupingAggregatorFunctionTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumLongGroupingAggregatorFunctionTests.java
index e0dc918b515d6..827dc06a4f542 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumLongGroupingAggregatorFunctionTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/SumLongGroupingAggregatorFunctionTests.java
@@ -9,6 +9,7 @@
 
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.SourceOperator;
@@ -32,9 +33,10 @@ protected String expectedDescriptionOfAggregator() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         long max = randomLongBetween(1, Long.MAX_VALUE / size / 5);
         return new TupleBlockSourceOperator(
+            blockFactory,
             LongStream.range(0, size).mapToObj(l -> Tuple.tuple(randomLongBetween(0, 4), randomLongBetween(-max, max)))
         );
     }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockBuilderTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockBuilderTests.java
index de552d242afa2..2179e68c47832 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockBuilderTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockBuilderTests.java
@@ -7,47 +7,48 @@
 
 package org.elasticsearch.compute.data;
 
+import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
+
+import org.elasticsearch.common.breaker.CircuitBreaker;
+import org.elasticsearch.common.breaker.CircuitBreakingException;
+import org.elasticsearch.common.unit.ByteSizeValue;
+import org.elasticsearch.common.util.BigArrays;
+import org.elasticsearch.common.util.MockBigArrays;
+import org.elasticsearch.common.util.PageCacheRecycler;
+import org.elasticsearch.indices.CrankyCircuitBreakerService;
 import org.elasticsearch.test.ESTestCase;
 
+import java.util.ArrayList;
 import java.util.List;
 
+import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.is;
 
 public class BlockBuilderTests extends ESTestCase {
-
-    public void testAllNullsInt() {
-        for (int numEntries : List.of(1, randomIntBetween(1, 100))) {
-            testAllNullsImpl(IntBlock.newBlockBuilder(0), numEntries);
-            testAllNullsImpl(IntBlock.newBlockBuilder(100), numEntries);
-            testAllNullsImpl(IntBlock.newBlockBuilder(1000), numEntries);
-            testAllNullsImpl(IntBlock.newBlockBuilder(randomIntBetween(0, 100)), numEntries);
+    @ParametersFactory
+    public static List<Object[]> params() {
+        List<Object[]> params = new ArrayList<>();
+        for (ElementType elementType : ElementType.values()) {
+            if (elementType == ElementType.UNKNOWN || elementType == ElementType.NULL || elementType == ElementType.DOC) {
+                continue;
+            }
+            params.add(new Object[] { elementType });
         }
+        return params;
     }
 
-    public void testAllNullsLong() {
-        for (int numEntries : List.of(1, randomIntBetween(1, 100))) {
-            testAllNullsImpl(LongBlock.newBlockBuilder(0), numEntries);
-            testAllNullsImpl(LongBlock.newBlockBuilder(100), numEntries);
-            testAllNullsImpl(LongBlock.newBlockBuilder(1000), numEntries);
-            testAllNullsImpl(LongBlock.newBlockBuilder(randomIntBetween(0, 100)), numEntries);
-        }
-    }
+    private final ElementType elementType;
 
-    public void testAllNullsDouble() {
-        for (int numEntries : List.of(1, randomIntBetween(1, 100))) {
-            testAllNullsImpl(DoubleBlock.newBlockBuilder(0), numEntries);
-            testAllNullsImpl(DoubleBlock.newBlockBuilder(100), numEntries);
-            testAllNullsImpl(DoubleBlock.newBlockBuilder(1000), numEntries);
-            testAllNullsImpl(DoubleBlock.newBlockBuilder(randomIntBetween(0, 100)), numEntries);
-        }
+    public BlockBuilderTests(ElementType elementType) {
+        this.elementType = elementType;
     }
 
-    public void testAllNullsBytesRef() {
+    public void testAllNulls() {
         for (int numEntries : List.of(1, randomIntBetween(1, 100))) {
-            testAllNullsImpl(BytesRefBlock.newBlockBuilder(0), numEntries);
-            testAllNullsImpl(BytesRefBlock.newBlockBuilder(100), numEntries);
-            testAllNullsImpl(BytesRefBlock.newBlockBuilder(1000), numEntries);
-            testAllNullsImpl(BytesRefBlock.newBlockBuilder(randomIntBetween(0, 100)), numEntries);
+            testAllNullsImpl(elementType.newBlockBuilder(0), numEntries);
+            testAllNullsImpl(elementType.newBlockBuilder(100), numEntries);
+            testAllNullsImpl(elementType.newBlockBuilder(1000), numEntries);
+            testAllNullsImpl(elementType.newBlockBuilder(randomIntBetween(0, 100)), numEntries);
         }
     }
 
@@ -65,4 +66,95 @@ private void testAllNullsImpl(Block.Builder builder, int numEntries) {
     static int randomPosition(int positionCount) {
         return positionCount == 1 ? 0 : randomIntBetween(0, positionCount - 1);
     }
+
+    public void testCloseWithoutBuilding() {
+        BlockFactory blockFactory = BlockFactoryTests.blockFactory(ByteSizeValue.ofGb(1));
+        elementType.newBlockBuilder(10, blockFactory).close();
+        assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
+    }
+
+    public void testBuildSmallSingleValued() {
+        testBuild(between(1, 100), false, 1);
+    }
+
+    public void testBuildHugeSingleValued() {
+        testBuild(between(1_000, 50_000), false, 1);
+    }
+
+    public void testBuildSmallSingleValuedNullable() {
+        testBuild(between(1, 100), true, 1);
+    }
+
+    public void testBuildHugeSingleValuedNullable() {
+        testBuild(between(1_000, 50_000), true, 1);
+    }
+
+    public void testBuildSmallMultiValued() {
+        testBuild(between(1, 100), false, 3);
+    }
+
+    public void testBuildHugeMultiValued() {
+        testBuild(between(1_000, 50_000), false, 3);
+    }
+
+    public void testBuildSmallMultiValuedNullable() {
+        testBuild(between(1, 100), true, 3);
+    }
+
+    public void testBuildHugeMultiValuedNullable() {
+        testBuild(between(1_000, 50_000), true, 3);
+    }
+
+    public void testBuildSingle() {
+        testBuild(1, false, 1);
+    }
+
+    private void testBuild(int size, boolean nullable, int maxValueCount) {
+        BlockFactory blockFactory = BlockFactoryTests.blockFactory(ByteSizeValue.ofGb(1));
+        try (Block.Builder builder = elementType.newBlockBuilder(randomBoolean() ? size : 1, blockFactory)) {
+            BasicBlockTests.RandomBlock random = BasicBlockTests.randomBlock(elementType, size, nullable, 1, maxValueCount, 0, 0);
+            builder.copyFrom(random.block(), 0, random.block().getPositionCount());
+            try (Block built = builder.build()) {
+                assertThat(built, equalTo(random.block()));
+                assertThat(blockFactory.breaker().getUsed(), equalTo(built.ramBytesUsed()));
+            }
+            assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
+        }
+        assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
+    }
+
+    public void testDoubleBuild() {
+        BlockFactory blockFactory = BlockFactoryTests.blockFactory(ByteSizeValue.ofGb(1));
+        try (Block.Builder builder = elementType.newBlockBuilder(10, blockFactory)) {
+            BasicBlockTests.RandomBlock random = BasicBlockTests.randomBlock(elementType, 10, false, 1, 1, 0, 0);
+            builder.copyFrom(random.block(), 0, random.block().getPositionCount());
+            try (Block built = builder.build()) {
+                assertThat(built, equalTo(random.block()));
+                assertThat(blockFactory.breaker().getUsed(), equalTo(built.ramBytesUsed()));
+            }
+            assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
+            Exception e = expectThrows(IllegalStateException.class, builder::build);
+            assertThat(e.getMessage(), equalTo("already closed"));
+        }
+        assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
+    }
+
+    public void testCranky() {
+        BigArrays bigArrays = new MockBigArrays(PageCacheRecycler.NON_RECYCLING_INSTANCE, new CrankyCircuitBreakerService());
+        BlockFactory blockFactory = new BlockFactory(bigArrays.breakerService().getBreaker(CircuitBreaker.REQUEST), bigArrays);
+        try {
+            try (Block.Builder builder = elementType.newBlockBuilder(10, blockFactory)) {
+                BasicBlockTests.RandomBlock random = BasicBlockTests.randomBlock(elementType, 10, false, 1, 1, 0, 0);
+                builder.copyFrom(random.block(), 0, random.block().getPositionCount());
+                try (Block built = builder.build()) {
+                    assertThat(built, equalTo(random.block()));
+                }
+            }
+            // If we made it this far cranky didn't fail us!
+        } catch (CircuitBreakingException e) {
+            logger.info("cranky", e);
+            assertThat(e.getMessage(), equalTo(CrankyCircuitBreakerService.ERROR_MESSAGE));
+        }
+        assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockFactoryTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockFactoryTests.java
index a524221dd50d7..24d4e27e92ad1 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockFactoryTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockFactoryTests.java
@@ -49,11 +49,29 @@ public static BlockFactory blockFactory(ByteSizeValue size) {
 
     @ParametersFactory
     public static List<Object[]> params() {
-        List<Supplier<BlockFactory>> l = List.of(() -> {
-            CircuitBreaker breaker = new MockBigArrays.LimitedBreaker("esql-test-breaker", ByteSizeValue.ofGb(1));
-            BigArrays bigArrays = new MockBigArrays(PageCacheRecycler.NON_RECYCLING_INSTANCE, mockBreakerService(breaker));
-            return BlockFactory.getInstance(breaker, bigArrays);
-        }, BlockFactory::getGlobalInstance);
+        List<Supplier<BlockFactory>> l = List.of(new Supplier<>() {
+            @Override
+            public BlockFactory get() {
+                CircuitBreaker breaker = new MockBigArrays.LimitedBreaker("esql-test-breaker", ByteSizeValue.ofGb(1));
+                BigArrays bigArrays = new MockBigArrays(PageCacheRecycler.NON_RECYCLING_INSTANCE, mockBreakerService(breaker));
+                return BlockFactory.getInstance(breaker, bigArrays);
+            }
+
+            @Override
+            public String toString() {
+                return "1gb";
+            }
+        }, new Supplier<>() {
+            @Override
+            public BlockFactory get() {
+                return BlockFactory.getGlobalInstance();
+            }
+
+            @Override
+            public String toString() {
+                return "global";
+            }
+        });
         return l.stream().map(s -> new Object[] { s }).toList();
     }
 
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockTestUtils.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockTestUtils.java
index a5637128705ca..dd61c8f6478d3 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockTestUtils.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockTestUtils.java
@@ -77,6 +77,7 @@ public static void readInto(List<List<Object>> values, Page page) {
         for (int i = 0; i < page.getBlockCount(); i++) {
             readInto(values.get(i), page.getBlock(i));
         }
+        page.releaseBlocks();
     }
 
     public static void readInto(List<Object> values, Block block) {
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BytesRefBlockEqualityTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BytesRefBlockEqualityTests.java
index 0eb9beec2e7f9..ee654497c1ec3 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BytesRefBlockEqualityTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BytesRefBlockEqualityTests.java
@@ -18,7 +18,6 @@
 import java.util.Arrays;
 import java.util.BitSet;
 import java.util.List;
-import java.util.stream.IntStream;
 
 public class BytesRefBlockEqualityTests extends ESTestCase {
 
@@ -332,10 +331,14 @@ public void testSimpleBlockWithSingleNull() {
     public void testSimpleBlockWithManyNulls() {
         int positions = randomIntBetween(1, 256);
         boolean grow = randomBoolean();
-        var builder = BytesRefBlock.newBlockBuilder(grow ? 0 : positions);
-        IntStream.range(0, positions).forEach(i -> builder.appendNull());
-        BytesRefBlock block1 = builder.build();
-        BytesRefBlock block2 = builder.build();
+        BytesRefBlock.Builder builder1 = BytesRefBlock.newBlockBuilder(grow ? 0 : positions);
+        BytesRefBlock.Builder builder2 = BytesRefBlock.newBlockBuilder(grow ? 0 : positions);
+        for (int p = 0; p < positions; p++) {
+            builder1.appendNull();
+            builder2.appendNull();
+        }
+        BytesRefBlock block1 = builder1.build();
+        BytesRefBlock block2 = builder2.build();
         assertEquals(positions, block1.getPositionCount());
         assertTrue(block1.mayHaveNulls());
         assertTrue(block1.isNull(0));
@@ -365,15 +368,27 @@ public void testSimpleBlockWithSingleMultiValue() {
     public void testSimpleBlockWithManyMultiValues() {
         int positions = randomIntBetween(1, 256);
         boolean grow = randomBoolean();
-        var builder = BytesRefBlock.newBlockBuilder(grow ? 0 : positions);
+        BytesRefBlock.Builder builder1 = BytesRefBlock.newBlockBuilder(grow ? 0 : positions);
+        BytesRefBlock.Builder builder2 = BytesRefBlock.newBlockBuilder(grow ? 0 : positions);
+        BytesRefBlock.Builder builder3 = BytesRefBlock.newBlockBuilder(grow ? 0 : positions);
         for (int pos = 0; pos < positions; pos++) {
-            builder.beginPositionEntry();
+            builder1.beginPositionEntry();
+            builder2.beginPositionEntry();
+            builder3.beginPositionEntry();
             int values = randomIntBetween(1, 16);
-            IntStream.range(0, values).forEach(i -> builder.appendBytesRef(new BytesRef(Integer.toHexString(randomInt()))));
+            for (int i = 0; i < values; i++) {
+                BytesRef value = new BytesRef(Integer.toHexString(randomInt()));
+                builder1.appendBytesRef(value);
+                builder2.appendBytesRef(value);
+                builder3.appendBytesRef(value);
+            }
+            builder1.endPositionEntry();
+            builder2.endPositionEntry();
+            builder3.endPositionEntry();
         }
-        BytesRefBlock block1 = builder.build();
-        BytesRefBlock block2 = builder.build();
-        BytesRefBlock block3 = builder.build();
+        BytesRefBlock block1 = builder1.build();
+        BytesRefBlock block2 = builder2.build();
+        BytesRefBlock block3 = builder3.build();
 
         assertEquals(positions, block1.getPositionCount());
         assertAllEquals(List.of(block1, block2, block3));
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/DocVectorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/DocVectorTests.java
index d8258ab28a078..0f76e024c7436 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/DocVectorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/DocVectorTests.java
@@ -8,6 +8,7 @@
 package org.elasticsearch.compute.data;
 
 import org.elasticsearch.common.Randomness;
+import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.core.Releasables;
 import org.elasticsearch.test.ESTestCase;
 
@@ -98,33 +99,37 @@ public void testRandomShardSegmentDocMap() {
     }
 
     private void assertShardSegmentDocMap(int[][] data, int[][] expected) {
-        DocBlock.Builder builder = DocBlock.newBlockBuilder(data.length);
-        for (int r = 0; r < data.length; r++) {
-            builder.appendShard(data[r][0]);
-            builder.appendSegment(data[r][1]);
-            builder.appendDoc(data[r][2]);
+        BlockFactory blockFactory = BlockFactoryTests.blockFactory(ByteSizeValue.ofGb(1));
+        try (DocBlock.Builder builder = DocBlock.newBlockBuilder(data.length, blockFactory)) {
+            for (int r = 0; r < data.length; r++) {
+                builder.appendShard(data[r][0]);
+                builder.appendSegment(data[r][1]);
+                builder.appendDoc(data[r][2]);
+            }
+            try (DocVector docVector = builder.build().asVector()) {
+                int[] forwards = docVector.shardSegmentDocMapForwards();
+
+                int[][] result = new int[docVector.getPositionCount()][];
+                for (int p = 0; p < result.length; p++) {
+                    result[p] = new int[] {
+                        docVector.shards().getInt(forwards[p]),
+                        docVector.segments().getInt(forwards[p]),
+                        docVector.docs().getInt(forwards[p]) };
+                }
+                assertThat(result, equalTo(expected));
+
+                int[] backwards = docVector.shardSegmentDocMapBackwards();
+                for (int p = 0; p < result.length; p++) {
+                    result[p] = new int[] {
+                        docVector.shards().getInt(backwards[forwards[p]]),
+                        docVector.segments().getInt(backwards[forwards[p]]),
+                        docVector.docs().getInt(backwards[forwards[p]]) };
+                }
+
+                assertThat(result, equalTo(data));
+            }
         }
-        DocVector docVector = builder.build().asVector();
-        int[] forwards = docVector.shardSegmentDocMapForwards();
-
-        int[][] result = new int[docVector.getPositionCount()][];
-        for (int p = 0; p < result.length; p++) {
-            result[p] = new int[] {
-                docVector.shards().getInt(forwards[p]),
-                docVector.segments().getInt(forwards[p]),
-                docVector.docs().getInt(forwards[p]) };
-        }
-        assertThat(result, equalTo(expected));
-
-        int[] backwards = docVector.shardSegmentDocMapBackwards();
-        for (int p = 0; p < result.length; p++) {
-            result[p] = new int[] {
-                docVector.shards().getInt(backwards[forwards[p]]),
-                docVector.segments().getInt(backwards[forwards[p]]),
-                docVector.docs().getInt(backwards[forwards[p]]) };
-        }
-
-        assertThat(result, equalTo(data));
+        assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
     }
 
     public void testCannotDoubleRelease() {
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/DoubleBlockEqualityTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/DoubleBlockEqualityTests.java
index 2abbcc0b989f1..7dda97f52834e 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/DoubleBlockEqualityTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/DoubleBlockEqualityTests.java
@@ -11,7 +11,6 @@
 
 import java.util.BitSet;
 import java.util.List;
-import java.util.stream.IntStream;
 
 public class DoubleBlockEqualityTests extends ESTestCase {
 
@@ -224,10 +223,14 @@ public void testSimpleBlockWithSingleNull() {
     public void testSimpleBlockWithManyNulls() {
         int positions = randomIntBetween(1, 256);
         boolean grow = randomBoolean();
-        var builder = DoubleBlock.newBlockBuilder(grow ? 0 : positions);
-        IntStream.range(0, positions).forEach(i -> builder.appendNull());
-        DoubleBlock block1 = builder.build();
-        DoubleBlock block2 = builder.build();
+        DoubleBlock.Builder builder1 = DoubleBlock.newBlockBuilder(grow ? 0 : positions);
+        DoubleBlock.Builder builder2 = DoubleBlock.newBlockBuilder(grow ? 0 : positions);
+        for (int p = 0; p < positions; p++) {
+            builder1.appendNull();
+            builder2.appendNull();
+        }
+        DoubleBlock block1 = builder1.build();
+        DoubleBlock block2 = builder2.build();
         assertEquals(positions, block1.getPositionCount());
         assertTrue(block1.mayHaveNulls());
         assertTrue(block1.isNull(0));
@@ -248,15 +251,27 @@ public void testSimpleBlockWithSingleMultiValue() {
     public void testSimpleBlockWithManyMultiValues() {
         int positions = randomIntBetween(1, 256);
         boolean grow = randomBoolean();
-        var builder = DoubleBlock.newBlockBuilder(grow ? 0 : positions);
+        DoubleBlock.Builder builder1 = DoubleBlock.newBlockBuilder(grow ? 0 : positions);
+        DoubleBlock.Builder builder2 = DoubleBlock.newBlockBuilder(grow ? 0 : positions);
+        DoubleBlock.Builder builder3 = DoubleBlock.newBlockBuilder(grow ? 0 : positions);
         for (int pos = 0; pos < positions; pos++) {
-            builder.beginPositionEntry();
+            builder1.beginPositionEntry();
+            builder2.beginPositionEntry();
+            builder3.beginPositionEntry();
             int values = randomIntBetween(1, 16);
-            IntStream.range(0, values).forEach(i -> builder.appendDouble(randomDouble()));
+            for (int i = 0; i < values; i++) {
+                double value = randomDouble();
+                builder1.appendDouble(value);
+                builder2.appendDouble(value);
+                builder3.appendDouble(value);
+            }
+            builder1.endPositionEntry();
+            builder2.endPositionEntry();
+            builder3.endPositionEntry();
         }
-        DoubleBlock block1 = builder.build();
-        DoubleBlock block2 = builder.build();
-        DoubleBlock block3 = builder.build();
+        DoubleBlock block1 = builder1.build();
+        DoubleBlock block2 = builder2.build();
+        DoubleBlock block3 = builder3.build();
 
         assertEquals(positions, block1.getPositionCount());
         assertAllEquals(List.of(block1, block2, block3));
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/IntBlockEqualityTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/IntBlockEqualityTests.java
index c4e19106d4368..40c84324f13d2 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/IntBlockEqualityTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/IntBlockEqualityTests.java
@@ -11,7 +11,6 @@
 
 import java.util.BitSet;
 import java.util.List;
-import java.util.stream.IntStream;
 
 public class IntBlockEqualityTests extends ESTestCase {
 
@@ -185,10 +184,14 @@ public void testSimpleBlockWithSingleNull() {
     public void testSimpleBlockWithManyNulls() {
         int positions = randomIntBetween(1, 256);
         boolean grow = randomBoolean();
-        var builder = IntBlock.newBlockBuilder(grow ? 0 : positions);
-        IntStream.range(0, positions).forEach(i -> builder.appendNull());
-        IntBlock block1 = builder.build();
-        IntBlock block2 = builder.build();
+        IntBlock.Builder builder1 = IntBlock.newBlockBuilder(grow ? 0 : positions);
+        IntBlock.Builder builder2 = IntBlock.newBlockBuilder(grow ? 0 : positions);
+        for (int p = 0; p < positions; p++) {
+            builder1.appendNull();
+            builder2.appendNull();
+        }
+        IntBlock block1 = builder1.build();
+        IntBlock block2 = builder2.build();
         assertEquals(positions, block1.getPositionCount());
         assertTrue(block1.mayHaveNulls());
         assertTrue(block1.isNull(0));
@@ -210,15 +213,27 @@ public void testSimpleBlockWithSingleMultiValue() {
     public void testSimpleBlockWithManyMultiValues() {
         int positions = randomIntBetween(1, 256);
         boolean grow = randomBoolean();
-        var builder = IntBlock.newBlockBuilder(grow ? 0 : positions);
+        IntBlock.Builder builder1 = IntBlock.newBlockBuilder(grow ? 0 : positions);
+        IntBlock.Builder builder2 = IntBlock.newBlockBuilder(grow ? 0 : positions);
+        IntBlock.Builder builder3 = IntBlock.newBlockBuilder(grow ? 0 : positions);
         for (int pos = 0; pos < positions; pos++) {
-            builder.beginPositionEntry();
+            builder1.beginPositionEntry();
+            builder2.beginPositionEntry();
+            builder3.beginPositionEntry();
             int values = randomIntBetween(1, 16);
-            IntStream.range(0, values).forEach(i -> builder.appendInt(randomInt()));
+            for (int i = 0; i < values; i++) {
+                int value = randomInt();
+                builder1.appendInt(value);
+                builder2.appendInt(value);
+                builder3.appendInt(value);
+            }
+            builder1.endPositionEntry();
+            builder2.endPositionEntry();
+            builder3.endPositionEntry();
         }
-        IntBlock block1 = builder.build();
-        IntBlock block2 = builder.build();
-        IntBlock block3 = builder.build();
+        IntBlock block1 = builder1.build();
+        IntBlock block2 = builder2.build();
+        IntBlock block3 = builder3.build();
 
         assertEquals(positions, block1.getPositionCount());
         assertAllEquals(List.of(block1, block2, block3));
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/LongBlockEqualityTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/LongBlockEqualityTests.java
index 3d08b2a96d635..a24b4a4dd6fa6 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/LongBlockEqualityTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/LongBlockEqualityTests.java
@@ -11,7 +11,6 @@
 
 import java.util.BitSet;
 import java.util.List;
-import java.util.stream.IntStream;
 
 public class LongBlockEqualityTests extends ESTestCase {
 
@@ -191,10 +190,14 @@ public void testSimpleBlockWithSingleNull() {
     public void testSimpleBlockWithManyNulls() {
         int positions = randomIntBetween(1, 256);
         boolean grow = randomBoolean();
-        var builder = LongBlock.newBlockBuilder(grow ? 0 : positions);
-        IntStream.range(0, positions).forEach(i -> builder.appendNull());
-        LongBlock block1 = builder.build();
-        LongBlock block2 = builder.build();
+        LongBlock.Builder builder1 = LongBlock.newBlockBuilder(grow ? 0 : positions);
+        LongBlock.Builder builder2 = LongBlock.newBlockBuilder(grow ? 0 : positions);
+        for (int p = 0; p < positions; p++) {
+            builder1.appendNull();
+            builder2.appendNull();
+        }
+        LongBlock block1 = builder1.build();
+        LongBlock block2 = builder2.build();
         assertEquals(positions, block1.getPositionCount());
         assertTrue(block1.mayHaveNulls());
         assertTrue(block1.isNull(0));
@@ -216,15 +219,27 @@ public void testSimpleBlockWithSingleMultiValue() {
     public void testSimpleBlockWithManyMultiValues() {
         int positions = randomIntBetween(1, 256);
         boolean grow = randomBoolean();
-        var builder = LongBlock.newBlockBuilder(grow ? 0 : positions);
+        LongBlock.Builder builder1 = LongBlock.newBlockBuilder(grow ? 0 : positions);
+        LongBlock.Builder builder2 = LongBlock.newBlockBuilder(grow ? 0 : positions);
+        LongBlock.Builder builder3 = LongBlock.newBlockBuilder(grow ? 0 : positions);
         for (int pos = 0; pos < positions; pos++) {
-            builder.beginPositionEntry();
-            int values = randomIntBetween(1, 16);
-            IntStream.range(0, values).forEach(i -> builder.appendLong(randomLong()));
+            builder1.beginPositionEntry();
+            builder2.beginPositionEntry();
+            builder3.beginPositionEntry();
+            int valueCount = randomIntBetween(1, 16);
+            for (int i = 0; i < valueCount; i++) {
+                long value = randomLong();
+                builder1.appendLong(value);
+                builder2.appendLong(value);
+                builder3.appendLong(value);
+            }
+            builder1.endPositionEntry();
+            builder2.endPositionEntry();
+            builder3.endPositionEntry();
         }
-        LongBlock block1 = builder.build();
-        LongBlock block2 = builder.build();
-        LongBlock block3 = builder.build();
+        LongBlock block1 = builder1.build();
+        LongBlock block2 = builder2.build();
+        LongBlock block3 = builder3.build();
 
         assertEquals(positions, block1.getPositionCount());
         assertAllEquals(List.of(block1, block2, block3));
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/TestBlockBuilder.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/TestBlockBuilder.java
index 4684da93a661a..d9377a490368d 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/TestBlockBuilder.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/TestBlockBuilder.java
@@ -139,6 +139,11 @@ public Block.Builder appendAllValuesToCurrentPosition(Block block) {
         public IntBlock build() {
             return builder.build();
         }
+
+        @Override
+        public void close() {
+            builder.close();
+        }
     }
 
     private static class TestLongBlockBuilder extends TestBlockBuilder {
@@ -195,6 +200,11 @@ public Block.Builder appendAllValuesToCurrentPosition(Block block) {
         public LongBlock build() {
             return builder.build();
         }
+
+        @Override
+        public void close() {
+            builder.close();
+        }
     }
 
     private static class TestDoubleBlockBuilder extends TestBlockBuilder {
@@ -251,6 +261,11 @@ public Block.Builder appendAllValuesToCurrentPosition(Block block) {
         public DoubleBlock build() {
             return builder.build();
         }
+
+        @Override
+        public void close() {
+            builder.close();
+        }
     }
 
     private static class TestBytesRefBlockBuilder extends TestBlockBuilder {
@@ -307,6 +322,11 @@ public Block.Builder appendAllValuesToCurrentPosition(Block block) {
         public BytesRefBlock build() {
             return builder.build();
         }
+
+        @Override
+        public void close() {
+            builder.close();
+        }
     }
 
     private static class TestBooleanBlockBuilder extends TestBlockBuilder {
@@ -366,5 +386,10 @@ public Block.Builder appendAllValuesToCurrentPosition(Block block) {
         public BooleanBlock build() {
             return builder.build();
         }
+
+        @Override
+        public void close() {
+            builder.close();
+        }
     }
 }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/VectorBuilderTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/VectorBuilderTests.java
new file mode 100644
index 0000000000000..656d79070f217
--- /dev/null
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/VectorBuilderTests.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; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.compute.data;
+
+import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
+
+import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.common.breaker.CircuitBreaker;
+import org.elasticsearch.common.breaker.CircuitBreakingException;
+import org.elasticsearch.common.unit.ByteSizeValue;
+import org.elasticsearch.common.util.BigArrays;
+import org.elasticsearch.common.util.MockBigArrays;
+import org.elasticsearch.common.util.PageCacheRecycler;
+import org.elasticsearch.indices.CrankyCircuitBreakerService;
+import org.elasticsearch.test.ESTestCase;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.hamcrest.Matchers.equalTo;
+
+public class VectorBuilderTests extends ESTestCase {
+    @ParametersFactory
+    public static List<Object[]> params() {
+        List<Object[]> params = new ArrayList<>();
+        for (ElementType elementType : ElementType.values()) {
+            if (elementType == ElementType.UNKNOWN || elementType == ElementType.NULL || elementType == ElementType.DOC) {
+                continue;
+            }
+            params.add(new Object[] { elementType });
+        }
+        return params;
+    }
+
+    private final ElementType elementType;
+
+    public VectorBuilderTests(ElementType elementType) {
+        this.elementType = elementType;
+    }
+
+    public void testCloseWithoutBuilding() {
+        BlockFactory blockFactory = BlockFactoryTests.blockFactory(ByteSizeValue.ofGb(1));
+        vectorBuilder(10, blockFactory).close();
+        assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
+    }
+
+    public void testBuildSmall() {
+        testBuild(between(1, 100));
+    }
+
+    public void testBuildHuge() {
+        testBuild(between(1_000, 50_000));
+    }
+
+    public void testBuildSingle() {
+        testBuild(1);
+    }
+
+    private void testBuild(int size) {
+        BlockFactory blockFactory = BlockFactoryTests.blockFactory(ByteSizeValue.ofGb(1));
+        try (Vector.Builder builder = vectorBuilder(randomBoolean() ? size : 1, blockFactory)) {
+            BasicBlockTests.RandomBlock random = BasicBlockTests.randomBlock(elementType, size, false, 1, 1, 0, 0);
+            fill(builder, random.block().asVector());
+            try (Vector built = builder.build()) {
+                assertThat(built, equalTo(random.block().asVector()));
+                assertThat(blockFactory.breaker().getUsed(), equalTo(built.ramBytesUsed()));
+            }
+            assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
+        }
+        assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
+    }
+
+    public void testDoubleBuild() {
+        BlockFactory blockFactory = BlockFactoryTests.blockFactory(ByteSizeValue.ofGb(1));
+        try (Vector.Builder builder = vectorBuilder(10, blockFactory)) {
+            BasicBlockTests.RandomBlock random = BasicBlockTests.randomBlock(elementType, 10, false, 1, 1, 0, 0);
+            fill(builder, random.block().asVector());
+            try (Vector built = builder.build()) {
+                assertThat(built, equalTo(random.block().asVector()));
+            }
+            assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
+            Exception e = expectThrows(IllegalStateException.class, builder::build);
+            assertThat(e.getMessage(), equalTo("already closed"));
+        }
+        assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
+    }
+
+    public void testCranky() {
+        BigArrays bigArrays = new MockBigArrays(PageCacheRecycler.NON_RECYCLING_INSTANCE, new CrankyCircuitBreakerService());
+        BlockFactory blockFactory = new BlockFactory(bigArrays.breakerService().getBreaker(CircuitBreaker.REQUEST), bigArrays);
+        try {
+            try (Vector.Builder builder = vectorBuilder(10, blockFactory)) {
+                BasicBlockTests.RandomBlock random = BasicBlockTests.randomBlock(elementType, 10, false, 1, 1, 0, 0);
+                fill(builder, random.block().asVector());
+                try (Vector built = builder.build()) {
+                    assertThat(built, equalTo(random.block().asVector()));
+                }
+            }
+            // If we made it this far cranky didn't fail us!
+        } catch (CircuitBreakingException e) {
+            logger.info("cranky", e);
+            assertThat(e.getMessage(), equalTo(CrankyCircuitBreakerService.ERROR_MESSAGE));
+        }
+        assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
+    }
+
+    private Vector.Builder vectorBuilder(int estimatedSize, BlockFactory blockFactory) {
+        return switch (elementType) {
+            case NULL, DOC, UNKNOWN -> throw new UnsupportedOperationException();
+            case BOOLEAN -> BooleanVector.newVectorBuilder(estimatedSize, blockFactory);
+            case BYTES_REF -> BytesRefVector.newVectorBuilder(estimatedSize, blockFactory);
+            case DOUBLE -> DoubleVector.newVectorBuilder(estimatedSize, blockFactory);
+            case INT -> IntVector.newVectorBuilder(estimatedSize, blockFactory);
+            case LONG -> LongVector.newVectorBuilder(estimatedSize, blockFactory);
+        };
+    }
+
+    private void fill(Vector.Builder builder, Vector from) {
+        switch (elementType) {
+            case NULL, DOC, UNKNOWN -> throw new UnsupportedOperationException();
+            case BOOLEAN -> {
+                for (int p = 0; p < from.getPositionCount(); p++) {
+                    ((BooleanVector.Builder) builder).appendBoolean(((BooleanVector) from).getBoolean(p));
+                }
+            }
+            case BYTES_REF -> {
+                for (int p = 0; p < from.getPositionCount(); p++) {
+                    ((BytesRefVector.Builder) builder).appendBytesRef(((BytesRefVector) from).getBytesRef(p, new BytesRef()));
+                }
+            }
+            case DOUBLE -> {
+                for (int p = 0; p < from.getPositionCount(); p++) {
+                    ((DoubleVector.Builder) builder).appendDouble(((DoubleVector) from).getDouble(p));
+                }
+            }
+            case INT -> {
+                for (int p = 0; p < from.getPositionCount(); p++) {
+                    ((IntVector.Builder) builder).appendInt(((IntVector) from).getInt(p));
+                }
+            }
+            case LONG -> {
+                for (int p = 0; p < from.getPositionCount(); p++) {
+                    ((LongVector.Builder) builder).appendLong(((LongVector) from).getLong(p));
+                }
+            }
+        }
+    }
+}
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/VectorFixedBuilderTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/VectorFixedBuilderTests.java
index 9fa9f7e32c654..df67ee2e7822a 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/VectorFixedBuilderTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/VectorFixedBuilderTests.java
@@ -45,6 +45,12 @@ public VectorFixedBuilderTests(ElementType elementType) {
         this.elementType = elementType;
     }
 
+    public void testCloseWithoutBuilding() {
+        BlockFactory blockFactory = BlockFactoryTests.blockFactory(ByteSizeValue.ofGb(1));
+        vectorBuilder(10, blockFactory).close();
+        assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
+    }
+
     public void testBuildSmall() {
         testBuild(between(1, 100));
     }
@@ -59,25 +65,32 @@ public void testBuildSingle() {
 
     private void testBuild(int size) {
         BlockFactory blockFactory = BlockFactoryTests.blockFactory(ByteSizeValue.ofGb(1));
-        Vector.Builder builder = vectorBuilder(size, blockFactory);
-        BasicBlockTests.RandomBlock random = BasicBlockTests.randomBlock(elementType, size, false, 1, 1, 0, 0);
-        fill(builder, random.block().asVector());
-        try (Vector built = builder.build()) {
-            assertThat(built, equalTo(random.block().asVector()));
-            assertThat(blockFactory.breaker().getUsed(), equalTo(built.ramBytesUsed()));
+        try (Vector.Builder builder = vectorBuilder(size, blockFactory)) {
+            BasicBlockTests.RandomBlock random = BasicBlockTests.randomBlock(elementType, size, false, 1, 1, 0, 0);
+            fill(builder, random.block().asVector());
+            try (Vector built = builder.build()) {
+                assertThat(built, equalTo(random.block().asVector()));
+                assertThat(blockFactory.breaker().getUsed(), equalTo(built.ramBytesUsed()));
+            }
+            assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
         }
+        assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
     }
 
     public void testDoubleBuild() {
         BlockFactory blockFactory = BlockFactoryTests.blockFactory(ByteSizeValue.ofGb(1));
-        Vector.Builder builder = vectorBuilder(10, blockFactory);
-        BasicBlockTests.RandomBlock random = BasicBlockTests.randomBlock(elementType, 10, false, 1, 1, 0, 0);
-        fill(builder, random.block().asVector());
-        try (Vector built = builder.build()) {
-            assertThat(built, equalTo(random.block().asVector()));
+        try (Vector.Builder builder = vectorBuilder(10, blockFactory)) {
+            BasicBlockTests.RandomBlock random = BasicBlockTests.randomBlock(elementType, 10, false, 1, 1, 0, 0);
+            fill(builder, random.block().asVector());
+            try (Vector built = builder.build()) {
+                assertThat(built, equalTo(random.block().asVector()));
+            }
+            assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
+            Exception e = expectThrows(IllegalStateException.class, builder::build);
+            assertThat(e.getMessage(), equalTo("already closed"));
         }
-        Exception e = expectThrows(IllegalStateException.class, builder::build);
-        assertThat(e.getMessage(), equalTo("already closed"));
+        assertThat(blockFactory.breaker().getUsed(), equalTo(0L));
+
     }
 
     public void testCranky() {
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/lucene/ValuesSourceReaderOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/lucene/ValuesSourceReaderOperatorTests.java
index 64edcaa43d89b..4776b40e12115 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/lucene/ValuesSourceReaderOperatorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/lucene/ValuesSourceReaderOperatorTests.java
@@ -26,6 +26,7 @@
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.BooleanBlock;
 import org.elasticsearch.compute.data.BooleanVector;
 import org.elasticsearch.compute.data.BytesRefBlock;
@@ -115,7 +116,7 @@ static Operator.OperatorFactory factory(IndexReader reader, ValuesSourceType vsT
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         // The test wants more than one segment. We shoot for about 10.
         int commitEvery = Math.max(1, size / 10);
         try (
@@ -198,21 +199,35 @@ protected ByteSizeValue smallEnoughToCircuitBreak() {
     }
 
     public void testLoadAll() {
-        loadSimpleAndAssert(CannedSourceOperator.collectPages(simpleInput(between(1_000, 100 * 1024))));
+        DriverContext driverContext = driverContext();
+        loadSimpleAndAssert(
+            driverContext,
+            CannedSourceOperator.collectPages(simpleInput(driverContext.blockFactory(), between(1_000, 100 * 1024)))
+        );
     }
 
     public void testLoadAllInOnePage() {
+        DriverContext driverContext = driverContext();
         loadSimpleAndAssert(
-            List.of(CannedSourceOperator.mergePages(CannedSourceOperator.collectPages(simpleInput(between(1_000, 100 * 1024)))))
+            driverContext,
+            List.of(
+                CannedSourceOperator.mergePages(
+                    CannedSourceOperator.collectPages(simpleInput(driverContext.blockFactory(), between(1_000, 100 * 1024)))
+                )
+            )
         );
     }
 
     public void testEmpty() {
-        loadSimpleAndAssert(CannedSourceOperator.collectPages(simpleInput(0)));
+        DriverContext driverContext = driverContext();
+        loadSimpleAndAssert(driverContext, CannedSourceOperator.collectPages(simpleInput(driverContext.blockFactory(), 0)));
     }
 
     public void testLoadAllInOnePageShuffled() {
-        Page source = CannedSourceOperator.mergePages(CannedSourceOperator.collectPages(simpleInput(between(1_000, 100 * 1024))));
+        DriverContext driverContext = driverContext();
+        Page source = CannedSourceOperator.mergePages(
+            CannedSourceOperator.collectPages(simpleInput(driverContext.blockFactory(), between(1_000, 100 * 1024)))
+        );
         List<Integer> shuffleList = new ArrayList<>();
         IntStream.range(0, source.getPositionCount()).forEach(i -> shuffleList.add(i));
         Randomness.shuffle(shuffleList);
@@ -222,11 +237,10 @@ public void testLoadAllInOnePageShuffled() {
             shuffledBlocks[b] = source.getBlock(b).filter(shuffleArray);
         }
         source = new Page(shuffledBlocks);
-        loadSimpleAndAssert(List.of(source));
+        loadSimpleAndAssert(driverContext, List.of(source));
     }
 
-    private void loadSimpleAndAssert(List<Page> input) {
-        DriverContext driverContext = driverContext();
+    private void loadSimpleAndAssert(DriverContext driverContext, List<Page> input) {
         List<Page> results = new ArrayList<>();
         List<Operator> operators = List.of(
             factory(
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/AggregationOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/AggregationOperatorTests.java
index 9eaa1e333f66e..784d5134e9608 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/AggregationOperatorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/AggregationOperatorTests.java
@@ -17,6 +17,7 @@
 import org.elasticsearch.compute.aggregation.SumLongAggregatorFunctionSupplier;
 import org.elasticsearch.compute.aggregation.SumLongAggregatorFunctionTests;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.Page;
 
 import java.util.List;
@@ -28,9 +29,9 @@
 
 public class AggregationOperatorTests extends ForkingOperatorTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         long max = randomLongBetween(1, Long.MAX_VALUE / size);
-        return new SequenceLongBlockSourceOperator(LongStream.range(0, size).map(l -> randomLongBetween(-max, max)));
+        return new SequenceLongBlockSourceOperator(blockFactory, LongStream.range(0, size).map(l -> randomLongBetween(-max, max)));
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/AnyOperatorTestCase.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/AnyOperatorTestCase.java
index 8f995d9a31bc3..14d83ce252e5f 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/AnyOperatorTestCase.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/AnyOperatorTestCase.java
@@ -95,7 +95,7 @@ protected final BigArrays nonBreakingBigArrays() {
     /**
      * A {@link DriverContext} with a nonBreakingBigArrays.
      */
-    protected DriverContext driverContext() {
+    protected DriverContext driverContext() { // TODO make this final and return a breaking block factory
         return new DriverContext(nonBreakingBigArrays(), BlockFactory.getNonBreakingInstance());
     }
 }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/CannedSourceOperator.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/CannedSourceOperator.java
index d5b07a713b8b4..57ea313b88dab 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/CannedSourceOperator.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/CannedSourceOperator.java
@@ -53,6 +53,25 @@ public static Page mergePages(List<Page> pages) {
         return new Page(blocks);
     }
 
+    /**
+     * Make a deep copy of some pages. Useful so that when the originals are
+     * released the copies are still live.
+     */
+    public static List<Page> deepCopyOf(List<Page> pages) {
+        List<Page> out = new ArrayList<>(pages.size());
+        for (Page p : pages) {
+            Block[] blocks = new Block[p.getBlockCount()];
+            for (int b = 0; b < blocks.length; b++) {
+                Block orig = p.getBlock(b);
+                Block.Builder builder = orig.elementType().newBlockBuilder(p.getPositionCount());
+                builder.copyFrom(orig, 0, p.getPositionCount());
+                blocks[b] = builder.build();
+            }
+            out.add(new Page(blocks));
+        }
+        return out;
+    }
+
     private final Iterator<Page> page;
 
     public CannedSourceOperator(Iterator<Page> page) {
@@ -77,5 +96,9 @@ public Page getOutput() {
     }
 
     @Override
-    public void close() {}
+    public void close() {
+        while (page.hasNext()) {
+            page.next().releaseBlocks();
+        }
+    }
 }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/ColumnExtractOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/ColumnExtractOperatorTests.java
index 7825e035df0db..f06a2780b7446 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/ColumnExtractOperatorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/ColumnExtractOperatorTests.java
@@ -12,6 +12,7 @@
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.BytesRefBlock;
 import org.elasticsearch.compute.data.ElementType;
 import org.elasticsearch.compute.data.Page;
@@ -24,7 +25,7 @@
 public class ColumnExtractOperatorTests extends OperatorTestCase {
 
     @Override
-    protected SourceOperator simpleInput(int end) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
         List<BytesRef> input = LongStream.range(0, end)
             .mapToObj(l -> new BytesRef("word1_" + l + " word2_" + l + " word3_" + l))
             .collect(Collectors.toList());
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/EvalOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/EvalOperatorTests.java
index 156f37d8d8e7a..91e18214abee2 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/EvalOperatorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/EvalOperatorTests.java
@@ -10,6 +10,7 @@
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.LongVector;
 import org.elasticsearch.compute.data.Page;
@@ -21,8 +22,8 @@
 
 public class EvalOperatorTests extends OperatorTestCase {
     @Override
-    protected SourceOperator simpleInput(int end) {
-        return new TupleBlockSourceOperator(LongStream.range(0, end).mapToObj(l -> Tuple.tuple(l, end - l)));
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
+        return new TupleBlockSourceOperator(blockFactory, LongStream.range(0, end).mapToObj(l -> Tuple.tuple(l, end - l)));
     }
 
     record Addition(int lhs, int rhs) implements EvalOperator.ExpressionEvaluator {
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/FilterOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/FilterOperatorTests.java
index b26fe0c33fe1c..9c29471473203 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/FilterOperatorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/FilterOperatorTests.java
@@ -10,6 +10,7 @@
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.BooleanVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.LongVector;
@@ -23,8 +24,8 @@
 
 public class FilterOperatorTests extends OperatorTestCase {
     @Override
-    protected SourceOperator simpleInput(int end) {
-        return new TupleBlockSourceOperator(LongStream.range(0, end).mapToObj(l -> Tuple.tuple(l, end - l)));
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
+        return new TupleBlockSourceOperator(blockFactory, LongStream.range(0, end).mapToObj(l -> Tuple.tuple(l, end - l)));
     }
 
     record SameLastDigit(int lhs, int rhs) implements EvalOperator.ExpressionEvaluator {
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/ForkingOperatorTestCase.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/ForkingOperatorTestCase.java
index 9d1084fcc4cf3..d01a5b17ac788 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/ForkingOperatorTestCase.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/ForkingOperatorTestCase.java
@@ -56,7 +56,7 @@ protected final Operator.OperatorFactory simple(BigArrays bigArrays) {
     public final void testInitialFinal() {
         BigArrays bigArrays = nonBreakingBigArrays();
         DriverContext driverContext = driverContext();
-        List<Page> input = CannedSourceOperator.collectPages(simpleInput(between(1_000, 100_000)));
+        List<Page> input = CannedSourceOperator.collectPages(simpleInput(driverContext.blockFactory(), between(1_000, 100_000)));
         List<Page> results = new ArrayList<>();
 
         try (
@@ -80,7 +80,7 @@ public final void testInitialFinal() {
     public final void testManyInitialFinal() {
         BigArrays bigArrays = nonBreakingBigArrays();
         DriverContext driverContext = driverContext();
-        List<Page> input = CannedSourceOperator.collectPages(simpleInput(between(1_000, 100_000)));
+        List<Page> input = CannedSourceOperator.collectPages(simpleInput(driverContext.blockFactory(), between(1_000, 100_000)));
         List<Page> partials = oneDriverPerPage(input, () -> List.of(simpleWithMode(bigArrays, AggregatorMode.INITIAL).get(driverContext)));
         List<Page> results = new ArrayList<>();
         try (
@@ -101,7 +101,7 @@ public final void testManyInitialFinal() {
     public final void testInitialIntermediateFinal() {
         BigArrays bigArrays = nonBreakingBigArrays();
         DriverContext driverContext = driverContext();
-        List<Page> input = CannedSourceOperator.collectPages(simpleInput(between(1_000, 100_000)));
+        List<Page> input = CannedSourceOperator.collectPages(simpleInput(driverContext.blockFactory(), between(1_000, 100_000)));
         List<Page> results = new ArrayList<>();
 
         try (
@@ -127,7 +127,7 @@ public final void testInitialIntermediateFinal() {
     public final void testManyInitialManyPartialFinal() {
         BigArrays bigArrays = nonBreakingBigArrays();
         DriverContext driverContext = driverContext();
-        List<Page> input = CannedSourceOperator.collectPages(simpleInput(between(1_000, 100_000)));
+        List<Page> input = CannedSourceOperator.collectPages(simpleInput(driverContext.blockFactory(), between(1_000, 100_000)));
 
         List<Page> partials = oneDriverPerPage(input, () -> List.of(simpleWithMode(bigArrays, AggregatorMode.INITIAL).get(driverContext)));
         Collections.shuffle(partials, random());
@@ -156,7 +156,7 @@ public final void testManyInitialManyPartialFinal() {
     // to move the data through the pipeline.
     public final void testManyInitialManyPartialFinalRunner() {
         BigArrays bigArrays = nonBreakingBigArrays();
-        List<Page> input = CannedSourceOperator.collectPages(simpleInput(between(1_000, 100_000)));
+        List<Page> input = CannedSourceOperator.collectPages(simpleInput(driverContext().blockFactory(), between(1_000, 100_000)));
         List<Page> results = new ArrayList<>();
 
         List<Driver> drivers = createDriversForInput(bigArrays, input, results, false /* no throwing ops */);
@@ -178,7 +178,7 @@ protected void start(Driver driver, ActionListener<Void> listener) {
     // runner behaves correctly and also releases all resources (bigArrays) appropriately.
     public final void testManyInitialManyPartialFinalRunnerThrowing() {
         BigArrays bigArrays = nonBreakingBigArrays();
-        List<Page> input = CannedSourceOperator.collectPages(simpleInput(between(1_000, 100_000)));
+        List<Page> input = CannedSourceOperator.collectPages(simpleInput(driverContext().blockFactory(), between(1_000, 100_000)));
         List<Page> results = new ArrayList<>();
 
         List<Driver> drivers = createDriversForInput(bigArrays, input, results, true /* one throwing op */);
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java
index 954a1f179f259..1afa5d3c02330 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java
@@ -17,6 +17,7 @@
 import org.elasticsearch.compute.aggregation.SumLongAggregatorFunctionSupplier;
 import org.elasticsearch.compute.aggregation.SumLongGroupingAggregatorFunctionTests;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.ElementType;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Page;
@@ -31,9 +32,12 @@
 
 public class HashAggregationOperatorTests extends ForkingOperatorTestCase {
     @Override
-    protected SourceOperator simpleInput(int size) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
         long max = randomLongBetween(1, Long.MAX_VALUE / size);
-        return new TupleBlockSourceOperator(LongStream.range(0, size).mapToObj(l -> Tuple.tuple(l % 5, randomLongBetween(-max, max))));
+        return new TupleBlockSourceOperator(
+            blockFactory,
+            LongStream.range(0, size).mapToObj(l -> Tuple.tuple(l % 5, randomLongBetween(-max, max)))
+        );
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/LimitOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/LimitOperatorTests.java
index 228fdf262cf62..bbbfd44014ffc 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/LimitOperatorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/LimitOperatorTests.java
@@ -10,6 +10,7 @@
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.Page;
 
 import java.util.List;
@@ -24,8 +25,8 @@ protected Operator.OperatorFactory simple(BigArrays bigArrays) {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
-        return new SequenceLongBlockSourceOperator(LongStream.range(0, size));
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
+        return new SequenceLongBlockSourceOperator(blockFactory, LongStream.range(0, size));
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/MvExpandOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/MvExpandOperatorTests.java
index 80ac57ed539e7..21ca59e0f45a4 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/MvExpandOperatorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/MvExpandOperatorTests.java
@@ -10,6 +10,7 @@
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.BasicBlockTests;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.ElementType;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.data.IntVector;
@@ -24,7 +25,7 @@
 
 public class MvExpandOperatorTests extends OperatorTestCase {
     @Override
-    protected SourceOperator simpleInput(int end) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
         return new AbstractBlockSourceOperator(8 * 1024) {
             private int idx;
 
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/OperatorTestCase.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/OperatorTestCase.java
index 3b2fac5271aa6..aee600b079b81 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/OperatorTestCase.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/OperatorTestCase.java
@@ -12,6 +12,7 @@
 import org.elasticsearch.common.Randomness;
 import org.elasticsearch.common.breaker.CircuitBreaker;
 import org.elasticsearch.common.breaker.CircuitBreakingException;
+import org.elasticsearch.common.collect.Iterators;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.util.BigArray;
@@ -21,6 +22,7 @@
 import org.elasticsearch.common.util.concurrent.EsExecutors;
 import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.Page;
+import org.elasticsearch.core.Releasables;
 import org.elasticsearch.core.TimeValue;
 import org.elasticsearch.indices.CrankyCircuitBreakerService;
 import org.elasticsearch.threadpool.FixedExecutorBuilder;
@@ -36,6 +38,7 @@
 
 import static org.hamcrest.Matchers.empty;
 import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.in;
 
 /**
  * Base tests for {@link Operator}s that are not {@link SourceOperator} or {@link SinkOperator}.
@@ -44,7 +47,7 @@ public abstract class OperatorTestCase extends AnyOperatorTestCase {
     /**
      * Valid input to be sent to {@link #simple};
      */
-    protected abstract SourceOperator simpleInput(int size);
+    protected abstract SourceOperator simpleInput(BlockFactory blockFactory, int size);
 
     /**
      * Assert that output from {@link #simple} is correct for the
@@ -80,15 +83,27 @@ public final void testSimpleLargeInput() {
      * in a sane way.
      */
     public final void testSimpleCircuitBreaking() {
-        BigArrays bigArrays = new MockBigArrays(PageCacheRecycler.NON_RECYCLING_INSTANCE, smallEnoughToCircuitBreak());
+        /*
+         * We build two CircuitBreakers - one for the input blocks and one for the operation itself.
+         * The input blocks don't count against the memory usage for the limited operator that we
+         * build.
+         */
+        DriverContext inputFactoryContext = driverContext();
+        BigArrays bigArrays = new MockBigArrays(PageCacheRecycler.NON_RECYCLING_INSTANCE, smallEnoughToCircuitBreak())
+            .withCircuitBreaking();
+        List<Page> input = CannedSourceOperator.collectPages(simpleInput(inputFactoryContext.blockFactory(), between(1_000, 10_000)));
         CircuitBreaker breaker = bigArrays.breakerService().getBreaker(CircuitBreaker.REQUEST);
         BlockFactory blockFactory = BlockFactory.getInstance(breaker, bigArrays);
         Exception e = expectThrows(
             CircuitBreakingException.class,
-            () -> assertSimple(new DriverContext(bigArrays, blockFactory), between(1_000, 10_000))
+            () -> drive(simple(bigArrays).get(new DriverContext(bigArrays, blockFactory)), input.iterator())
         );
         assertThat(e.getMessage(), equalTo(MockBigArrays.ERROR_MESSAGE));
         assertThat(bigArrays.breakerService().getBreaker(CircuitBreaker.REQUEST).getUsed(), equalTo(0L));
+
+        // Note the lack of try/finally here - we're asserting that when the driver throws an exception we clear the breakers.
+        assertThat(bigArrays.breakerService().getBreaker(CircuitBreaker.REQUEST).getUsed(), equalTo(0L));
+        assertThat(inputFactoryContext.breaker().getUsed(), equalTo(0L));
     }
 
     /**
@@ -98,15 +113,24 @@ public final void testSimpleCircuitBreaking() {
      * in ctors.
      */
     public final void testSimpleWithCranky() {
-        CrankyCircuitBreakerService breaker = new CrankyCircuitBreakerService();
-        BigArrays bigArrays = new MockBigArrays(PageCacheRecycler.NON_RECYCLING_INSTANCE, breaker).withCircuitBreaking();
-        BlockFactory blockFactory = BlockFactory.getInstance(breaker.getBreaker("request"), bigArrays);
+        DriverContext inputFactoryContext = driverContext();
+        List<Page> input = CannedSourceOperator.collectPages(simpleInput(inputFactoryContext.blockFactory(), between(1_000, 10_000)));
+
+        CrankyCircuitBreakerService cranky = new CrankyCircuitBreakerService();
+        BigArrays bigArrays = new MockBigArrays(PageCacheRecycler.NON_RECYCLING_INSTANCE, cranky).withCircuitBreaking();
+        BlockFactory blockFactory = BlockFactory.getInstance(cranky.getBreaker(CircuitBreaker.REQUEST), bigArrays);
         try {
-            assertSimple(new DriverContext(bigArrays, blockFactory), between(1_000, 10_000));
+            List<Page> result = drive(simple(bigArrays).get(new DriverContext(bigArrays, blockFactory)), input.iterator());
+            Releasables.close(() -> Iterators.map(result.iterator(), p -> p::releaseBlocks));
             // Either we get lucky and cranky doesn't throw and the test completes or we don't and it throws
         } catch (CircuitBreakingException e) {
+            logger.info("broken", e);
             assertThat(e.getMessage(), equalTo(CrankyCircuitBreakerService.ERROR_MESSAGE));
         }
+
+        // Note the lack of try/finally here - we're asserting that when the driver throws an exception we clear the breakers.
+        assertThat(bigArrays.breakerService().getBreaker(CircuitBreaker.REQUEST).getUsed(), equalTo(0L));
+        assertThat(inputFactoryContext.breaker().getUsed(), equalTo(0L));
     }
 
     /**
@@ -139,10 +163,12 @@ protected final List<Page> oneDriverPerPageList(Iterator<List<Page>> source, Sup
     }
 
     private void assertSimple(DriverContext context, int size) {
-        List<Page> input = CannedSourceOperator.collectPages(simpleInput(size));
+        List<Page> input = CannedSourceOperator.collectPages(simpleInput(context.blockFactory(), size));
+        // Clone the input so that the operator can close it, then, later, we can read it again to build the assertion.
+        List<Page> inputClone = CannedSourceOperator.deepCopyOf(input);
         BigArrays bigArrays = context.bigArrays().withCircuitBreaking();
         List<Page> results = drive(simple(bigArrays).get(context), input.iterator());
-        assertSimpleOutput(input, results);
+        assertSimpleOutput(inputClone, results);
         results.forEach(Page::releaseBlocks);
         assertThat(bigArrays.breakerService().getBreaker(CircuitBreaker.REQUEST).getUsed(), equalTo(0L));
     }
@@ -180,7 +206,11 @@ public static void runDriver(List<Driver> drivers) {
                     "dummy-session",
                     new DriverContext(BigArrays.NON_RECYCLING_INSTANCE, BlockFactory.getNonBreakingInstance()),
                     () -> "dummy-driver",
-                    new SequenceLongBlockSourceOperator(LongStream.range(0, between(1, 100)), between(1, 100)),
+                    new SequenceLongBlockSourceOperator(
+                        BlockFactory.getNonBreakingInstance(),
+                        LongStream.range(0, between(1, 100)),
+                        between(1, 100)
+                    ),
                     List.of(),
                     new PageConsumerOperator(page -> {}),
                     Driver.DEFAULT_STATUS_INTERVAL,
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/ProjectOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/ProjectOperatorTests.java
index baa7842bdc1f9..6ec0183bbf224 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/ProjectOperatorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/ProjectOperatorTests.java
@@ -90,7 +90,7 @@ private List<Integer> randomProjection(int size) {
     }
 
     @Override
-    protected SourceOperator simpleInput(int end) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
         return new TupleBlockSourceOperator(blockFactory, LongStream.range(0, end).mapToObj(l -> Tuple.tuple(l, end - l)));
     }
 
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/SequenceLongBlockSourceOperator.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/SequenceLongBlockSourceOperator.java
index 0aa78f3ad0ab3..f7c3ee825d695 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/SequenceLongBlockSourceOperator.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/SequenceLongBlockSourceOperator.java
@@ -21,23 +21,27 @@ public class SequenceLongBlockSourceOperator extends AbstractBlockSourceOperator
 
     static final int DEFAULT_MAX_PAGE_POSITIONS = 8 * 1024;
 
+    private final BlockFactory blockFactory;
+
     private final long[] values;
 
-    public SequenceLongBlockSourceOperator(LongStream values) {
-        this(values, DEFAULT_MAX_PAGE_POSITIONS);
+    public SequenceLongBlockSourceOperator(BlockFactory blockFactory, LongStream values) {
+        this(blockFactory, values, DEFAULT_MAX_PAGE_POSITIONS);
     }
 
-    public SequenceLongBlockSourceOperator(LongStream values, int maxPagePositions) {
+    public SequenceLongBlockSourceOperator(BlockFactory blockFactory, LongStream values, int maxPagePositions) {
         super(maxPagePositions);
+        this.blockFactory = blockFactory;
         this.values = values.toArray();
     }
 
-    public SequenceLongBlockSourceOperator(List<Long> values) {
-        this(values, DEFAULT_MAX_PAGE_POSITIONS);
+    public SequenceLongBlockSourceOperator(BlockFactory blockFactory, List<Long> values) {
+        this(blockFactory, values, DEFAULT_MAX_PAGE_POSITIONS);
     }
 
-    public SequenceLongBlockSourceOperator(List<Long> values, int maxPagePositions) {
+    public SequenceLongBlockSourceOperator(BlockFactory blockFactory, List<Long> values, int maxPagePositions) {
         super(maxPagePositions);
+        this.blockFactory = blockFactory;
         this.values = values.stream().mapToLong(Long::longValue).toArray();
     }
 
@@ -48,7 +52,7 @@ protected Page createPage(int positionOffset, int length) {
             array[i] = values[positionOffset + i];
         }
         currentPosition += length;
-        return new Page(BlockFactory.getNonBreakingInstance().newLongArrayVector(array, array.length).asBlock()); // TODO: just for compile
+        return new Page(blockFactory.newLongArrayVector(array, array.length).asBlock()); // TODO: just for compile
     }
 
     protected int remaining() {
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/StringExtractOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/StringExtractOperatorTests.java
index f3c67f18589fa..1e72ecb0c3ee4 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/StringExtractOperatorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/StringExtractOperatorTests.java
@@ -11,6 +11,7 @@
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.BytesRefBlock;
 import org.elasticsearch.compute.data.Page;
 
@@ -25,7 +26,7 @@
 
 public class StringExtractOperatorTests extends OperatorTestCase {
     @Override
-    protected SourceOperator simpleInput(int end) {
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int end) {
         List<BytesRef> input = LongStream.range(0, end)
             .mapToObj(l -> new BytesRef("word1_" + l + " word2_" + l + " word3_" + l))
             .collect(Collectors.toList());
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/TupleBlockSourceOperator.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/TupleBlockSourceOperator.java
index 78cff5897c917..9b87dbe01224a 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/TupleBlockSourceOperator.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/TupleBlockSourceOperator.java
@@ -26,10 +26,6 @@ public class TupleBlockSourceOperator extends AbstractBlockSourceOperator {
 
     private final List<Tuple<Long, Long>> values;
 
-    public TupleBlockSourceOperator(Stream<Tuple<Long, Long>> values) {
-        this(BlockFactory.getNonBreakingInstance(), values, DEFAULT_MAX_PAGE_POSITIONS);
-    }
-
     public TupleBlockSourceOperator(BlockFactory blockFactory, Stream<Tuple<Long, Long>> values) {
         this(blockFactory, values, DEFAULT_MAX_PAGE_POSITIONS);
     }
@@ -40,14 +36,14 @@ public TupleBlockSourceOperator(BlockFactory blockFactory, Stream<Tuple<Long, Lo
         this.values = values.toList();
     }
 
-    public TupleBlockSourceOperator(List<Tuple<Long, Long>> values) {
-        this(values, DEFAULT_MAX_PAGE_POSITIONS);
+    public TupleBlockSourceOperator(BlockFactory blockFactory, List<Tuple<Long, Long>> values) {
+        this(blockFactory, values, DEFAULT_MAX_PAGE_POSITIONS);
     }
 
-    public TupleBlockSourceOperator(List<Tuple<Long, Long>> values, int maxPagePositions) {
+    public TupleBlockSourceOperator(BlockFactory blockFactory, List<Tuple<Long, Long>> values, int maxPagePositions) {
         super(maxPagePositions);
+        this.blockFactory = blockFactory;
         this.values = values;
-        blockFactory = BlockFactory.getNonBreakingInstance();
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/topn/ExtractorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/topn/ExtractorTests.java
index d79fde19f5487..9c4358e5d9ee0 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/topn/ExtractorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/topn/ExtractorTests.java
@@ -14,6 +14,7 @@
 import org.elasticsearch.common.breaker.CircuitBreaker;
 import org.elasticsearch.common.breaker.NoopCircuitBreaker;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.BlockTestUtils;
 import org.elasticsearch.compute.data.BlockUtils;
 import org.elasticsearch.compute.data.DocVector;
@@ -142,7 +143,13 @@ public void testNotInKey() {
         ValueExtractor.extractorFor(testCase.type, testCase.encoder.toUnsortable(), false, value).writeValue(valuesBuilder, 0);
         assertThat(valuesBuilder.length(), greaterThan(0));
 
-        ResultBuilder result = ResultBuilder.resultBuilderFor(testCase.type, testCase.encoder.toUnsortable(), false, 1);
+        ResultBuilder result = ResultBuilder.resultBuilderFor(
+            BlockFactory.getNonBreakingInstance(),
+            testCase.type,
+            testCase.encoder.toUnsortable(),
+            false,
+            1
+        );
         BytesRef values = valuesBuilder.bytesRefView();
         result.decodeValue(values);
         assertThat(values.length, equalTo(0));
@@ -163,7 +170,13 @@ public void testInKey() {
         ValueExtractor.extractorFor(testCase.type, testCase.encoder.toUnsortable(), true, value).writeValue(valuesBuilder, 0);
         assertThat(valuesBuilder.length(), greaterThan(0));
 
-        ResultBuilder result = ResultBuilder.resultBuilderFor(testCase.type, testCase.encoder.toUnsortable(), true, 1);
+        ResultBuilder result = ResultBuilder.resultBuilderFor(
+            BlockFactory.getNonBreakingInstance(),
+            testCase.type,
+            testCase.encoder.toUnsortable(),
+            true,
+            1
+        );
         BytesRef keys = keysBuilder.bytesRefView();
         if (testCase.type == ElementType.NULL) {
             assertThat(keys.length, equalTo(1));
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/topn/TopNOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/topn/TopNOperatorTests.java
index 7491ffde6766e..95f6613d3c0a4 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/topn/TopNOperatorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/topn/TopNOperatorTests.java
@@ -15,6 +15,7 @@
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.common.util.MockBigArrays;
+import org.elasticsearch.common.util.PageCacheRecycler;
 import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.BlockFactory;
 import org.elasticsearch.compute.data.BooleanBlock;
@@ -37,16 +38,21 @@
 import org.elasticsearch.compute.operator.TupleBlockSourceOperator;
 import org.elasticsearch.core.Tuple;
 import org.elasticsearch.test.ESTestCase;
+import org.elasticsearch.test.ListMatcher;
 import org.elasticsearch.xpack.versionfield.Version;
+import org.junit.After;
 
+import java.lang.reflect.Field;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -143,8 +149,12 @@ protected String expectedToStringOfSimple() {
     }
 
     @Override
-    protected SourceOperator simpleInput(int size) {
-        return new SequenceLongBlockSourceOperator(LongStream.range(0, size).map(l -> ESTestCase.randomLong()), between(1, size * 2));
+    protected SourceOperator simpleInput(BlockFactory blockFactory, int size) {
+        return new SequenceLongBlockSourceOperator(
+            blockFactory,
+            LongStream.range(0, size).map(l -> ESTestCase.randomLong()),
+            between(1, size * 2)
+        );
     }
 
     @Override
@@ -180,26 +190,48 @@ protected ByteSizeValue smallEnoughToCircuitBreak() {
     }
 
     public void testRamBytesUsed() {
+        RamUsageTester.Accumulator acc = new RamUsageTester.Accumulator() {
+            @Override
+            public long accumulateObject(Object o, long shallowSize, Map<Field, Object> fieldValues, Collection<Object> queue) {
+                if (o instanceof ElementType) {
+                    return 0; // shared
+                }
+                if (o instanceof TopNEncoder) {
+                    return 0; // shared
+                }
+                if (o instanceof CircuitBreaker) {
+                    return 0; // shared
+                }
+                if (o instanceof BlockFactory) {
+                    return 0; // shard
+                }
+                return super.accumulateObject(o, shallowSize, fieldValues, queue);
+            }
+        };
         int topCount = 10_000;
         // We under-count by a few bytes because of the lists. In that end that's fine, but we need to account for it here.
-        long underCount = 100;
-        TopNOperator op = new TopNOperator.TopNOperatorFactory(
-            topCount,
-            List.of(LONG),
-            List.of(DEFAULT_UNSORTABLE),
-            List.of(new TopNOperator.SortOrder(0, true, false)),
-            pageSize
-        ).get(driverContext());
-        long actualEmpty = RamUsageTester.ramUsed(op) - RamUsageTester.ramUsed(LONG) - RamUsageTester.ramUsed(DEFAULT_UNSORTABLE)
-            - RamUsageTester.ramUsed(op.breaker());
-        assertThat(op.ramBytesUsed(), both(greaterThan(actualEmpty - underCount)).and(lessThan(actualEmpty)));
-        // But when we fill it then we're quite close
-        for (Page p : CannedSourceOperator.collectPages(simpleInput(topCount))) {
-            op.addInput(p);
+        long underCount = 200;
+        DriverContext context = driverContext();
+        try (
+            TopNOperator op = new TopNOperator.TopNOperatorFactory(
+                topCount,
+                List.of(LONG),
+                List.of(DEFAULT_UNSORTABLE),
+                List.of(new TopNOperator.SortOrder(0, true, false)),
+                pageSize
+            ).get(context)
+        ) {
+            long actualEmpty = RamUsageTester.ramUsed(op, acc);
+            assertThat(op.ramBytesUsed(), both(greaterThan(actualEmpty - underCount)).and(lessThan(actualEmpty)));
+            // But when we fill it then we're quite close
+            for (Page p : CannedSourceOperator.collectPages(simpleInput(context.blockFactory(), topCount))) {
+                op.addInput(p);
+            }
+            long actualFull = RamUsageTester.ramUsed(op, acc);
+            assertThat(op.ramBytesUsed(), both(greaterThan(actualFull - underCount)).and(lessThan(actualFull)));
+
+            // TODO empty it again and check.
         }
-        long actualFull = RamUsageTester.ramUsed(op) - RamUsageTester.ramUsed(LONG) - RamUsageTester.ramUsed(DEFAULT_UNSORTABLE)
-            - RamUsageTester.ramUsed(op.breaker());
-        assertThat(op.ramBytesUsed(), both(greaterThan(actualFull - underCount)).and(lessThan(actualFull)));
     }
 
     public void testRandomTopN() {
@@ -471,6 +503,7 @@ public void testCollectAllValues() {
                 new CannedSourceOperator(List.of(new Page(blocks.toArray(Block[]::new))).iterator()),
                 List.of(
                     new TopNOperator(
+                        blockFactory,
                         nonBreakingBigArrays().breakerService().getBreaker("request"),
                         topCount,
                         elementTypes,
@@ -559,6 +592,7 @@ public void testCollectAllValues_RandomMultiValues() {
                 new CannedSourceOperator(List.of(new Page(blocks.toArray(Block[]::new))).iterator()),
                 List.of(
                     new TopNOperator(
+                        blockFactory,
                         nonBreakingBigArrays().breakerService().getBreaker("request"),
                         topCount,
                         elementTypes,
@@ -590,9 +624,10 @@ private List<Tuple<Long, Long>> topNTwoColumns(
         try (
             Driver driver = new Driver(
                 driverContext,
-                new TupleBlockSourceOperator(inputValues, randomIntBetween(1, 1000)),
+                new TupleBlockSourceOperator(driverContext.blockFactory(), inputValues, randomIntBetween(1, 1000)),
                 List.of(
                     new TopNOperator(
+                        driverContext.blockFactory(),
                         nonBreakingBigArrays().breakerService().getBreaker("request"),
                         limit,
                         elementTypes,
@@ -607,6 +642,7 @@ private List<Tuple<Long, Long>> topNTwoColumns(
                     for (int i = 0; i < block1.getPositionCount(); i++) {
                         outputValues.add(tuple(block1.isNull(i) ? null : block1.getLong(i), block2.isNull(i) ? null : block2.getLong(i)));
                     }
+                    page.releaseBlocks();
                 }),
                 () -> {}
             )
@@ -848,6 +884,7 @@ private void assertSortingOnMV(
         TopNEncoder encoder,
         TopNOperator.SortOrder... sortOrders
     ) {
+        DriverContext driverContext = driverContext();
         Block block = TestBlockBuilder.blockFromValues(values, blockType);
         assert block.mvOrdering() == Block.MvOrdering.UNORDERED : "Blocks created for this test must have unordered multi-values";
         Page page = new Page(block);
@@ -856,10 +893,11 @@ private void assertSortingOnMV(
         int topCount = randomIntBetween(1, values.size());
         try (
             Driver driver = new Driver(
-                driverContext(),
+                driverContext,
                 new CannedSourceOperator(List.of(page).iterator()),
                 List.of(
                     new TopNOperator(
+                        driverContext.blockFactory(),
                         nonBreakingBigArrays().breakerService().getBreaker("request"),
                         topCount,
                         List.of(blockType),
@@ -878,6 +916,7 @@ private void assertSortingOnMV(
     }
 
     public void testRandomMultiValuesTopN() {
+        DriverContext driverContext = driverContext();
         int rows = randomIntBetween(50, 100);
         int topCount = randomIntBetween(1, rows);
         int blocksCount = randomIntBetween(20, 30);
@@ -969,8 +1008,9 @@ public void testRandomMultiValuesTopN() {
         }
 
         List<List<List<Object>>> actualValues = new ArrayList<>();
-        List<Page> results = this.drive(
+        List<Page> results = drive(
             new TopNOperator(
+                driverContext.blockFactory(),
                 nonBreakingBigArrays().breakerService().getBreaker("request"),
                 topCount,
                 elementTypes,
@@ -982,6 +1022,7 @@ public void testRandomMultiValuesTopN() {
         );
         for (Page p : results) {
             readAsRows(actualValues, p);
+            p.releaseBlocks();
         }
 
         List<List<List<Object>>> topNExpectedValues = expectedValues.stream()
@@ -1003,13 +1044,15 @@ public void testIPSortingSingleValue() throws UnknownHostException {
             append(builder, new BytesRef(InetAddressPoint.encode(InetAddress.getByName(ip))));
         }
 
+        DriverContext driverContext = driverContext();
         List<List<Object>> actual = new ArrayList<>();
         try (
             Driver driver = new Driver(
-                driverContext(),
+                driverContext,
                 new CannedSourceOperator(List.of(new Page(builder.build())).iterator()),
                 List.of(
                     new TopNOperator(
+                        driverContext.blockFactory(),
                         nonBreakingBigArrays().breakerService().getBreaker("request"),
                         ips.size(),
                         List.of(BYTES_REF),
@@ -1128,12 +1171,14 @@ private void assertIPSortingOnMultiValues(
         }
 
         List<List<Object>> actual = new ArrayList<>();
+        DriverContext driverContext = driverContext();
         try (
             Driver driver = new Driver(
-                driverContext(),
+                driverContext,
                 new CannedSourceOperator(List.of(new Page(builder.build())).iterator()),
                 List.of(
                     new TopNOperator(
+                        driverContext.blockFactory(),
                         nonBreakingBigArrays().breakerService().getBreaker("request"),
                         ips.size(),
                         List.of(BYTES_REF),
@@ -1210,12 +1255,14 @@ public void testZeroByte() {
         blocks.add(builderInt.build());
 
         List<List<Object>> actual = new ArrayList<>();
+        DriverContext driverContext = driverContext();
         try (
             Driver driver = new Driver(
-                driverContext(),
+                driverContext,
                 new CannedSourceOperator(List.of(new Page(blocks.toArray(Block[]::new))).iterator()),
                 List.of(
                     new TopNOperator(
+                        driverContext.blockFactory(),
                         nonBreakingBigArrays().breakerService().getBreaker("request"),
                         2,
                         List.of(BYTES_REF, INT),
@@ -1243,10 +1290,55 @@ public void testZeroByte() {
         assertThat((Integer) actual.get(1).get(1), equalTo(100));
     }
 
+    public void testErrorBeforeFullyDraining() {
+        int maxPageSize = between(1, 100);
+        int topCount = maxPageSize * 4;
+        int docCount = topCount * 10;
+        List<List<Object>> actual = new ArrayList<>();
+        DriverContext driverContext = driverContext();
+        try (
+            Driver driver = new Driver(
+                driverContext,
+                new SequenceLongBlockSourceOperator(driverContext.blockFactory(), LongStream.range(0, docCount)),
+                List.of(
+                    new TopNOperator(
+                        driverContext.blockFactory(),
+                        nonBreakingBigArrays().breakerService().getBreaker("request"),
+                        topCount,
+                        List.of(LONG),
+                        List.of(DEFAULT_UNSORTABLE),
+                        List.of(new TopNOperator.SortOrder(0, true, randomBoolean())),
+                        maxPageSize
+                    )
+                ),
+                new PageConsumerOperator(p -> {
+                    assertThat(p.getPositionCount(), equalTo(maxPageSize));
+                    if (actual.isEmpty()) {
+                        readInto(actual, p);
+                    } else {
+                        p.releaseBlocks();
+                        throw new RuntimeException("boo");
+                    }
+                }),
+                () -> {}
+            )
+        ) {
+            Exception e = expectThrows(RuntimeException.class, () -> runDriver(driver));
+            assertThat(e.getMessage(), equalTo("boo"));
+        }
+
+        ListMatcher values = matchesList();
+        for (int i = 0; i < maxPageSize; i++) {
+            values = values.item((long) i);
+        }
+        assertMap(actual, matchesList().item(values));
+    }
+
     public void testCloseWithoutCompleting() {
         CircuitBreaker breaker = new MockBigArrays.LimitedBreaker(CircuitBreaker.REQUEST, ByteSizeValue.ofGb(1));
         try (
             TopNOperator op = new TopNOperator(
+                driverContext().blockFactory(),
                 breaker,
                 2,
                 List.of(INT),
@@ -1257,7 +1349,23 @@ public void testCloseWithoutCompleting() {
         ) {
             op.addInput(new Page(new IntArrayVector(new int[] { 1 }, 1).asBlock()));
         }
-        assertThat(breaker.getUsed(), equalTo(0L));
+    }
+
+    private final List<CircuitBreaker> breakers = new ArrayList<>();
+
+    @Override
+    protected DriverContext driverContext() { // TODO remove this when the parent uses a breaking block factory
+        BigArrays bigArrays = new MockBigArrays(PageCacheRecycler.NON_RECYCLING_INSTANCE, ByteSizeValue.ofGb(1)).withCircuitBreaking();
+        CircuitBreaker breaker = bigArrays.breakerService().getBreaker(CircuitBreaker.REQUEST);
+        breakers.add(breaker);
+        return new DriverContext(bigArrays, new BlockFactory(breaker, bigArrays));
+    }
+
+    @After
+    public void allBreakersEmpty() {
+        for (CircuitBreaker breaker : breakers) {
+            assertThat(breaker.getUsed(), equalTo(0L));
+        }
     }
 
     @SuppressWarnings({ "unchecked", "rawtypes" })
diff --git a/x-pack/plugin/esql/qa/server/single-node/src/yamlRestTest/resources/rest-api-spec/test/50_index_patterns.yml b/x-pack/plugin/esql/qa/server/single-node/src/yamlRestTest/resources/rest-api-spec/test/50_index_patterns.yml
index 280a32aa10cd3..bae0e623d12a3 100644
--- a/x-pack/plugin/esql/qa/server/single-node/src/yamlRestTest/resources/rest-api-spec/test/50_index_patterns.yml
+++ b/x-pack/plugin/esql/qa/server/single-node/src/yamlRestTest/resources/rest-api-spec/test/50_index_patterns.yml
@@ -235,35 +235,36 @@ disjoint_mappings:
   - length: { values: 1 }
   - match: { values.0.0: 2 }
 
-  - do:
-      esql.query:
-        body:
-          query: 'from test1,test2 | sort message1, message2 | eval x = message1, y = message2 + 1 | keep message1, message2, x, y'
-  - match: { columns.0.name: message1 }
-  - match: { columns.0.type: keyword }
-  - match: { columns.1.name: message2 }
-  - match: { columns.1.type: long }
-  - match: { columns.2.name: x }
-  - match: { columns.2.type: keyword }
-  - match: { columns.3.name: y }
-  - match: { columns.3.type: long }
-  - length: { values: 4 }
-  - match: { values.0.0: foo1 }
-  - match: { values.0.1: null }
-  - match: { values.0.2: foo1 }
-  - match: { values.0.3: null }
-  - match: { values.1.0: foo2 }
-  - match: { values.1.1: null }
-  - match: { values.1.2: foo2 }
-  - match: { values.1.3: null }
-  - match: { values.2.0: null }
-  - match: { values.2.1: 1 }
-  - match: { values.2.2: null }
-  - match: { values.2.3: 2 }
-  - match: { values.3.0: null }
-  - match: { values.3.1: 2 }
-  - match: { values.3.2: null }
-  - match: { values.3.3: 3 }
+# AwaitsFix https://github.com/elastic/elasticsearch/issues/99826
+#  - do:
+#      esql.query:
+#        body:
+#          query: 'from test1,test2 | sort message1, message2 | eval x = message1, y = message2 + 1 | keep message1, message2, x, y'
+#  - match: { columns.0.name: message1 }
+#  - match: { columns.0.type: keyword }
+#  - match: { columns.1.name: message2 }
+#  - match: { columns.1.type: long }
+#  - match: { columns.2.name: x }
+#  - match: { columns.2.type: keyword }
+#  - match: { columns.3.name: y }
+#  - match: { columns.3.type: long }
+#  - length: { values: 4 }
+#  - match: { values.0.0: foo1 }
+#  - match: { values.0.1: null }
+#  - match: { values.0.2: foo1 }
+#  - match: { values.0.3: null }
+#  - match: { values.1.0: foo2 }
+#  - match: { values.1.1: null }
+#  - match: { values.1.2: foo2 }
+#  - match: { values.1.3: null }
+#  - match: { values.2.0: null }
+#  - match: { values.2.1: 1 }
+#  - match: { values.2.2: null }
+#  - match: { values.2.3: 2 }
+#  - match: { values.3.0: null }
+#  - match: { values.3.1: 2 }
+#  - match: { values.3.2: null }
+#  - match: { values.3.3: 3 }
 
 ---
 same_name_different_type:
diff --git a/x-pack/plugin/esql/qa/testFixtures/src/main/resources/metadata-ignoreCsvTests.csv-spec b/x-pack/plugin/esql/qa/testFixtures/src/main/resources/metadata-ignoreCsvTests.csv-spec
index d89f3337c081b..82fd27416c526 100644
--- a/x-pack/plugin/esql/qa/testFixtures/src/main/resources/metadata-ignoreCsvTests.csv-spec
+++ b/x-pack/plugin/esql/qa/testFixtures/src/main/resources/metadata-ignoreCsvTests.csv-spec
@@ -7,7 +7,8 @@ emp_no:integer |_index:keyword |_version:long
 10002          |employees      |1
 ;
 
-aliasWithSameName
+# AwaitsFix https://github.com/elastic/elasticsearch/issues/99826
+aliasWithSameName-Ignore
 from employees [metadata _index, _version] | sort emp_no | limit 2 | eval _index = _index, _version = _version | keep emp_no, _index, _version;
 
 emp_no:integer |_index:keyword |_version:long
diff --git a/x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/action/EsqlActionIT.java b/x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/action/EsqlActionIT.java
index f8aeee1569f2e..800e36949f5ea 100644
--- a/x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/action/EsqlActionIT.java
+++ b/x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/action/EsqlActionIT.java
@@ -9,7 +9,6 @@
 
 import org.elasticsearch.Build;
 import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest;
-import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
 import org.elasticsearch.action.bulk.BulkRequestBuilder;
 import org.elasticsearch.action.delete.DeleteRequest;
 import org.elasticsearch.action.index.IndexRequest;
@@ -109,32 +108,33 @@ public void testFromStatsGroupingAvgWithAliases() {
     }
 
     private void testFromStatsGroupingAvgImpl(String command, String expectedGroupName, String expectedFieldName) {
-        EsqlQueryResponse results = run(command);
-        logger.info(results);
-        Assert.assertEquals(2, results.columns().size());
-
-        // assert column metadata
-        ColumnInfo valuesColumn = results.columns().get(0);
-        assertEquals(expectedFieldName, valuesColumn.name());
-        assertEquals("double", valuesColumn.type());
-        ColumnInfo groupColumn = results.columns().get(1);
-        assertEquals(expectedGroupName, groupColumn.name());
-        assertEquals("long", groupColumn.type());
+        try (EsqlQueryResponse results = run(command)) {
+            logger.info(results);
+            Assert.assertEquals(2, results.columns().size());
 
-        // assert column values
-        List<List<Object>> valueValues = getValuesList(results);
-        assertEquals(2, valueValues.size());
-        // This is loathsome, find a declarative way to assert the expected output.
-        if ((long) valueValues.get(0).get(1) == 1L) {
-            assertEquals(42.0, (double) valueValues.get(0).get(0), 0.0);
-            assertEquals(2L, (long) valueValues.get(1).get(1));
-            assertEquals(44.0, (double) valueValues.get(1).get(0), 0.0);
-        } else if ((long) valueValues.get(0).get(1) == 2L) {
-            assertEquals(42.0, (double) valueValues.get(1).get(0), 0.0);
-            assertEquals(1L, (long) valueValues.get(1).get(1));
-            assertEquals(44.0, (double) valueValues.get(0).get(0), 0.0);
-        } else {
-            fail("Unexpected group value: " + valueValues.get(0).get(0));
+            // assert column metadata
+            ColumnInfo valuesColumn = results.columns().get(0);
+            assertEquals(expectedFieldName, valuesColumn.name());
+            assertEquals("double", valuesColumn.type());
+            ColumnInfo groupColumn = results.columns().get(1);
+            assertEquals(expectedGroupName, groupColumn.name());
+            assertEquals("long", groupColumn.type());
+
+            // assert column values
+            List<List<Object>> valueValues = getValuesList(results);
+            assertEquals(2, valueValues.size());
+            // This is loathsome, find a declarative way to assert the expected output.
+            if ((long) valueValues.get(0).get(1) == 1L) {
+                assertEquals(42.0, (double) valueValues.get(0).get(0), 0.0);
+                assertEquals(2L, (long) valueValues.get(1).get(1));
+                assertEquals(44.0, (double) valueValues.get(1).get(0), 0.0);
+            } else if ((long) valueValues.get(0).get(1) == 2L) {
+                assertEquals(42.0, (double) valueValues.get(1).get(0), 0.0);
+                assertEquals(1L, (long) valueValues.get(1).get(1));
+                assertEquals(44.0, (double) valueValues.get(0).get(0), 0.0);
+            } else {
+                fail("Unexpected group value: " + valueValues.get(0).get(0));
+            }
         }
     }
 
@@ -211,19 +211,20 @@ public void testFromGroupingByNumericFieldWithNulls() {
             }
         }
         client().admin().indices().prepareRefresh("test").get();
-        EsqlQueryResponse results = run("from test | stats avg(count) by data | sort data");
-        logger.info(results);
+        try (EsqlQueryResponse results = run("from test | stats avg(count) by data | sort data")) {
+            logger.info(results);
 
-        assertThat(results.columns(), hasSize(2));
-        assertEquals("avg(count)", results.columns().get(0).name());
-        assertEquals("double", results.columns().get(0).type());
-        assertEquals("data", results.columns().get(1).name());
-        assertEquals("long", results.columns().get(1).type());
+            assertThat(results.columns(), hasSize(2));
+            assertEquals("avg(count)", results.columns().get(0).name());
+            assertEquals("double", results.columns().get(0).type());
+            assertEquals("data", results.columns().get(1).name());
+            assertEquals("long", results.columns().get(1).type());
 
-        record Group(Long data, Double avg) {}
-        List<Group> expectedGroups = List.of(new Group(1L, 42.0), new Group(2L, 44.0), new Group(99L, null), new Group(null, 12.0));
-        List<Group> actualGroups = getValuesList(results).stream().map(l -> new Group((Long) l.get(1), (Double) l.get(0))).toList();
-        assertThat(actualGroups, equalTo(expectedGroups));
+            record Group(Long data, Double avg) {}
+            List<Group> expectedGroups = List.of(new Group(1L, 42.0), new Group(2L, 44.0), new Group(99L, null), new Group(null, 12.0));
+            List<Group> actualGroups = getValuesList(results).stream().map(l -> new Group((Long) l.get(1), (Double) l.get(0))).toList();
+            assertThat(actualGroups, equalTo(expectedGroups));
+        }
     }
 
     public void testFromStatsGroupingByKeyword() {
@@ -332,18 +333,19 @@ record Group(double avg, long mi, long ma, long s, long c, String color) {}
     }
 
     public void testFromSortWithTieBreakerLimit() {
-        EsqlQueryResponse results = run("from test | sort data, count desc, time | limit 5 | keep data, count, time");
-        logger.info(results);
-        assertThat(
-            getValuesList(results),
-            contains(
-                List.of(1L, 44L, epoch + 2),
-                List.of(1L, 44L, epoch + 6),
-                List.of(1L, 44L, epoch + 10),
-                List.of(1L, 44L, epoch + 14),
-                List.of(1L, 44L, epoch + 18)
-            )
-        );
+        try (EsqlQueryResponse results = run("from test | sort data, count desc, time | limit 5 | keep data, count, time")) {
+            logger.info(results);
+            assertThat(
+                getValuesList(results),
+                contains(
+                    List.of(1L, 44L, epoch + 2),
+                    List.of(1L, 44L, epoch + 6),
+                    List.of(1L, 44L, epoch + 10),
+                    List.of(1L, 44L, epoch + 14),
+                    List.of(1L, 44L, epoch + 18)
+                )
+            );
+        }
     }
 
     public void testFromStatsProjectGroup() {
@@ -778,10 +780,11 @@ public void testFromStatsLimit() {
     }
 
     public void testFromLimit() {
-        EsqlQueryResponse results = run("from test | keep data | limit 2");
-        logger.info(results);
-        assertThat(results.columns(), contains(new ColumnInfo("data", "long")));
-        assertThat(getValuesList(results), contains(anyOf(contains(1L), contains(2L)), anyOf(contains(1L), contains(2L))));
+        try (EsqlQueryResponse results = run("from test | keep data | limit 2")) {
+            logger.info(results);
+            assertThat(results.columns(), contains(new ColumnInfo("data", "long")));
+            assertThat(getValuesList(results), contains(anyOf(contains(1L), contains(2L)), anyOf(contains(1L), contains(2L))));
+        }
     }
 
     public void testDropAllColumns() {
@@ -1000,27 +1003,25 @@ public void testTopNPushedToLuceneOnSortedIndex() {
         );
 
         int limit = randomIntBetween(1, 5);
-        EsqlQueryResponse results = run("from sorted_test_index | sort time " + sortOrder + " | limit " + limit + " | keep time");
-        logger.info(results);
-        Assert.assertEquals(1, results.columns().size());
-        Assert.assertEquals(limit, getValuesList(results).size());
-
-        // assert column metadata
-        assertEquals("time", results.columns().get(0).name());
-        assertEquals("long", results.columns().get(0).type());
+        try (EsqlQueryResponse results = run("from sorted_test_index | sort time " + sortOrder + " | limit " + limit + " | keep time")) {
+            logger.info(results);
+            Assert.assertEquals(1, results.columns().size());
+            Assert.assertEquals(limit, getValuesList(results).size());
 
-        boolean sortedDesc = "desc".equals(sortOrder);
-        var expected = LongStream.range(0, 40)
-            .map(i -> epoch + i)
-            .boxed()
-            .sorted(sortedDesc ? reverseOrder() : naturalOrder())
-            .limit(limit)
-            .toList();
-        var actual = getValuesList(results).stream().map(l -> (Long) l.get(0)).toList();
-        assertThat(actual, equalTo(expected));
+            // assert column metadata
+            assertEquals("time", results.columns().get(0).name());
+            assertEquals("long", results.columns().get(0).type());
 
-        // clean-up
-        client().admin().indices().delete(new DeleteIndexRequest("sorted_test_index")).actionGet();
+            boolean sortedDesc = "desc".equals(sortOrder);
+            var expected = LongStream.range(0, 40)
+                .map(i -> epoch + i)
+                .boxed()
+                .sorted(sortedDesc ? reverseOrder() : naturalOrder())
+                .limit(limit)
+                .toList();
+            var actual = getValuesList(results).stream().map(l -> (Long) l.get(0)).toList();
+            assertThat(actual, equalTo(expected));
+        }
     }
 
     /*
diff --git a/x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/action/EsqlDisruptionIT.java b/x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/action/EsqlDisruptionIT.java
index 19893bf8072f1..2636a7cf3c133 100644
--- a/x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/action/EsqlDisruptionIT.java
+++ b/x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/action/EsqlDisruptionIT.java
@@ -7,6 +7,7 @@
 
 package org.elasticsearch.xpack.esql.action;
 
+import org.apache.lucene.tests.util.LuceneTestCase;
 import org.elasticsearch.action.ActionFuture;
 import org.elasticsearch.cluster.coordination.Coordinator;
 import org.elasticsearch.cluster.coordination.FollowersChecker;
@@ -18,6 +19,7 @@
 import org.elasticsearch.test.ESIntegTestCase;
 import org.elasticsearch.test.disruption.NetworkDisruption;
 import org.elasticsearch.test.disruption.ServiceDisruptionScheme;
+import org.elasticsearch.test.junit.annotations.TestLogging;
 import org.elasticsearch.test.transport.MockTransportService;
 import org.elasticsearch.transport.TransportSettings;
 
@@ -29,7 +31,9 @@
 import static org.elasticsearch.test.ESIntegTestCase.Scope.TEST;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
 
+@TestLogging(value = "org.elasticsearch.indices.breaker:TRACE", reason = "failing")
 @ESIntegTestCase.ClusterScope(scope = TEST, minNumDataNodes = 2, maxNumDataNodes = 4)
+@LuceneTestCase.AwaitsFix(bugUrl = "https://github.com/elastic/elasticsearch/issues/99173")
 public class EsqlDisruptionIT extends EsqlActionIT {
 
     // copied from AbstractDisruptionTestCase

From 0fc9fa232c3107308b7a4182136fcfee12a4b007 Mon Sep 17 00:00:00 2001
From: David Roberts <dave.roberts@elastic.co>
Date: Thu, 28 Sep 2023 18:43:42 +0100
Subject: [PATCH 16/32] [ML] Reducing use of DiscoveryNode.getVersion (#100024)

Remove as much usage as possible of DiscoveryNode.getVersion.
Generally for these cases we should be using MlConfigVersion.
---
 .../ml/action/TrainedModelValidator.java      |  2 +-
 ...ransportStartDataFrameAnalyticsAction.java |  2 +-
 .../xpack/ml/job/JobNodeSelector.java         |  3 +-
 .../task/OpenJobPersistentTasksExecutor.java  |  2 +-
 .../ml/action/TrainedModelValidatorTests.java | 45 ++++++++++---------
 .../xpack/ml/job/JobNodeSelectorTests.java    | 35 ++++++++++-----
 6 files changed, 54 insertions(+), 35 deletions(-)

diff --git a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TrainedModelValidator.java b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TrainedModelValidator.java
index d1d66299db67f..acd0a124d59c2 100644
--- a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TrainedModelValidator.java
+++ b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TrainedModelValidator.java
@@ -59,7 +59,7 @@ static void validateMinimumVersion(ModelPackageConfig resolvedModelPackageConfig
         if (MlConfigVersion.getMinMlConfigVersion(state.nodes()).before(minimumVersion)) {
             throw new ActionRequestValidationException().addValidationError(
                 format(
-                    "The model [%s] requires that all nodes are at least version [%s]",
+                    "The model [%s] requires that all nodes have ML config version [%s] or higher",
                     resolvedModelPackageConfig.getPackagedModelId(),
                     resolvedModelPackageConfig.getMinimumVersion()
                 )
diff --git a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TransportStartDataFrameAnalyticsAction.java b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TransportStartDataFrameAnalyticsAction.java
index 2a1844ea1fccf..ab215106c8ed0 100644
--- a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TransportStartDataFrameAnalyticsAction.java
+++ b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TransportStartDataFrameAnalyticsAction.java
@@ -807,7 +807,7 @@ public static String nodeFilter(DiscoveryNode node, TaskParams params) {
                     + id
                     + "] on node ["
                     + JobNodeSelector.nodeNameAndVersion(node)
-                    + "], because the data frame analytics requires a node of version ["
+                    + "], because the data frame analytics requires a node with ML config version ["
                     + TaskParams.VERSION_INTRODUCED
                     + "] or higher";
             }
diff --git a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/job/JobNodeSelector.java b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/job/JobNodeSelector.java
index 2997af2e5a1a8..a24e671d1fe25 100644
--- a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/job/JobNodeSelector.java
+++ b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/job/JobNodeSelector.java
@@ -14,6 +14,7 @@
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.core.Tuple;
 import org.elasticsearch.persistent.PersistentTasksCustomMetadata;
+import org.elasticsearch.xpack.core.ml.MlConfigVersion;
 import org.elasticsearch.xpack.ml.MachineLearning;
 import org.elasticsearch.xpack.ml.autoscaling.NativeMemoryCapacity;
 import org.elasticsearch.xpack.ml.process.MlMemoryTracker;
@@ -346,7 +347,7 @@ static String nodeNameOrId(DiscoveryNode node) {
     public static String nodeNameAndVersion(DiscoveryNode node) {
         String nodeNameOrID = nodeNameOrId(node);
         StringBuilder builder = new StringBuilder("{").append(nodeNameOrID).append('}');
-        builder.append('{').append("version=").append(node.getVersion()).append('}');
+        builder.append('{').append("ML config version=").append(MlConfigVersion.fromNode(node)).append('}');
         return builder.toString();
     }
 
diff --git a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/job/task/OpenJobPersistentTasksExecutor.java b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/job/task/OpenJobPersistentTasksExecutor.java
index b19c0fb670a59..15b1993dc0586 100644
--- a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/job/task/OpenJobPersistentTasksExecutor.java
+++ b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/job/task/OpenJobPersistentTasksExecutor.java
@@ -179,7 +179,7 @@ public static String nodeFilter(DiscoveryNode node, Job job) {
                 + jobId
                 + "] on node ["
                 + JobNodeSelector.nodeNameAndVersion(node)
-                + "], because the job's model snapshot requires a node of version ["
+                + "], because the job's model snapshot requires a node with ML config version ["
                 + job.getModelSnapshotMinVersion()
                 + "] or higher";
         }
diff --git a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/action/TrainedModelValidatorTests.java b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/action/TrainedModelValidatorTests.java
index d99147e6b4e98..f8755b282c6a1 100644
--- a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/action/TrainedModelValidatorTests.java
+++ b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/action/TrainedModelValidatorTests.java
@@ -11,13 +11,16 @@
 import org.elasticsearch.action.ActionRequestValidationException;
 import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.node.DiscoveryNode;
+import org.elasticsearch.cluster.node.DiscoveryNodeRole;
+import org.elasticsearch.cluster.node.DiscoveryNodeUtils;
 import org.elasticsearch.cluster.node.DiscoveryNodes;
-import org.elasticsearch.index.IndexVersion;
+import org.elasticsearch.common.transport.TransportAddress;
 import org.elasticsearch.test.ESTestCase;
 import org.elasticsearch.xpack.core.ml.MlConfigVersion;
 import org.elasticsearch.xpack.core.ml.inference.trainedmodel.ModelPackageConfig;
 import org.elasticsearch.xpack.core.ml.inference.trainedmodel.ModelPackageConfigTests;
 
+import java.net.InetAddress;
 import java.util.Map;
 
 import static org.mockito.Mockito.mock;
@@ -31,12 +34,14 @@ public void testValidateMinimumVersion() {
                 .setMinimumVersion("9999.0.0")
                 .build();
 
-            DiscoveryNode node = mock(DiscoveryNode.class);
             final Map<String, String> attributes = Map.of(MlConfigVersion.ML_CONFIG_VERSION_NODE_ATTR, MlConfigVersion.CURRENT.toString());
-            when(node.getAttributes()).thenReturn(attributes);
-            when(node.getVersion()).thenReturn(Version.CURRENT);
-            when(node.getMinIndexVersion()).thenReturn(IndexVersion.current());
-            when(node.getId()).thenReturn("node1");
+            DiscoveryNode node = DiscoveryNodeUtils.create(
+                "node1name",
+                "node1",
+                new TransportAddress(InetAddress.getLoopbackAddress(), 9301),
+                attributes,
+                DiscoveryNodeRole.roles()
+            );
 
             DiscoveryNodes nodes = DiscoveryNodes.builder().add(node).build();
 
@@ -52,7 +57,7 @@ public void testValidateMinimumVersion() {
             assertEquals(
                 "Validation Failed: 1: The model ["
                     + packageConfig.getPackagedModelId()
-                    + "] requires that all nodes are at least version [9999.0.0];",
+                    + "] requires that all nodes have ML config version [9999.0.0] or higher;",
                 e.getMessage()
             );
         }
@@ -63,12 +68,11 @@ public void testValidateMinimumVersion() {
                 ModelPackageConfigTests.randomModulePackageConfig()
             ).setMinimumVersion(MlConfigVersion.CURRENT.toString()).build();
 
-            DiscoveryNode node = mock(DiscoveryNode.class);
-            final Map<String, String> attributes = Map.of(MlConfigVersion.ML_CONFIG_VERSION_NODE_ATTR, MlConfigVersion.V_8_7_0.toString());
-            when(node.getAttributes()).thenReturn(attributes);
-            when(node.getVersion()).thenReturn(Version.V_8_7_0);
-            when(node.getMinIndexVersion()).thenReturn(IndexVersion.current());
-            when(node.getId()).thenReturn("node1");
+            DiscoveryNode node = DiscoveryNodeUtils.create(
+                "node1",
+                new TransportAddress(InetAddress.getLoopbackAddress(), 9300),
+                Version.V_8_7_0
+            );
 
             DiscoveryNodes nodes = DiscoveryNodes.builder().add(node).build();
 
@@ -82,9 +86,9 @@ public void testValidateMinimumVersion() {
             assertEquals(
                 "Validation Failed: 1: The model ["
                     + packageConfigCurrent.getPackagedModelId()
-                    + "] requires that all nodes are at least version ["
+                    + "] requires that all nodes have ML config version ["
                     + MlConfigVersion.CURRENT
-                    + "];",
+                    + "] or higher;",
                 e.getMessage()
             );
         }
@@ -95,12 +99,11 @@ public void testValidateMinimumVersion() {
                 ModelPackageConfigTests.randomModulePackageConfig()
             ).setMinimumVersion("_broken_version_").build();
 
-            DiscoveryNode node = mock(DiscoveryNode.class);
-            final Map<String, String> attributes = Map.of(MlConfigVersion.ML_CONFIG_VERSION_NODE_ATTR, MlConfigVersion.V_8_7_0.toString());
-            when(node.getAttributes()).thenReturn(attributes);
-            when(node.getVersion()).thenReturn(Version.V_8_7_0);
-            when(node.getMinIndexVersion()).thenReturn(IndexVersion.current());
-            when(node.getId()).thenReturn("node1");
+            DiscoveryNode node = DiscoveryNodeUtils.create(
+                "node1",
+                new TransportAddress(InetAddress.getLoopbackAddress(), 9300),
+                Version.V_8_7_0
+            );
 
             DiscoveryNodes nodes = DiscoveryNodes.builder().add(node).build();
 
diff --git a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/job/JobNodeSelectorTests.java b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/job/JobNodeSelectorTests.java
index 19546b37c00cd..ab815aad543b8 100644
--- a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/job/JobNodeSelectorTests.java
+++ b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/job/JobNodeSelectorTests.java
@@ -42,7 +42,6 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -81,12 +80,25 @@ public void setup() {
         when(memoryTracker.getJobMemoryRequirement(anyString(), anyString())).thenReturn(JOB_MEMORY_REQUIREMENT.getBytes());
     }
 
-    public void testNodeNameAndVersion() {
+    public void testNodeNameAndVersionForRecentNode() {
         TransportAddress ta = new TransportAddress(InetAddress.getLoopbackAddress(), 9300);
-        Map<String, String> attributes = new HashMap<>();
-        attributes.put("unrelated", "attribute");
+        Map<String, String> attributes = Map.of(MlConfigVersion.ML_CONFIG_VERSION_NODE_ATTR, "10.0.0", "unrelated", "attribute");
         DiscoveryNode node = DiscoveryNodeUtils.create("_node_name1", "_node_id1", ta, attributes, ROLES_WITHOUT_ML);
-        assertEquals("{_node_name1}{version=" + node.getVersion() + "}", JobNodeSelector.nodeNameAndVersion(node));
+        assertEquals("{_node_name1}{ML config version=10.0.0}", JobNodeSelector.nodeNameAndVersion(node));
+    }
+
+    public void testNodeNameAndVersionForOldNode() {
+        TransportAddress ta = new TransportAddress(InetAddress.getLoopbackAddress(), 9300);
+        Map<String, String> attributes = Map.of("unrelated", "attribute");
+        DiscoveryNode node = new DiscoveryNode(
+            "_node_name2",
+            "_node_id2",
+            ta,
+            attributes,
+            ROLES_WITH_ML,
+            VersionInformation.inferVersions(Version.V_8_7_0)
+        );
+        assertEquals("{_node_name2}{ML config version=8.7.0}", JobNodeSelector.nodeNameAndVersion(node));
     }
 
     public void testNodeNameAndMlAttributes() {
@@ -869,12 +881,12 @@ public void testSelectLeastLoadedMlNode_reasonsAreInDeterministicOrder() {
         assertThat(
             result.getExplanation(),
             equalTo(
-                "Not opening job [incompatible_type_job] on node [{_node_name1}{version="
-                    + Version.CURRENT
+                "Not opening job [incompatible_type_job] on node [{_node_name1}{ML config version="
+                    + MlConfigVersion.CURRENT
                     + "}], "
                     + "because this node does not support jobs of type [incompatible_type]|"
-                    + "Not opening job [incompatible_type_job] on node [{_node_name2}{version="
-                    + Version.CURRENT
+                    + "Not opening job [incompatible_type_job] on node [{_node_name2}{ML config version="
+                    + MlConfigVersion.CURRENT
                     + "}], "
                     + "because this node does not support jobs of type [incompatible_type]"
             )
@@ -946,7 +958,10 @@ public void testSelectLeastLoadedMlNode_noNodesMatchingModelSnapshotMinVersion()
             node -> nodeFilter(node, job)
         );
         PersistentTasksCustomMetadata.Assignment result = jobNodeSelector.selectNode(10, 2, 30, MAX_JOB_BYTES, false);
-        assertThat(result.getExplanation(), containsString("job's model snapshot requires a node of version [7.3.0] or higher"));
+        assertThat(
+            result.getExplanation(),
+            containsString("job's model snapshot requires a node with ML config version [7.3.0] or higher")
+        );
         assertNull(result.getExecutorNode());
     }
 

From f202ad02fe65da38bcbc91d626bb087ca2ce236e Mon Sep 17 00:00:00 2001
From: Andrei Dan <andrei.dan@elastic.co>
Date: Thu, 28 Sep 2023 18:48:17 +0100
Subject: [PATCH 17/32] GET _data_stream displays both ILM and DSL information
 (#99947)

This add support to the `GET _data_stream` API for displaying the value
of the `index.lifecycle.prefer_ilm` setting both at the backing index
level and at the top level (top level meaning, similarly to the existing
`ilm_policy` field, the value in the index template that's backing the
data stream), an `ilm_policy` field for each backing index displaying
the actual ILM policy configured for the index itself, a `managed_by`
field for each backing index indicating who manages this index (the
possible values are: `Index Lifecycle Management`, `Data stream
lifecycle`, and `Unmanaged`).

This also adds a top level field to indicate which system would manage
the next generation index for this data stream based on the current
configuration. This field is called `next_generation_managed_by` and the
same values as the indices level `managed_by` field has are available.

An example output for a data stream that has 2 backing indices managed
by ILM and the write index by DSL:

```
{
	"data_streams": [{
		"name": "datastream-psnyudmbitp",
		"timestamp_field": {
			"name": "@timestamp"
		},
		"indices": [{
			"index_name": ".ds-datastream-psnyudmbitp-2023.09.27-000001",
			"index_uuid": "kyw0WEXvS8-ahchYS10NRQ",
                        "prefer_ilm": true,
			"ilm_policy": "policy-uVBEI",
			"managed_by": "Index Lifecycle Management"
		}, {
			"index_name": ".ds-datastream-psnyudmbitp-2023.09.27-000002",
			"index_uuid": "pDLdc4DERwO54GRzDr4krw",
			"prefer_ilm": true,
			"ilm_policy": "policy-uVBEI",
			"managed_by": "Index Lifecycle Management"
		}, {
			"index_name": ".ds-datastream-psnyudmbitp-2023.09.27-000003",
			"index_uuid": "gYZirLKcS3mlc1c3oHRpYw",
			"prefer_ilm": false,
			"ilm_policy": "policy-uVBEI",
                        "managed_by": "Data stream lifecycle"
		}],
		"generation": 3,
		"status": "YELLOW",
		"template": "indextemplate-obcvkbjqand",
		"lifecycle": {
			"enabled": true,
			"data_retention": "90d"
		},
		"ilm_policy": "policy-uVBEI",
                "next_generation_managed_by": "Data stream lifecycle",
		"prefer_ilm": false,
		"hidden": false,
		"system": false,
		"allow_custom_routing": false,
		"replicated": false
	}]
}
```
---
 docs/changelog/99947.yaml                     |   5 +
 .../change-mappings-and-settings.asciidoc     |  10 +-
 .../data-streams/downsampling-manual.asciidoc |   6 +-
 .../indices/get-data-stream.asciidoc          |  21 +-
 .../datastreams/DataStreamIT.java             |  10 +-
 .../action/GetDataStreamsTransportAction.java |  42 ++-
 .../action/GetDataStreamsResponseTests.java   | 240 +++++++++++++++++-
 .../test/data_stream/10_basic.yml             |  71 ++++++
 .../org/elasticsearch/TransportVersions.java  |   3 +-
 .../datastreams/GetDataStreamAction.java      | 132 +++++++++-
 .../java/org/elasticsearch/index/Index.java   |   7 +-
 ...ataStreamAndIndexLifecycleMixingTests.java | 127 +++++++++
 12 files changed, 645 insertions(+), 29 deletions(-)
 create mode 100644 docs/changelog/99947.yaml

diff --git a/docs/changelog/99947.yaml b/docs/changelog/99947.yaml
new file mode 100644
index 0000000000000..61996c8fde92b
--- /dev/null
+++ b/docs/changelog/99947.yaml
@@ -0,0 +1,5 @@
+pr: 99947
+summary: GET `_data_stream` displays both ILM and DSL information
+area: Data streams
+type: feature
+issues: []
diff --git a/docs/reference/data-streams/change-mappings-and-settings.asciidoc b/docs/reference/data-streams/change-mappings-and-settings.asciidoc
index 461addf65c53c..3922ef018a713 100644
--- a/docs/reference/data-streams/change-mappings-and-settings.asciidoc
+++ b/docs/reference/data-streams/change-mappings-and-settings.asciidoc
@@ -573,15 +573,21 @@ stream's oldest backing index.
       "indices": [
         {
           "index_name": ".ds-my-data-stream-2099.03.07-000001", <1>
-          "index_uuid": "Gpdiyq8sRuK9WuthvAdFbw"
+          "index_uuid": "Gpdiyq8sRuK9WuthvAdFbw",
+          "prefer_ilm": true,
+          "managed_by": "Unmanaged"
         },
         {
           "index_name": ".ds-my-data-stream-2099.03.08-000002",
-          "index_uuid": "_eEfRrFHS9OyhqWntkgHAQ"
+          "index_uuid": "_eEfRrFHS9OyhqWntkgHAQ",
+          "prefer_ilm": true,
+          "managed_by": "Unmanaged"
         }
       ],
       "generation": 2,
       "status": "GREEN",
+      "next_generation_managed_by": "Unmanaged",
+      "prefer_ilm": true,
       "template": "my-data-stream-template",
       "hidden": false,
       "system": false,
diff --git a/docs/reference/data-streams/downsampling-manual.asciidoc b/docs/reference/data-streams/downsampling-manual.asciidoc
index 6b98816c2cf56..cc74e98b258de 100644
--- a/docs/reference/data-streams/downsampling-manual.asciidoc
+++ b/docs/reference/data-streams/downsampling-manual.asciidoc
@@ -358,11 +358,15 @@ This returns:
       "indices": [
         {
           "index_name": ".ds-my-data-stream-2023.07.26-000001", <1>
-          "index_uuid": "ltOJGmqgTVm4T-Buoe7Acg"
+          "index_uuid": "ltOJGmqgTVm4T-Buoe7Acg",
+          "prefer_ilm": true,
+          "managed_by": "Data stream lifecycle"
         }
       ],
       "generation": 1,
       "status": "GREEN",
+      "next_generation_managed_by": "Data stream lifecycle",
+      "prefer_ilm": true,
       "template": "my-data-stream-template",
       "hidden": false,
       "system": false,
diff --git a/docs/reference/indices/get-data-stream.asciidoc b/docs/reference/indices/get-data-stream.asciidoc
index ef2cf7eeee946..36998e7aa5fa3 100644
--- a/docs/reference/indices/get-data-stream.asciidoc
+++ b/docs/reference/indices/get-data-stream.asciidoc
@@ -225,7 +225,7 @@ cluster can not write into this data stream or change its mappings.
 
 `lifecycle`::
 (object)
-Functionality in preview:[]. Contains the configuration for the data stream lifecycle management of this data stream.
+Contains the configuration for the data stream lifecycle management of this data stream.
 +
 .Properties of `lifecycle`
 [%collapsible%open]
@@ -265,11 +265,17 @@ The API returns the following response:
       "indices": [
         {
           "index_name": ".ds-my-data-stream-2099.03.07-000001",
-          "index_uuid": "xCEhwsp8Tey0-FLNFYVwSg"
+          "index_uuid": "xCEhwsp8Tey0-FLNFYVwSg",
+          "prefer_ilm": true,
+          "ilm_policy": "my-lifecycle-policy",
+          "managed_by": "Index Lifecycle Management"
         },
         {
           "index_name": ".ds-my-data-stream-2099.03.08-000002",
-          "index_uuid": "PA_JquKGSiKcAKBA8DJ5gw"
+          "index_uuid": "PA_JquKGSiKcAKBA8DJ5gw",
+          "prefer_ilm": true,
+          "ilm_policy": "my-lifecycle-policy",
+          "managed_by": "Index Lifecycle Management"
         }
       ],
       "generation": 2,
@@ -277,6 +283,8 @@ The API returns the following response:
         "my-meta-field": "foo"
       },
       "status": "GREEN",
+      "next_generation_managed_by": "Index Lifecycle Management",
+      "prefer_ilm": true,
       "template": "my-index-template",
       "ilm_policy": "my-lifecycle-policy",
       "hidden": false,
@@ -292,7 +300,10 @@ The API returns the following response:
       "indices": [
         {
           "index_name": ".ds-my-data-stream-two-2099.03.08-000001",
-          "index_uuid": "3liBu2SYS5axasRt6fUIpA"
+          "index_uuid": "3liBu2SYS5axasRt6fUIpA",
+          "prefer_ilm": true,
+          "ilm_policy": "my-lifecycle-policy",
+          "managed_by": "Index Lifecycle Management"
         }
       ],
       "generation": 1,
@@ -300,6 +311,8 @@ The API returns the following response:
         "my-meta-field": "foo"
       },
       "status": "YELLOW",
+      "next_generation_managed_by": "Index Lifecycle Management",
+      "prefer_ilm": true,
       "template": "my-index-template",
       "ilm_policy": "my-lifecycle-policy",
       "hidden": false,
diff --git a/modules/data-streams/src/internalClusterTest/java/org/elasticsearch/datastreams/DataStreamIT.java b/modules/data-streams/src/internalClusterTest/java/org/elasticsearch/datastreams/DataStreamIT.java
index 384970bdc7ab9..bd4a449f640ce 100644
--- a/modules/data-streams/src/internalClusterTest/java/org/elasticsearch/datastreams/DataStreamIT.java
+++ b/modules/data-streams/src/internalClusterTest/java/org/elasticsearch/datastreams/DataStreamIT.java
@@ -1320,11 +1320,17 @@ public void testGetDataStream() throws Exception {
         ).actionGet();
         assertThat(response.getDataStreams().size(), is(1));
         DataStreamInfo metricsFooDataStream = response.getDataStreams().get(0);
-        assertThat(metricsFooDataStream.getDataStream().getName(), is("metrics-foo"));
+        DataStream dataStream = metricsFooDataStream.getDataStream();
+        assertThat(dataStream.getName(), is("metrics-foo"));
         assertThat(metricsFooDataStream.getDataStreamStatus(), is(ClusterHealthStatus.YELLOW));
         assertThat(metricsFooDataStream.getIndexTemplate(), is("template_for_foo"));
         assertThat(metricsFooDataStream.getIlmPolicy(), is(nullValue()));
-        assertThat(metricsFooDataStream.getDataStream().getLifecycle(), is(lifecycle));
+        assertThat(dataStream.getLifecycle(), is(lifecycle));
+        assertThat(metricsFooDataStream.templatePreferIlmValue(), is(true));
+        GetDataStreamAction.Response.IndexProperties indexProperties = metricsFooDataStream.getIndexSettingsValues()
+            .get(dataStream.getWriteIndex());
+        assertThat(indexProperties.ilmPolicyName(), is(nullValue()));
+        assertThat(indexProperties.preferIlm(), is(true));
     }
 
     private static void assertBackingIndex(String backingIndex, String timestampFieldPathInMapping, Map<?, ?> expectedMapping) {
diff --git a/modules/data-streams/src/main/java/org/elasticsearch/datastreams/action/GetDataStreamsTransportAction.java b/modules/data-streams/src/main/java/org/elasticsearch/datastreams/action/GetDataStreamsTransportAction.java
index 73af952af524d..de81ca9bef18c 100644
--- a/modules/data-streams/src/main/java/org/elasticsearch/datastreams/action/GetDataStreamsTransportAction.java
+++ b/modules/data-streams/src/main/java/org/elasticsearch/datastreams/action/GetDataStreamsTransportAction.java
@@ -11,6 +11,8 @@
 import org.apache.logging.log4j.Logger;
 import org.elasticsearch.action.ActionListener;
 import org.elasticsearch.action.datastreams.GetDataStreamAction;
+import org.elasticsearch.action.datastreams.GetDataStreamAction.Response.IndexProperties;
+import org.elasticsearch.action.datastreams.GetDataStreamAction.Response.ManagedBy;
 import org.elasticsearch.action.support.ActionFilters;
 import org.elasticsearch.action.support.master.TransportMasterNodeReadAction;
 import org.elasticsearch.cluster.ClusterState;
@@ -21,6 +23,7 @@
 import org.elasticsearch.cluster.metadata.DataStreamLifecycle;
 import org.elasticsearch.cluster.metadata.IndexMetadata;
 import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver;
+import org.elasticsearch.cluster.metadata.Metadata;
 import org.elasticsearch.cluster.metadata.MetadataIndexTemplateService;
 import org.elasticsearch.cluster.service.ClusterService;
 import org.elasticsearch.common.inject.Inject;
@@ -39,9 +42,12 @@
 import java.time.Instant;
 import java.util.ArrayList;
 import java.util.Comparator;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import static org.elasticsearch.index.IndexSettings.PREFER_ILM_SETTING;
+
 public class GetDataStreamsTransportAction extends TransportMasterNodeReadAction<
     GetDataStreamAction.Request,
     GetDataStreamAction.Response> {
@@ -95,6 +101,7 @@ static GetDataStreamAction.Response innerOperation(
         List<GetDataStreamAction.Response.DataStreamInfo> dataStreamInfos = new ArrayList<>(dataStreams.size());
         for (DataStream dataStream : dataStreams) {
             final String indexTemplate;
+            boolean indexTemplatePreferIlmValue = true;
             String ilmPolicyName = null;
             if (dataStream.isSystem()) {
                 SystemDataStreamDescriptor dataStreamDescriptor = systemIndices.findMatchingDataStreamDescriptor(dataStream.getName());
@@ -104,13 +111,15 @@ static GetDataStreamAction.Response innerOperation(
                         dataStreamDescriptor.getComposableIndexTemplate(),
                         dataStreamDescriptor.getComponentTemplates()
                     );
-                    ilmPolicyName = settings.get("index.lifecycle.name");
+                    ilmPolicyName = settings.get(IndexMetadata.LIFECYCLE_NAME);
+                    indexTemplatePreferIlmValue = PREFER_ILM_SETTING.get(settings);
                 }
             } else {
                 indexTemplate = MetadataIndexTemplateService.findV2Template(state.metadata(), dataStream.getName(), false);
                 if (indexTemplate != null) {
                     Settings settings = MetadataIndexTemplateService.resolveSettings(state.metadata(), indexTemplate);
-                    ilmPolicyName = settings.get("index.lifecycle.name");
+                    ilmPolicyName = settings.get(IndexMetadata.LIFECYCLE_NAME);
+                    indexTemplatePreferIlmValue = PREFER_ILM_SETTING.get(settings);
                 } else {
                     LOGGER.warn(
                         "couldn't find any matching template for data stream [{}]. has it been restored (and possibly renamed)"
@@ -125,18 +134,35 @@ static GetDataStreamAction.Response innerOperation(
                 dataStream.getIndices().stream().map(Index::getName).toArray(String[]::new)
             );
 
+            Map<Index, IndexProperties> backingIndicesSettingsValues = new HashMap<>();
+            Metadata metadata = state.getMetadata();
+            for (Index index : dataStream.getIndices()) {
+                IndexMetadata indexMetadata = metadata.index(index);
+                Boolean preferIlm = PREFER_ILM_SETTING.get(indexMetadata.getSettings());
+                assert preferIlm != null : "must use the default prefer ilm setting value, if nothing else";
+                ManagedBy managedBy;
+                if (metadata.isIndexManagedByILM(indexMetadata)) {
+                    managedBy = ManagedBy.ILM;
+                } else if (dataStream.isIndexManagedByDataStreamLifecycle(index, metadata::index)) {
+                    managedBy = ManagedBy.LIFECYCLE;
+                } else {
+                    managedBy = ManagedBy.UNMANAGED;
+                }
+                backingIndicesSettingsValues.put(index, new IndexProperties(preferIlm, indexMetadata.getLifecyclePolicyName(), managedBy));
+            }
+
             GetDataStreamAction.Response.TimeSeries timeSeries = null;
             if (dataStream.getIndexMode() == IndexMode.TIME_SERIES) {
                 List<Tuple<Instant, Instant>> ranges = new ArrayList<>();
                 Tuple<Instant, Instant> current = null;
                 String previousIndexName = null;
                 for (Index index : dataStream.getIndices()) {
-                    IndexMetadata metadata = state.getMetadata().index(index);
-                    if (metadata.getIndexMode() != IndexMode.TIME_SERIES) {
+                    IndexMetadata indexMetadata = metadata.index(index);
+                    if (indexMetadata.getIndexMode() != IndexMode.TIME_SERIES) {
                         continue;
                     }
-                    Instant start = metadata.getTimeSeriesStart();
-                    Instant end = metadata.getTimeSeriesEnd();
+                    Instant start = indexMetadata.getTimeSeriesStart();
+                    Instant end = indexMetadata.getTimeSeriesEnd();
                     if (current == null) {
                         current = new Tuple<>(start, end);
                     } else if (current.v2().compareTo(start) == 0) {
@@ -175,7 +201,9 @@ static GetDataStreamAction.Response innerOperation(
                     streamHealth.getStatus(),
                     indexTemplate,
                     ilmPolicyName,
-                    timeSeries
+                    timeSeries,
+                    backingIndicesSettingsValues,
+                    indexTemplatePreferIlmValue
                 )
             );
         }
diff --git a/modules/data-streams/src/test/java/org/elasticsearch/datastreams/action/GetDataStreamsResponseTests.java b/modules/data-streams/src/test/java/org/elasticsearch/datastreams/action/GetDataStreamsResponseTests.java
index 469c72e539c45..12e1604d10c1f 100644
--- a/modules/data-streams/src/test/java/org/elasticsearch/datastreams/action/GetDataStreamsResponseTests.java
+++ b/modules/data-streams/src/test/java/org/elasticsearch/datastreams/action/GetDataStreamsResponseTests.java
@@ -8,15 +8,33 @@
 package org.elasticsearch.datastreams.action;
 
 import org.elasticsearch.action.datastreams.GetDataStreamAction.Response;
+import org.elasticsearch.action.datastreams.GetDataStreamAction.Response.ManagedBy;
 import org.elasticsearch.cluster.health.ClusterHealthStatus;
+import org.elasticsearch.cluster.metadata.DataStream;
+import org.elasticsearch.cluster.metadata.DataStreamLifecycle;
 import org.elasticsearch.cluster.metadata.DataStreamTestHelper;
+import org.elasticsearch.common.UUIDs;
+import org.elasticsearch.common.bytes.BytesReference;
 import org.elasticsearch.common.io.stream.Writeable;
 import org.elasticsearch.core.Tuple;
+import org.elasticsearch.index.Index;
+import org.elasticsearch.index.IndexMode;
 import org.elasticsearch.test.AbstractWireSerializingTestCase;
+import org.elasticsearch.xcontent.ToXContent;
+import org.elasticsearch.xcontent.XContentBuilder;
+import org.elasticsearch.xcontent.XContentFactory;
+import org.elasticsearch.xcontent.XContentParser;
+import org.elasticsearch.xcontent.json.JsonXContent;
 
 import java.time.Instant;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+
+import static org.elasticsearch.cluster.metadata.DataStream.getDefaultBackingIndexName;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.nullValue;
 
 public class GetDataStreamsResponseTests extends AbstractWireSerializingTestCase<Response> {
 
@@ -43,13 +61,198 @@ protected Response mutateInstance(Response instance) {
         return new Response(instance.getDataStreams().stream().map(this::mutateInstance).toList());
     }
 
+    @SuppressWarnings("unchecked")
+    public void testResponseIlmAndDataStreamLifecycleRepresentation() throws Exception {
+        // we'll test a data stream with 3 backing indices - two managed by ILM (having the ILM policy configured for them)
+        // and one without any ILM policy configured
+        String dataStreamName = "logs";
+
+        Index firstGenerationIndex = new Index(getDefaultBackingIndexName(dataStreamName, 1), UUIDs.base64UUID());
+        Index secondGenerationIndex = new Index(getDefaultBackingIndexName(dataStreamName, 2), UUIDs.base64UUID());
+        Index writeIndex = new Index(getDefaultBackingIndexName(dataStreamName, 3), UUIDs.base64UUID());
+        List<Index> indices = List.of(firstGenerationIndex, secondGenerationIndex, writeIndex);
+        {
+            // data stream has an enabled lifecycle
+            DataStream logs = new DataStream(
+                "logs",
+                indices,
+                3,
+                null,
+                false,
+                false,
+                false,
+                true,
+                IndexMode.STANDARD,
+                new DataStreamLifecycle()
+            );
+
+            String ilmPolicyName = "rollover-30days";
+            Map<Index, Response.IndexProperties> indexSettingsValues = Map.of(
+                firstGenerationIndex,
+                new Response.IndexProperties(true, ilmPolicyName, ManagedBy.ILM),
+                secondGenerationIndex,
+                new Response.IndexProperties(false, ilmPolicyName, ManagedBy.LIFECYCLE),
+                writeIndex,
+                new Response.IndexProperties(false, null, ManagedBy.LIFECYCLE)
+            );
+
+            Response.DataStreamInfo dataStreamInfo = new Response.DataStreamInfo(
+                logs,
+                ClusterHealthStatus.GREEN,
+                "index-template",
+                null,
+                null,
+                indexSettingsValues,
+                false
+            );
+            Response response = new Response(List.of(dataStreamInfo));
+            XContentBuilder contentBuilder = XContentFactory.jsonBuilder();
+            response.toXContent(contentBuilder, ToXContent.EMPTY_PARAMS);
+
+            BytesReference bytes = BytesReference.bytes(contentBuilder);
+            try (XContentParser parser = createParser(JsonXContent.jsonXContent, bytes)) {
+                Map<String, Object> map = parser.map();
+                List<Object> dataStreams = (List<Object>) map.get(Response.DATA_STREAMS_FIELD.getPreferredName());
+                assertThat(dataStreams.size(), is(1));
+                Map<String, Object> dataStreamMap = (Map<String, Object>) dataStreams.get(0);
+                assertThat(dataStreamMap.get(DataStream.NAME_FIELD.getPreferredName()), is(dataStreamName));
+
+                assertThat(dataStreamMap.get(Response.DataStreamInfo.PREFER_ILM.getPreferredName()), is(false));
+                assertThat(dataStreamMap.get(Response.DataStreamInfo.ILM_POLICY_FIELD.getPreferredName()), is(nullValue()));
+                assertThat(dataStreamMap.get(Response.DataStreamInfo.LIFECYCLE_FIELD.getPreferredName()), is(Map.of("enabled", true)));
+                assertThat(
+                    dataStreamMap.get(Response.DataStreamInfo.NEXT_GENERATION_INDEX_MANAGED_BY.getPreferredName()),
+                    is(ManagedBy.LIFECYCLE.displayValue)
+                );
+
+                List<Object> indicesRepresentation = (List<Object>) dataStreamMap.get(DataStream.INDICES_FIELD.getPreferredName());
+                Map<String, Object> firstGenIndexRepresentation = (Map<String, Object>) indicesRepresentation.get(0);
+                assertThat(firstGenIndexRepresentation.get("index_name"), is(firstGenerationIndex.getName()));
+                assertThat(firstGenIndexRepresentation.get(Response.DataStreamInfo.PREFER_ILM.getPreferredName()), is(true));
+                assertThat(firstGenIndexRepresentation.get(Response.DataStreamInfo.ILM_POLICY_FIELD.getPreferredName()), is(ilmPolicyName));
+                assertThat(
+                    firstGenIndexRepresentation.get(Response.DataStreamInfo.MANAGED_BY.getPreferredName()),
+                    is(ManagedBy.ILM.displayValue)
+                );
+
+                Map<String, Object> secondGenIndexRepresentation = (Map<String, Object>) indicesRepresentation.get(1);
+                assertThat(secondGenIndexRepresentation.get("index_name"), is(secondGenerationIndex.getName()));
+                assertThat(secondGenIndexRepresentation.get(Response.DataStreamInfo.PREFER_ILM.getPreferredName()), is(false));
+                assertThat(
+                    secondGenIndexRepresentation.get(Response.DataStreamInfo.ILM_POLICY_FIELD.getPreferredName()),
+                    is(ilmPolicyName)
+                );
+                assertThat(
+                    secondGenIndexRepresentation.get(Response.DataStreamInfo.MANAGED_BY.getPreferredName()),
+                    is(ManagedBy.LIFECYCLE.displayValue)
+                );
+
+                // the write index is managed by data stream lifecycle
+                Map<String, Object> writeIndexRepresentation = (Map<String, Object>) indicesRepresentation.get(2);
+                assertThat(writeIndexRepresentation.get("index_name"), is(writeIndex.getName()));
+                assertThat(writeIndexRepresentation.get(Response.DataStreamInfo.PREFER_ILM.getPreferredName()), is(false));
+                assertThat(writeIndexRepresentation.get(Response.DataStreamInfo.ILM_POLICY_FIELD.getPreferredName()), is(nullValue()));
+                assertThat(
+                    writeIndexRepresentation.get(Response.DataStreamInfo.MANAGED_BY.getPreferredName()),
+                    is(ManagedBy.LIFECYCLE.displayValue)
+                );
+            }
+        }
+
+        {
+            // data stream has a lifecycle that's not enabled
+            DataStream logs = new DataStream(
+                "logs",
+                indices,
+                3,
+                null,
+                false,
+                false,
+                false,
+                true,
+                IndexMode.STANDARD,
+                new DataStreamLifecycle(null, null, false)
+            );
+
+            String ilmPolicyName = "rollover-30days";
+            Map<Index, Response.IndexProperties> indexSettingsValues = Map.of(
+                firstGenerationIndex,
+                new Response.IndexProperties(true, ilmPolicyName, ManagedBy.ILM),
+                secondGenerationIndex,
+                new Response.IndexProperties(true, ilmPolicyName, ManagedBy.ILM),
+                writeIndex,
+                new Response.IndexProperties(false, null, ManagedBy.UNMANAGED)
+            );
+
+            Response.DataStreamInfo dataStreamInfo = new Response.DataStreamInfo(
+                logs,
+                ClusterHealthStatus.GREEN,
+                "index-template",
+                null,
+                null,
+                indexSettingsValues,
+                false
+            );
+            Response response = new Response(List.of(dataStreamInfo));
+            XContentBuilder contentBuilder = XContentFactory.jsonBuilder();
+            response.toXContent(contentBuilder, ToXContent.EMPTY_PARAMS);
+
+            BytesReference bytes = BytesReference.bytes(contentBuilder);
+            try (XContentParser parser = createParser(JsonXContent.jsonXContent, bytes)) {
+                Map<String, Object> map = parser.map();
+                List<Object> dataStreams = (List<Object>) map.get(Response.DATA_STREAMS_FIELD.getPreferredName());
+                assertThat(dataStreams.size(), is(1));
+                Map<String, Object> dataStreamMap = (Map<String, Object>) dataStreams.get(0);
+                assertThat(dataStreamMap.get(DataStream.NAME_FIELD.getPreferredName()), is(dataStreamName));
+                // note that the prefer_ilm value is displayed at the top level even if the template backing the data stream doesn't have a
+                // policy specified anymore
+                assertThat(dataStreamMap.get(Response.DataStreamInfo.PREFER_ILM.getPreferredName()), is(false));
+                assertThat(dataStreamMap.get(Response.DataStreamInfo.ILM_POLICY_FIELD.getPreferredName()), is(nullValue()));
+                assertThat(dataStreamMap.get(Response.DataStreamInfo.LIFECYCLE_FIELD.getPreferredName()), is(Map.of("enabled", false)));
+                assertThat(
+                    dataStreamMap.get(Response.DataStreamInfo.NEXT_GENERATION_INDEX_MANAGED_BY.getPreferredName()),
+                    is(ManagedBy.UNMANAGED.displayValue)
+                );
+
+                List<Object> indicesRepresentation = (List<Object>) dataStreamMap.get(DataStream.INDICES_FIELD.getPreferredName());
+                Map<String, Object> firstGenIndexRepresentation = (Map<String, Object>) indicesRepresentation.get(0);
+                assertThat(firstGenIndexRepresentation.get("index_name"), is(firstGenerationIndex.getName()));
+                assertThat(firstGenIndexRepresentation.get(Response.DataStreamInfo.PREFER_ILM.getPreferredName()), is(true));
+                assertThat(firstGenIndexRepresentation.get(Response.DataStreamInfo.ILM_POLICY_FIELD.getPreferredName()), is(ilmPolicyName));
+                assertThat(
+                    firstGenIndexRepresentation.get(Response.DataStreamInfo.MANAGED_BY.getPreferredName()),
+                    is(ManagedBy.ILM.displayValue)
+                );
+
+                // the write index is managed by data stream lifecycle
+                Map<String, Object> writeIndexRepresentation = (Map<String, Object>) indicesRepresentation.get(2);
+                assertThat(writeIndexRepresentation.get("index_name"), is(writeIndex.getName()));
+                assertThat(writeIndexRepresentation.get(Response.DataStreamInfo.PREFER_ILM.getPreferredName()), is(false));
+                assertThat(writeIndexRepresentation.get(Response.DataStreamInfo.ILM_POLICY_FIELD.getPreferredName()), is(nullValue()));
+                assertThat(
+                    writeIndexRepresentation.get(Response.DataStreamInfo.MANAGED_BY.getPreferredName()),
+                    is(ManagedBy.UNMANAGED.displayValue)
+                );
+            }
+        }
+    }
+
+    public void testManagedByDisplayValuesDontAccidentalyChange() {
+        // UI might derive logic based on the display values so any changes should be coordinated with the UI team
+        assertThat(ManagedBy.ILM.displayValue, is("Index Lifecycle Management"));
+        assertThat(ManagedBy.LIFECYCLE.displayValue, is("Data stream lifecycle"));
+        assertThat(ManagedBy.UNMANAGED.displayValue, is("Unmanaged"));
+    }
+
     private Response.DataStreamInfo mutateInstance(Response.DataStreamInfo instance) {
         var dataStream = instance.getDataStream();
         var status = instance.getDataStreamStatus();
         var indexTemplate = instance.getIndexTemplate();
         var ilmPolicyName = instance.getIlmPolicy();
         var timeSeries = instance.getTimeSeries();
-        switch (randomIntBetween(0, 4)) {
+        var indexSettings = instance.getIndexSettingsValues();
+        var templatePreferIlm = instance.templatePreferIlmValue();
+        switch (randomIntBetween(0, 6)) {
             case 0 -> dataStream = randomValueOtherThan(dataStream, DataStreamTestHelper::randomInstance);
             case 1 -> status = randomValueOtherThan(status, () -> randomFrom(ClusterHealthStatus.values()));
             case 2 -> indexTemplate = randomBoolean() && indexTemplate != null ? null : randomAlphaOfLengthBetween(2, 10);
@@ -57,8 +260,22 @@ private Response.DataStreamInfo mutateInstance(Response.DataStreamInfo instance)
             case 4 -> timeSeries = randomBoolean() && timeSeries != null
                 ? null
                 : randomValueOtherThan(timeSeries, () -> new Response.TimeSeries(generateRandomTimeSeries()));
+            case 5 -> indexSettings = randomValueOtherThan(
+                indexSettings,
+                () -> randomBoolean()
+                    ? Map.of()
+                    : Map.of(
+                        new Index(randomAlphaOfLengthBetween(50, 100), UUIDs.base64UUID()),
+                        new Response.IndexProperties(
+                            randomBoolean(),
+                            randomAlphaOfLengthBetween(50, 100),
+                            randomBoolean() ? ManagedBy.ILM : ManagedBy.LIFECYCLE
+                        )
+                    )
+            );
+            case 6 -> templatePreferIlm = templatePreferIlm ? false : true;
         }
-        return new Response.DataStreamInfo(dataStream, status, indexTemplate, ilmPolicyName, timeSeries);
+        return new Response.DataStreamInfo(dataStream, status, indexTemplate, ilmPolicyName, timeSeries, indexSettings, templatePreferIlm);
     }
 
     private List<Tuple<Instant, Instant>> generateRandomTimeSeries() {
@@ -70,6 +287,21 @@ private List<Tuple<Instant, Instant>> generateRandomTimeSeries() {
         return timeSeries;
     }
 
+    private Map<Index, Response.IndexProperties> generateRandomIndexSettingsValues() {
+        Map<Index, Response.IndexProperties> values = new HashMap<>();
+        for (int i = 0; i < randomIntBetween(0, 3); i++) {
+            values.put(
+                new Index(randomAlphaOfLengthBetween(50, 100), UUIDs.base64UUID()),
+                new Response.IndexProperties(
+                    randomBoolean(),
+                    randomAlphaOfLengthBetween(50, 100),
+                    randomBoolean() ? ManagedBy.ILM : ManagedBy.LIFECYCLE
+                )
+            );
+        }
+        return values;
+    }
+
     private Response.DataStreamInfo generateRandomDataStreamInfo() {
         List<Tuple<Instant, Instant>> timeSeries = randomBoolean() ? generateRandomTimeSeries() : null;
         return new Response.DataStreamInfo(
@@ -77,7 +309,9 @@ private Response.DataStreamInfo generateRandomDataStreamInfo() {
             ClusterHealthStatus.GREEN,
             randomAlphaOfLengthBetween(2, 10),
             randomAlphaOfLengthBetween(2, 10),
-            timeSeries != null ? new Response.TimeSeries(timeSeries) : null
+            timeSeries != null ? new Response.TimeSeries(timeSeries) : null,
+            generateRandomIndexSettingsValues(),
+            randomBoolean()
         );
     }
 }
diff --git a/modules/data-streams/src/yamlRestTest/resources/rest-api-spec/test/data_stream/10_basic.yml b/modules/data-streams/src/yamlRestTest/resources/rest-api-spec/test/data_stream/10_basic.yml
index 50c8e2c74dc74..09cec438d10cc 100644
--- a/modules/data-streams/src/yamlRestTest/resources/rest-api-spec/test/data_stream/10_basic.yml
+++ b/modules/data-streams/src/yamlRestTest/resources/rest-api-spec/test/data_stream/10_basic.yml
@@ -311,6 +311,77 @@ setup:
         name: simple-data-stream2
   - is_true: acknowledged
 
+---
+"Get data stream and check DSL and ILM information":
+  - skip:
+      version: " - 8.10.99"
+      reason: "data streams DSL and ILM mixing information available in 8.11+"
+
+  - do:
+      allowed_warnings:
+        - "index template [mixing-dsl-template] has index patterns [mixing-dsl-stream] matching patterns from existing older templates
+        [global] with patterns (global => [*]); this template [mixing-dsl-template] will take precedence during new index creation"
+      indices.put_index_template:
+        name: mixing-dsl-template
+        body:
+          index_patterns: [mixing-dsl-stream]
+          template:
+            mappings:
+              properties:
+                '@timestamp':
+                  type: date_nanos
+            lifecycle:
+              data_retention: "30d"
+              enabled: false
+            settings:
+              index.lifecycle.prefer_ilm: false
+              index.lifecycle.name: "missing_ilm_policy"
+          data_stream: {}
+
+  - do:
+      indices.create_data_stream:
+        name: mixing-dsl-stream
+  - is_true: acknowledged
+
+  - do:
+      indices.get_data_stream:
+        name: mixing-dsl-stream
+  - match: { data_streams.0.name: mixing-dsl-stream }
+  - match: { data_streams.0.timestamp_field.name: '@timestamp' }
+  - match: { data_streams.0.generation: 1 }
+  - match: { data_streams.0.ilm_policy: "missing_ilm_policy" }
+  - match: { data_streams.0.prefer_ilm: false }
+  - match: { data_streams.0.next_generation_managed_by: "Index Lifecycle Management" }
+  - length: { data_streams.0.indices: 1 }
+  - match: { data_streams.0.indices.0.prefer_ilm: false }
+  - match: { data_streams.0.indices.0.ilm_policy: "missing_ilm_policy" }
+  - match: { data_streams.0.indices.0.managed_by: "Index Lifecycle Management" }
+
+  - do:
+      indices.put_data_lifecycle:
+        name: "*"
+        body: >
+          {
+            "data_retention": "30d",
+            "enabled": true
+          }
+
+  - is_true: acknowledged
+
+  - do:
+      indices.get_data_stream:
+        name: mixing-dsl-stream
+  - match: { data_streams.0.name: mixing-dsl-stream }
+  - match: { data_streams.0.timestamp_field.name: '@timestamp' }
+  - match: { data_streams.0.generation: 1 }
+  - match: { data_streams.0.ilm_policy: "missing_ilm_policy" }
+  - match: { data_streams.0.prefer_ilm: false }
+  - match: { data_streams.0.next_generation_managed_by: "Data stream lifecycle" }
+  - length: { data_streams.0.indices: 1 }
+  - match: { data_streams.0.indices.0.prefer_ilm: false }
+  - match: { data_streams.0.indices.0.ilm_policy: "missing_ilm_policy" }
+  - match: { data_streams.0.indices.0.managed_by: "Data stream lifecycle" }
+
 ---
 "Delete data stream with backing indices":
   - skip:
diff --git a/server/src/main/java/org/elasticsearch/TransportVersions.java b/server/src/main/java/org/elasticsearch/TransportVersions.java
index 5f120134acb04..360af92d6aa43 100644
--- a/server/src/main/java/org/elasticsearch/TransportVersions.java
+++ b/server/src/main/java/org/elasticsearch/TransportVersions.java
@@ -145,8 +145,9 @@ static TransportVersion def(int id) {
     public static final TransportVersion WAIT_FOR_CLUSTER_STATE_IN_RECOVERY_ADDED = def(8_502_00_0);
     public static final TransportVersion RECOVERY_COMMIT_TOO_NEW_EXCEPTION_ADDED = def(8_503_00_0);
     public static final TransportVersion NODE_INFO_COMPONENT_VERSIONS_ADDED = def(8_504_00_0);
-
     public static final TransportVersion COMPACT_FIELD_CAPS_ADDED = def(8_505_00_0);
+    public static final TransportVersion DATA_STREAM_RESPONSE_INDEX_PROPERTIES = def(8_506_00_0);
+
     /*
      * STOP! READ THIS FIRST! No, really,
      *        ____ _____ ___  ____  _        ____  _____    _    ____    _____ _   _ ___ ____    _____ ___ ____  ____ _____ _
diff --git a/server/src/main/java/org/elasticsearch/action/datastreams/GetDataStreamAction.java b/server/src/main/java/org/elasticsearch/action/datastreams/GetDataStreamAction.java
index aa69ede54dea1..9c1fb63a6b8d0 100644
--- a/server/src/main/java/org/elasticsearch/action/datastreams/GetDataStreamAction.java
+++ b/server/src/main/java/org/elasticsearch/action/datastreams/GetDataStreamAction.java
@@ -23,6 +23,7 @@
 import org.elasticsearch.common.io.stream.Writeable;
 import org.elasticsearch.core.Nullable;
 import org.elasticsearch.core.Tuple;
+import org.elasticsearch.index.Index;
 import org.elasticsearch.index.mapper.DateFieldMapper;
 import org.elasticsearch.xcontent.ParseField;
 import org.elasticsearch.xcontent.ToXContentObject;
@@ -32,8 +33,11 @@
 import java.time.Instant;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 
+import static org.elasticsearch.TransportVersions.DATA_STREAM_RESPONSE_INDEX_PROPERTIES;
+
 public class GetDataStreamAction extends ActionType<GetDataStreamAction.Response> {
 
     public static final GetDataStreamAction INSTANCE = new GetDataStreamAction();
@@ -142,12 +146,28 @@ public Request includeDefaults(boolean includeDefaults) {
     }
 
     public static class Response extends ActionResponse implements ToXContentObject {
+
+        public enum ManagedBy {
+            ILM("Index Lifecycle Management"),
+            LIFECYCLE("Data stream lifecycle"),
+            UNMANAGED("Unmanaged");
+
+            public final String displayValue;
+
+            ManagedBy(String displayValue) {
+                this.displayValue = displayValue;
+            }
+        }
+
         public static final ParseField DATA_STREAMS_FIELD = new ParseField("data_streams");
 
         public static class DataStreamInfo implements SimpleDiffable<DataStreamInfo>, ToXContentObject {
 
             public static final ParseField STATUS_FIELD = new ParseField("status");
             public static final ParseField INDEX_TEMPLATE_FIELD = new ParseField("template");
+            public static final ParseField PREFER_ILM = new ParseField("prefer_ilm");
+            public static final ParseField MANAGED_BY = new ParseField("managed_by");
+            public static final ParseField NEXT_GENERATION_INDEX_MANAGED_BY = new ParseField("next_generation_managed_by");
             public static final ParseField ILM_POLICY_FIELD = new ParseField("ilm_policy");
             public static final ParseField LIFECYCLE_FIELD = new ParseField("lifecycle");
             public static final ParseField HIDDEN_FIELD = new ParseField("hidden");
@@ -167,28 +187,39 @@ public static class DataStreamInfo implements SimpleDiffable<DataStreamInfo>, To
             private final String ilmPolicyName;
             @Nullable
             private final TimeSeries timeSeries;
+            private final Map<Index, IndexProperties> indexSettingsValues;
+            private final boolean templatePreferIlmValue;
 
             public DataStreamInfo(
                 DataStream dataStream,
                 ClusterHealthStatus dataStreamStatus,
                 @Nullable String indexTemplate,
                 @Nullable String ilmPolicyName,
-                @Nullable TimeSeries timeSeries
+                @Nullable TimeSeries timeSeries,
+                Map<Index, IndexProperties> indexSettingsValues,
+                boolean templatePreferIlmValue
             ) {
                 this.dataStream = dataStream;
                 this.dataStreamStatus = dataStreamStatus;
                 this.indexTemplate = indexTemplate;
                 this.ilmPolicyName = ilmPolicyName;
                 this.timeSeries = timeSeries;
+                this.indexSettingsValues = indexSettingsValues;
+                this.templatePreferIlmValue = templatePreferIlmValue;
             }
 
+            @SuppressWarnings("unchecked")
             DataStreamInfo(StreamInput in) throws IOException {
                 this(
                     new DataStream(in),
                     ClusterHealthStatus.readFrom(in),
                     in.readOptionalString(),
                     in.readOptionalString(),
-                    in.getTransportVersion().onOrAfter(TransportVersions.V_8_3_0) ? in.readOptionalWriteable(TimeSeries::new) : null
+                    in.getTransportVersion().onOrAfter(TransportVersions.V_8_3_0) ? in.readOptionalWriteable(TimeSeries::new) : null,
+                    in.getTransportVersion().onOrAfter(DATA_STREAM_RESPONSE_INDEX_PROPERTIES)
+                        ? in.readMap(Index::new, IndexProperties::new)
+                        : Map.of(),
+                    in.getTransportVersion().onOrAfter(DATA_STREAM_RESPONSE_INDEX_PROPERTIES) ? in.readBoolean() : true
                 );
             }
 
@@ -215,6 +246,14 @@ public TimeSeries getTimeSeries() {
                 return timeSeries;
             }
 
+            public Map<Index, IndexProperties> getIndexSettingsValues() {
+                return indexSettingsValues;
+            }
+
+            public boolean templatePreferIlmValue() {
+                return templatePreferIlmValue;
+            }
+
             @Override
             public void writeTo(StreamOutput out) throws IOException {
                 dataStream.writeTo(out);
@@ -224,6 +263,10 @@ public void writeTo(StreamOutput out) throws IOException {
                 if (out.getTransportVersion().onOrAfter(TransportVersions.V_8_3_0)) {
                     out.writeOptionalWriteable(timeSeries);
                 }
+                if (out.getTransportVersion().onOrAfter(DATA_STREAM_RESPONSE_INDEX_PROPERTIES)) {
+                    out.writeMap(indexSettingsValues);
+                    out.writeBoolean(templatePreferIlmValue);
+                }
             }
 
             @Override
@@ -242,7 +285,27 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params, @Nulla
                     .startObject()
                     .field(DataStream.NAME_FIELD.getPreferredName(), DataStream.TIMESTAMP_FIELD_NAME)
                     .endObject();
-                builder.xContentList(DataStream.INDICES_FIELD.getPreferredName(), dataStream.getIndices());
+
+                builder.field(DataStream.INDICES_FIELD.getPreferredName());
+                if (dataStream.getIndices() == null) {
+                    builder.nullValue();
+                } else {
+                    builder.startArray();
+                    for (Index index : dataStream.getIndices()) {
+                        builder.startObject();
+                        index.toXContentFragment(builder);
+                        IndexProperties indexProperties = indexSettingsValues.get(index);
+                        if (indexProperties != null) {
+                            builder.field(PREFER_ILM.getPreferredName(), indexProperties.preferIlm());
+                            if (indexProperties.ilmPolicyName() != null) {
+                                builder.field(ILM_POLICY_FIELD.getPreferredName(), indexProperties.ilmPolicyName());
+                            }
+                            builder.field(MANAGED_BY.getPreferredName(), indexProperties.managedBy.displayValue);
+                        }
+                        builder.endObject();
+                    }
+                    builder.endArray();
+                }
                 builder.field(DataStream.GENERATION_FIELD.getPreferredName(), dataStream.getGeneration());
                 if (dataStream.getMetadata() != null) {
                     builder.field(DataStream.METADATA_FIELD.getPreferredName(), dataStream.getMetadata());
@@ -258,6 +321,8 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params, @Nulla
                 if (ilmPolicyName != null) {
                     builder.field(ILM_POLICY_FIELD.getPreferredName(), ilmPolicyName);
                 }
+                builder.field(NEXT_GENERATION_INDEX_MANAGED_BY.getPreferredName(), getNextGenerationManagedBy().displayValue);
+                builder.field(PREFER_ILM.getPreferredName(), templatePreferIlmValue);
                 builder.field(HIDDEN_FIELD.getPreferredName(), dataStream.isHidden());
                 builder.field(SYSTEM_FIELD.getPreferredName(), dataStream.isSystem());
                 builder.field(ALLOW_CUSTOM_ROUTING.getPreferredName(), dataStream.isAllowCustomRouting());
@@ -280,21 +345,55 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params, @Nulla
                 return builder;
             }
 
+            /**
+             * Computes and returns which system will manage the next generation for this data stream.
+             */
+            public ManagedBy getNextGenerationManagedBy() {
+                // both ILM and DSL are configured so let's check the prefer_ilm setting to see which system takes precedence
+                if (ilmPolicyName != null && dataStream.getLifecycle() != null && dataStream.getLifecycle().isEnabled()) {
+                    return templatePreferIlmValue ? ManagedBy.ILM : ManagedBy.LIFECYCLE;
+                }
+
+                if (ilmPolicyName != null) {
+                    return ManagedBy.ILM;
+                }
+
+                if (dataStream.getLifecycle() != null && dataStream.getLifecycle().isEnabled()) {
+                    return ManagedBy.LIFECYCLE;
+                }
+
+                return ManagedBy.UNMANAGED;
+            }
+
             @Override
             public boolean equals(Object o) {
-                if (this == o) return true;
-                if (o == null || getClass() != o.getClass()) return false;
+                if (this == o) {
+                    return true;
+                }
+                if (o == null || getClass() != o.getClass()) {
+                    return false;
+                }
                 DataStreamInfo that = (DataStreamInfo) o;
-                return dataStream.equals(that.dataStream)
+                return templatePreferIlmValue == that.templatePreferIlmValue
+                    && Objects.equals(dataStream, that.dataStream)
                     && dataStreamStatus == that.dataStreamStatus
                     && Objects.equals(indexTemplate, that.indexTemplate)
                     && Objects.equals(ilmPolicyName, that.ilmPolicyName)
-                    && Objects.equals(timeSeries, that.timeSeries);
+                    && Objects.equals(timeSeries, that.timeSeries)
+                    && Objects.equals(indexSettingsValues, that.indexSettingsValues);
             }
 
             @Override
             public int hashCode() {
-                return Objects.hash(dataStream, dataStreamStatus, indexTemplate, ilmPolicyName, timeSeries);
+                return Objects.hash(
+                    dataStream,
+                    dataStreamStatus,
+                    indexTemplate,
+                    ilmPolicyName,
+                    timeSeries,
+                    indexSettingsValues,
+                    templatePreferIlmValue
+                );
             }
         }
 
@@ -326,6 +425,23 @@ public int hashCode() {
             }
         }
 
+        /**
+         * Encapsulates the configured properties we want to display for each backing index.
+         * They'll usually be settings values, but could also be additional properties derived from settings.
+         */
+        public record IndexProperties(boolean preferIlm, @Nullable String ilmPolicyName, ManagedBy managedBy) implements Writeable {
+            public IndexProperties(StreamInput in) throws IOException {
+                this(in.readBoolean(), in.readOptionalString(), in.readEnum(ManagedBy.class));
+            }
+
+            @Override
+            public void writeTo(StreamOutput out) throws IOException {
+                out.writeBoolean(preferIlm);
+                out.writeOptionalString(ilmPolicyName);
+                out.writeEnum(managedBy);
+            }
+        }
+
         private final List<DataStreamInfo> dataStreams;
         @Nullable
         private final RolloverConfiguration rolloverConfiguration;
diff --git a/server/src/main/java/org/elasticsearch/index/Index.java b/server/src/main/java/org/elasticsearch/index/Index.java
index 85468326954d6..e11fd394d60a9 100644
--- a/server/src/main/java/org/elasticsearch/index/Index.java
+++ b/server/src/main/java/org/elasticsearch/index/Index.java
@@ -103,9 +103,14 @@ public void writeTo(final StreamOutput out) throws IOException {
     @Override
     public XContentBuilder toXContent(final XContentBuilder builder, final Params params) throws IOException {
         builder.startObject();
+        toXContentFragment(builder);
+        return builder.endObject();
+    }
+
+    public XContentBuilder toXContentFragment(final XContentBuilder builder) throws IOException {
         builder.field(INDEX_NAME_KEY, name);
         builder.field(INDEX_UUID_KEY, uuid);
-        return builder.endObject();
+        return builder;
     }
 
     public static Index fromXContent(final XContentParser parser) throws IOException {
diff --git a/x-pack/plugin/ilm/src/internalClusterTest/java/org/elasticsearch/xpack/ilm/DataStreamAndIndexLifecycleMixingTests.java b/x-pack/plugin/ilm/src/internalClusterTest/java/org/elasticsearch/xpack/ilm/DataStreamAndIndexLifecycleMixingTests.java
index 4086a1a729c14..de355cd675089 100644
--- a/x-pack/plugin/ilm/src/internalClusterTest/java/org/elasticsearch/xpack/ilm/DataStreamAndIndexLifecycleMixingTests.java
+++ b/x-pack/plugin/ilm/src/internalClusterTest/java/org/elasticsearch/xpack/ilm/DataStreamAndIndexLifecycleMixingTests.java
@@ -15,6 +15,7 @@
 import org.elasticsearch.action.bulk.BulkResponse;
 import org.elasticsearch.action.datastreams.CreateDataStreamAction;
 import org.elasticsearch.action.datastreams.GetDataStreamAction;
+import org.elasticsearch.action.datastreams.GetDataStreamAction.Response.ManagedBy;
 import org.elasticsearch.action.datastreams.lifecycle.ExplainIndexDataStreamLifecycle;
 import org.elasticsearch.action.index.IndexRequest;
 import org.elasticsearch.cluster.metadata.ComposableIndexTemplate;
@@ -56,10 +57,13 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
 
 import static org.elasticsearch.cluster.metadata.DataStreamTestHelper.backingIndexEqualTo;
 import static org.elasticsearch.cluster.metadata.MetadataIndexTemplateService.DEFAULT_TIMESTAMP_FIELD;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
+import static org.hamcrest.Matchers.containsInAnyOrder;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.nullValue;
@@ -798,6 +802,129 @@ public void testUpdateIndexTemplateToMigrateFromDataStreamLifecycleToIlm() throw
         });
     }
 
+    public void testGetDataStreamResponse() throws Exception {
+        // ILM rolls over every 2 documents
+        RolloverAction rolloverIlmAction = new RolloverAction(RolloverConditions.newBuilder().addMaxIndexDocsCondition(2L).build());
+        Phase hotPhase = new Phase("hot", TimeValue.ZERO, Map.of(rolloverIlmAction.getWriteableName(), rolloverIlmAction));
+        LifecyclePolicy lifecyclePolicy = new LifecyclePolicy(policy, Map.of("hot", hotPhase));
+        PutLifecycleAction.Request putLifecycleRequest = new PutLifecycleAction.Request(lifecyclePolicy);
+        assertAcked(client().execute(PutLifecycleAction.INSTANCE, putLifecycleRequest).get());
+
+        putComposableIndexTemplate(
+            indexTemplateName,
+            null,
+            List.of(dataStreamName + "*"),
+            Settings.builder().put(LifecycleSettings.LIFECYCLE_NAME, policy).build(),
+            null,
+            null
+        );
+        CreateDataStreamAction.Request createDataStreamRequest = new CreateDataStreamAction.Request(dataStreamName);
+        client().execute(CreateDataStreamAction.INSTANCE, createDataStreamRequest).get();
+
+        indexDocs(dataStreamName, 2);
+
+        // wait to rollover
+        assertBusy(() -> {
+            GetDataStreamAction.Request getDataStreamRequest = new GetDataStreamAction.Request(new String[] { dataStreamName });
+            GetDataStreamAction.Response getDataStreamResponse = client().execute(GetDataStreamAction.INSTANCE, getDataStreamRequest)
+                .actionGet();
+            assertThat(getDataStreamResponse.getDataStreams().size(), equalTo(1));
+            assertThat(getDataStreamResponse.getDataStreams().get(0).getDataStream().getIndices().size(), is(2));
+        });
+
+        // prefer_ilm false in the index template
+        putComposableIndexTemplate(
+            indexTemplateName,
+            null,
+            List.of(dataStreamName + "*"),
+            Settings.builder().put(LifecycleSettings.LIFECYCLE_NAME, policy).put(IndexSettings.PREFER_ILM, false).build(),
+            null,
+            null
+        );
+
+        client().execute(
+            PutDataStreamLifecycleAction.INSTANCE,
+            new PutDataStreamLifecycleAction.Request(new String[] { dataStreamName }, TimeValue.timeValueDays(90))
+        ).actionGet();
+
+        // rollover again - at this point this data stream should have 2 backing indices managed by ILM and the write index managed by
+        // data stream lifecycle
+        indexDocs(dataStreamName, 2);
+
+        assertBusy(() -> {
+            GetDataStreamAction.Request getDataStreamRequest = new GetDataStreamAction.Request(new String[] { dataStreamName });
+            GetDataStreamAction.Response getDataStreamResponse = client().execute(GetDataStreamAction.INSTANCE, getDataStreamRequest)
+                .actionGet();
+            assertThat(getDataStreamResponse.getDataStreams().size(), equalTo(1));
+            GetDataStreamAction.Response.DataStreamInfo dataStreamInfo = getDataStreamResponse.getDataStreams().get(0);
+            List<Index> indices = dataStreamInfo.getDataStream().getIndices();
+            assertThat(indices.size(), is(3));
+
+            // the prefer_ilm value from the template should be reflected in the response at the top level
+            assertThat(dataStreamInfo.templatePreferIlmValue(), is(false));
+            // the template ILM policy should still be reflected at the top level
+            assertThat(dataStreamInfo.getIlmPolicy(), is(policy));
+
+            List<String> backingIndices = getBackingIndices(dataStreamName);
+            String firstGenerationIndex = backingIndices.get(0);
+            String secondGenerationIndex = backingIndices.get(1);
+            String writeIndex = backingIndices.get(2);
+            assertThat(
+                indices.stream().map(i -> i.getName()).toList(),
+                containsInAnyOrder(firstGenerationIndex, secondGenerationIndex, writeIndex)
+            );
+
+            Function<String, Optional<Index>> backingIndexSupplier = indexName -> indices.stream()
+                .filter(index -> index.getName().equals(indexName))
+                .findFirst();
+
+            // let's assert the policy is reported for all indices (as it's present in the index template) and the value of the
+            // prefer_ilm setting remains true for the first 2 generations and is false for the write index (the generation after rollover)
+            Optional<Index> firstGenSettings = backingIndexSupplier.apply(firstGenerationIndex);
+            assertThat(firstGenSettings.isPresent(), is(true));
+            assertThat(dataStreamInfo.getIndexSettingsValues().get(firstGenSettings.get()).preferIlm(), is(true));
+            assertThat(dataStreamInfo.getIndexSettingsValues().get(firstGenSettings.get()).ilmPolicyName(), is(policy));
+            assertThat(dataStreamInfo.getIndexSettingsValues().get(firstGenSettings.get()).managedBy(), is(ManagedBy.ILM));
+            Optional<Index> secondGenSettings = backingIndexSupplier.apply(secondGenerationIndex);
+            assertThat(secondGenSettings.isPresent(), is(true));
+            assertThat(dataStreamInfo.getIndexSettingsValues().get(secondGenSettings.get()).preferIlm(), is(true));
+            assertThat(dataStreamInfo.getIndexSettingsValues().get(secondGenSettings.get()).ilmPolicyName(), is(policy));
+            assertThat(dataStreamInfo.getIndexSettingsValues().get(secondGenSettings.get()).managedBy(), is(ManagedBy.ILM));
+            Optional<Index> writeIndexSettings = backingIndexSupplier.apply(writeIndex);
+            assertThat(writeIndexSettings.isPresent(), is(true));
+            assertThat(dataStreamInfo.getIndexSettingsValues().get(writeIndexSettings.get()).preferIlm(), is(false));
+            assertThat(dataStreamInfo.getIndexSettingsValues().get(writeIndexSettings.get()).ilmPolicyName(), is(policy));
+            assertThat(dataStreamInfo.getIndexSettingsValues().get(writeIndexSettings.get()).managedBy(), is(ManagedBy.LIFECYCLE));
+
+            // with the current configuratino, the next generation index will be managed by DSL
+            assertThat(dataStreamInfo.getNextGenerationManagedBy(), is(ManagedBy.LIFECYCLE));
+        });
+
+        // remove ILM policy and prefer_ilm from template
+        putComposableIndexTemplate(indexTemplateName, null, List.of(dataStreamName + "*"), Settings.builder().build(), null, null);
+        GetDataStreamAction.Request getDataStreamRequest = new GetDataStreamAction.Request(new String[] { dataStreamName });
+        GetDataStreamAction.Response getDataStreamResponse = client().execute(GetDataStreamAction.INSTANCE, getDataStreamRequest)
+            .actionGet();
+        assertThat(getDataStreamResponse.getDataStreams().size(), equalTo(1));
+        GetDataStreamAction.Response.DataStreamInfo dataStreamInfo = getDataStreamResponse.getDataStreams().get(0);
+        // since the ILM related settings are gone from the index template, this data stream should now be managed by lifecycle
+        assertThat(dataStreamInfo.getNextGenerationManagedBy(), is(ManagedBy.LIFECYCLE));
+
+        // disable data stream lifecycle on the data stream. the future generations will be UNMANAGED
+        client().execute(
+            PutDataStreamLifecycleAction.INSTANCE,
+            new PutDataStreamLifecycleAction.Request(new String[] { dataStreamName }, TimeValue.timeValueDays(90), false)
+        ).actionGet();
+
+        getDataStreamRequest = new GetDataStreamAction.Request(new String[] { dataStreamName });
+        getDataStreamResponse = client().execute(GetDataStreamAction.INSTANCE, getDataStreamRequest).actionGet();
+        assertThat(getDataStreamResponse.getDataStreams().size(), equalTo(1));
+        dataStreamInfo = getDataStreamResponse.getDataStreams().get(0);
+        // since the ILM related settings are gone from the index template and the lifeclcye is disabled, this data stream should now be
+        // managed unmanaged
+        assertThat(dataStreamInfo.getNextGenerationManagedBy(), is(ManagedBy.UNMANAGED));
+    }
+
     static void indexDocs(String dataStream, int numDocs) {
         BulkRequest bulkRequest = new BulkRequest();
         for (int i = 0; i < numDocs; i++) {

From 7c21ce3f1b461c7a73abd90af58bf7ca53a2b1b2 Mon Sep 17 00:00:00 2001
From: Max Hniebergall <137079448+maxhniebergall@users.noreply.github.com>
Date: Thu, 28 Sep 2023 13:56:45 -0400
Subject: [PATCH 18/32] Platform specific models (#99584)

* Added platform architecture field to TrainedModelMetadata and users of TrainedModelMetadata

* Added TransportVersions guarding for TrainedModelMetadata

* Prevent platform-specific models from being deployed on the wrong architecture

* Added logic to only verify node architectures for models which are platform specific

* Handle null platform architecture

* Added logging for the detection of heterogeneous platform architectures among ML nodes and refactoring to support this

* Added platform architecture field to TrainedModelConfig

* Stop platform-speficic model when rebalance occurs and the cluster has a heterogeneous architecture among ML nodes

* Added logic to TransportPutTrainedModelAction to return a warning response header when the model is paltform-specific and cannot be depoloyed on the cluster at that time due to heterogenous architectures among ML nodes

* Added MlPlatformArchitecturesUtilTests

* Updated Create Trained Models API docs to describe the new platform_architecture optional field.

* Updated/incremented InferenceIndexConstants

* Added special override to make  models with linux-x86_64 in the model ID to be platform specific
---
 docs/changelog/99584.yaml                     |   5 +
 .../apis/put-trained-models.asciidoc          |  12 ++
 .../org/elasticsearch/TransportVersions.java  |   1 +
 .../core/ml/inference/TrainedModelConfig.java |  39 +++-
 .../persistence/InferenceIndexConstants.java  |   8 +-
 .../ml/inference/TrainedModelConfigTests.java |  13 +-
 .../ml/inference_index_mappings.json          |   3 +
 .../xpack/ml/MachineLearning.java             |   3 +-
 .../TransportPutTrainedModelAction.java       |  89 ++++++--
 .../TrainedModelAssignmentClusterService.java | 159 ++++++++++----
 .../deployment/DeploymentManager.java         |  52 ++++-
 .../MlPlatformArchitecturesUtil.java          | 127 +++++++++++
 .../TransportPutTrainedModelActionTests.java  |  70 ++++++
 ...nedModelAssignmentClusterServiceTests.java | 178 ++++++++++++++-
 .../deployment/DeploymentManagerTests.java    |   1 +
 .../MlPlatformArchitecturesUtilTests.java     | 202 ++++++++++++++++++
 .../xpack/ml/test/MockAppender.java           |  36 ++++
 .../rest-api-spec/test/ml/inference_crud.yml  |  27 +++
 18 files changed, 947 insertions(+), 78 deletions(-)
 create mode 100644 docs/changelog/99584.yaml
 create mode 100644 x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/deployment/MlPlatformArchitecturesUtil.java
 create mode 100644 x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/deployment/MlPlatformArchitecturesUtilTests.java
 create mode 100644 x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/test/MockAppender.java

diff --git a/docs/changelog/99584.yaml b/docs/changelog/99584.yaml
new file mode 100644
index 0000000000000..229e3d8024506
--- /dev/null
+++ b/docs/changelog/99584.yaml
@@ -0,0 +1,5 @@
+pr: 99584
+summary: Adding an option for trained models to be platform specific
+area: Machine Learning
+type: enhancement
+issues: []
diff --git a/docs/reference/ml/trained-models/apis/put-trained-models.asciidoc b/docs/reference/ml/trained-models/apis/put-trained-models.asciidoc
index 82fd1872e6a76..7da46e13a8ce4 100644
--- a/docs/reference/ml/trained-models/apis/put-trained-models.asciidoc
+++ b/docs/reference/ml/trained-models/apis/put-trained-models.asciidoc
@@ -3,7 +3,9 @@
 = Create trained models API
 [subs="attributes"]
 ++++
+
 <titleabbrev>Create trained models</titleabbrev>
+
 ++++
 
 Creates a trained model.
@@ -1645,6 +1647,16 @@ Appropriate types are:
 * `pytorch`: The stored definition is a PyTorch (specifically a TorchScript) model. Currently only
 NLP models are supported. For more information, refer to {ml-docs}/ml-nlp.html[{nlp-cap}].
 --
+`platform_architecture`::
+(Optional, string)
+If the model only works on one platform, because it is heavily
+optimized for a particular processor architecture and OS combination,
+then this field specifies which. The format of the string must match
+the platform identifiers used by Elasticsearch, so one of, `linux-x86_64`,
+`linux-aarch64`, `darwin-x86_64`, `darwin-aarch64`, or `windows-x86_64`.
+For portable models (those that work independent of processor architecture or
+OS features), leave this field unset.
+
 
 `tags`::
 (Optional, string)
diff --git a/server/src/main/java/org/elasticsearch/TransportVersions.java b/server/src/main/java/org/elasticsearch/TransportVersions.java
index 360af92d6aa43..30cff2ce427be 100644
--- a/server/src/main/java/org/elasticsearch/TransportVersions.java
+++ b/server/src/main/java/org/elasticsearch/TransportVersions.java
@@ -147,6 +147,7 @@ static TransportVersion def(int id) {
     public static final TransportVersion NODE_INFO_COMPONENT_VERSIONS_ADDED = def(8_504_00_0);
     public static final TransportVersion COMPACT_FIELD_CAPS_ADDED = def(8_505_00_0);
     public static final TransportVersion DATA_STREAM_RESPONSE_INDEX_PROPERTIES = def(8_506_00_0);
+    public static final TransportVersion ML_TRAINED_MODEL_CONFIG_PLATFORM_ADDED = def(8_507_00_0);
 
     /*
      * STOP! READ THIS FIRST! No, really,
diff --git a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/inference/TrainedModelConfig.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/inference/TrainedModelConfig.java
index 9d4442f877b85..9dfa2d51f0fc0 100644
--- a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/inference/TrainedModelConfig.java
+++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/inference/TrainedModelConfig.java
@@ -103,6 +103,7 @@ public class TrainedModelConfig implements ToXContentObject, Writeable {
 
     public static final ParseField PER_DEPLOYMENT_MEMORY_BYTES = new ParseField("per_deployment_memory_bytes");
     public static final ParseField PER_ALLOCATION_MEMORY_BYTES = new ParseField("per_allocation_memory_bytes");
+    public static final ParseField PLATFORM_ARCHITECTURE = new ParseField("platform_architecture");
 
     public static final TransportVersion VERSION_3RD_PARTY_CONFIG_ADDED = TransportVersions.V_8_0_0;
     public static final TransportVersion VERSION_ALLOCATION_MEMORY_ADDED = TransportVersions.V_8_500_064;
@@ -168,6 +169,7 @@ private static ObjectParser<TrainedModelConfig.Builder, Void> createParser(boole
             (p, c) -> ignoreUnknownFields ? ModelPackageConfig.fromXContentLenient(p) : ModelPackageConfig.fromXContentStrict(p),
             MODEL_PACKAGE
         );
+        parser.declareString(TrainedModelConfig.Builder::setPlatformArchitecture, PLATFORM_ARCHITECTURE);
 
         return parser;
     }
@@ -195,6 +197,7 @@ public static TrainedModelConfig.Builder fromXContent(XContentParser parser, boo
     private final TrainedModelLocation location;
     private final ModelPackageConfig modelPackageConfig;
     private Boolean fullDefinition;
+    private String platformArchitecture;
 
     TrainedModelConfig(
         String modelId,
@@ -213,7 +216,8 @@ public static TrainedModelConfig.Builder fromXContent(XContentParser parser, boo
         Map<String, String> defaultFieldMap,
         InferenceConfig inferenceConfig,
         TrainedModelLocation location,
-        ModelPackageConfig modelPackageConfig
+        ModelPackageConfig modelPackageConfig,
+        String platformArchitecture
     ) {
         this.modelId = ExceptionsHelper.requireNonNull(modelId, MODEL_ID);
         this.modelType = modelType;
@@ -240,6 +244,7 @@ public static TrainedModelConfig.Builder fromXContent(XContentParser parser, boo
         this.inferenceConfig = inferenceConfig;
         this.location = location;
         this.modelPackageConfig = modelPackageConfig;
+        this.platformArchitecture = platformArchitecture;
     }
 
     private static TrainedModelInput handleDefaultInput(TrainedModelInput input, TrainedModelType modelType) {
@@ -279,6 +284,11 @@ public TrainedModelConfig(StreamInput in) throws IOException {
             modelPackageConfig = null;
             fullDefinition = null;
         }
+        if (in.getTransportVersion().onOrAfter(TransportVersions.ML_TRAINED_MODEL_CONFIG_PLATFORM_ADDED)) {
+            platformArchitecture = in.readOptionalString();
+        } else {
+            platformArchitecture = null;
+        }
     }
 
     public boolean isPackagedModel() {
@@ -421,6 +431,10 @@ public long getPerAllocationMemoryBytes() {
             : 0L;
     }
 
+    public String getPlatformArchitecture() {
+        return platformArchitecture;
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         out.writeString(modelId);
@@ -451,6 +465,10 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeOptionalWriteable(modelPackageConfig);
             out.writeOptionalBoolean(fullDefinition);
         }
+
+        if (out.getTransportVersion().onOrAfter(TransportVersions.ML_TRAINED_MODEL_CONFIG_PLATFORM_ADDED)) {
+            out.writeOptionalString(platformArchitecture);
+        }
     }
 
     @Override
@@ -463,6 +481,9 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         if (modelPackageConfig != null) {
             builder.field(MODEL_PACKAGE.getPreferredName(), modelPackageConfig);
         }
+        if (platformArchitecture != null) {
+            builder.field(PLATFORM_ARCHITECTURE.getPreferredName(), platformArchitecture);
+        }
 
         // If the model is to be exported for future import to another cluster, these fields are irrelevant.
         if (params.paramAsBoolean(EXCLUDE_GENERATED, false) == false) {
@@ -543,7 +564,8 @@ public boolean equals(Object o) {
             && Objects.equals(defaultFieldMap, that.defaultFieldMap)
             && Objects.equals(inferenceConfig, that.inferenceConfig)
             && Objects.equals(metadata, that.metadata)
-            && Objects.equals(location, that.location);
+            && Objects.equals(location, that.location)
+            && Objects.equals(platformArchitecture, that.platformArchitecture);
     }
 
     @Override
@@ -565,7 +587,8 @@ public int hashCode() {
             licenseLevel,
             inferenceConfig,
             defaultFieldMap,
-            location
+            location,
+            platformArchitecture
         );
     }
 
@@ -590,6 +613,7 @@ public static class Builder {
         private ModelPackageConfig modelPackageConfig;
         private Long perDeploymentMemoryBytes;
         private Long perAllocationMemoryBytes;
+        private String platformArchitecture;
 
         public Builder() {}
 
@@ -611,6 +635,7 @@ public Builder(TrainedModelConfig config) {
             this.inferenceConfig = config.inferenceConfig;
             this.location = config.location;
             this.modelPackageConfig = config.modelPackageConfig;
+            this.platformArchitecture = config.platformArchitecture;
         }
 
         public Builder setModelId(String modelId) {
@@ -703,6 +728,11 @@ public Builder setHyperparameters(List<Hyperparameters> hyperparameters) {
             return addToMetadata(HYPERPARAMETERS, hyperparameters.stream().map(Hyperparameters::asMap).collect(Collectors.toList()));
         }
 
+        public Builder setPlatformArchitecture(String platformArchitecture) {
+            this.platformArchitecture = platformArchitecture;
+            return this;
+        }
+
         public Builder setModelAliases(Set<String> modelAliases) {
             if (modelAliases == null || modelAliases.isEmpty()) {
                 return this;
@@ -1022,7 +1052,8 @@ public TrainedModelConfig build() {
                 defaultFieldMap,
                 inferenceConfig,
                 location,
-                modelPackageConfig
+                modelPackageConfig,
+                platformArchitecture
             );
         }
     }
diff --git a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/inference/persistence/InferenceIndexConstants.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/inference/persistence/InferenceIndexConstants.java
index ca70f9e9e761d..6c8fc6fec4e0e 100644
--- a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/inference/persistence/InferenceIndexConstants.java
+++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/inference/persistence/InferenceIndexConstants.java
@@ -42,11 +42,15 @@ public final class InferenceIndexConstants {
     public static final ParseField DOC_TYPE = new ParseField("doc_type");
 
     private static final String NATIVE_INDEX_PREFIX = INDEX_NAME_PREFIX + "native-";
-    private static final String NATIVE_INDEX_VERSION = "000001";
+
+    // 000002 added support for platform specific models
+    private static final String NATIVE_INDEX_VERSION = "000002";
     private static final String NATIVE_LATEST_INDEX = NATIVE_INDEX_PREFIX + NATIVE_INDEX_VERSION;
 
     private static final String MAPPINGS_VERSION_VARIABLE = "xpack.ml.version";
-    public static final int INFERENCE_INDEX_MAPPINGS_VERSION = 1;
+
+    // 2 added support for platform specific models
+    public static final int INFERENCE_INDEX_MAPPINGS_VERSION = 2;
 
     public static String mapping() {
         return TemplateUtils.loadTemplate(
diff --git a/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/ml/inference/TrainedModelConfigTests.java b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/ml/inference/TrainedModelConfigTests.java
index 51f65fe0c9a0b..8b382beeb0644 100644
--- a/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/ml/inference/TrainedModelConfigTests.java
+++ b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/ml/inference/TrainedModelConfigTests.java
@@ -7,6 +7,7 @@
 package org.elasticsearch.xpack.core.ml.inference;
 
 import org.elasticsearch.TransportVersion;
+import org.elasticsearch.TransportVersions;
 import org.elasticsearch.action.ActionRequestValidationException;
 import org.elasticsearch.common.bytes.BytesReference;
 import org.elasticsearch.common.io.stream.NamedWriteableRegistry;
@@ -104,7 +105,8 @@ public static TrainedModelConfig.Builder createTestInstance(String modelId, bool
             .setLicenseLevel(randomFrom(License.OperationMode.PLATINUM.description(), License.OperationMode.BASIC.description()))
             .setInferenceConfig(randomFrom(inferenceConfigs))
             .setTags(tags)
-            .setLocation(randomBoolean() ? null : IndexLocationTests.randomInstance());
+            .setLocation(randomBoolean() ? null : IndexLocationTests.randomInstance())
+            .setPlatformArchitecture(randomBoolean() ? null : randomAlphaOfLength(10));
     }
 
     @Before
@@ -191,7 +193,8 @@ public void testToXContentWithParams() throws IOException {
                     .collect(Collectors.toMap(Function.identity(), (k) -> randomAlphaOfLength(10))),
             randomFrom(ClassificationConfigTests.randomClassificationConfig(), RegressionConfigTests.randomRegressionConfig()),
             null,
-            ModelPackageConfigTests.randomModulePackageConfig()
+            ModelPackageConfigTests.randomModulePackageConfig(),
+            randomAlphaOfLength(10)
         );
 
         BytesReference reference = XContentHelper.toXContent(config, XContentType.JSON, ToXContent.EMPTY_PARAMS, false);
@@ -241,7 +244,8 @@ public void testParseWithBothDefinitionAndCompressedSupplied() throws IOExceptio
                     .collect(Collectors.toMap(Function.identity(), (k) -> randomAlphaOfLength(10))),
             randomFrom(ClassificationConfigTests.randomClassificationConfig(), RegressionConfigTests.randomRegressionConfig()),
             null,
-            ModelPackageConfigTests.randomModulePackageConfig()
+            ModelPackageConfigTests.randomModulePackageConfig(),
+            randomAlphaOfLength(10)
         );
 
         BytesReference reference = XContentHelper.toXContent(config, XContentType.JSON, ToXContent.EMPTY_PARAMS, false);
@@ -453,6 +457,9 @@ protected TrainedModelConfig mutateInstanceForVersion(TrainedModelConfig instanc
         if (instance.getInferenceConfig() instanceof NlpConfig nlpConfig) {
             builder.setInferenceConfig(InferenceConfigItemTestCase.mutateForVersion(nlpConfig, version));
         }
+        if (version.before(TransportVersions.ML_TRAINED_MODEL_CONFIG_PLATFORM_ADDED)) {
+            builder.setPlatformArchitecture(null);
+        }
         return builder.build();
     }
 }
diff --git a/x-pack/plugin/core/template-resources/src/main/resources/ml/inference_index_mappings.json b/x-pack/plugin/core/template-resources/src/main/resources/ml/inference_index_mappings.json
index 7ff961a0aac9c..77634546e0e6e 100644
--- a/x-pack/plugin/core/template-resources/src/main/resources/ml/inference_index_mappings.json
+++ b/x-pack/plugin/core/template-resources/src/main/resources/ml/inference_index_mappings.json
@@ -12,6 +12,9 @@
       "model_id": {
         "type": "keyword"
       },
+      "platform_architecture" : {
+        "type" : "keyword"
+      },
       "created_by": {
         "type": "keyword"
       },
diff --git a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/MachineLearning.java b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/MachineLearning.java
index c8e4fd488394a..d2d6bd4fcb443 100644
--- a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/MachineLearning.java
+++ b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/MachineLearning.java
@@ -1227,7 +1227,8 @@ public Collection<Object> createComponents(
                 threadPool,
                 new NodeLoadDetector(memoryTracker),
                 systemAuditor,
-                nodeAvailabilityZoneMapper
+                nodeAvailabilityZoneMapper,
+                client
             )
         );
 
diff --git a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TransportPutTrainedModelAction.java b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TransportPutTrainedModelAction.java
index 6f97689222196..a0a2a81791550 100644
--- a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TransportPutTrainedModelAction.java
+++ b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TransportPutTrainedModelAction.java
@@ -28,6 +28,7 @@
 import org.elasticsearch.common.ValidationException;
 import org.elasticsearch.common.bytes.BytesReference;
 import org.elasticsearch.common.inject.Inject;
+import org.elasticsearch.common.logging.HeaderWarning;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.util.concurrent.EsExecutors;
@@ -71,6 +72,7 @@
 import org.elasticsearch.xpack.core.ml.utils.ExceptionsHelper;
 import org.elasticsearch.xpack.ml.inference.ModelAliasMetadata;
 import org.elasticsearch.xpack.ml.inference.assignment.TrainedModelAssignmentMetadata;
+import org.elasticsearch.xpack.ml.inference.deployment.MlPlatformArchitecturesUtil;
 import org.elasticsearch.xpack.ml.inference.persistence.TrainedModelProvider;
 import org.elasticsearch.xpack.ml.utils.TaskRetriever;
 
@@ -78,6 +80,7 @@
 import java.time.Instant;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicReference;
 
@@ -132,7 +135,7 @@ protected void masterOperation(
         Task task,
         PutTrainedModelAction.Request request,
         ClusterState state,
-        ActionListener<Response> listener
+        ActionListener<Response> finalResponseListener
     ) {
         TrainedModelConfig config = request.getTrainedModelConfig();
         try {
@@ -140,7 +143,9 @@ protected void masterOperation(
                 config.ensureParsedDefinition(xContentRegistry);
             }
         } catch (IOException ex) {
-            listener.onFailure(ExceptionsHelper.badRequestException("Failed to parse definition for [{}]", ex, config.getModelId()));
+            finalResponseListener.onFailure(
+                ExceptionsHelper.badRequestException("Failed to parse definition for [{}]", ex, config.getModelId())
+            );
             return;
         }
 
@@ -150,7 +155,7 @@ protected void masterOperation(
             try {
                 config.getModelDefinition().getTrainedModel().validate();
             } catch (ElasticsearchException ex) {
-                listener.onFailure(
+                finalResponseListener.onFailure(
                     ExceptionsHelper.badRequestException("Definition for [{}] has validation failures.", ex, config.getModelId())
                 );
                 return;
@@ -158,7 +163,7 @@ protected void masterOperation(
 
             TrainedModelType trainedModelType = TrainedModelType.typeFromTrainedModel(config.getModelDefinition().getTrainedModel());
             if (trainedModelType == null) {
-                listener.onFailure(
+                finalResponseListener.onFailure(
                     ExceptionsHelper.badRequestException(
                         "Unknown trained model definition class [{}]",
                         config.getModelDefinition().getTrainedModel().getName()
@@ -171,7 +176,7 @@ protected void masterOperation(
                 // Set the model type from the definition
                 config = new TrainedModelConfig.Builder(config).setModelType(trainedModelType).build();
             } else if (trainedModelType != config.getModelType()) {
-                listener.onFailure(
+                finalResponseListener.onFailure(
                     ExceptionsHelper.badRequestException(
                         "{} [{}] does not match the model definition type [{}]",
                         TrainedModelConfig.MODEL_TYPE.getPreferredName(),
@@ -183,7 +188,7 @@ protected void masterOperation(
             }
 
             if (config.getInferenceConfig().isTargetTypeSupported(config.getModelDefinition().getTrainedModel().targetType()) == false) {
-                listener.onFailure(
+                finalResponseListener.onFailure(
                     ExceptionsHelper.badRequestException(
                         "Model [{}] inference config type [{}] does not support definition target type [{}]",
                         config.getModelId(),
@@ -196,7 +201,7 @@ protected void masterOperation(
 
             TransportVersion minCompatibilityVersion = config.getModelDefinition().getTrainedModel().getMinimalCompatibilityVersion();
             if (state.getMinTransportVersion().before(minCompatibilityVersion)) {
-                listener.onFailure(
+                finalResponseListener.onFailure(
                     ExceptionsHelper.badRequestException(
                         "Cannot create model [{}] while cluster upgrade is in progress.",
                         config.getModelId()
@@ -223,7 +228,7 @@ protected void masterOperation(
         }
 
         if (ModelAliasMetadata.fromState(state).getModelId(trainedModelConfig.getModelId()) != null) {
-            listener.onFailure(
+            finalResponseListener.onFailure(
                 ExceptionsHelper.badRequestException(
                     "requested model_id [{}] is the same as an existing model_alias. Model model_aliases and ids must be unique",
                     config.getModelId()
@@ -233,7 +238,7 @@ protected void masterOperation(
         }
 
         if (TrainedModelAssignmentMetadata.fromState(state).hasDeployment(trainedModelConfig.getModelId())) {
-            listener.onFailure(
+            finalResponseListener.onFailure(
                 ExceptionsHelper.badRequestException(
                     "Cannot create model [{}] the id is the same as an current model deployment",
                     config.getModelId()
@@ -242,6 +247,14 @@ protected void masterOperation(
             return;
         }
 
+        ActionListener<TrainedModelConfig> finalResponseAction = ActionListener.wrap((configToReturn) -> {
+            finalResponseListener.onResponse(new PutTrainedModelAction.Response(configToReturn));
+        }, finalResponseListener::onFailure);
+
+        ActionListener<TrainedModelConfig> verifyClusterAndModelArchitectures = ActionListener.wrap((configToReturn) -> {
+            verifyMlNodesAndModelArchitectures(configToReturn, client, threadPool, finalResponseAction);
+        }, finalResponseListener::onFailure);
+
         ActionListener<Boolean> finishedStoringListener = ActionListener.wrap(bool -> {
             TrainedModelConfig configToReturn = trainedModelConfig.clearDefinition().build();
             if (modelPackageConfigHolder.get() != null) {
@@ -250,19 +263,19 @@ protected void masterOperation(
                     modelPackageConfigHolder.get(),
                     request.isWaitForCompletion(),
                     ActionListener.wrap(
-                        downloadTriggered -> listener.onResponse(new PutTrainedModelAction.Response(configToReturn)),
-                        listener::onFailure
+                        downloadTriggered -> verifyClusterAndModelArchitectures.onResponse(configToReturn),
+                        finalResponseListener::onFailure
                     )
                 );
             } else {
-                listener.onResponse(new PutTrainedModelAction.Response(configToReturn));
+                finalResponseListener.onResponse(new PutTrainedModelAction.Response(configToReturn));
             }
-        }, listener::onFailure);
+        }, finalResponseListener::onFailure);
 
         var isPackageModel = config.isPackagedModel();
         ActionListener<Void> checkStorageIndexSizeListener = ActionListener.wrap(
             r -> trainedModelProvider.storeTrainedModel(trainedModelConfig.build(), finishedStoringListener, isPackageModel),
-            listener::onFailure
+            finalResponseListener::onFailure
         );
 
         ActionListener<Void> tagsModelIdCheckListener = ActionListener.wrap(r -> {
@@ -276,7 +289,7 @@ protected void masterOperation(
                         IndexStats indexStats = stats.getIndices().get(InferenceIndexConstants.nativeDefinitionStore());
                         if (indexStats != null
                             && indexStats.getTotal().getStore().getSizeInBytes() > MAX_NATIVE_DEFINITION_INDEX_SIZE.getBytes()) {
-                            listener.onFailure(
+                            finalResponseListener.onFailure(
                                 new ElasticsearchStatusException(
                                     "Native model store has exceeded the maximum acceptable size of {}, "
                                         + "please delete older unused pytorch models",
@@ -293,7 +306,7 @@ protected void masterOperation(
                             checkStorageIndexSizeListener.onResponse(null);
                             return;
                         }
-                        listener.onFailure(
+                        finalResponseListener.onFailure(
                             new ElasticsearchStatusException(
                                 "Unable to calculate stats for definition storage index [{}], please try again later",
                                 RestStatus.SERVICE_UNAVAILABLE,
@@ -305,11 +318,11 @@ protected void masterOperation(
                 return;
             }
             checkStorageIndexSizeListener.onResponse(null);
-        }, listener::onFailure);
+        }, finalResponseListener::onFailure);
 
         ActionListener<Void> modelIdTagCheckListener = ActionListener.wrap(
             r -> checkTagsAgainstModelIds(request.getTrainedModelConfig().getTags(), tagsModelIdCheckListener),
-            listener::onFailure
+            finalResponseListener::onFailure
         );
 
         ActionListener<Void> handlePackageAndTagsListener = ActionListener.wrap(r -> {
@@ -318,29 +331,61 @@ protected void masterOperation(
                     try {
                         TrainedModelValidator.validatePackage(trainedModelConfig, resolvedModelPackageConfig, state);
                     } catch (ValidationException e) {
-                        listener.onFailure(e);
+                        finalResponseListener.onFailure(e);
                         return;
                     }
                     modelPackageConfigHolder.set(resolvedModelPackageConfig);
                     setTrainedModelConfigFieldsFromPackagedModel(trainedModelConfig, resolvedModelPackageConfig, xContentRegistry);
 
                     checkModelIdAgainstTags(trainedModelConfig.getModelId(), modelIdTagCheckListener);
-                }, listener::onFailure));
+                }, finalResponseListener::onFailure));
             } else {
                 checkModelIdAgainstTags(trainedModelConfig.getModelId(), modelIdTagCheckListener);
             }
-        }, listener::onFailure);
+        }, finalResponseListener::onFailure);
 
         checkForExistingTask(
             client,
             trainedModelConfig.getModelId(),
             request.isWaitForCompletion(),
-            listener,
+            finalResponseListener,
             handlePackageAndTagsListener,
             request.timeout()
         );
     }
 
+    void verifyMlNodesAndModelArchitectures(
+        TrainedModelConfig configToReturn,
+        Client client,
+        ThreadPool threadPool,
+        ActionListener<TrainedModelConfig> configToReturnListener
+    ) {
+        ActionListener<TrainedModelConfig> addWarningHeaderOnFailureListener = new ActionListener<TrainedModelConfig>() {
+            @Override
+            public void onResponse(TrainedModelConfig config) {
+                assert Objects.equals(config, configToReturn);
+                configToReturnListener.onResponse(configToReturn);
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                HeaderWarning.addWarning(e.getMessage());
+                configToReturnListener.onResponse(configToReturn);
+            }
+        };
+
+        callVerifyMlNodesAndModelArchitectures(configToReturn, addWarningHeaderOnFailureListener, client, threadPool);
+    }
+
+    void callVerifyMlNodesAndModelArchitectures(
+        TrainedModelConfig configToReturn,
+        ActionListener<TrainedModelConfig> failureListener,
+        Client client,
+        ThreadPool threadPool
+    ) {
+        MlPlatformArchitecturesUtil.verifyMlNodesAndModelArchitectures(failureListener, client, threadPool, configToReturn);
+    }
+
     /**
      * This method is package private for testing
      */
diff --git a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/assignment/TrainedModelAssignmentClusterService.java b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/assignment/TrainedModelAssignmentClusterService.java
index efc8bd84c6350..ea52c4918d05b 100644
--- a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/assignment/TrainedModelAssignmentClusterService.java
+++ b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/assignment/TrainedModelAssignmentClusterService.java
@@ -15,6 +15,7 @@
 import org.elasticsearch.TransportVersions;
 import org.elasticsearch.action.ActionListener;
 import org.elasticsearch.action.support.master.AcknowledgedResponse;
+import org.elasticsearch.client.internal.Client;
 import org.elasticsearch.cluster.ClusterChangedEvent;
 import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.ClusterStateListener;
@@ -47,6 +48,7 @@
 import org.elasticsearch.xpack.ml.MachineLearning;
 import org.elasticsearch.xpack.ml.autoscaling.NodeAvailabilityZoneMapper;
 import org.elasticsearch.xpack.ml.inference.assignment.planning.AllocationReducer;
+import org.elasticsearch.xpack.ml.inference.deployment.MlPlatformArchitecturesUtil;
 import org.elasticsearch.xpack.ml.job.NodeLoad;
 import org.elasticsearch.xpack.ml.job.NodeLoadDetector;
 import org.elasticsearch.xpack.ml.notifications.SystemAuditor;
@@ -78,6 +80,7 @@ public class TrainedModelAssignmentClusterService implements ClusterStateListene
     private final NodeLoadDetector nodeLoadDetector;
     private final SystemAuditor systemAuditor;
     private final NodeAvailabilityZoneMapper nodeAvailabilityZoneMapper;
+    private final Client client;
     private volatile int maxMemoryPercentage;
     private volatile boolean useAuto;
     private volatile int maxOpenJobs;
@@ -91,7 +94,8 @@ public TrainedModelAssignmentClusterService(
         ThreadPool threadPool,
         NodeLoadDetector nodeLoadDetector,
         SystemAuditor systemAuditor,
-        NodeAvailabilityZoneMapper nodeAvailabilityZoneMapper
+        NodeAvailabilityZoneMapper nodeAvailabilityZoneMapper,
+        Client client
     ) {
         this.clusterService = Objects.requireNonNull(clusterService);
         this.threadPool = Objects.requireNonNull(threadPool);
@@ -104,6 +108,7 @@ public TrainedModelAssignmentClusterService(
         this.maxLazyMLNodes = MachineLearning.MAX_LAZY_ML_NODES.get(settings);
         this.maxMLNodeSize = MachineLearning.MAX_ML_NODE_SIZE.get(settings).getBytes();
         this.allocatedProcessorsScale = MachineLearning.ALLOCATED_PROCESSORS_SCALE.get(settings);
+        this.client = client;
         // Only nodes that can possibly be master nodes really need this service running
         if (DiscoveryNode.isMasterNode(settings)) {
             clusterService.addListener(this);
@@ -150,14 +155,14 @@ private void submitUnbatchedTask(@SuppressWarnings("SameParameterValue") String
 
     @Override
     public void clusterChanged(ClusterChangedEvent event) {
-        if (event.state().blocks().hasGlobalBlock(GatewayService.STATE_NOT_RECOVERED_BLOCK)) {
+        if (eventStateHasGlobalBlockStateNotRecoveredBlock(event)) {
             return;
         }
         if (event.localNodeMaster() == false) {
             return;
         }
 
-        if (event.state().getMinTransportVersion().before(DISTRIBUTED_MODEL_ALLOCATION_TRANSPORT_VERSION)) {
+        if (eventStateMinTransportVersionIsBeforeDistributedModelAllocationTransportVersion(event)) {
             // we should not try to rebalance assignments while there may be nodes running on a version
             // prior to introducing distributed model allocation.
             // But we should remove routing to removed or shutting down nodes.
@@ -165,6 +170,10 @@ public void clusterChanged(ClusterChangedEvent event) {
             return;
         }
 
+        if (event.nodesAdded()) {
+            logMlNodeHeterogeneity();
+        }
+
         Optional<String> rebalanceReason = detectReasonToRebalanceModels(event);
         if (rebalanceReason.isPresent()) {
             // As this produces a cluster state update task, we are certain that if the persistent
@@ -187,6 +196,42 @@ public void clusterChanged(ClusterChangedEvent event) {
         }
     }
 
+    boolean eventStateMinTransportVersionIsBeforeDistributedModelAllocationTransportVersion(ClusterChangedEvent event) {
+        return event.state().getMinTransportVersion().before(DISTRIBUTED_MODEL_ALLOCATION_TRANSPORT_VERSION);
+    }
+
+    boolean eventStateHasGlobalBlockStateNotRecoveredBlock(ClusterChangedEvent event) {
+        return event.state().blocks().hasGlobalBlock(GatewayService.STATE_NOT_RECOVERED_BLOCK);
+    }
+
+    void logMlNodeHeterogeneity() {
+        ActionListener<Set<String>> architecturesListener = getArchitecturesSetActionListener();
+        MlPlatformArchitecturesUtil.getMlNodesArchitecturesSet(architecturesListener, client, threadPool);
+    }
+
+    static ActionListener<Set<String>> getArchitecturesSetActionListener() {
+        ActionListener<Set<String>> architecturesListener = new ActionListener<Set<String>>() {
+            @Override
+            public void onResponse(Set<String> architectures) {
+                if (architectures.size() > 1) {
+                    logger.warn(
+                        format(
+                            "Heterogeneous platform architectures were detected among ML nodes. "
+                                + "This will prevent the deployment of some trained models. Distinct platform architectures detected: %s",
+                            architectures
+                        )
+                    );
+                }
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                logger.error("Failed to detect heterogeneity among ML nodes with exception: ", e);
+            }
+        };
+        return architecturesListener;
+    }
+
     private void removeRoutingToRemovedOrShuttingDownNodes(ClusterChangedEvent event) {
         if (areAssignedNodesRemoved(event)) {
             submitUnbatchedTask("removing routing entries for removed or shutting down nodes", new ClusterStateUpdateTask() {
@@ -486,51 +531,89 @@ private void rebalanceAssignments(
         String reason,
         ActionListener<TrainedModelAssignmentMetadata> listener
     ) {
-        threadPool.executor(MachineLearning.UTILITY_THREAD_POOL_NAME).execute(() -> {
-            logger.debug(() -> format("Rebalancing model allocations because [%s]", reason));
-            TrainedModelAssignmentMetadata.Builder rebalancedMetadata;
-            try {
-                rebalancedMetadata = rebalanceAssignments(clusterState, modelToAdd);
-            } catch (Exception e) {
-                listener.onFailure(e);
-                return;
-            }
+        ActionListener<Set<String>> architecturesListener = ActionListener.wrap((mlNodesArchitectures) -> {
+            threadPool.executor(MachineLearning.UTILITY_THREAD_POOL_NAME).execute(() -> {
+                logger.debug(() -> format("Rebalancing model allocations because [%s]", reason));
+
+                TrainedModelAssignmentMetadata.Builder rebalancedMetadata;
+                try {
+                    rebalancedMetadata = rebalanceAssignments(clusterState, modelToAdd);
+                } catch (Exception e) {
+                    listener.onFailure(e);
+                    return;
+                }
 
-            submitUnbatchedTask(reason, new ClusterStateUpdateTask() {
+                submitUnbatchedTask(reason, new ClusterStateUpdateTask() {
 
-                private volatile boolean isUpdated;
-                private volatile boolean isChanged;
+                    private volatile boolean isUpdated;
+                    private volatile boolean isChanged;
 
-                @Override
-                public ClusterState execute(ClusterState currentState) {
+                    @Override
+                    public ClusterState execute(ClusterState currentState) {
 
-                    if (areClusterStatesCompatibleForRebalance(clusterState, currentState)) {
-                        isUpdated = true;
-                        ClusterState updatedState = update(currentState, rebalancedMetadata);
-                        isChanged = updatedState != currentState;
-                        return updatedState;
+                        currentState = stopPlatformSpecificModelsInHeterogeneousClusters(
+                            currentState,
+                            mlNodesArchitectures,
+                            modelToAdd,
+                            clusterState
+                        );
+
+                        if (areClusterStatesCompatibleForRebalance(clusterState, currentState)) {
+                            isUpdated = true;
+                            ClusterState updatedState = update(currentState, rebalancedMetadata);
+                            isChanged = updatedState != currentState;
+                            return updatedState;
+                        }
+
+                        rebalanceAssignments(currentState, modelToAdd, reason, listener);
+                        return currentState;
                     }
-                    rebalanceAssignments(currentState, modelToAdd, reason, listener);
-                    return currentState;
-                }
 
-                @Override
-                public void onFailure(Exception e) {
-                    listener.onFailure(e);
-                }
+                    @Override
+                    public void onFailure(Exception e) {
+                        listener.onFailure(e);
+                    }
 
-                @Override
-                public void clusterStateProcessed(ClusterState oldState, ClusterState newState) {
-                    if (isUpdated) {
-                        if (isChanged) {
-                            threadPool.executor(MachineLearning.UTILITY_THREAD_POOL_NAME)
-                                .execute(() -> systemAuditor.info(Messages.getMessage(Messages.INFERENCE_DEPLOYMENT_REBALANCED, reason)));
+                    @Override
+                    public void clusterStateProcessed(ClusterState oldState, ClusterState newState) {
+                        if (isUpdated) {
+                            if (isChanged) {
+                                threadPool.executor(MachineLearning.UTILITY_THREAD_POOL_NAME)
+                                    .execute(
+                                        () -> systemAuditor.info(Messages.getMessage(Messages.INFERENCE_DEPLOYMENT_REBALANCED, reason))
+                                    );
+                            }
+                            listener.onResponse(TrainedModelAssignmentMetadata.fromState(newState));
                         }
-                        listener.onResponse(TrainedModelAssignmentMetadata.fromState(newState));
                     }
-                }
+                });
             });
-        });
+        }, listener::onFailure);
+
+        MlPlatformArchitecturesUtil.getMlNodesArchitecturesSet(architecturesListener, client, threadPool);
+    }
+
+    ClusterState stopPlatformSpecificModelsInHeterogeneousClusters(
+        ClusterState updatedState,
+        Set<String> mlNodesArchitectures,
+        Optional<StartTrainedModelDeploymentAction.TaskParams> modelToAdd,
+        ClusterState clusterState
+    ) {
+        if (mlNodesArchitectures.size() > 1 && modelToAdd.isPresent()) {
+            String reasonToStop = format(
+                "ML nodes in this cluster have multiple platform architectures, "
+                    + "but can only have one for this model ([%s]); "
+                    + "detected architectures: %s",
+                modelToAdd.get().getModelId(),
+                mlNodesArchitectures
+            );
+            updatedState = callSetToStopping(reasonToStop, modelToAdd.get().getDeploymentId(), clusterState);
+        }
+        return updatedState;
+    }
+
+    ClusterState callSetToStopping(String reasonToStop, String deploymentId, ClusterState clusterState) {
+        return setToStopping(clusterState, deploymentId, reasonToStop);
     }
 
     private boolean areClusterStatesCompatibleForRebalance(ClusterState source, ClusterState target) {
diff --git a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/deployment/DeploymentManager.java b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/deployment/DeploymentManager.java
index 03f34dacb1faf..fcb44d0f391fe 100644
--- a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/deployment/DeploymentManager.java
+++ b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/deployment/DeploymentManager.java
@@ -164,9 +164,7 @@ public void startDeployment(TrainedModelDeploymentTask task, ActionListener<Trai
             finalListener.onResponse(task);
         }, failedDeploymentListener::onFailure);
 
-        ActionListener<GetTrainedModelsAction.Response> getModelListener = ActionListener.wrap(getModelResponse -> {
-            assert getModelResponse.getResources().results().size() == 1;
-            TrainedModelConfig modelConfig = getModelResponse.getResources().results().get(0);
+        ActionListener<TrainedModelConfig> getVerifiedModel = ActionListener.wrap((modelConfig) -> {
             processContext.modelInput.set(modelConfig.getInput());
 
             if (modelConfig.getInferenceConfig() instanceof NlpConfig nlpConfig) {
@@ -209,15 +207,57 @@ public void startDeployment(TrainedModelDeploymentTask task, ActionListener<Trai
             }
         }, failedDeploymentListener::onFailure);
 
+        ActionListener<GetTrainedModelsAction.Response> verifyModelAndClusterArchitecturesListener = ActionListener.wrap(
+            getModelResponse -> {
+                assert getModelResponse.getResources().results().size() == 1;
+                TrainedModelConfig modelConfig = getModelResponse.getResources().results().get(0);
+
+                verifyMlNodesAndModelArchitectures(modelConfig, client, threadPool, getVerifiedModel);
+
+            },
+            failedDeploymentListener::onFailure
+        );
+
         executeAsyncWithOrigin(
             client,
             ML_ORIGIN,
             GetTrainedModelsAction.INSTANCE,
             new GetTrainedModelsAction.Request(task.getParams().getModelId()),
-            getModelListener
+            verifyModelAndClusterArchitecturesListener
         );
     }
 
+    void verifyMlNodesAndModelArchitectures(
+        TrainedModelConfig configToReturn,
+        Client client,
+        ThreadPool threadPool,
+        ActionListener<TrainedModelConfig> configToReturnListener
+    ) {
+        ActionListener<TrainedModelConfig> verifyConfigListener = new ActionListener<TrainedModelConfig>() {
+            @Override
+            public void onResponse(TrainedModelConfig config) {
+                assert Objects.equals(config, configToReturn);
+                configToReturnListener.onResponse(configToReturn);
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                configToReturnListener.onFailure(e);
+            }
+        };
+
+        callVerifyMlNodesAndModelArchitectures(configToReturn, verifyConfigListener, client, threadPool);
+    }
+
+    void callVerifyMlNodesAndModelArchitectures(
+        TrainedModelConfig configToReturn,
+        ActionListener<TrainedModelConfig> configToReturnListener,
+        Client client,
+        ThreadPool threadPool
+    ) {
+        MlPlatformArchitecturesUtil.verifyMlNodesAndModelArchitectures(configToReturnListener, client, threadPool, configToReturn);
+    }
+
     private SearchRequest vocabSearchRequest(VocabularyConfig vocabularyConfig, String modelId) {
         return client.prepareSearch(vocabularyConfig.getIndex())
             .setQuery(new IdsQueryBuilder().addIds(VocabularyConfig.docId(modelId)))
@@ -394,11 +434,11 @@ class ProcessContext {
         private final PyTorchResultProcessor resultProcessor;
         private final PyTorchStateStreamer stateStreamer;
         private final PriorityProcessWorkerExecutorService priorityProcessWorker;
+        private final AtomicInteger rejectedExecutionCount = new AtomicInteger();
+        private final AtomicInteger timeoutCount = new AtomicInteger();
         private volatile Instant startTime;
         private volatile Integer numThreadsPerAllocation;
         private volatile Integer numAllocations;
-        private final AtomicInteger rejectedExecutionCount = new AtomicInteger();
-        private final AtomicInteger timeoutCount = new AtomicInteger();
         private volatile boolean isStopped;
 
         private static final TimeValue COMPLETION_TIMEOUT = TimeValue.timeValueMinutes(3);
diff --git a/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/deployment/MlPlatformArchitecturesUtil.java b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/deployment/MlPlatformArchitecturesUtil.java
new file mode 100644
index 0000000000000..ff8ac1dbb3eec
--- /dev/null
+++ b/x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/inference/deployment/MlPlatformArchitecturesUtil.java
@@ -0,0 +1,127 @@
+/*
+ * 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; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.ml.inference.deployment;
+
+import org.elasticsearch.action.ActionListener;
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoAction;
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest;
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequestBuilder;
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoResponse;
+import org.elasticsearch.client.internal.Client;
+import org.elasticsearch.cluster.node.DiscoveryNodeRole;
+import org.elasticsearch.monitor.os.OsInfo;
+import org.elasticsearch.plugins.Platforms;
+import org.elasticsearch.threadpool.ThreadPool;
+import org.elasticsearch.xpack.core.ml.inference.TrainedModelConfig;
+import org.elasticsearch.xpack.ml.MachineLearning;
+
+import java.util.Iterator;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.elasticsearch.core.Strings.format;
+import static org.elasticsearch.xpack.core.ClientHelper.ML_ORIGIN;
+import static org.elasticsearch.xpack.core.ClientHelper.executeAsyncWithOrigin;
+
+public class MlPlatformArchitecturesUtil {
+
+    public static void getMlNodesArchitecturesSet(ActionListener<Set<String>> architecturesListener, Client client, ThreadPool threadPool) {
+        ActionListener<NodesInfoResponse> listener = MlPlatformArchitecturesUtil.getArchitecturesSetFromNodesInfoResponseListener(
+            threadPool,
+            architecturesListener
+        );
+
+        NodesInfoRequest request = MlPlatformArchitecturesUtil.getNodesInfoBuilderWithMlNodeArchitectureInfo(client).request();
+        executeAsyncWithOrigin(client, ML_ORIGIN, NodesInfoAction.INSTANCE, request, listener);
+    }
+
+    static ActionListener<NodesInfoResponse> getArchitecturesSetFromNodesInfoResponseListener(
+        ThreadPool threadPool,
+        ActionListener<Set<String>> architecturesListener
+    ) {
+        return ActionListener.wrap(nodesInfoResponse -> {
+            threadPool.executor(MachineLearning.UTILITY_THREAD_POOL_NAME).execute(() -> {
+                architecturesListener.onResponse(getArchitecturesSetFromNodesInfoResponse(nodesInfoResponse));
+            });
+        }, architecturesListener::onFailure);
+    }
+
+    static NodesInfoRequestBuilder getNodesInfoBuilderWithMlNodeArchitectureInfo(Client client) {
+        return client.admin().cluster().prepareNodesInfo().clear().setNodesIds("ml:true").setOs(true).setPlugins(true);
+    }
+
+    private static Set<String> getArchitecturesSetFromNodesInfoResponse(NodesInfoResponse nodesInfoResponse) {
+        return nodesInfoResponse.getNodes()
+            .stream()
+            .filter(node -> node.getNode().hasRole(DiscoveryNodeRole.ML_ROLE.roleName()))
+            .map(node -> {
+                OsInfo osInfo = node.getInfo(OsInfo.class);
+                return Platforms.platformName(osInfo.getName(), osInfo.getArch());
+            })
+            .collect(Collectors.toUnmodifiableSet());
+    }
+
+    public static void verifyMlNodesAndModelArchitectures(
+        ActionListener<TrainedModelConfig> successOrFailureListener,
+        Client client,
+        ThreadPool threadPool,
+        TrainedModelConfig configToReturn
+    ) {
+        String modelID = configToReturn.getModelId();
+        String modelPlatformArchitecture = configToReturn.getPlatformArchitecture();
+
+        String modifiedPlatformArchitecture = (modelPlatformArchitecture == null && modelID.contains("linux-x86_64"))
+            ? "linux-x86_64"
+            : null;
+        ActionListener<Set<String>> architecturesListener = ActionListener.wrap((architectures) -> {
+            verifyMlNodesAndModelArchitectures(architectures, modifiedPlatformArchitecture, modelID);
+            successOrFailureListener.onResponse(configToReturn);
+        }, successOrFailureListener::onFailure);
+
+        getMlNodesArchitecturesSet(architecturesListener, client, threadPool);
+    }
+
+    static void verifyMlNodesAndModelArchitectures(Set<String> architectures, String modelPlatformArchitecture, String modelID)
+        throws IllegalArgumentException, IllegalStateException {
+
+        String architecture = null;
+        Iterator<String> architecturesIterator = architectures.iterator();
+        // If there are no ML nodes at all in the current cluster we assume that any that are added later will work
+        if (modelPlatformArchitecture == null || architectures.isEmpty() || architecturesIterator.hasNext() == false) {
+            return;
+        }
+
+        if (architectures.size() > 1) {
+            throw new IllegalStateException(
+                format(
+                    "ML nodes in this cluster have multiple platform architectures, but can only have one for this model ([%s]); "
+                        + "expected [%s]; "
+                        + "but was %s",
+                    modelID,
+                    modelPlatformArchitecture,
+                    architectures
+                )
+            );
+        }
+
+        if (Objects.equals(architecturesIterator.next(), modelPlatformArchitecture) == false) {
+
+            throw new IllegalArgumentException(
+                format(
+                    "The model being deployed ([%s]) is platform specific and incompatible with ML nodes in the cluster; "
+                        + "expected [%s]; "
+                        + "but was %s",
+                    modelID,
+                    modelPlatformArchitecture,
+                    architectures
+                )
+            );
+        }
+    }
+}
diff --git a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/action/TransportPutTrainedModelActionTests.java b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/action/TransportPutTrainedModelActionTests.java
index 514a1e2243531..f708ef1fb2959 100644
--- a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/action/TransportPutTrainedModelActionTests.java
+++ b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/action/TransportPutTrainedModelActionTests.java
@@ -11,9 +11,12 @@
 import org.elasticsearch.action.ActionListener;
 import org.elasticsearch.action.admin.cluster.node.tasks.list.ListTasksAction;
 import org.elasticsearch.action.admin.cluster.node.tasks.list.ListTasksResponse;
+import org.elasticsearch.action.support.ActionFilters;
 import org.elasticsearch.action.support.PlainActionFuture;
 import org.elasticsearch.client.internal.Client;
+import org.elasticsearch.cluster.service.ClusterService;
 import org.elasticsearch.common.bytes.BytesReference;
+import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.xcontent.LoggingDeprecationHandler;
 import org.elasticsearch.common.xcontent.XContentHelper;
 import org.elasticsearch.core.TimeValue;
@@ -21,6 +24,7 @@
 import org.elasticsearch.test.ESTestCase;
 import org.elasticsearch.threadpool.TestThreadPool;
 import org.elasticsearch.threadpool.ThreadPool;
+import org.elasticsearch.transport.TransportService;
 import org.elasticsearch.xcontent.NamedXContentRegistry;
 import org.elasticsearch.xcontent.ToXContent;
 import org.elasticsearch.xcontent.XContentBuilder;
@@ -50,6 +54,7 @@
 import org.elasticsearch.xpack.core.ml.inference.trainedmodel.TextSimilarityConfigTests;
 import org.junit.After;
 import org.junit.Before;
+import org.mockito.ArgumentCaptor;
 
 import java.io.IOException;
 import java.util.Collections;
@@ -65,6 +70,11 @@
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
 
 public class TransportPutTrainedModelActionTests extends ESTestCase {
     private static final TimeValue TIMEOUT = new TimeValue(30, TimeUnit.SECONDS);
@@ -205,6 +215,42 @@ public void testCheckForExistingTaskReturnsTask() {
         assertThat(returnedModel.getResponse().getModelId(), is(trainedModel.getModelId()));
     }
 
+    public void testVerifyMlNodesAndModelArchitectures_GivenIllegalArgumentException_ThenSetHeaderWarning() {
+
+        TransportPutTrainedModelAction actionSpy = spy(createTransportPutTrainedModelAction());
+        @SuppressWarnings("unchecked")
+        ArgumentCaptor<ActionListener<TrainedModelConfig>> failureListener = ArgumentCaptor.forClass(ActionListener.class);
+        @SuppressWarnings("unchecked")
+        ActionListener<TrainedModelConfig> mockConfigToReturnListener = mock(ActionListener.class);
+        TrainedModelConfig mockConfigToReturn = mock(TrainedModelConfig.class);
+        doNothing().when(mockConfigToReturnListener).onResponse(any());
+
+        doNothing().when(actionSpy).callVerifyMlNodesAndModelArchitectures(any(), any(), any(), any());
+        actionSpy.verifyMlNodesAndModelArchitectures(mockConfigToReturn, null, threadPool, mockConfigToReturnListener);
+        verify(actionSpy).verifyMlNodesAndModelArchitectures(any(), any(), any(), any());
+        verify(actionSpy).callVerifyMlNodesAndModelArchitectures(any(), failureListener.capture(), any(), any());
+
+        String warningMessage = "TEST HEADER WARNING";
+        failureListener.getValue().onFailure(new IllegalArgumentException(warningMessage));
+        assertWarnings(warningMessage);
+    }
+
+    public void testVerifyMlNodesAndModelArchitectures_GivenArchitecturesMatch_ThenTriggerOnResponse() {
+
+        TransportPutTrainedModelAction actionSpy = spy(createTransportPutTrainedModelAction());
+        @SuppressWarnings("unchecked")
+        ArgumentCaptor<ActionListener<TrainedModelConfig>> successListener = ArgumentCaptor.forClass(ActionListener.class);
+        @SuppressWarnings("unchecked")
+        ActionListener<TrainedModelConfig> mockConfigToReturnListener = mock(ActionListener.class);
+        TrainedModelConfig mockConfigToReturn = mock(TrainedModelConfig.class);
+
+        doNothing().when(actionSpy).callVerifyMlNodesAndModelArchitectures(any(), any(), any(), any());
+        actionSpy.verifyMlNodesAndModelArchitectures(mockConfigToReturn, null, threadPool, mockConfigToReturnListener);
+        verify(actionSpy).callVerifyMlNodesAndModelArchitectures(any(), successListener.capture(), any(), any());
+
+        ensureNoWarnings();
+    }
+
     private static void prepareGetTrainedModelResponse(Client client, List<TrainedModelConfig> trainedModels) {
         doAnswer(invocationOnMock -> {
             @SuppressWarnings("unchecked")
@@ -220,6 +266,30 @@ private static void prepareGetTrainedModelResponse(Client client, List<TrainedMo
         }).when(client).execute(same(GetTrainedModelsAction.INSTANCE), any(), any());
     }
 
+    private TransportPutTrainedModelAction createTransportPutTrainedModelAction() {
+        TransportService mockTransportService = mock(TransportService.class);
+        doReturn(threadPool).when(mockTransportService).getThreadPool();
+        ClusterService mockClusterService = mock(ClusterService.class);
+        ActionFilters mockFilters = mock(ActionFilters.class);
+        doReturn(null).when(mockFilters).filters();
+        Client mockClient = mock(Client.class);
+        doReturn(null).when(mockClient).settings();
+        doReturn(threadPool).when(mockClient).threadPool();
+
+        return new TransportPutTrainedModelAction(
+            Settings.EMPTY,
+            mockTransportService,
+            mockClusterService,
+            threadPool,
+            null,
+            mockFilters,
+            null,
+            mockClient,
+            null,
+            null
+        );
+    }
+
     @Override
     protected NamedXContentRegistry xContentRegistry() {
         return new NamedXContentRegistry(new MlInferenceNamedXContentProvider().getNamedXContentParsers());
diff --git a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/assignment/TrainedModelAssignmentClusterServiceTests.java b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/assignment/TrainedModelAssignmentClusterServiceTests.java
index d37edcd85946a..9e9266c8302e8 100644
--- a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/assignment/TrainedModelAssignmentClusterServiceTests.java
+++ b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/assignment/TrainedModelAssignmentClusterServiceTests.java
@@ -7,12 +7,18 @@
 
 package org.elasticsearch.xpack.ml.inference.assignment;
 
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.message.Message;
 import org.elasticsearch.ElasticsearchStatusException;
 import org.elasticsearch.ResourceAlreadyExistsException;
 import org.elasticsearch.ResourceNotFoundException;
 import org.elasticsearch.Version;
 import org.elasticsearch.action.ActionListener;
 import org.elasticsearch.action.LatchedActionListener;
+import org.elasticsearch.client.internal.Client;
 import org.elasticsearch.cluster.ClusterChangedEvent;
 import org.elasticsearch.cluster.ClusterName;
 import org.elasticsearch.cluster.ClusterState;
@@ -27,10 +33,13 @@
 import org.elasticsearch.cluster.routing.allocation.decider.AwarenessAllocationDecider;
 import org.elasticsearch.cluster.service.ClusterService;
 import org.elasticsearch.cluster.version.CompatibilityVersionsUtils;
+import org.elasticsearch.common.logging.Loggers;
 import org.elasticsearch.common.settings.ClusterSettings;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.util.set.Sets;
+import org.elasticsearch.core.CheckedConsumer;
+import org.elasticsearch.core.Strings;
 import org.elasticsearch.persistent.PersistentTasksCustomMetadata;
 import org.elasticsearch.rest.RestStatus;
 import org.elasticsearch.test.ESTestCase;
@@ -55,17 +64,24 @@
 import org.elasticsearch.xpack.ml.job.task.OpenJobPersistentTasksExecutorTests;
 import org.elasticsearch.xpack.ml.notifications.SystemAuditor;
 import org.elasticsearch.xpack.ml.process.MlMemoryTracker;
+import org.elasticsearch.xpack.ml.test.MockAppender;
+import org.junit.After;
 import org.junit.Before;
+import org.mockito.Mockito;
 
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
 import java.util.function.Function;
 
 import static java.util.Map.entry;
+import static org.elasticsearch.core.Strings.format;
 import static org.hamcrest.Matchers.aMapWithSize;
 import static org.hamcrest.Matchers.anEmptyMap;
 import static org.hamcrest.Matchers.containsString;
@@ -77,7 +93,13 @@
 import static org.hamcrest.Matchers.not;
 import static org.hamcrest.Matchers.notNullValue;
 import static org.hamcrest.Matchers.nullValue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 public class TrainedModelAssignmentClusterServiceTests extends ESTestCase {
@@ -87,9 +109,12 @@ public class TrainedModelAssignmentClusterServiceTests extends ESTestCase {
     private NodeLoadDetector nodeLoadDetector;
     private SystemAuditor systemAuditor;
     private NodeAvailabilityZoneMapper nodeAvailabilityZoneMapper;
+    private Client client;
+    private static MockAppender appender;
+    private static Logger testLogger1 = LogManager.getLogger(TrainedModelAssignmentClusterService.class);
 
     @Before
-    public void setupObjects() {
+    public void setupObjects() throws IllegalAccessException {
         clusterService = mock(ClusterService.class);
         ClusterSettings clusterSettings = new ClusterSettings(
             Settings.EMPTY,
@@ -111,6 +136,122 @@ public void setupObjects() {
         nodeLoadDetector = new NodeLoadDetector(memoryTracker);
 
         systemAuditor = mock(SystemAuditor.class);
+        client = mock(Client.class);
+
+        appender = new MockAppender("trace_appender");
+        appender.start();
+        Loggers.addAppender(testLogger1, appender);
+    }
+
+    @After
+    public void cleanup() {
+        appender.stop();
+        Loggers.removeAppender(testLogger1, appender);
+    }
+
+    public void testLogMlNodeHeterogeneity_GivenZeroOrOneArchitectures_ThenNothing() throws InterruptedException {
+        Set<String> architecturesSet = new HashSet<>(randomList(0, 1, () -> randomAlphaOfLength(10)));
+
+        final ActionListener<Set<String>> underTestListener = TrainedModelAssignmentClusterService.getArchitecturesSetActionListener();
+
+        underTestListener.onResponse(architecturesSet);
+
+        LogEvent lastEvent = appender.getLastEventAndReset();
+        assertNull(lastEvent);
+    }
+
+    public void testLogMlNodeHeterogeneity_GivenTwoArchitecture_ThenWarn() throws InterruptedException {
+        String nodeArch = randomAlphaOfLength(10);
+        Set<String> architecturesSet = Set.of(nodeArch, nodeArch + "2"); // architectures must be different
+
+        final ActionListener<Set<String>> underTestListener = TrainedModelAssignmentClusterService.getArchitecturesSetActionListener();
+        underTestListener.onResponse(architecturesSet);
+
+        LogEvent lastEvent = appender.getLastEventAndReset();
+
+        assertEquals(Level.WARN, lastEvent.getLevel());
+
+        Message m = lastEvent.getMessage();
+        String fm = m.getFormattedMessage();
+        String expected = Strings.format(
+            "Heterogeneous platform architectures were detected among ML nodes. "
+                + "This will prevent the deployment of some trained models. Distinct platform architectures detected: %s",
+            architecturesSet
+        );
+
+        assertEquals(expected, fm);
+    }
+
+    public void testLogMlNodeHeterogeneity_GivenFailure_ThenError() throws InterruptedException {
+        RuntimeException e = new RuntimeException("Test Runtime Exception");
+        final ActionListener<Set<String>> underTestListener = TrainedModelAssignmentClusterService.getArchitecturesSetActionListener();
+        underTestListener.onFailure(e);
+
+        LogEvent lastEvent = appender.getLastEventAndReset();
+
+        assertEquals(Level.ERROR, lastEvent.getLevel());
+
+        Message m = lastEvent.getMessage();
+        String fm = m.getFormattedMessage();
+
+        assertEquals("Failed to detect heterogeneity among ML nodes with exception: ", fm);
+        assertEquals(e, lastEvent.getThrown());
+    }
+
+    public void testClusterChanged_GivenNodesAdded_ThenLogMlNodeHeterogeneityCalled() {
+        nodeAvailabilityZoneMapper = mock(NodeAvailabilityZoneMapper.class);
+        TrainedModelAssignmentClusterService serviceSpy = spy(createClusterService(randomInt(5)));
+        doNothing().when(serviceSpy).logMlNodeHeterogeneity();
+        doReturn(false).when(serviceSpy).eventStateHasGlobalBlockStateNotRecoveredBlock(any());
+        doReturn(false).when(serviceSpy).eventStateMinTransportVersionIsBeforeDistributedModelAllocationTransportVersion(any());
+
+        ClusterChangedEvent mockNodesAddedEvent = mock(ClusterChangedEvent.class);
+        ClusterState mockState = mock(ClusterState.class);
+        doReturn(mockState).when(mockNodesAddedEvent).state();
+        Metadata mockMetadata = mock(Metadata.class);
+        doReturn(mockMetadata).when(mockState).getMetadata();
+        doReturn(null).when(mockState).custom(anyString());
+
+        doReturn(true).when(mockNodesAddedEvent).localNodeMaster();
+        doReturn(true).when(mockNodesAddedEvent).nodesAdded();
+
+        serviceSpy.clusterChanged(mockNodesAddedEvent);
+        Mockito.verify(serviceSpy).logMlNodeHeterogeneity();
+        Mockito.verify(mockNodesAddedEvent).nodesAdded();
+    }
+
+    public void testStopPlatformSpecificModelsInHeterogeneousClusters_GivenMultipleMlNodeArchitectures_ThenCallSetToStopping() {
+        nodeAvailabilityZoneMapper = mock(NodeAvailabilityZoneMapper.class);
+        TrainedModelAssignmentClusterService serviceSpy = spy(createClusterService(randomInt(5)));
+
+        Set<String> architecturesSet = new HashSet<>(randomList(2, 5, () -> randomAlphaOfLength(10)));
+        ClusterState mockUpdatedState = mock(ClusterState.class);
+        ClusterState mockClusterState = mock(ClusterState.class);
+        StartTrainedModelDeploymentAction.TaskParams mockModelToAdd = mock(StartTrainedModelDeploymentAction.TaskParams.class);
+        Optional<StartTrainedModelDeploymentAction.TaskParams> optionalModelToAdd = Optional.of(mockModelToAdd);
+        String modelId = randomAlphaOfLength(10);
+        String deploymentId = randomAlphaOfLength(10);
+        when(mockModelToAdd.getModelId()).thenReturn(modelId);
+        when(mockModelToAdd.getDeploymentId()).thenReturn(deploymentId);
+
+        String reasonToStop = format(
+            "ML nodes in this cluster have multiple platform architectures, "
+                + "but can only have one for this model ([%s]); "
+                + "detected architectures: %s",
+            modelId,
+            architecturesSet
+        );
+
+        doReturn(mockUpdatedState).when(serviceSpy).callSetToStopping(reasonToStop, deploymentId, mockClusterState);
+
+        ClusterState updatedMockClusterState = serviceSpy.stopPlatformSpecificModelsInHeterogeneousClusters(
+            mockUpdatedState,
+            architecturesSet,
+            optionalModelToAdd,
+            mockClusterState
+        );
+
+        verify(serviceSpy).callSetToStopping(reasonToStop, deploymentId, mockClusterState);
     }
 
     public void testUpdateModelRoutingTable() {
@@ -1878,7 +2019,8 @@ private TrainedModelAssignmentClusterService createClusterService(int maxLazyNod
             threadPool,
             nodeLoadDetector,
             systemAuditor,
-            nodeAvailabilityZoneMapper
+            nodeAvailabilityZoneMapper,
+            client
         );
     }
 
@@ -1948,4 +2090,36 @@ private static StartTrainedModelDeploymentAction.TaskParams newParams(
         );
     }
 
+    protected <T> void assertAsync(
+        Consumer<ActionListener<T>> function,
+        T expected,
+        CheckedConsumer<T, ? extends Exception> onAnswer,
+        Consumer<Exception> onException
+    ) throws InterruptedException {
+
+        CountDownLatch latch = new CountDownLatch(1);
+
+        LatchedActionListener<T> listener = new LatchedActionListener<>(ActionListener.wrap(r -> {
+            if (expected == null) {
+                fail("expected an exception but got a response");
+            } else {
+                assertThat(r, equalTo(expected));
+            }
+            if (onAnswer != null) {
+                onAnswer.accept(r);
+            }
+        }, e -> {
+            if (onException == null) {
+                logger.error("got unexpected exception", e);
+                fail("got unexpected exception: " + e.getMessage());
+            } else {
+                onException.accept(e);
+            }
+        }), latch);
+
+        function.accept(listener);
+        latch.countDown();
+        assertTrue("timed out after 20s", latch.await(20, TimeUnit.SECONDS));
+    }
+
 }
diff --git a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/deployment/DeploymentManagerTests.java b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/deployment/DeploymentManagerTests.java
index 0bc898f434030..028c4b48ad355 100644
--- a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/deployment/DeploymentManagerTests.java
+++ b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/deployment/DeploymentManagerTests.java
@@ -108,4 +108,5 @@ public void testRejectedExecution() {
 
         assertThat(rejectedCount.intValue(), equalTo(1));
     }
+
 }
diff --git a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/deployment/MlPlatformArchitecturesUtilTests.java b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/deployment/MlPlatformArchitecturesUtilTests.java
new file mode 100644
index 0000000000000..28fc3db10cbe8
--- /dev/null
+++ b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/inference/deployment/MlPlatformArchitecturesUtilTests.java
@@ -0,0 +1,202 @@
+/*
+ * 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; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.ml.inference.deployment;
+
+import org.elasticsearch.action.ActionListener;
+import org.elasticsearch.action.LatchedActionListener;
+import org.elasticsearch.action.admin.cluster.node.info.NodeInfo;
+import org.elasticsearch.action.admin.cluster.node.info.NodesInfoResponse;
+import org.elasticsearch.cluster.node.DiscoveryNode;
+import org.elasticsearch.cluster.node.DiscoveryNodeRole;
+import org.elasticsearch.core.CheckedConsumer;
+import org.elasticsearch.monitor.os.OsInfo;
+import org.elasticsearch.plugins.Platforms;
+import org.elasticsearch.test.ESTestCase;
+import org.elasticsearch.threadpool.ThreadPool;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class MlPlatformArchitecturesUtilTests extends ESTestCase {
+
+    public void testGetNodesOsArchitectures() throws InterruptedException {
+        var threadPool = mock(ThreadPool.class);
+        var mockExectutorServervice = mock(ExecutorService.class);
+        doNothing().when(mockExectutorServervice).execute(any());
+        when(threadPool.executor(anyString())).thenReturn(mockExectutorServervice);
+
+        var mockNodesInfoResponse = mock(NodesInfoResponse.class);
+        List<NodeInfo> nodeInfoList = randomNodeInfos(4);
+        when(mockNodesInfoResponse.getNodes()).thenReturn(nodeInfoList);
+
+        var expected = nodeInfoList.stream().filter(node -> node.getNode().hasRole(DiscoveryNodeRole.ML_ROLE.roleName())).map(node -> {
+            OsInfo osInfo = node.getInfo(OsInfo.class);
+            return Platforms.platformName(osInfo.getName(), osInfo.getArch());
+        }).collect(Collectors.toUnmodifiableSet());
+
+        assertAsync(new Consumer<ActionListener<Set<String>>>() {
+            @Override
+            public void accept(ActionListener<Set<String>> setActionListener) {
+                final ActionListener<NodesInfoResponse> nodesInfoResponseActionListener = MlPlatformArchitecturesUtil
+                    .getArchitecturesSetFromNodesInfoResponseListener(threadPool, setActionListener);
+                nodesInfoResponseActionListener.onResponse(mockNodesInfoResponse);
+            }
+
+        }, expected, null, null);
+    }
+
+    public void testVerifyMlNodesAndModelArchitectures_GivenNullModelArchitecture_ThenNothing() {
+        var architectures = nArchitectures(randomIntBetween(2, 10));
+        MlPlatformArchitecturesUtil.verifyMlNodesAndModelArchitectures(architectures, null, randomAlphaOfLength(10));
+    }
+
+    public void testVerifyMlNodesAndModelArchitectures_GivenZeroArches_ThenNothing() {
+        var architectures = new HashSet<String>();
+        MlPlatformArchitecturesUtil.verifyMlNodesAndModelArchitectures(architectures, randomAlphaOfLength(10), randomAlphaOfLength(10));
+    }
+
+    public void testVerifyMlNodesAndModelArchitectures_GivenOneArchMatches_ThenNothing() {
+        Set<String> architectures = nArchitectures(1);
+        String architecture = architectures.iterator().next();
+        MlPlatformArchitecturesUtil.verifyMlNodesAndModelArchitectures(architectures, architecture, randomAlphaOfLength(10));
+    }
+
+    public void testVerifyMlNodesAndModelArchitectures_GivenAtLeastTwoArches_ThenThrowsISE() {
+        var architectures = nArchitectures(randomIntBetween(2, 10));
+        var modelId = randomAlphaOfLength(10);
+        var requiredArch = randomAlphaOfLength(10);
+        String message = "ML nodes in this cluster have multiple platform architectures, "
+            + "but can only have one for this model (["
+            + modelId
+            + "]); "
+            + "expected ["
+            + requiredArch
+            + "]; but was "
+            + architectures
+            + "";
+
+        Throwable exception = expectThrows(
+            IllegalStateException.class,
+            "Expected IllegalStateException but no exception was thrown",
+            () -> MlPlatformArchitecturesUtil.verifyMlNodesAndModelArchitectures(architectures, requiredArch, modelId)
+        );
+        assertEquals(exception.getMessage(), message);
+    }
+
+    public void testVerifyArchitectureMatchesModelPlatformArchitecture_GivenRequiredArchMatches_ThenNothing() {
+        var requiredArch = randomAlphaOfLength(10);
+
+        var modelId = randomAlphaOfLength(10);
+
+        MlPlatformArchitecturesUtil.verifyMlNodesAndModelArchitectures(
+            new HashSet<>(Collections.singleton(requiredArch)),
+            requiredArch,
+            modelId
+        );
+    }
+
+    public void testVerifyArchitectureMatchesModelPlatformArchitecture_GivenRequiredArchDoesNotMatch_ThenThrowsIAE() {
+        var requiredArch = randomAlphaOfLength(10);
+        String architecturesStr = requiredArch + "-DIFFERENT";
+
+        var modelId = randomAlphaOfLength(10);
+        String message = "The model being deployed (["
+            + modelId
+            + "]) is platform specific and incompatible with ML nodes in the cluster; "
+            + "expected ["
+            + requiredArch
+            + "]; but was ["
+            + architecturesStr
+            + "]";
+
+        Throwable exception = expectThrows(
+            IllegalArgumentException.class,
+            "Expected IllegalArgumentException but no exception was thrown",
+            () -> MlPlatformArchitecturesUtil.verifyMlNodesAndModelArchitectures(Set.of(architecturesStr), requiredArch, modelId)
+        );
+        assertEquals(exception.getMessage(), message);
+    }
+
+    private Set<String> nArchitectures(Integer n) {
+        Set<String> architectures = new HashSet<String>(n);
+        for (int i = 0; i < n; i++) {
+            architectures.add(randomAlphaOfLength(10));
+        }
+        return architectures;
+    }
+
+    private List<NodeInfo> randomNodeInfos(int max) {
+        assertTrue(max > 0);
+        int n = randomInt(max);
+        List<NodeInfo> nodeInfos = new ArrayList<>(n);
+        for (int i = 0; i < n; i++) {
+            nodeInfos.add(mockNodeInfo());
+        }
+        return nodeInfos;
+    }
+
+    private NodeInfo mockNodeInfo() {
+        var mockNodeInfo = mock(NodeInfo.class);
+        var mockDiscoveryNode = mock(DiscoveryNode.class);
+        when(mockNodeInfo.getNode()).thenReturn(mockDiscoveryNode);
+        when(mockDiscoveryNode.hasRole(DiscoveryNodeRole.ML_ROLE.roleName())).thenReturn(randomBoolean());
+        var mockOsInfo = mock(OsInfo.class);
+        when(mockNodeInfo.getInfo(OsInfo.class)).thenReturn(mockOsInfo);
+        when(mockOsInfo.getArch()).thenReturn(randomAlphaOfLength(10));
+        when(mockOsInfo.getName()).thenReturn(randomAlphaOfLength(10));
+
+        return mockNodeInfo;
+    }
+
+    protected <T> void assertAsync(
+        Consumer<ActionListener<T>> function,
+        T expected,
+        CheckedConsumer<T, ? extends Exception> onAnswer,
+        Consumer<Exception> onException
+    ) throws InterruptedException {
+
+        CountDownLatch latch = new CountDownLatch(1);
+
+        LatchedActionListener<T> listener = new LatchedActionListener<>(ActionListener.wrap(r -> {
+            if (expected == null) {
+                fail("expected an exception but got a response");
+            } else {
+                assertThat(r, equalTo(expected));
+            }
+            if (onAnswer != null) {
+                onAnswer.accept(r);
+            }
+        }, e -> {
+            if (onException == null) {
+                logger.error("got unexpected exception", e);
+                fail("got unexpected exception: " + e.getMessage());
+            } else {
+                onException.accept(e);
+            }
+        }), latch);
+
+        function.accept(listener);
+        latch.countDown();
+        assertTrue("timed out after 20s", latch.await(20, TimeUnit.SECONDS));
+    }
+}
diff --git a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/test/MockAppender.java b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/test/MockAppender.java
new file mode 100644
index 0000000000000..99c3c58f4ee81
--- /dev/null
+++ b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/test/MockAppender.java
@@ -0,0 +1,36 @@
+/*
+ * 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; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.ml.test;
+
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.filter.RegexFilter;
+import org.apache.logging.log4j.message.Message;
+
+public class MockAppender extends AbstractAppender {
+    public LogEvent lastEvent;
+
+    public MockAppender(final String name) throws IllegalAccessException {
+        super(name, RegexFilter.createFilter(".*(\n.*)*", new String[0], false, null, null), null, false);
+    }
+
+    @Override
+    public void append(LogEvent event) {
+        lastEvent = event.toImmutable();
+    }
+
+    Message lastMessage() {
+        return lastEvent.getMessage();
+    }
+
+    public LogEvent getLastEventAndReset() {
+        LogEvent toReturn = lastEvent;
+        lastEvent = null;
+        return toReturn;
+    }
+}
diff --git a/x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/ml/inference_crud.yml b/x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/ml/inference_crud.yml
index 417c52e391b7d..b38c6857108cc 100644
--- a/x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/ml/inference_crud.yml
+++ b/x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/ml/inference_crud.yml
@@ -1214,3 +1214,30 @@ setup:
       ml.get_trained_models:
         model_id: a-regression-model-0
         include: definition_status
+
+---
+"Test include model platform architecture":
+  - do:
+      ml.put_trained_model:
+        model_id: model-without-definition
+        body: >
+          {
+            "model_type": "pytorch",
+            "inference_config": {
+              "ner": {
+              }
+            },
+          "platform_architecture": "windows-x86_64"
+          }
+
+  - do:
+      ml.get_trained_models:
+        model_id: model-without-definition
+        include: definition_status
+  - match: { count: 1 }
+  - match: { trained_model_configs.0.fully_defined: false }
+  - do:
+      ml.get_trained_models:
+        model_id: model-without-definition
+  - match: { count: 1 }
+  - match: { trained_model_configs.0.platform_architecture: windows-x86_64 }

From 0ac04ccdd027553a434f2ed3897b5663b35c5d04 Mon Sep 17 00:00:00 2001
From: Nik Everett <nik9000@gmail.com>
Date: Thu, 28 Sep 2023 14:19:50 -0400
Subject: [PATCH 19/32] ESQL: Don't build Pages out of closed Blocks (#99980)

This makes sure none of the `Block`s passed to the ctor of `Page` are
closed. We never expect to do that. And you can't read the `Block` from
the `Page` anyway.
---
 .../java/org/elasticsearch/compute/data/Page.java    |  8 ++++----
 .../elasticsearch/compute/data/BasicBlockTests.java  | 12 +++++++++---
 .../compute/data/BlockFactoryTests.java              |  7 +++++--
 .../elasticsearch/compute/data/DocVectorTests.java   | 12 ++++++++----
 4 files changed, 26 insertions(+), 13 deletions(-)

diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Page.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Page.java
index 873565592dfaf..a4c89422213b1 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Page.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Page.java
@@ -10,7 +10,6 @@
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.common.io.stream.Writeable;
-import org.elasticsearch.core.Assertions;
 import org.elasticsearch.core.Releasables;
 
 import java.io.IOException;
@@ -69,9 +68,10 @@ private Page(boolean copyBlocks, int positionCount, Block[] blocks) {
         // assert assertPositionCount(blocks);
         this.positionCount = positionCount;
         this.blocks = copyBlocks ? blocks.clone() : blocks;
-        if (Assertions.ENABLED) {
-            for (Block b : blocks) {
-                assert b.getPositionCount() == positionCount : "expected positionCount=" + positionCount + " but was " + b;
+        for (Block b : blocks) {
+            assert b.getPositionCount() == positionCount : "expected positionCount=" + positionCount + " but was " + b;
+            if (b.isReleased()) {
+                throw new IllegalArgumentException("can't build page out of released blocks but [" + b + "] was released");
             }
         }
     }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BasicBlockTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BasicBlockTests.java
index cf7fbbea1c775..f99ded96a9984 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BasicBlockTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BasicBlockTests.java
@@ -906,10 +906,12 @@ void assertZeroPositionsAndRelease(Vector vector) {
 
     void releaseAndAssertBreaker(Block... blocks) {
         assertThat(breaker.getUsed(), greaterThan(0L));
+        Page[] pages = Arrays.stream(blocks).map(Page::new).toArray(Page[]::new);
         Releasables.closeExpectNoException(blocks);
         Arrays.stream(blocks).forEach(block -> assertThat(block.isReleased(), is(true)));
         Arrays.stream(blocks).forEach(BasicBlockTests::assertCannotDoubleRelease);
-        Arrays.stream(blocks).forEach(BasicBlockTests::assertCannotReadFromPage);
+        Arrays.stream(pages).forEach(BasicBlockTests::assertCannotReadFromPage);
+        Arrays.stream(blocks).forEach(BasicBlockTests::assertCannotAddToPage);
         assertThat(breaker.getUsed(), is(0L));
     }
 
@@ -924,12 +926,16 @@ static void assertCannotDoubleRelease(Block block) {
         assertThat(ex.getMessage(), containsString("can't release already released block"));
     }
 
-    static void assertCannotReadFromPage(Block block) {
-        Page page = new Page(block);
+    static void assertCannotReadFromPage(Page page) {
         var e = expectThrows(IllegalStateException.class, () -> page.getBlock(0));
         assertThat(e.getMessage(), containsString("can't read released block"));
     }
 
+    static void assertCannotAddToPage(Block block) {
+        var e = expectThrows(IllegalArgumentException.class, () -> new Page(block));
+        assertThat(e.getMessage(), containsString("can't build page out of released blocks but"));
+    }
+
     static int randomPosition(int positionCount) {
         return positionCount == 1 ? 0 : randomIntBetween(0, positionCount - 1);
     }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockFactoryTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockFactoryTests.java
index 24d4e27e92ad1..7be79e73b5d9d 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockFactoryTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BlockFactoryTests.java
@@ -573,13 +573,16 @@ static Block.MvOrdering randomOrdering() {
     }
 
     <T extends Releasable & Accountable> void releaseAndAssertBreaker(T data) {
+        Page page = data instanceof Block block ? new Page(block) : null;
         assertThat(breaker.getUsed(), greaterThan(0L));
         Releasables.closeExpectNoException(data);
         if (data instanceof Block block) {
             assertThat(block.isReleased(), is(true));
-            Page page = new Page(block);
-            var e = expectThrows(IllegalStateException.class, () -> page.getBlock(0));
+            Exception e = expectThrows(IllegalStateException.class, () -> page.getBlock(0));
             assertThat(e.getMessage(), containsString("can't read released block"));
+
+            e = expectThrows(IllegalArgumentException.class, () -> new Page(block));
+            assertThat(e.getMessage(), containsString("can't build page out of released blocks"));
         }
         assertThat(breaker.getUsed(), is(0L));
     }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/DocVectorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/DocVectorTests.java
index 0f76e024c7436..465dc95a15ea4 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/DocVectorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/DocVectorTests.java
@@ -136,14 +136,18 @@ public void testCannotDoubleRelease() {
         var block = new DocVector(IntVector.range(0, 2), IntBlock.newConstantBlockWith(0, 2).asVector(), IntVector.range(0, 2), null)
             .asBlock();
         assertThat(block.isReleased(), is(false));
+        Page page = new Page(block);
+
         Releasables.closeExpectNoException(block);
         assertThat(block.isReleased(), is(true));
 
-        var ex = expectThrows(IllegalStateException.class, () -> block.close());
-        assertThat(ex.getMessage(), containsString("can't release already released block"));
+        Exception e = expectThrows(IllegalStateException.class, () -> block.close());
+        assertThat(e.getMessage(), containsString("can't release already released block"));
 
-        Page page = new Page(block);
-        var e = expectThrows(IllegalStateException.class, () -> page.getBlock(0));
+        e = expectThrows(IllegalStateException.class, () -> page.getBlock(0));
         assertThat(e.getMessage(), containsString("can't read released block"));
+
+        e = expectThrows(IllegalArgumentException.class, () -> new Page(block));
+        assertThat(e.getMessage(), containsString("can't build page out of released blocks"));
     }
 }

From c879e54592f388dc19b3de076c318e3b7649ef09 Mon Sep 17 00:00:00 2001
From: Carlos Delgado <6339205+carlosdelest@users.noreply.github.com>
Date: Thu, 28 Sep 2023 20:43:06 +0200
Subject: [PATCH 20/32] Allow text_expansion query to use sparse_vector field
 type (#99910)

---
 .../ml/integration/TextExpansionQueryIT.java  |  56 ++++++---
 .../text_expansion_search_rank_features.yml   | 111 ++++++++++++++++++
 .../text_expansion_search_sparse_vector.yml   | 111 ++++++++++++++++++
 3 files changed, 262 insertions(+), 16 deletions(-)
 create mode 100644 x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/ml/text_expansion_search_rank_features.yml
 create mode 100644 x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/ml/text_expansion_search_sparse_vector.yml

diff --git a/x-pack/plugin/ml/qa/native-multi-node-tests/src/javaRestTest/java/org/elasticsearch/xpack/ml/integration/TextExpansionQueryIT.java b/x-pack/plugin/ml/qa/native-multi-node-tests/src/javaRestTest/java/org/elasticsearch/xpack/ml/integration/TextExpansionQueryIT.java
index 7ae7d4b0497e0..dbf489e8abf23 100644
--- a/x-pack/plugin/ml/qa/native-multi-node-tests/src/javaRestTest/java/org/elasticsearch/xpack/ml/integration/TextExpansionQueryIT.java
+++ b/x-pack/plugin/ml/qa/native-multi-node-tests/src/javaRestTest/java/org/elasticsearch/xpack/ml/integration/TextExpansionQueryIT.java
@@ -103,8 +103,16 @@ public class TextExpansionQueryIT extends PyTorchModelRestTestCase {
         RAW_MODEL_SIZE = Base64.getDecoder().decode(BASE_64_ENCODED_MODEL).length;
     }
 
+    public void testRankFeaturesTextExpansionQuery() throws IOException {
+        testTextExpansionQuery("rank_features");
+    }
+
+    public void testSparseVectorTextExpansionQuery() throws IOException {
+        testTextExpansionQuery("sparse_vector");
+    }
+
     @SuppressWarnings("unchecked")
-    public void testTextExpansionQuery() throws IOException {
+    private void testTextExpansionQuery(String tokensFieldType) throws IOException {
         String modelId = "text-expansion-test";
         String indexName = modelId + "-index";
 
@@ -140,7 +148,7 @@ public void testTextExpansionQuery() throws IOException {
         }
 
         // index tokens
-        createRankFeaturesIndex(indexName);
+        createIndex(indexName, tokensFieldType);
         bulkIndexDocs(inputs, tokenWeights, indexName);
 
         // Test text expansion search against the indexed rank features
@@ -157,7 +165,15 @@ public void testTextExpansionQuery() throws IOException {
         }
     }
 
-    public void testWithPipelineIngest() throws IOException {
+    public void testRankFeaturesWithPipelineIngest() throws IOException {
+        testWithPipelineIngest("rank_features");
+    }
+
+    public void testSparseVectorWithPipelineIngest() throws IOException {
+        testWithPipelineIngest("sparse_vector");
+    }
+
+    private void testWithPipelineIngest(String tokensFieldType) throws IOException {
         String modelId = "text-expansion-pipeline-test";
         String indexName = modelId + "-index";
 
@@ -182,7 +198,7 @@ public void testWithPipelineIngest() throws IOException {
         );
 
         // index tokens
-        createRankFeaturesIndex(indexName);
+        createIndex(indexName, tokensFieldType);
         var pipelineId = putPipeline(modelId);
         bulkIndexThroughPipeline(inputs, indexName, pipelineId);
 
@@ -201,7 +217,15 @@ public void testWithPipelineIngest() throws IOException {
         }
     }
 
-    public void testWithDotsInTokenNames() throws IOException {
+    public void testRankFeaturesWithDotsInTokenNames() throws IOException {
+        testWithDotsInTokenNames("rank_features");
+    }
+
+    public void testSparseVectorWithDotsInTokenNames() throws IOException {
+        testWithDotsInTokenNames("sparse_vector");
+    }
+
+    private void testWithDotsInTokenNames(String tokensFieldType) throws IOException {
         String modelId = "text-expansion-dots-in-tokens";
         String indexName = modelId + "-index";
 
@@ -214,7 +238,7 @@ public void testWithDotsInTokenNames() throws IOException {
         List<String> inputs = List.of("these are my words.");
 
         // index tokens
-        createRankFeaturesIndex(indexName);
+        createIndex(indexName, tokensFieldType);
         var pipelineId = putPipeline(modelId);
         bulkIndexThroughPipeline(inputs, indexName, pipelineId);
 
@@ -278,18 +302,18 @@ protected void createTextExpansionModel(String modelId) throws IOException {
         client().performRequest(request);
     }
 
-    private void createRankFeaturesIndex(String indexName) throws IOException {
+    private void createIndex(String indexName, String tokensFieldType) throws IOException {
         Request createIndex = new Request("PUT", "/" + indexName);
         createIndex.setJsonEntity("""
-            {
-              "mappings": {
-                "properties": {
-                  "text_field": {
-                    "type": "text"
-                  },
-                  "ml.tokens": {
-                    "type": "rank_features"
-                  }
+              {
+                "mappings": {
+                  "properties": {
+                    "text_field": {
+                      "type": "text"
+                    },
+                    "ml.tokens": {
+            """ + "\"type\": \"" + tokensFieldType + "\"" + """
+                    }
                 }
               }
             }""");
diff --git a/x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/ml/text_expansion_search_rank_features.yml b/x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/ml/text_expansion_search_rank_features.yml
new file mode 100644
index 0000000000000..28a6ad826bc64
--- /dev/null
+++ b/x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/ml/text_expansion_search_rank_features.yml
@@ -0,0 +1,111 @@
+# This test uses the simple model defined in
+# TextExpansionQueryIT.java to create the token weights.
+setup:
+  - skip:
+      version: ' - 8.10.99'
+      reason: "sparse_vector field type reintroduced in 8.11"
+      features: headers
+  - do:
+      headers:
+        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
+      indices.create:
+        index: index-with-rank-features
+        body:
+          mappings:
+            properties:
+              source_text:
+                type: keyword
+              ml.tokens:
+                type: rank_features
+
+  - do:
+      headers:
+        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
+      indices.create:
+        index: unrelated
+        body:
+          mappings:
+            properties:
+              source_text:
+                type: keyword
+
+  - do:
+      headers:
+        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
+      ml.put_trained_model:
+        model_id: "text_expansion_model"
+        body: >
+          {
+            "description": "simple model for testing",
+            "model_type": "pytorch",
+            "inference_config": {
+              "text_expansion": {
+                "tokenization": {
+                  "bert": {
+                    "with_special_tokens": false
+                  }
+                }
+              }
+            }
+          }
+  - do:
+      headers:
+        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
+      ml.put_trained_model_vocabulary:
+        model_id: "text_expansion_model"
+        body: >
+          { "vocabulary": ["[PAD]", "[UNK]", "these", "are", "my", "words", "the", "washing", "machine", "is", "leaking", "octopus", "comforter", "smells"] }
+  - do:
+      headers:
+        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
+      ml.put_trained_model_definition_part:
+        model_id: "text_expansion_model"
+        part: 0
+        body: >
+          {
+            "total_definition_length":2078,
+            "definition": "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",
+            "total_parts": 1
+          }
+  - do:
+      headers:
+        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
+        Content-Type: application/json
+      bulk:
+        index: index-with-rank-features
+        refresh: true
+        body: |
+          {"index": {}}
+          {"source_text": "my words comforter", "ml.tokens":{"my":1.0, "words":1.0,"comforter":1.0}}
+          {"index": {}}
+          {"source_text": "the machine is leaking", "ml.tokens":{"the":1.0,"machine":1.0,"is":1.0,"leaking":1.0}}
+          {"index": {}}
+          {"source_text": "these are my words", "ml.tokens":{"these":1.0,"are":1.0,"my":1.0,"words":1.0}}
+          {"index": {}}
+          {"source_text": "the octopus comforter smells", "ml.tokens":{"the":1.0,"octopus":1.0,"comforter":1.0,"smells":1.0}}
+          {"index": {}}
+          {"source_text": "the octopus comforter is leaking", "ml.tokens":{"the":1.0,"octopus":1.0,"comforter":1.0,"is":1.0,"leaking":1.0}}
+          {"index": {}}
+          {"source_text": "washing machine smells", "ml.tokens":{"washing":1.0,"machine":1.0,"smells":1.0}}
+
+  - do:
+      headers:
+        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
+        Content-Type: application/json
+      ml.start_trained_model_deployment:
+        model_id: text_expansion_model
+        wait_for: started
+
+---
+"Test text expansion search":
+  - do:
+      search:
+        index: index-with-rank-features
+        body:
+          query:
+            text_expansion:
+              ml.tokens:
+                model_id: text_expansion_model
+                model_text: "octopus comforter smells"
+  - match: { hits.total.value: 4 }
+  - match: { hits.hits.0._source.source_text: "the octopus comforter smells" }
diff --git a/x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/ml/text_expansion_search_sparse_vector.yml b/x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/ml/text_expansion_search_sparse_vector.yml
new file mode 100644
index 0000000000000..5a31af18f8269
--- /dev/null
+++ b/x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/ml/text_expansion_search_sparse_vector.yml
@@ -0,0 +1,111 @@
+# This test uses the simple model defined in
+# TextExpansionQueryIT.java to create the token weights.
+setup:
+  - skip:
+      features: headers
+      version: ' - 8.7.99'
+      reason: "text_expansion query introduced in 8.8"
+  - do:
+      headers:
+        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
+      indices.create:
+        index: index-with-rank-features
+        body:
+          mappings:
+            properties:
+              source_text:
+                type: keyword
+              ml.tokens:
+                type: sparse_vector
+
+  - do:
+      headers:
+        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
+      indices.create:
+        index: unrelated
+        body:
+          mappings:
+            properties:
+              source_text:
+                type: keyword
+
+  - do:
+      headers:
+        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
+      ml.put_trained_model:
+        model_id: "text_expansion_model"
+        body: >
+          {
+            "description": "simple model for testing",
+            "model_type": "pytorch",
+            "inference_config": {
+              "text_expansion": {
+                "tokenization": {
+                  "bert": {
+                    "with_special_tokens": false
+                  }
+                }
+              }
+            }
+          }
+  - do:
+      headers:
+        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
+      ml.put_trained_model_vocabulary:
+        model_id: "text_expansion_model"
+        body: >
+          { "vocabulary": ["[PAD]", "[UNK]", "these", "are", "my", "words", "the", "washing", "machine", "is", "leaking", "octopus", "comforter", "smells"] }
+  - do:
+      headers:
+        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
+      ml.put_trained_model_definition_part:
+        model_id: "text_expansion_model"
+        part: 0
+        body: >
+          {
+            "total_definition_length":2078,
+            "definition": "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",
+            "total_parts": 1
+          }
+  - do:
+      headers:
+        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
+        Content-Type: application/json
+      bulk:
+        index: index-with-rank-features
+        refresh: true
+        body: |
+          {"index": {}}
+          {"source_text": "my words comforter", "ml.tokens":{"my":1.0, "words":1.0,"comforter":1.0}}
+          {"index": {}}
+          {"source_text": "the machine is leaking", "ml.tokens":{"the":1.0,"machine":1.0,"is":1.0,"leaking":1.0}}
+          {"index": {}}
+          {"source_text": "these are my words", "ml.tokens":{"these":1.0,"are":1.0,"my":1.0,"words":1.0}}
+          {"index": {}}
+          {"source_text": "the octopus comforter smells", "ml.tokens":{"the":1.0,"octopus":1.0,"comforter":1.0,"smells":1.0}}
+          {"index": {}}
+          {"source_text": "the octopus comforter is leaking", "ml.tokens":{"the":1.0,"octopus":1.0,"comforter":1.0,"is":1.0,"leaking":1.0}}
+          {"index": {}}
+          {"source_text": "washing machine smells", "ml.tokens":{"washing":1.0,"machine":1.0,"smells":1.0}}
+
+  - do:
+      headers:
+        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
+        Content-Type: application/json
+      ml.start_trained_model_deployment:
+        model_id: text_expansion_model
+        wait_for: started
+
+---
+"Test text expansion search":
+  - do:
+      search:
+        index: index-with-rank-features
+        body:
+          query:
+            text_expansion:
+              ml.tokens:
+                model_id: text_expansion_model
+                model_text: "octopus comforter smells"
+  - match: { hits.total.value: 4 }
+  - match: { hits.hits.0._source.source_text: "the octopus comforter smells" }

From 163b5eff5a6a580975efc7206460e0dd54614de3 Mon Sep 17 00:00:00 2001
From: Nhat Nguyen <nhat.nguyen@elastic.co>
Date: Thu, 28 Sep 2023 12:41:39 -0700
Subject: [PATCH 21/32] Add deduplicated attribute to MvOrdering (#100027)

Today, we have the ability to specify whether multivalued fields are
sorted in ascending order or not. This feature allows operators like
topn to enable optimizations. However, we are currently missing the
deduplicated attribute. If multivalued fields are deduplicated at each
position, we can further optimize operators such as hash and mv_dedup.
In fact, blocks should not have mv_ascending property alone; it always
goes together with mv_deduplicated. Additionally, mv_dedup or hash
should generate blocks that have only the mv_dedup property.
---
 .../compute/operator/EvalBenchmark.java       |  2 +-
 .../compute/gen/MvEvaluatorImplementer.java   |  2 +-
 .../operator/MultivalueDedupeBytesRef.java    |  6 ++--
 .../operator/MultivalueDedupeDouble.java      |  6 ++--
 .../compute/operator/MultivalueDedupeInt.java |  6 ++--
 .../operator/MultivalueDedupeLong.java        |  6 ++--
 .../operator/topn/KeyExtractorForBoolean.java |  5 ++-
 .../topn/KeyExtractorForBytesRef.java         |  5 ++-
 .../operator/topn/KeyExtractorForDouble.java  |  5 ++-
 .../operator/topn/KeyExtractorForInt.java     |  5 ++-
 .../operator/topn/KeyExtractorForLong.java    |  5 ++-
 .../blockhash/DoubleBlockHash.java            |  3 +-
 .../aggregation/blockhash/IntBlockHash.java   |  2 +-
 .../aggregation/blockhash/LongBlockHash.java  |  3 +-
 .../compute/data/AbstractVectorBlock.java     |  2 +-
 .../org/elasticsearch/compute/data/Block.java | 32 ++++++++++++++++---
 .../compute/data/BlockUtils.java              | 20 ++++++++++--
 .../compute/lucene/BlockDocValuesReader.java  | 18 +++++------
 .../operator/X-MultivalueDedupe.java.st       |  6 ++--
 .../operator/topn/X-KeyExtractor.java.st      |  5 ++-
 .../ValuesSourceReaderOperatorTests.java      | 10 +++---
 .../operator/topn/TopNOperatorTests.java      |  8 ++---
 .../multivalue/MvMaxBooleanEvaluator.java     |  4 +--
 .../multivalue/MvMaxBytesRefEvaluator.java    |  4 +--
 .../multivalue/MvMaxDoubleEvaluator.java      |  4 +--
 .../scalar/multivalue/MvMaxIntEvaluator.java  |  4 +--
 .../scalar/multivalue/MvMaxLongEvaluator.java |  4 +--
 .../multivalue/MvMedianIntEvaluator.java      |  4 +--
 .../multivalue/MvMedianLongEvaluator.java     |  4 +--
 .../MvMedianUnsignedLongEvaluator.java        |  4 +--
 .../multivalue/MvMinBooleanEvaluator.java     |  4 +--
 .../multivalue/MvMinBytesRefEvaluator.java    |  4 +--
 .../multivalue/MvMinDoubleEvaluator.java      |  4 +--
 .../scalar/multivalue/MvMinIntEvaluator.java  |  4 +--
 .../scalar/multivalue/MvMinLongEvaluator.java |  4 +--
 .../AbstractMultivalueFunctionTestCase.java   | 14 +++++++-
 36 files changed, 137 insertions(+), 91 deletions(-)

diff --git a/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/EvalBenchmark.java b/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/EvalBenchmark.java
index 82c9416515d24..e129cdaa12469 100644
--- a/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/EvalBenchmark.java
+++ b/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/EvalBenchmark.java
@@ -229,7 +229,7 @@ private static Page page(String operation) {
             case "mv_min", "mv_min_ascending" -> {
                 var builder = LongBlock.newBlockBuilder(BLOCK_LENGTH);
                 if (operation.endsWith("ascending")) {
-                    builder.mvOrdering(Block.MvOrdering.ASCENDING);
+                    builder.mvOrdering(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING);
                 }
                 for (int i = 0; i < BLOCK_LENGTH; i++) {
                     builder.beginPositionEntry();
diff --git a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/MvEvaluatorImplementer.java b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/MvEvaluatorImplementer.java
index 86ae6d3f46789..0e29cc7673fee 100644
--- a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/MvEvaluatorImplementer.java
+++ b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/MvEvaluatorImplementer.java
@@ -261,7 +261,7 @@ private MethodSpec eval(String name, boolean nullable) {
             if (ascendingFunction == null) {
                 return;
             }
-            builder.beginControlFlow("if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING)");
+            builder.beginControlFlow("if (fieldVal.mvSortedAscending())");
             builder.addStatement("return $L(fieldVal)", name.replace("eval", "evalAscending"));
             builder.endControlFlow();
         }, builder -> {
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeBytesRef.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeBytesRef.java
index 48aec38b800ce..89c15d9eeab72 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeBytesRef.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeBytesRef.java
@@ -44,7 +44,7 @@ public MultivalueDedupeBytesRef(BytesRefBlock block) {
      * {@link Block} using an adaptive algorithm based on the size of the input list.
      */
     public BytesRefBlock dedupeToBlockAdaptive() {
-        if (false == block.mayHaveMultivaluedFields()) {
+        if (block.mvDeduplicated()) {
             return block;
         }
         BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(block.getPositionCount());
@@ -92,7 +92,7 @@ public BytesRefBlock dedupeToBlockAdaptive() {
      * which picks based on the number of elements at each position.
      */
     public BytesRefBlock dedupeToBlockUsingCopyAndSort() {
-        if (false == block.mayHaveMultivaluedFields()) {
+        if (block.mvDeduplicated()) {
             return block;
         }
         BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(block.getPositionCount());
@@ -120,7 +120,7 @@ public BytesRefBlock dedupeToBlockUsingCopyAndSort() {
      * {@link #dedupeToBlockAdaptive} unless you need the results sorted.
      */
     public BytesRefBlock dedupeToBlockUsingCopyMissing() {
-        if (false == block.mayHaveMultivaluedFields()) {
+        if (block.mvDeduplicated()) {
             return block;
         }
         BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(block.getPositionCount());
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeDouble.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeDouble.java
index d30292f6fa32c..22f5cef2d57d8 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeDouble.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeDouble.java
@@ -41,7 +41,7 @@ public MultivalueDedupeDouble(DoubleBlock block) {
      * {@link Block} using an adaptive algorithm based on the size of the input list.
      */
     public DoubleBlock dedupeToBlockAdaptive() {
-        if (false == block.mayHaveMultivaluedFields()) {
+        if (block.mvDeduplicated()) {
             return block;
         }
         DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(block.getPositionCount());
@@ -89,7 +89,7 @@ public DoubleBlock dedupeToBlockAdaptive() {
      * which picks based on the number of elements at each position.
      */
     public DoubleBlock dedupeToBlockUsingCopyAndSort() {
-        if (false == block.mayHaveMultivaluedFields()) {
+        if (block.mvDeduplicated()) {
             return block;
         }
         DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(block.getPositionCount());
@@ -117,7 +117,7 @@ public DoubleBlock dedupeToBlockUsingCopyAndSort() {
      * {@link #dedupeToBlockAdaptive} unless you need the results sorted.
      */
     public DoubleBlock dedupeToBlockUsingCopyMissing() {
-        if (false == block.mayHaveMultivaluedFields()) {
+        if (block.mvDeduplicated()) {
             return block;
         }
         DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(block.getPositionCount());
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeInt.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeInt.java
index cda9308a7e6d2..be6d08cfc39d7 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeInt.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeInt.java
@@ -40,7 +40,7 @@ public MultivalueDedupeInt(IntBlock block) {
      * {@link Block} using an adaptive algorithm based on the size of the input list.
      */
     public IntBlock dedupeToBlockAdaptive() {
-        if (false == block.mayHaveMultivaluedFields()) {
+        if (block.mvDeduplicated()) {
             return block;
         }
         IntBlock.Builder builder = IntBlock.newBlockBuilder(block.getPositionCount());
@@ -88,7 +88,7 @@ public IntBlock dedupeToBlockAdaptive() {
      * which picks based on the number of elements at each position.
      */
     public IntBlock dedupeToBlockUsingCopyAndSort() {
-        if (false == block.mayHaveMultivaluedFields()) {
+        if (block.mvDeduplicated()) {
             return block;
         }
         IntBlock.Builder builder = IntBlock.newBlockBuilder(block.getPositionCount());
@@ -116,7 +116,7 @@ public IntBlock dedupeToBlockUsingCopyAndSort() {
      * {@link #dedupeToBlockAdaptive} unless you need the results sorted.
      */
     public IntBlock dedupeToBlockUsingCopyMissing() {
-        if (false == block.mayHaveMultivaluedFields()) {
+        if (block.mvDeduplicated()) {
             return block;
         }
         IntBlock.Builder builder = IntBlock.newBlockBuilder(block.getPositionCount());
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeLong.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeLong.java
index 0266131fba37c..d4da43f93d503 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeLong.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/MultivalueDedupeLong.java
@@ -42,7 +42,7 @@ public MultivalueDedupeLong(LongBlock block) {
      * {@link Block} using an adaptive algorithm based on the size of the input list.
      */
     public LongBlock dedupeToBlockAdaptive() {
-        if (false == block.mayHaveMultivaluedFields()) {
+        if (block.mvDeduplicated()) {
             return block;
         }
         LongBlock.Builder builder = LongBlock.newBlockBuilder(block.getPositionCount());
@@ -90,7 +90,7 @@ public LongBlock dedupeToBlockAdaptive() {
      * which picks based on the number of elements at each position.
      */
     public LongBlock dedupeToBlockUsingCopyAndSort() {
-        if (false == block.mayHaveMultivaluedFields()) {
+        if (block.mvDeduplicated()) {
             return block;
         }
         LongBlock.Builder builder = LongBlock.newBlockBuilder(block.getPositionCount());
@@ -118,7 +118,7 @@ public LongBlock dedupeToBlockUsingCopyAndSort() {
      * {@link #dedupeToBlockAdaptive} unless you need the results sorted.
      */
     public LongBlock dedupeToBlockUsingCopyMissing() {
-        if (false == block.mayHaveMultivaluedFields()) {
+        if (block.mvDeduplicated()) {
             return block;
         }
         LongBlock.Builder builder = LongBlock.newBlockBuilder(block.getPositionCount());
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForBoolean.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForBoolean.java
index 0bdc5ac620eb0..40fe7ffdde661 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForBoolean.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForBoolean.java
@@ -7,7 +7,6 @@
 
 package org.elasticsearch.compute.operator.topn;
 
-import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.BooleanBlock;
 import org.elasticsearch.compute.data.BooleanVector;
 import org.elasticsearch.compute.operator.BreakingBytesRefBuilder;
@@ -19,11 +18,11 @@ static KeyExtractorForBoolean extractorFor(TopNEncoder encoder, boolean ascendin
             return new KeyExtractorForBoolean.ForVector(encoder, nul, nonNul, v);
         }
         if (ascending) {
-            return block.mvOrdering() == Block.MvOrdering.ASCENDING
+            return block.mvSortedAscending()
                 ? new KeyExtractorForBoolean.MinForAscending(encoder, nul, nonNul, block)
                 : new KeyExtractorForBoolean.MinForUnordered(encoder, nul, nonNul, block);
         }
-        return block.mvOrdering() == Block.MvOrdering.ASCENDING
+        return block.mvSortedAscending()
             ? new KeyExtractorForBoolean.MaxForAscending(encoder, nul, nonNul, block)
             : new KeyExtractorForBoolean.MaxForUnordered(encoder, nul, nonNul, block);
     }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForBytesRef.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForBytesRef.java
index accce46f38e30..2f546a46aaeaf 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForBytesRef.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForBytesRef.java
@@ -8,7 +8,6 @@
 package org.elasticsearch.compute.operator.topn;
 
 import org.apache.lucene.util.BytesRef;
-import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.BytesRefBlock;
 import org.elasticsearch.compute.data.BytesRefVector;
 import org.elasticsearch.compute.operator.BreakingBytesRefBuilder;
@@ -20,11 +19,11 @@ static KeyExtractorForBytesRef extractorFor(TopNEncoder encoder, boolean ascendi
             return new KeyExtractorForBytesRef.ForVector(encoder, nul, nonNul, v);
         }
         if (ascending) {
-            return block.mvOrdering() == Block.MvOrdering.ASCENDING
+            return block.mvSortedAscending()
                 ? new KeyExtractorForBytesRef.MinForAscending(encoder, nul, nonNul, block)
                 : new KeyExtractorForBytesRef.MinForUnordered(encoder, nul, nonNul, block);
         }
-        return block.mvOrdering() == Block.MvOrdering.ASCENDING
+        return block.mvSortedAscending()
             ? new KeyExtractorForBytesRef.MaxForAscending(encoder, nul, nonNul, block)
             : new KeyExtractorForBytesRef.MaxForUnordered(encoder, nul, nonNul, block);
     }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForDouble.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForDouble.java
index 2f2968da16d83..5e821b9e24db5 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForDouble.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForDouble.java
@@ -7,7 +7,6 @@
 
 package org.elasticsearch.compute.operator.topn;
 
-import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.DoubleVector;
 import org.elasticsearch.compute.operator.BreakingBytesRefBuilder;
@@ -19,11 +18,11 @@ static KeyExtractorForDouble extractorFor(TopNEncoder encoder, boolean ascending
             return new KeyExtractorForDouble.ForVector(encoder, nul, nonNul, v);
         }
         if (ascending) {
-            return block.mvOrdering() == Block.MvOrdering.ASCENDING
+            return block.mvSortedAscending()
                 ? new KeyExtractorForDouble.MinForAscending(encoder, nul, nonNul, block)
                 : new KeyExtractorForDouble.MinForUnordered(encoder, nul, nonNul, block);
         }
-        return block.mvOrdering() == Block.MvOrdering.ASCENDING
+        return block.mvSortedAscending()
             ? new KeyExtractorForDouble.MaxForAscending(encoder, nul, nonNul, block)
             : new KeyExtractorForDouble.MaxForUnordered(encoder, nul, nonNul, block);
     }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForInt.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForInt.java
index 400c43168277d..d4269a622f098 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForInt.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForInt.java
@@ -7,7 +7,6 @@
 
 package org.elasticsearch.compute.operator.topn;
 
-import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.data.IntVector;
 import org.elasticsearch.compute.operator.BreakingBytesRefBuilder;
@@ -19,11 +18,11 @@ static KeyExtractorForInt extractorFor(TopNEncoder encoder, boolean ascending, b
             return new KeyExtractorForInt.ForVector(encoder, nul, nonNul, v);
         }
         if (ascending) {
-            return block.mvOrdering() == Block.MvOrdering.ASCENDING
+            return block.mvSortedAscending()
                 ? new KeyExtractorForInt.MinForAscending(encoder, nul, nonNul, block)
                 : new KeyExtractorForInt.MinForUnordered(encoder, nul, nonNul, block);
         }
-        return block.mvOrdering() == Block.MvOrdering.ASCENDING
+        return block.mvSortedAscending()
             ? new KeyExtractorForInt.MaxForAscending(encoder, nul, nonNul, block)
             : new KeyExtractorForInt.MaxForUnordered(encoder, nul, nonNul, block);
     }
diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForLong.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForLong.java
index 843efdd95471f..6a200efff529d 100644
--- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForLong.java
+++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/operator/topn/KeyExtractorForLong.java
@@ -7,7 +7,6 @@
 
 package org.elasticsearch.compute.operator.topn;
 
-import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.LongVector;
 import org.elasticsearch.compute.operator.BreakingBytesRefBuilder;
@@ -19,11 +18,11 @@ static KeyExtractorForLong extractorFor(TopNEncoder encoder, boolean ascending,
             return new KeyExtractorForLong.ForVector(encoder, nul, nonNul, v);
         }
         if (ascending) {
-            return block.mvOrdering() == Block.MvOrdering.ASCENDING
+            return block.mvSortedAscending()
                 ? new KeyExtractorForLong.MinForAscending(encoder, nul, nonNul, block)
                 : new KeyExtractorForLong.MinForUnordered(encoder, nul, nonNul, block);
         }
-        return block.mvOrdering() == Block.MvOrdering.ASCENDING
+        return block.mvSortedAscending()
             ? new KeyExtractorForLong.MaxForAscending(encoder, nul, nonNul, block)
             : new KeyExtractorForLong.MaxForUnordered(encoder, nul, nonNul, block);
     }
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/DoubleBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/DoubleBlockHash.java
index 3a52beb9c2d87..f3ca16869898f 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/DoubleBlockHash.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/DoubleBlockHash.java
@@ -82,7 +82,8 @@ public DoubleBlock[] getKeys() {
             }
             BitSet nulls = new BitSet(1);
             nulls.set(0);
-            return new DoubleBlock[] { new DoubleArrayBlock(keys, keys.length, null, nulls, Block.MvOrdering.ASCENDING) };
+            return new DoubleBlock[] {
+                new DoubleArrayBlock(keys, keys.length, null, nulls, Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING) };
         }
 
         final int size = Math.toIntExact(longHash.size());
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/IntBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/IntBlockHash.java
index 4fcd9735f6158..08b2cd15aa53e 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/IntBlockHash.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/IntBlockHash.java
@@ -78,7 +78,7 @@ public IntBlock[] getKeys() {
             }
             BitSet nulls = new BitSet(1);
             nulls.set(0);
-            return new IntBlock[] { new IntArrayBlock(keys, keys.length, null, nulls, Block.MvOrdering.ASCENDING) };
+            return new IntBlock[] { new IntArrayBlock(keys, keys.length, null, nulls, Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING) };
         }
         final int size = Math.toIntExact(longHash.size());
         final int[] keys = new int[size];
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongBlockHash.java
index 5e5b46ae6eda1..00e93db9cec00 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongBlockHash.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongBlockHash.java
@@ -82,7 +82,8 @@ public LongBlock[] getKeys() {
             }
             BitSet nulls = new BitSet(1);
             nulls.set(0);
-            return new LongBlock[] { new LongArrayBlock(keys, keys.length, null, nulls, Block.MvOrdering.ASCENDING) };
+            return new LongBlock[] {
+                new LongArrayBlock(keys, keys.length, null, nulls, Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING) };
         }
 
         final int size = Math.toIntExact(longHash.size());
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVectorBlock.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVectorBlock.java
index d83d26cf33831..4a019db5e03c0 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVectorBlock.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVectorBlock.java
@@ -52,7 +52,7 @@ public boolean mayHaveMultivaluedFields() {
 
     @Override
     public final MvOrdering mvOrdering() {
-        return MvOrdering.UNORDERED;
+        return MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING;
     }
 
     @Override
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Block.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Block.java
index ca0721ebbe4f8..9c05d6d0ddfb8 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Block.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Block.java
@@ -102,12 +102,20 @@ public interface Block extends Accountable, NamedWriteable, Releasable {
 
     /**
      * How are multivalued fields ordered?
-     * <p>Note that there isn't a {@code DESCENDING} because we don't have
-     * anything that makes descending fields.</p>
+     * Some operators can enable its optimization when mv_values are sorted ascending or de-duplicated.
      */
     enum MvOrdering {
-        ASCENDING,
-        UNORDERED;
+        UNORDERED(false, false),
+        DEDUPLICATED_UNORDERD(true, false),
+        DEDUPLICATED_AND_SORTED_ASCENDING(true, true);
+
+        private final boolean deduplicated;
+        private final boolean sortedAscending;
+
+        MvOrdering(boolean deduplicated, boolean sortedAscending) {
+            this.deduplicated = deduplicated;
+            this.sortedAscending = sortedAscending;
+        }
     }
 
     /**
@@ -115,6 +123,20 @@ enum MvOrdering {
      */
     MvOrdering mvOrdering();
 
+    /**
+     * Are multivalued fields de-duplicated in each position
+     */
+    default boolean mvDeduplicated() {
+        return mayHaveMultivaluedFields() == false || mvOrdering().deduplicated;
+    }
+
+    /**
+     * Are multivalued fields sorted ascending in each position
+     */
+    default boolean mvSortedAscending() {
+        return mayHaveMultivaluedFields() == false || mvOrdering().sortedAscending;
+    }
+
     /**
      * Expand multivalued fields into one row per value. Returns the
      * block if there aren't any multivalued fields to expand.
@@ -172,7 +194,7 @@ interface Builder extends Releasable {
 
         /**
          * How are multivalued fields ordered? This defaults to {@link Block.MvOrdering#UNORDERED}
-         * but when you set it to {@link Block.MvOrdering#ASCENDING} some operators can optimize
+         * but when you set it to {@link Block.MvOrdering#DEDUPLICATED_AND_SORTED_ASCENDING} some operators can optimize
          * themselves. This is a <strong>promise</strong> that is never checked. If you set this
          * to anything other than {@link Block.MvOrdering#UNORDERED} be sure the values are in
          * that order or other operators will make mistakes. The actual ordering isn't checked
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/BlockUtils.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/BlockUtils.java
index 0d09f7bb480e0..a41ea0383368d 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/BlockUtils.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/BlockUtils.java
@@ -8,10 +8,13 @@
 package org.elasticsearch.compute.data;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.common.Randomness;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Random;
 import java.util.function.Consumer;
 
 import static org.elasticsearch.common.lucene.BytesRefs.toBytesRef;
@@ -68,8 +71,13 @@ public static Block[] fromListRow(List<Object> row, int blockSize) {
             if (object instanceof List<?> listVal) {
                 BuilderWrapper wrapper = wrapperFor(fromJava(listVal.get(0).getClass()), blockSize);
                 wrapper.accept(listVal);
-                if (isAscending(listVal)) {
-                    wrapper.builder.mvOrdering(Block.MvOrdering.ASCENDING);
+                Random random = Randomness.get();
+                if (isDeduplicated(listVal) && random.nextBoolean()) {
+                    if (isAscending(listVal) && random.nextBoolean()) {
+                        wrapper.builder.mvOrdering(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING);
+                    } else {
+                        wrapper.builder.mvOrdering(Block.MvOrdering.DEDUPLICATED_UNORDERD);
+                    }
                 }
                 blocks[i] = wrapper.builder.build();
             } else {
@@ -100,6 +108,14 @@ private static boolean isAscending(List<?> values) {
         return true;
     }
 
+    /**
+     * Detect blocks with deduplicated fields. This is *mostly* useful for
+     * exercising the specialized ascending implementations.
+     */
+    private static boolean isDeduplicated(List<?> values) {
+        return new HashSet<>(values).size() == values.size();
+    }
+
     public static Block[] fromList(List<List<Object>> list) {
         var size = list.size();
         if (size == 0) {
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/lucene/BlockDocValuesReader.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/lucene/BlockDocValuesReader.java
index 4290075b05ae8..28a9359497393 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/lucene/BlockDocValuesReader.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/lucene/BlockDocValuesReader.java
@@ -142,7 +142,7 @@ private static class LongSingletonValuesReader extends BlockDocValuesReader {
 
         @Override
         public LongBlock.Builder builder(int positionCount) {
-            return LongBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.ASCENDING);
+            return LongBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING);
         }
 
         @Override
@@ -197,7 +197,7 @@ private static class LongValuesReader extends BlockDocValuesReader {
 
         @Override
         public LongBlock.Builder builder(int positionCount) {
-            return LongBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.ASCENDING);
+            return LongBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING);
         }
 
         @Override
@@ -259,7 +259,7 @@ private static class IntSingletonValuesReader extends BlockDocValuesReader {
 
         @Override
         public IntBlock.Builder builder(int positionCount) {
-            return IntBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.ASCENDING);
+            return IntBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING);
         }
 
         @Override
@@ -314,7 +314,7 @@ private static class IntValuesReader extends BlockDocValuesReader {
 
         @Override
         public IntBlock.Builder builder(int positionCount) {
-            return IntBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.ASCENDING);
+            return IntBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING);
         }
 
         @Override
@@ -378,7 +378,7 @@ private static class DoubleSingletonValuesReader extends BlockDocValuesReader {
 
         @Override
         public DoubleBlock.Builder builder(int positionCount) {
-            return DoubleBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.ASCENDING);
+            return DoubleBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING);
         }
 
         @Override
@@ -435,7 +435,7 @@ private static class DoubleValuesReader extends BlockDocValuesReader {
 
         @Override
         public DoubleBlock.Builder builder(int positionCount) {
-            return DoubleBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.ASCENDING);
+            return DoubleBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING);
         }
 
         @Override
@@ -497,7 +497,7 @@ private static class BytesValuesReader extends BlockDocValuesReader {
 
         @Override
         public BytesRefBlock.Builder builder(int positionCount) {
-            return BytesRefBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.ASCENDING);
+            return BytesRefBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING);
         }
 
         @Override
@@ -558,7 +558,7 @@ private static class BooleanSingletonValuesReader extends BlockDocValuesReader {
 
         @Override
         public BooleanBlock.Builder builder(int positionCount) {
-            return BooleanBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.ASCENDING);
+            return BooleanBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING);
         }
 
         @Override
@@ -613,7 +613,7 @@ private static class BooleanValuesReader extends BlockDocValuesReader {
 
         @Override
         public BooleanBlock.Builder builder(int positionCount) {
-            return BooleanBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.ASCENDING);
+            return BooleanBlock.newBlockBuilder(positionCount).mvOrdering(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING);
         }
 
         @Override
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/X-MultivalueDedupe.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/X-MultivalueDedupe.java.st
index 337b095ebe8d0..bd3e290a3625c 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/X-MultivalueDedupe.java.st
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/X-MultivalueDedupe.java.st
@@ -70,7 +70,7 @@ $endif$
      * {@link Block} using an adaptive algorithm based on the size of the input list.
      */
     public $Type$Block dedupeToBlockAdaptive() {
-        if (false == block.mayHaveMultivaluedFields()) {
+        if (block.mvDeduplicated()) {
             return block;
         }
         $Type$Block.Builder builder = $Type$Block.newBlockBuilder(block.getPositionCount());
@@ -122,7 +122,7 @@ $endif$
      * which picks based on the number of elements at each position.
      */
     public $Type$Block dedupeToBlockUsingCopyAndSort() {
-        if (false == block.mayHaveMultivaluedFields()) {
+        if (block.mvDeduplicated()) {
             return block;
         }
         $Type$Block.Builder builder = $Type$Block.newBlockBuilder(block.getPositionCount());
@@ -154,7 +154,7 @@ $endif$
      * {@link #dedupeToBlockAdaptive} unless you need the results sorted.
      */
     public $Type$Block dedupeToBlockUsingCopyMissing() {
-        if (false == block.mayHaveMultivaluedFields()) {
+        if (block.mvDeduplicated()) {
             return block;
         }
         $Type$Block.Builder builder = $Type$Block.newBlockBuilder(block.getPositionCount());
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/X-KeyExtractor.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/X-KeyExtractor.java.st
index 9ec03270da093..dbe0b23af93bb 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/X-KeyExtractor.java.st
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/topn/X-KeyExtractor.java.st
@@ -10,7 +10,6 @@ package org.elasticsearch.compute.operator.topn;
 $if(BytesRef)$
 import org.apache.lucene.util.BytesRef;
 $endif$
-import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.$Type$Block;
 import org.elasticsearch.compute.data.$Type$Vector;
 import org.elasticsearch.compute.operator.BreakingBytesRefBuilder;
@@ -22,11 +21,11 @@ abstract class KeyExtractorFor$Type$ implements KeyExtractor {
             return new KeyExtractorFor$Type$.ForVector(encoder, nul, nonNul, v);
         }
         if (ascending) {
-            return block.mvOrdering() == Block.MvOrdering.ASCENDING
+            return block.mvSortedAscending()
                 ? new KeyExtractorFor$Type$.MinForAscending(encoder, nul, nonNul, block)
                 : new KeyExtractorFor$Type$.MinForUnordered(encoder, nul, nonNul, block);
         }
-        return block.mvOrdering() == Block.MvOrdering.ASCENDING
+        return block.mvSortedAscending()
             ? new KeyExtractorFor$Type$.MaxForAscending(encoder, nul, nonNul, block)
             : new KeyExtractorFor$Type$.MaxForUnordered(encoder, nul, nonNul, block);
     }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/lucene/ValuesSourceReaderOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/lucene/ValuesSourceReaderOperatorTests.java
index 4776b40e12115..4c0e33e5cfb82 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/lucene/ValuesSourceReaderOperatorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/lucene/ValuesSourceReaderOperatorTests.java
@@ -328,7 +328,7 @@ private void loadSimpleAndAssert(DriverContext driverContext, List<Page> input)
                     assertThat(mvKeywords.getBytesRef(offset + v, new BytesRef()).utf8ToString(), equalTo(PREFIX[v] + key));
                 }
                 if (key % 3 > 0) {
-                    assertThat(mvKeywords.mvOrdering(), equalTo(Block.MvOrdering.ASCENDING));
+                    assertThat(mvKeywords.mvOrdering(), equalTo(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING));
                 }
 
                 assertThat(bools.getBoolean(i), equalTo(key % 2 == 0));
@@ -338,7 +338,7 @@ private void loadSimpleAndAssert(DriverContext driverContext, List<Page> input)
                     assertThat(mvBools.getBoolean(offset + v), equalTo(BOOLEANS[key % 3][v]));
                 }
                 if (key % 3 > 0) {
-                    assertThat(mvBools.mvOrdering(), equalTo(Block.MvOrdering.ASCENDING));
+                    assertThat(mvBools.mvOrdering(), equalTo(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING));
                 }
 
                 assertThat(mvInts.getValueCount(i), equalTo(key % 3 + 1));
@@ -347,7 +347,7 @@ private void loadSimpleAndAssert(DriverContext driverContext, List<Page> input)
                     assertThat(mvInts.getInt(offset + v), equalTo(1_000 * key + v));
                 }
                 if (key % 3 > 0) {
-                    assertThat(mvInts.mvOrdering(), equalTo(Block.MvOrdering.ASCENDING));
+                    assertThat(mvInts.mvOrdering(), equalTo(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING));
                 }
 
                 assertThat(mvLongs.getValueCount(i), equalTo(key % 3 + 1));
@@ -356,7 +356,7 @@ private void loadSimpleAndAssert(DriverContext driverContext, List<Page> input)
                     assertThat(mvLongs.getLong(offset + v), equalTo(-1_000L * key + v));
                 }
                 if (key % 3 > 0) {
-                    assertThat(mvLongs.mvOrdering(), equalTo(Block.MvOrdering.ASCENDING));
+                    assertThat(mvLongs.mvOrdering(), equalTo(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING));
                 }
 
                 assertThat(doubles.getDouble(i), equalTo(key / 123_456d));
@@ -365,7 +365,7 @@ private void loadSimpleAndAssert(DriverContext driverContext, List<Page> input)
                     assertThat(mvDoubles.getDouble(offset + v), equalTo(key / 123_456d + v));
                 }
                 if (key % 3 > 0) {
-                    assertThat(mvDoubles.mvOrdering(), equalTo(Block.MvOrdering.ASCENDING));
+                    assertThat(mvDoubles.mvOrdering(), equalTo(Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING));
                 }
             }
         }
diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/topn/TopNOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/topn/TopNOperatorTests.java
index 95f6613d3c0a4..c331b7ab013ae 100644
--- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/topn/TopNOperatorTests.java
+++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/topn/TopNOperatorTests.java
@@ -1118,7 +1118,7 @@ public void testIPSortingUnorderedMultiValues() throws UnknownHostException {
 
     public void testIPSortingOrderedMultiValues() throws UnknownHostException {
         List<List<String>> ips = new ArrayList<>();
-        ips.add(List.of("123.4.245.23", "123.4.245.23"));
+        ips.add(List.of("123.4.245.23", "123.4.245.24"));
         ips.add(null);
         ips.add(List.of("104.30.244.2", "127.0.0.1"));
         ips.add(null);
@@ -1135,17 +1135,17 @@ public void testIPSortingOrderedMultiValues() throws UnknownHostException {
             expectedDecodedIps.add(List.of("104.30.244.2", "127.0.0.1"));
             expectedDecodedIps.add(List.of("104.30.244.2", "124.255.255.255"));
             expectedDecodedIps.add(List.of("104.244.4.1"));
-            expectedDecodedIps.add(List.of("123.4.245.23", "123.4.245.23"));
+            expectedDecodedIps.add(List.of("123.4.245.23", "123.4.245.24"));
         } else {
             expectedDecodedIps.add(List.of("1.198.3.93", "2.3.4.5", "255.123.123.0"));
             expectedDecodedIps.add(List.of("104.30.244.2", "127.0.0.1"));
             expectedDecodedIps.add(List.of("104.30.244.2", "124.255.255.255"));
-            expectedDecodedIps.add(List.of("123.4.245.23", "123.4.245.23"));
+            expectedDecodedIps.add(List.of("123.4.245.23", "123.4.245.24"));
             expectedDecodedIps.add(List.of("104.244.4.1"));
             expectedDecodedIps.add(List.of("1.1.1.0", "32.183.93.40"));
         }
 
-        assertIPSortingOnMultiValues(ips, asc, Block.MvOrdering.ASCENDING, expectedDecodedIps);
+        assertIPSortingOnMultiValues(ips, asc, Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING, expectedDecodedIps);
     }
 
     private void assertIPSortingOnMultiValues(
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxBooleanEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxBooleanEvaluator.java
index 3b15fe9f17293..67ad08a101dab 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxBooleanEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxBooleanEvaluator.java
@@ -36,7 +36,7 @@ public String name() {
    */
   @Override
   public Block evalNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNullable(fieldVal);
     }
     BooleanBlock v = (BooleanBlock) fieldVal;
@@ -66,7 +66,7 @@ public Block evalNullable(Block fieldVal) {
    */
   @Override
   public Vector evalNotNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNotNullable(fieldVal);
     }
     BooleanBlock v = (BooleanBlock) fieldVal;
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxBytesRefEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxBytesRefEvaluator.java
index 6401664c9aa0d..36eaecf36e345 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxBytesRefEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxBytesRefEvaluator.java
@@ -37,7 +37,7 @@ public String name() {
    */
   @Override
   public Block evalNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNullable(fieldVal);
     }
     BytesRefBlock v = (BytesRefBlock) fieldVal;
@@ -69,7 +69,7 @@ public Block evalNullable(Block fieldVal) {
    */
   @Override
   public Vector evalNotNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNotNullable(fieldVal);
     }
     BytesRefBlock v = (BytesRefBlock) fieldVal;
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxDoubleEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxDoubleEvaluator.java
index 0ec72b82e2438..072dc413168ec 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxDoubleEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxDoubleEvaluator.java
@@ -35,7 +35,7 @@ public String name() {
    */
   @Override
   public Block evalNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNullable(fieldVal);
     }
     DoubleBlock v = (DoubleBlock) fieldVal;
@@ -65,7 +65,7 @@ public Block evalNullable(Block fieldVal) {
    */
   @Override
   public Vector evalNotNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNotNullable(fieldVal);
     }
     DoubleBlock v = (DoubleBlock) fieldVal;
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxIntEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxIntEvaluator.java
index 2bf14b26c6c5e..4d6a68ed67f26 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxIntEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxIntEvaluator.java
@@ -35,7 +35,7 @@ public String name() {
    */
   @Override
   public Block evalNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNullable(fieldVal);
     }
     IntBlock v = (IntBlock) fieldVal;
@@ -65,7 +65,7 @@ public Block evalNullable(Block fieldVal) {
    */
   @Override
   public Vector evalNotNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNotNullable(fieldVal);
     }
     IntBlock v = (IntBlock) fieldVal;
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxLongEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxLongEvaluator.java
index ce5a95bee7699..fd0ee6bf57740 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxLongEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMaxLongEvaluator.java
@@ -35,7 +35,7 @@ public String name() {
    */
   @Override
   public Block evalNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNullable(fieldVal);
     }
     LongBlock v = (LongBlock) fieldVal;
@@ -65,7 +65,7 @@ public Block evalNullable(Block fieldVal) {
    */
   @Override
   public Vector evalNotNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNotNullable(fieldVal);
     }
     LongBlock v = (LongBlock) fieldVal;
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMedianIntEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMedianIntEvaluator.java
index 711992a20763e..a84a4059b1dc0 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMedianIntEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMedianIntEvaluator.java
@@ -35,7 +35,7 @@ public String name() {
    */
   @Override
   public Block evalNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNullable(fieldVal);
     }
     IntBlock v = (IntBlock) fieldVal;
@@ -65,7 +65,7 @@ public Block evalNullable(Block fieldVal) {
    */
   @Override
   public Vector evalNotNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNotNullable(fieldVal);
     }
     IntBlock v = (IntBlock) fieldVal;
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMedianLongEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMedianLongEvaluator.java
index 67d3c123a6953..4c5798bed2e35 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMedianLongEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMedianLongEvaluator.java
@@ -36,7 +36,7 @@ public String name() {
    */
   @Override
   public Block evalNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNullable(fieldVal);
     }
     LongBlock v = (LongBlock) fieldVal;
@@ -66,7 +66,7 @@ public Block evalNullable(Block fieldVal) {
    */
   @Override
   public Vector evalNotNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNotNullable(fieldVal);
     }
     LongBlock v = (LongBlock) fieldVal;
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMedianUnsignedLongEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMedianUnsignedLongEvaluator.java
index 93538708039b5..1731d0733b511 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMedianUnsignedLongEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMedianUnsignedLongEvaluator.java
@@ -36,7 +36,7 @@ public String name() {
    */
   @Override
   public Block evalNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNullable(fieldVal);
     }
     LongBlock v = (LongBlock) fieldVal;
@@ -66,7 +66,7 @@ public Block evalNullable(Block fieldVal) {
    */
   @Override
   public Vector evalNotNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNotNullable(fieldVal);
     }
     LongBlock v = (LongBlock) fieldVal;
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinBooleanEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinBooleanEvaluator.java
index 6e16c8db4b896..afb5e1cb7cda1 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinBooleanEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinBooleanEvaluator.java
@@ -36,7 +36,7 @@ public String name() {
    */
   @Override
   public Block evalNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNullable(fieldVal);
     }
     BooleanBlock v = (BooleanBlock) fieldVal;
@@ -66,7 +66,7 @@ public Block evalNullable(Block fieldVal) {
    */
   @Override
   public Vector evalNotNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNotNullable(fieldVal);
     }
     BooleanBlock v = (BooleanBlock) fieldVal;
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinBytesRefEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinBytesRefEvaluator.java
index 99a671cf0a2df..41b487553dc8e 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinBytesRefEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinBytesRefEvaluator.java
@@ -37,7 +37,7 @@ public String name() {
    */
   @Override
   public Block evalNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNullable(fieldVal);
     }
     BytesRefBlock v = (BytesRefBlock) fieldVal;
@@ -69,7 +69,7 @@ public Block evalNullable(Block fieldVal) {
    */
   @Override
   public Vector evalNotNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNotNullable(fieldVal);
     }
     BytesRefBlock v = (BytesRefBlock) fieldVal;
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinDoubleEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinDoubleEvaluator.java
index e40ff78d0d364..63da4bd86c673 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinDoubleEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinDoubleEvaluator.java
@@ -35,7 +35,7 @@ public String name() {
    */
   @Override
   public Block evalNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNullable(fieldVal);
     }
     DoubleBlock v = (DoubleBlock) fieldVal;
@@ -65,7 +65,7 @@ public Block evalNullable(Block fieldVal) {
    */
   @Override
   public Vector evalNotNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNotNullable(fieldVal);
     }
     DoubleBlock v = (DoubleBlock) fieldVal;
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinIntEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinIntEvaluator.java
index 9412930da53c5..46dedaed43a3d 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinIntEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinIntEvaluator.java
@@ -35,7 +35,7 @@ public String name() {
    */
   @Override
   public Block evalNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNullable(fieldVal);
     }
     IntBlock v = (IntBlock) fieldVal;
@@ -65,7 +65,7 @@ public Block evalNullable(Block fieldVal) {
    */
   @Override
   public Vector evalNotNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNotNullable(fieldVal);
     }
     IntBlock v = (IntBlock) fieldVal;
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinLongEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinLongEvaluator.java
index 1fac131f0de0c..8e17c8f08a906 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinLongEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvMinLongEvaluator.java
@@ -35,7 +35,7 @@ public String name() {
    */
   @Override
   public Block evalNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNullable(fieldVal);
     }
     LongBlock v = (LongBlock) fieldVal;
@@ -65,7 +65,7 @@ public Block evalNullable(Block fieldVal) {
    */
   @Override
   public Vector evalNotNullable(Block fieldVal) {
-    if (fieldVal.mvOrdering() == Block.MvOrdering.ASCENDING) {
+    if (fieldVal.mvSortedAscending()) {
       return evalAscendingNotNullable(fieldVal);
     }
     LongBlock v = (LongBlock) fieldVal;
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/AbstractMultivalueFunctionTestCase.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/AbstractMultivalueFunctionTestCase.java
index 714112b2db543..cef65b6c477c5 100644
--- a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/AbstractMultivalueFunctionTestCase.java
+++ b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/AbstractMultivalueFunctionTestCase.java
@@ -26,6 +26,8 @@
 
 import java.math.BigInteger;
 import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.function.BiFunction;
 import java.util.stream.DoubleStream;
@@ -385,7 +387,17 @@ private static <T extends Comparable<T>> void putInOrder(List<T> mvData, Block.M
         switch (ordering) {
             case UNORDERED -> {
             }
-            case ASCENDING -> Collections.sort(mvData);
+            case DEDUPLICATED_UNORDERD -> {
+                var dedup = new LinkedHashSet<>(mvData);
+                mvData.clear();
+                mvData.addAll(dedup);
+            }
+            case DEDUPLICATED_AND_SORTED_ASCENDING -> {
+                var dedup = new HashSet<>(mvData);
+                mvData.clear();
+                mvData.addAll(dedup);
+                Collections.sort(mvData);
+            }
             default -> throw new UnsupportedOperationException("unsupported ordering [" + ordering + "]");
         }
     }

From 8f3d374d6dd58a220d5ee8f1f94c09d5d7e9dcb7 Mon Sep 17 00:00:00 2001
From: James Rodewig <james.rodewig@elastic.co>
Date: Thu, 28 Sep 2023 16:05:12 -0400
Subject: [PATCH 22/32] [DOCS] Add security update to 8.9.2 release notes
 (#99949)

Adds an update for the [audit logs security announcement](https://discuss.elastic.co/t/elasticsearch-8-9-2-and-7-17-13-security-update/342479) to the 8.9.2 release notes. This was overlooked when the announcement was first made.

I plan to add a similar note to the 7.17.13 release notes.
---
 docs/reference/release-notes/8.9.2.asciidoc | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/docs/reference/release-notes/8.9.2.asciidoc b/docs/reference/release-notes/8.9.2.asciidoc
index d4244eab27645..6b00405261daf 100644
--- a/docs/reference/release-notes/8.9.2.asciidoc
+++ b/docs/reference/release-notes/8.9.2.asciidoc
@@ -3,6 +3,25 @@
 
 Also see <<breaking-changes-8.9,Breaking changes in 8.9>>.
 
+[float]
+[[security-updates-8.9.2]]
+=== Security updates
+
+* {es} generally filters out sensitive information and credentials before
+logging to the audit log. It was found that this filtering was not applied when
+requests to {es} use certain deprecated `_xpack/security` URIs for APIs. The
+impact of this flaw is that sensitive information, such as passwords and tokens,
+might be printed in cleartext in {es} audit logs. Note that audit logging is
+disabled by default and needs to be explicitly enabled. Even when audit logging
+is enabled, request bodies that could contain sensitive information are not
+printed to the audit log unless explicitly configured.
++
+The issue is resolved in {es} 8.9.2.
++
+For more information, see our related
+https://discuss.elastic.co/t/elasticsearch-8-9-2-and-7-17-13-security-update/342479[security
+announcement].
+
 [[bug-8.9.2]]
 [float]
 === Bug fixes

From f99a80f42d4c5eff8a539ffca99a865e9e2dffe6 Mon Sep 17 00:00:00 2001
From: Chris Cressman <chris@chriscressman.com>
Date: Thu, 28 Sep 2023 17:32:37 -0400
Subject: [PATCH 23/32] [DOCS] Create URLs for docs migrating from Enterprise
 Search (#100032)

Several docs are going to migrate from Enterprise Search to
Elasticsearch.

Create the new URLs without yet placing the pages into the Elasticsearch
navigation. This will allow us to handle redirects for Kibana, docs, and
the web without waiting for additional content design decisions.

The new URLs will be:

- https://www.elastic.co/guide/en/elasticsearch/reference/master/ingest-pipeline-search.html
- https://www.elastic.co/guide/en/elasticsearch/reference/master/ingest-pipeline-search-inference.html
- https://www.elastic.co/guide/en/elasticsearch/reference/master/ingest-pipeline-search-inference.html#ingest-pipeline-search-inference-update-mapping
- https://www.elastic.co/guide/en/elasticsearch/reference/master/nlp-example.html
- https://www.elastic.co/guide/en/elasticsearch/reference/master/behavioral-analytics-overview.html
- https://www.elastic.co/guide/en/elasticsearch/reference/master/behavioral-analytics-start.html
- https://www.elastic.co/guide/en/elasticsearch/reference/master/behavioral-analytics-api.html
- https://www.elastic.co/guide/en/elasticsearch/reference/master/behavioral-analytics-event.html
- https://www.elastic.co/guide/en/elasticsearch/reference/master/behavioral-analytics-event-reference.html
- https://www.elastic.co/guide/en/elasticsearch/reference/master/behavioral-analytics-cors.html
- https://www.elastic.co/guide/en/elasticsearch/reference/master/search-application-overview.html
- https://www.elastic.co/guide/en/elasticsearch/reference/master/search-application-api.html
- https://www.elastic.co/guide/en/elasticsearch/reference/master/search-application-client.html
- https://www.elastic.co/guide/en/elasticsearch/reference/master/search-application-security.html
---
 docs/reference/redirects.asciidoc | 70 +++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)

diff --git a/docs/reference/redirects.asciidoc b/docs/reference/redirects.asciidoc
index 8e1023c47b929..4ec8c203bbef9 100644
--- a/docs/reference/redirects.asciidoc
+++ b/docs/reference/redirects.asciidoc
@@ -1932,3 +1932,73 @@ Refer to <<remote-clusters>>.
 === Configure roles and users for remote clusters
 
 Refer to <<remote-clusters>>.
+
+[role="exclude",id="ingest-pipeline-search"]
+=== Ingest pipelines for Search indices
+
+coming::[8.11.0]
+
+[role="exclude",id="ingest-pipeline-search-inference"]
+=== Inference processing for Search indices
+
+coming::[8.11.0]
+
+[id="ingest-pipeline-search-inference-update-mapping"]
+==== Update mapping
+
+coming::[8.11.0]
+
+[role="exclude",id="nlp-example"]
+=== Tutorial: Natural language processing (NLP)
+
+coming::[8.11.0]
+
+[role="exclude",id="behavioral-analytics-overview"]
+=== Elastic Behavioral Analytics
+
+coming::[8.11.0]
+
+[role="exclude",id="behavioral-analytics-start"]
+=== Get started with Behavioral Analytics
+
+coming::[8.11.0]
+
+[role="exclude",id="behavioral-analytics-api"]
+=== Behavioral Analytics APIs
+
+coming::[8.11.0]
+
+[role="exclude",id="behavioral-analytics-event"]
+=== View Behavioral Analytics Events
+
+coming::[8.11.0]
+
+[role="exclude",id="behavioral-analytics-event-reference"]
+=== Behavioral Analytics events reference
+
+coming::[8.11.0]
+
+[role="exclude",id="behavioral-analytics-cors"]
+=== Set up CORS for Behavioral Analytics
+
+coming::[8.11.0]
+
+[role="exclude",id="search-application-overview"]
+=== Elastic Search Applications
+
+coming::[8.11.0]
+
+[role="exclude",id="search-application-api"]
+=== Search Applications search API and templates
+
+coming::[8.11.0]
+
+[role="exclude",id="search-application-client"]
+=== Search Applications client
+
+coming::[8.11.0]
+
+[role="exclude",id="search-application-security"]
+=== Search Applications security
+
+coming::[8.11.0]

From f8d09e9c6cf4b611de3dc7509b0aab6e6a1d5d7a Mon Sep 17 00:00:00 2001
From: Stuart Tettemer <stu@elastic.co>
Date: Thu, 28 Sep 2023 19:35:46 -0500
Subject: [PATCH 24/32] APM Metering API (#99832)

Adds Metering instrument interfaces and adapter implementations for opentelemetry instrument types:
* Gauge - a single number that can go up or down
* Histogram - bucketed samples
* Counter - monotonically increasing summed value
* UpDownCounter - summed value that may decrease

Supports both Long* and Double* versions of the instruments.

Instruments can be registered and retrieved by name through APMMeter which is available via the APMTelemetryProvider.

The metering provider starts as the open telemetry noop provider.

`telemetry.metrics.enabled` turns on metering.
---
 docs/changelog/99832.yaml                     |   5 +
 .../org/elasticsearch/telemetry/apm/APM.java  |   6 +-
 .../apm/internal/APMAgentSettings.java        |  26 +-
 .../apm/internal/APMTelemetryProvider.java    |   8 +
 .../apm/internal/metrics/APMMeter.java        | 180 ++++++++++++++
 .../internal/metrics/AbstractInstrument.java  |  66 +++++
 .../metrics/DoubleCounterAdapter.java         |  52 ++++
 .../internal/metrics/DoubleGaugeAdapter.java  |  42 ++++
 .../metrics/DoubleHistogramAdapter.java       |  42 ++++
 .../metrics/DoubleUpDownCounterAdapter.java   |  46 ++++
 .../apm/internal/metrics/Instruments.java     | 184 ++++++++++++++
 .../internal/metrics/LongCounterAdapter.java  |  49 ++++
 .../internal/metrics/LongGaugeAdapter.java    |  46 ++++
 .../metrics/LongHistogramAdapter.java         |  46 ++++
 .../metrics/LongUpDownCounterAdapter.java     |  42 ++++
 .../apm/internal/metrics/OtelHelper.java      |  36 +++
 .../apm/internal/tracing/APMTracer.java       |   2 +-
 .../plugin-metadata/plugin-security.policy    |   2 +
 .../apm/internal/metrics/APMMeterTests.java   |  85 +++++++
 .../metrics/InstrumentsConcurrencyTests.java  | 112 +++++++++
 .../internal/metrics/InstrumentsTests.java    |  77 ++++++
 server/src/main/java/module-info.java         |   1 +
 .../telemetry/TelemetryProvider.java          |   8 +
 .../telemetry/metric/DoubleCounter.java       |  60 +++++
 .../telemetry/metric/DoubleGauge.java         |  47 ++++
 .../telemetry/metric/DoubleHistogram.java     |  48 ++++
 .../telemetry/metric/DoubleUpDownCounter.java |  50 ++++
 .../telemetry/metric/Instrument.java          |  13 +
 .../telemetry/metric/LongCounter.java         |  60 +++++
 .../telemetry/metric/LongGauge.java           |  49 ++++
 .../telemetry/metric/LongHistogram.java       |  48 ++++
 .../telemetry/metric/LongUpDownCounter.java   |  50 ++++
 .../elasticsearch/telemetry/metric/Meter.java | 228 ++++++++++++++++++
 33 files changed, 1811 insertions(+), 5 deletions(-)
 create mode 100644 docs/changelog/99832.yaml
 create mode 100644 modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/APMMeter.java
 create mode 100644 modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/AbstractInstrument.java
 create mode 100644 modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleCounterAdapter.java
 create mode 100644 modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleGaugeAdapter.java
 create mode 100644 modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleHistogramAdapter.java
 create mode 100644 modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleUpDownCounterAdapter.java
 create mode 100644 modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/Instruments.java
 create mode 100644 modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongCounterAdapter.java
 create mode 100644 modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongGaugeAdapter.java
 create mode 100644 modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongHistogramAdapter.java
 create mode 100644 modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongUpDownCounterAdapter.java
 create mode 100644 modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/OtelHelper.java
 create mode 100644 modules/apm/src/test/java/org/elasticsearch/telemetry/apm/internal/metrics/APMMeterTests.java
 create mode 100644 modules/apm/src/test/java/org/elasticsearch/telemetry/apm/internal/metrics/InstrumentsConcurrencyTests.java
 create mode 100644 modules/apm/src/test/java/org/elasticsearch/telemetry/apm/internal/metrics/InstrumentsTests.java
 create mode 100644 server/src/main/java/org/elasticsearch/telemetry/metric/DoubleCounter.java
 create mode 100644 server/src/main/java/org/elasticsearch/telemetry/metric/DoubleGauge.java
 create mode 100644 server/src/main/java/org/elasticsearch/telemetry/metric/DoubleHistogram.java
 create mode 100644 server/src/main/java/org/elasticsearch/telemetry/metric/DoubleUpDownCounter.java
 create mode 100644 server/src/main/java/org/elasticsearch/telemetry/metric/Instrument.java
 create mode 100644 server/src/main/java/org/elasticsearch/telemetry/metric/LongCounter.java
 create mode 100644 server/src/main/java/org/elasticsearch/telemetry/metric/LongGauge.java
 create mode 100644 server/src/main/java/org/elasticsearch/telemetry/metric/LongHistogram.java
 create mode 100644 server/src/main/java/org/elasticsearch/telemetry/metric/LongUpDownCounter.java
 create mode 100644 server/src/main/java/org/elasticsearch/telemetry/metric/Meter.java

diff --git a/docs/changelog/99832.yaml b/docs/changelog/99832.yaml
new file mode 100644
index 0000000000000..9bd83591ba920
--- /dev/null
+++ b/docs/changelog/99832.yaml
@@ -0,0 +1,5 @@
+pr: 99832
+summary: APM Metering API
+area: Infra/Core
+type: enhancement
+issues: []
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/APM.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/APM.java
index be59eda4a63c2..935c4958ba3d7 100644
--- a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/APM.java
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/APM.java
@@ -27,6 +27,7 @@
 import org.elasticsearch.telemetry.TelemetryProvider;
 import org.elasticsearch.telemetry.apm.internal.APMAgentSettings;
 import org.elasticsearch.telemetry.apm.internal.APMTelemetryProvider;
+import org.elasticsearch.telemetry.apm.internal.metrics.APMMeter;
 import org.elasticsearch.telemetry.apm.internal.tracing.APMTracer;
 import org.elasticsearch.threadpool.ThreadPool;
 import org.elasticsearch.watcher.ResourceWatcherService;
@@ -97,13 +98,16 @@ public Collection<Object> createComponents(
         apmAgentSettings.syncAgentSystemProperties(settings);
         apmAgentSettings.addClusterSettingsListeners(clusterService, telemetryProvider.get());
 
-        return List.of(apmTracer);
+        final APMMeter apmMeter = telemetryProvider.get().getMeter();
+
+        return List.of(apmTracer, apmMeter);
     }
 
     @Override
     public List<Setting<?>> getSettings() {
         return List.of(
             APMAgentSettings.APM_ENABLED_SETTING,
+            APMAgentSettings.TELEMETRY_METRICS_ENABLED_SETTING,
             APMAgentSettings.APM_TRACING_NAMES_INCLUDE_SETTING,
             APMAgentSettings.APM_TRACING_NAMES_EXCLUDE_SETTING,
             APMAgentSettings.APM_TRACING_SANITIZE_FIELD_NAMES,
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/APMAgentSettings.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/APMAgentSettings.java
index 75ca94bb13ad6..e4a194ebe0172 100644
--- a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/APMAgentSettings.java
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/APMAgentSettings.java
@@ -17,6 +17,7 @@
 import org.elasticsearch.common.settings.Setting;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.core.SuppressForbidden;
+import org.elasticsearch.telemetry.apm.internal.metrics.APMMeter;
 import org.elasticsearch.telemetry.apm.internal.tracing.APMTracer;
 
 import java.security.AccessController;
@@ -40,14 +41,24 @@ public class APMAgentSettings {
      * Sensible defaults that Elasticsearch configures. This cannot be done via the APM agent
      * config file, as then their values could not be overridden dynamically via system properties.
      */
-    static Map<String, String> APM_AGENT_DEFAULT_SETTINGS = Map.of("transaction_sample_rate", "0.2");
+    static Map<String, String> APM_AGENT_DEFAULT_SETTINGS = Map.of(
+        "transaction_sample_rate",
+        "0.2",
+        "enable_experimental_instrumentations",
+        "true"
+    );
 
     public void addClusterSettingsListeners(ClusterService clusterService, APMTelemetryProvider apmTelemetryProvider) {
         final ClusterSettings clusterSettings = clusterService.getClusterSettings();
         final APMTracer apmTracer = apmTelemetryProvider.getTracer();
+        final APMMeter apmMeter = apmTelemetryProvider.getMeter();
 
         clusterSettings.addSettingsUpdateConsumer(APM_ENABLED_SETTING, enabled -> {
             apmTracer.setEnabled(enabled);
+            this.setAgentSetting("instrument", Boolean.toString(enabled));
+        });
+        clusterSettings.addSettingsUpdateConsumer(TELEMETRY_METRICS_ENABLED_SETTING, enabled -> {
+            apmMeter.setEnabled(enabled);
             // The agent records data other than spans, e.g. JVM metrics, so we toggle this setting in order to
             // minimise its impact to a running Elasticsearch.
             this.setAgentSetting("recording", Boolean.toString(enabled));
@@ -106,8 +117,10 @@ public void setAgentSetting(String key, String value) {
     private static final List<String> PROHIBITED_AGENT_KEYS = List.of(
         // ES generates a config file and sets this value
         "config_file",
-        // ES controls this via `tracing.apm.enabled`
-        "recording"
+        // ES controls this via `telemetry.metrics.enabled`
+        "recording",
+        // ES controls this via `apm.enabled`
+        "instrument"
     );
 
     public static final Setting.AffixSetting<String> APM_AGENT_SETTINGS = Setting.prefixKeySetting(
@@ -164,6 +177,13 @@ public void setAgentSetting(String key, String value) {
         NodeScope
     );
 
+    public static final Setting<Boolean> TELEMETRY_METRICS_ENABLED_SETTING = Setting.boolSetting(
+        "telemetry.metrics.enabled",
+        false,
+        OperatorDynamic,
+        NodeScope
+    );
+
     public static final Setting<SecureString> APM_SECRET_TOKEN_SETTING = SecureSetting.secureString(
         APM_SETTING_PREFIX + "secret_token",
         null
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/APMTelemetryProvider.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/APMTelemetryProvider.java
index 495afd43bf176..ae9d91cc6ec51 100644
--- a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/APMTelemetryProvider.java
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/APMTelemetryProvider.java
@@ -10,19 +10,27 @@
 
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.telemetry.TelemetryProvider;
+import org.elasticsearch.telemetry.apm.internal.metrics.APMMeter;
 import org.elasticsearch.telemetry.apm.internal.tracing.APMTracer;
 
 public class APMTelemetryProvider implements TelemetryProvider {
     private final Settings settings;
     private final APMTracer apmTracer;
+    private final APMMeter apmMeter;
 
     public APMTelemetryProvider(Settings settings) {
         this.settings = settings;
         apmTracer = new APMTracer(settings);
+        apmMeter = new APMMeter(settings);
     }
 
     @Override
     public APMTracer getTracer() {
         return apmTracer;
     }
+
+    @Override
+    public APMMeter getMeter() {
+        return apmMeter;
+    }
 }
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/APMMeter.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/APMMeter.java
new file mode 100644
index 0000000000000..0a8d425579ca2
--- /dev/null
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/APMMeter.java
@@ -0,0 +1,180 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.apm.internal.metrics;
+
+import io.opentelemetry.api.GlobalOpenTelemetry;
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.api.metrics.Meter;
+
+import org.elasticsearch.cluster.service.ClusterService;
+import org.elasticsearch.common.component.AbstractLifecycleComponent;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.telemetry.apm.internal.APMTelemetryProvider;
+import org.elasticsearch.telemetry.metric.DoubleCounter;
+import org.elasticsearch.telemetry.metric.DoubleGauge;
+import org.elasticsearch.telemetry.metric.DoubleHistogram;
+import org.elasticsearch.telemetry.metric.DoubleUpDownCounter;
+import org.elasticsearch.telemetry.metric.LongCounter;
+import org.elasticsearch.telemetry.metric.LongGauge;
+import org.elasticsearch.telemetry.metric.LongHistogram;
+import org.elasticsearch.telemetry.metric.LongUpDownCounter;
+
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.function.Supplier;
+
+import static org.elasticsearch.telemetry.apm.internal.APMAgentSettings.TELEMETRY_METRICS_ENABLED_SETTING;
+
+public class APMMeter extends AbstractLifecycleComponent implements org.elasticsearch.telemetry.metric.Meter {
+    private final Instruments instruments;
+
+    private final Supplier<Meter> otelMeterSupplier;
+    private final Supplier<Meter> noopMeterSupplier;
+
+    private volatile boolean enabled;
+
+    public APMMeter(Settings settings) {
+        this(settings, APMMeter.otelMeter(), APMMeter.noopMeter());
+    }
+
+    public APMMeter(Settings settings, Supplier<Meter> otelMeterSupplier, Supplier<Meter> noopMeterSupplier) {
+        this.enabled = TELEMETRY_METRICS_ENABLED_SETTING.get(settings);
+        this.otelMeterSupplier = otelMeterSupplier;
+        this.noopMeterSupplier = noopMeterSupplier;
+        this.instruments = new Instruments(enabled ? createOtelMeter() : createNoopMeter());
+    }
+
+    /**
+     * @see org.elasticsearch.telemetry.apm.internal.APMAgentSettings#addClusterSettingsListeners(ClusterService, APMTelemetryProvider)
+     */
+    public void setEnabled(boolean enabled) {
+        this.enabled = enabled;
+        if (enabled) {
+            instruments.setProvider(createOtelMeter());
+        } else {
+            instruments.setProvider(createNoopMeter());
+        }
+    }
+
+    @Override
+    protected void doStart() {}
+
+    @Override
+    protected void doStop() {
+        instruments.setProvider(createNoopMeter());
+    }
+
+    @Override
+    protected void doClose() {}
+
+    @Override
+    public DoubleCounter registerDoubleCounter(String name, String description, String unit) {
+        return instruments.registerDoubleCounter(name, description, unit);
+    }
+
+    @Override
+    public DoubleCounter getDoubleCounter(String name) {
+        return instruments.getDoubleCounter(name);
+    }
+
+    @Override
+    public DoubleUpDownCounter registerDoubleUpDownCounter(String name, String description, String unit) {
+        return instruments.registerDoubleUpDownCounter(name, description, unit);
+    }
+
+    @Override
+    public DoubleUpDownCounter getDoubleUpDownCounter(String name) {
+        return instruments.getDoubleUpDownCounter(name);
+    }
+
+    @Override
+    public DoubleGauge registerDoubleGauge(String name, String description, String unit) {
+        return instruments.registerDoubleGauge(name, description, unit);
+    }
+
+    @Override
+    public DoubleGauge getDoubleGauge(String name) {
+        return instruments.getDoubleGauge(name);
+    }
+
+    @Override
+    public DoubleHistogram registerDoubleHistogram(String name, String description, String unit) {
+        return instruments.registerDoubleHistogram(name, description, unit);
+    }
+
+    @Override
+    public DoubleHistogram getDoubleHistogram(String name) {
+        return instruments.getDoubleHistogram(name);
+    }
+
+    @Override
+    public LongCounter registerLongCounter(String name, String description, String unit) {
+        return instruments.registerLongCounter(name, description, unit);
+    }
+
+    @Override
+    public LongCounter getLongCounter(String name) {
+        return instruments.getLongCounter(name);
+    }
+
+    @Override
+    public LongUpDownCounter registerLongUpDownCounter(String name, String description, String unit) {
+        return instruments.registerLongUpDownCounter(name, description, unit);
+    }
+
+    @Override
+    public LongUpDownCounter getLongUpDownCounter(String name) {
+        return instruments.getLongUpDownCounter(name);
+    }
+
+    @Override
+    public LongGauge registerLongGauge(String name, String description, String unit) {
+        return instruments.registerLongGauge(name, description, unit);
+    }
+
+    @Override
+    public LongGauge getLongGauge(String name) {
+        return instruments.getLongGauge(name);
+    }
+
+    @Override
+    public LongHistogram registerLongHistogram(String name, String description, String unit) {
+        return instruments.registerLongHistogram(name, description, unit);
+    }
+
+    @Override
+    public LongHistogram getLongHistogram(String name) {
+        return instruments.getLongHistogram(name);
+    }
+
+    Meter createOtelMeter() {
+        assert this.enabled;
+        return AccessController.doPrivileged((PrivilegedAction<Meter>) otelMeterSupplier::get);
+    }
+
+    private Meter createNoopMeter() {
+        return noopMeterSupplier.get();
+    }
+
+    private static Supplier<Meter> noopMeter() {
+        return () -> OpenTelemetry.noop().getMeter("noop");
+    }
+
+    // to be used within doPrivileged block
+    private static Supplier<Meter> otelMeter() {
+        var openTelemetry = GlobalOpenTelemetry.get();
+        var meter = openTelemetry.getMeter("elasticsearch");
+        return () -> meter;
+    }
+
+    // scope for testing
+    Instruments getInstruments() {
+        return instruments;
+    }
+}
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/AbstractInstrument.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/AbstractInstrument.java
new file mode 100644
index 0000000000000..d3d485f52bc49
--- /dev/null
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/AbstractInstrument.java
@@ -0,0 +1,66 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.apm.internal.metrics;
+
+import io.opentelemetry.api.metrics.Meter;
+
+import org.elasticsearch.core.Nullable;
+import org.elasticsearch.telemetry.metric.Instrument;
+
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * An instrument that contains the name, description and unit.  The delegate may be replaced when
+ * the provider is updated.
+ * Subclasses should implement the builder, which is used on initialization and provider updates.
+ * @param <T> delegated instrument
+ */
+public abstract class AbstractInstrument<T> implements Instrument {
+    private final AtomicReference<T> delegate;
+    private final String name;
+    private final String description;
+    private final String unit;
+
+    public AbstractInstrument(Meter meter, String name, String description, String unit) {
+        this.name = Objects.requireNonNull(name);
+        this.description = Objects.requireNonNull(description);
+        this.unit = Objects.requireNonNull(unit);
+        this.delegate = new AtomicReference<>(doBuildInstrument(meter));
+    }
+
+    private T doBuildInstrument(Meter meter) {
+        return AccessController.doPrivileged((PrivilegedAction<T>) () -> buildInstrument(meter));
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    public String getUnit() {
+        return unit.toString();
+    }
+
+    T getInstrument() {
+        return delegate.get();
+    }
+
+    String getDescription() {
+        return description;
+    }
+
+    void setProvider(@Nullable Meter meter) {
+        delegate.set(doBuildInstrument(Objects.requireNonNull(meter)));
+    }
+
+    abstract T buildInstrument(Meter meter);
+}
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleCounterAdapter.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleCounterAdapter.java
new file mode 100644
index 0000000000000..b25ffdff5481b
--- /dev/null
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleCounterAdapter.java
@@ -0,0 +1,52 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.apm.internal.metrics;
+
+import io.opentelemetry.api.metrics.Meter;
+
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * DoubleGaugeAdapter wraps an otel ObservableDoubleMeasurement
+ */
+public class DoubleCounterAdapter extends AbstractInstrument<io.opentelemetry.api.metrics.DoubleCounter>
+    implements
+        org.elasticsearch.telemetry.metric.DoubleCounter {
+
+    public DoubleCounterAdapter(Meter meter, String name, String description, String unit) {
+        super(meter, name, description, unit);
+    }
+
+    io.opentelemetry.api.metrics.DoubleCounter buildInstrument(Meter meter) {
+        return Objects.requireNonNull(meter)
+            .counterBuilder(getName())
+            .ofDoubles()
+            .setDescription(getDescription())
+            .setUnit(getUnit())
+            .build();
+    }
+
+    @Override
+    public void increment() {
+        getInstrument().add(1d);
+    }
+
+    @Override
+    public void incrementBy(double inc) {
+        assert inc >= 0;
+        getInstrument().add(inc);
+    }
+
+    @Override
+    public void incrementBy(double inc, Map<String, Object> attributes) {
+        assert inc >= 0;
+        getInstrument().add(inc, OtelHelper.fromMap(attributes));
+    }
+}
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleGaugeAdapter.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleGaugeAdapter.java
new file mode 100644
index 0000000000000..9d55d475d4a93
--- /dev/null
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleGaugeAdapter.java
@@ -0,0 +1,42 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.apm.internal.metrics;
+
+import io.opentelemetry.api.metrics.Meter;
+
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * DoubleGaugeAdapter wraps an otel ObservableDoubleMeasurement
+ */
+public class DoubleGaugeAdapter extends AbstractInstrument<io.opentelemetry.api.metrics.ObservableDoubleMeasurement>
+    implements
+        org.elasticsearch.telemetry.metric.DoubleGauge {
+
+    public DoubleGaugeAdapter(Meter meter, String name, String description, String unit) {
+        super(meter, name, description, unit);
+    }
+
+    @Override
+    io.opentelemetry.api.metrics.ObservableDoubleMeasurement buildInstrument(Meter meter) {
+        var builder = Objects.requireNonNull(meter).gaugeBuilder(getName());
+        return builder.setDescription(getDescription()).setUnit(getUnit()).buildObserver();
+    }
+
+    @Override
+    public void record(double value) {
+        getInstrument().record(value);
+    }
+
+    @Override
+    public void record(double value, Map<String, Object> attributes) {
+        getInstrument().record(value, OtelHelper.fromMap(attributes));
+    }
+}
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleHistogramAdapter.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleHistogramAdapter.java
new file mode 100644
index 0000000000000..5fd1a8a189b0f
--- /dev/null
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleHistogramAdapter.java
@@ -0,0 +1,42 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.apm.internal.metrics;
+
+import io.opentelemetry.api.metrics.Meter;
+
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * DoubleHistogramAdapter wraps an otel DoubleHistogram
+ */
+public class DoubleHistogramAdapter extends AbstractInstrument<io.opentelemetry.api.metrics.DoubleHistogram>
+    implements
+        org.elasticsearch.telemetry.metric.DoubleHistogram {
+
+    public DoubleHistogramAdapter(Meter meter, String name, String description, String unit) {
+        super(meter, name, description, unit);
+    }
+
+    @Override
+    io.opentelemetry.api.metrics.DoubleHistogram buildInstrument(Meter meter) {
+        var builder = Objects.requireNonNull(meter).histogramBuilder(getName());
+        return builder.setDescription(getDescription()).setUnit(getUnit()).build();
+    }
+
+    @Override
+    public void record(double value) {
+        getInstrument().record(value);
+    }
+
+    @Override
+    public void record(double value, Map<String, Object> attributes) {
+        getInstrument().record(value, OtelHelper.fromMap(attributes));
+    }
+}
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleUpDownCounterAdapter.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleUpDownCounterAdapter.java
new file mode 100644
index 0000000000000..9a2fc1b564766
--- /dev/null
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/DoubleUpDownCounterAdapter.java
@@ -0,0 +1,46 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.apm.internal.metrics;
+
+import io.opentelemetry.api.metrics.Meter;
+
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * DoubleUpDownCounterAdapter wraps an otel DoubleUpDownCounter
+ */
+public class DoubleUpDownCounterAdapter extends AbstractInstrument<io.opentelemetry.api.metrics.DoubleUpDownCounter>
+    implements
+        org.elasticsearch.telemetry.metric.DoubleUpDownCounter {
+
+    public DoubleUpDownCounterAdapter(Meter meter, String name, String description, String unit) {
+        super(meter, name, description, unit);
+    }
+
+    @Override
+    io.opentelemetry.api.metrics.DoubleUpDownCounter buildInstrument(Meter meter) {
+        return Objects.requireNonNull(meter)
+            .upDownCounterBuilder(getName())
+            .ofDoubles()
+            .setDescription(getDescription())
+            .setUnit(getUnit())
+            .build();
+    }
+
+    @Override
+    public void add(double inc) {
+        getInstrument().add(inc);
+    }
+
+    @Override
+    public void add(double inc, Map<String, Object> attributes) {
+        getInstrument().add(inc, OtelHelper.fromMap(attributes));
+    }
+}
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/Instruments.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/Instruments.java
new file mode 100644
index 0000000000000..92d7d692f0ea5
--- /dev/null
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/Instruments.java
@@ -0,0 +1,184 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.apm.internal.metrics;
+
+import io.opentelemetry.api.metrics.Meter;
+
+import org.elasticsearch.common.util.concurrent.ConcurrentCollections;
+import org.elasticsearch.common.util.concurrent.ReleasableLock;
+import org.elasticsearch.telemetry.metric.DoubleCounter;
+import org.elasticsearch.telemetry.metric.DoubleGauge;
+import org.elasticsearch.telemetry.metric.DoubleHistogram;
+import org.elasticsearch.telemetry.metric.DoubleUpDownCounter;
+import org.elasticsearch.telemetry.metric.LongCounter;
+import org.elasticsearch.telemetry.metric.LongGauge;
+import org.elasticsearch.telemetry.metric.LongHistogram;
+import org.elasticsearch.telemetry.metric.LongUpDownCounter;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * Container for registering and fetching instruments by type and name.
+ * Instrument names must be unique for a given type on registration.
+ * {@link #setProvider(Meter)} is used to change the provider for all existing instruments.
+ */
+public class Instruments {
+    private final Registrar<DoubleCounterAdapter> doubleCounters = new Registrar<>();
+    private final Registrar<DoubleUpDownCounterAdapter> doubleUpDownCounters = new Registrar<>();
+    private final Registrar<DoubleGaugeAdapter> doubleGauges = new Registrar<>();
+    private final Registrar<DoubleHistogramAdapter> doubleHistograms = new Registrar<>();
+    private final Registrar<LongCounterAdapter> longCounters = new Registrar<>();
+    private final Registrar<LongUpDownCounterAdapter> longUpDownCounters = new Registrar<>();
+    private final Registrar<LongGaugeAdapter> longGauges = new Registrar<>();
+    private final Registrar<LongHistogramAdapter> longHistograms = new Registrar<>();
+
+    private final Meter meter;
+
+    public Instruments(Meter meter) {
+        this.meter = meter;
+    }
+
+    private final List<Registrar<?>> registrars = List.of(
+        doubleCounters,
+        doubleUpDownCounters,
+        doubleGauges,
+        doubleHistograms,
+        longCounters,
+        longUpDownCounters,
+        longGauges,
+        longHistograms
+    );
+
+    // Access to registration has to be restricted when the provider is updated in ::setProvider
+    protected final ReleasableLock registerLock = new ReleasableLock(new ReentrantLock());
+
+    public <T> DoubleCounter registerDoubleCounter(String name, String description, String unit) {
+        try (ReleasableLock lock = registerLock.acquire()) {
+            return doubleCounters.register(new DoubleCounterAdapter(meter, name, description, unit));
+        }
+    }
+
+    public DoubleCounter getDoubleCounter(String name) {
+        return doubleCounters.get(name);
+    }
+
+    public <T> DoubleUpDownCounter registerDoubleUpDownCounter(String name, String description, String unit) {
+        try (ReleasableLock lock = registerLock.acquire()) {
+            return doubleUpDownCounters.register(new DoubleUpDownCounterAdapter(meter, name, description, unit));
+        }
+    }
+
+    public DoubleUpDownCounter getDoubleUpDownCounter(String name) {
+        return doubleUpDownCounters.get(name);
+    }
+
+    public <T> DoubleGauge registerDoubleGauge(String name, String description, String unit) {
+        try (ReleasableLock lock = registerLock.acquire()) {
+            return doubleGauges.register(new DoubleGaugeAdapter(meter, name, description, unit));
+        }
+    }
+
+    public DoubleGauge getDoubleGauge(String name) {
+        return doubleGauges.get(name);
+    }
+
+    public <T> DoubleHistogram registerDoubleHistogram(String name, String description, String unit) {
+        try (ReleasableLock lock = registerLock.acquire()) {
+            return doubleHistograms.register(new DoubleHistogramAdapter(meter, name, description, unit));
+        }
+    }
+
+    public DoubleHistogram getDoubleHistogram(String name) {
+        return doubleHistograms.get(name);
+    }
+
+    public <T> LongCounter registerLongCounter(String name, String description, String unit) {
+        try (ReleasableLock lock = registerLock.acquire()) {
+            return longCounters.register(new LongCounterAdapter(meter, name, description, unit));
+        }
+    }
+
+    public LongCounter getLongCounter(String name) {
+        return longCounters.get(name);
+    }
+
+    public <T> LongUpDownCounter registerLongUpDownCounter(String name, String description, String unit) {
+        try (ReleasableLock lock = registerLock.acquire()) {
+            return longUpDownCounters.register(new LongUpDownCounterAdapter(meter, name, description, unit));
+        }
+    }
+
+    public LongUpDownCounter getLongUpDownCounter(String name) {
+        return longUpDownCounters.get(name);
+    }
+
+    public <T> LongGauge registerLongGauge(String name, String description, String unit) {
+        try (ReleasableLock lock = registerLock.acquire()) {
+            return longGauges.register(new LongGaugeAdapter(meter, name, description, unit));
+        }
+    }
+
+    public LongGauge getLongGauge(String name) {
+        return longGauges.get(name);
+    }
+
+    public <T> LongHistogram registerLongHistogram(String name, String description, String unit) {
+        try (ReleasableLock lock = registerLock.acquire()) {
+            return longHistograms.register(new LongHistogramAdapter(meter, name, description, unit));
+        }
+    }
+
+    public LongHistogram getLongHistogram(String name) {
+        return longHistograms.get(name);
+    }
+
+    public void setProvider(Meter meter) {
+        try (ReleasableLock lock = registerLock.acquire()) {
+            for (Registrar<?> registrar : registrars) {
+                registrar.setProvider(meter);
+            }
+        }
+    }
+
+    /**
+     * A typed wrapper for a instrument that
+     * @param <T>
+     */
+    private static class Registrar<T extends AbstractInstrument<?>> {
+        private final Map<String, T> registered = ConcurrentCollections.newConcurrentMap();
+
+        T register(T instrument) {
+            registered.compute(instrument.getName(), (k, v) -> {
+                if (v != null) {
+                    throw new IllegalStateException(
+                        instrument.getClass().getSimpleName() + "[" + instrument.getName() + "] already registered"
+                    );
+                }
+
+                return instrument;
+            });
+            return instrument;
+        }
+
+        T get(String name) {
+            return registered.get(name);
+        }
+
+        void setProvider(Meter meter) {
+            registered.forEach((k, v) -> v.setProvider(meter));
+        }
+    }
+
+    // scope for testing
+    Meter getMeter() {
+        return meter;
+    }
+}
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongCounterAdapter.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongCounterAdapter.java
new file mode 100644
index 0000000000000..122d16d9e1aa4
--- /dev/null
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongCounterAdapter.java
@@ -0,0 +1,49 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.apm.internal.metrics;
+
+import io.opentelemetry.api.metrics.Meter;
+
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * LongCounterAdapter wraps an otel LongCounter
+ */
+public class LongCounterAdapter extends AbstractInstrument<io.opentelemetry.api.metrics.LongCounter>
+    implements
+        org.elasticsearch.telemetry.metric.LongCounter {
+
+    public LongCounterAdapter(Meter meter, String name, String description, String unit) {
+        super(meter, name, description, unit);
+    }
+
+    @Override
+    io.opentelemetry.api.metrics.LongCounter buildInstrument(Meter meter) {
+        var builder = Objects.requireNonNull(meter).counterBuilder(getName());
+        return builder.setDescription(getDescription()).setUnit(getUnit()).build();
+    }
+
+    @Override
+    public void increment() {
+        getInstrument().add(1L);
+    }
+
+    @Override
+    public void incrementBy(long inc) {
+        assert inc >= 0;
+        getInstrument().add(inc);
+    }
+
+    @Override
+    public void incrementBy(long inc, Map<String, Object> attributes) {
+        assert inc >= 0;
+        getInstrument().add(inc, OtelHelper.fromMap(attributes));
+    }
+}
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongGaugeAdapter.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongGaugeAdapter.java
new file mode 100644
index 0000000000000..48430285a5173
--- /dev/null
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongGaugeAdapter.java
@@ -0,0 +1,46 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.apm.internal.metrics;
+
+import io.opentelemetry.api.metrics.Meter;
+
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * LongGaugeAdapter wraps an otel ObservableLongMeasurement
+ */
+public class LongGaugeAdapter extends AbstractInstrument<io.opentelemetry.api.metrics.ObservableLongMeasurement>
+    implements
+        org.elasticsearch.telemetry.metric.LongGauge {
+
+    public LongGaugeAdapter(Meter meter, String name, String description, String unit) {
+        super(meter, name, description, unit);
+    }
+
+    @Override
+    io.opentelemetry.api.metrics.ObservableLongMeasurement buildInstrument(Meter meter) {
+        return Objects.requireNonNull(meter)
+            .gaugeBuilder(getName())
+            .ofLongs()
+            .setDescription(getDescription())
+            .setUnit(getUnit())
+            .buildObserver();
+    }
+
+    @Override
+    public void record(long value) {
+        getInstrument().record(value);
+    }
+
+    @Override
+    public void record(long value, Map<String, Object> attributes) {
+        getInstrument().record(value, OtelHelper.fromMap(attributes));
+    }
+}
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongHistogramAdapter.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongHistogramAdapter.java
new file mode 100644
index 0000000000000..bb5be4866e7b7
--- /dev/null
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongHistogramAdapter.java
@@ -0,0 +1,46 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.apm.internal.metrics;
+
+import io.opentelemetry.api.metrics.Meter;
+
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * LongHistogramAdapter wraps an otel LongHistogram
+ */
+public class LongHistogramAdapter extends AbstractInstrument<io.opentelemetry.api.metrics.LongHistogram>
+    implements
+        org.elasticsearch.telemetry.metric.LongHistogram {
+
+    public LongHistogramAdapter(Meter meter, String name, String description, String unit) {
+        super(meter, name, description, unit);
+    }
+
+    @Override
+    io.opentelemetry.api.metrics.LongHistogram buildInstrument(Meter meter) {
+        return Objects.requireNonNull(meter)
+            .histogramBuilder(getName())
+            .ofLongs()
+            .setDescription(getDescription())
+            .setUnit(getUnit())
+            .build();
+    }
+
+    @Override
+    public void record(long value) {
+        getInstrument().record(value);
+    }
+
+    @Override
+    public void record(long value, Map<String, Object> attributes) {
+        getInstrument().record(value, OtelHelper.fromMap(attributes));
+    }
+}
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongUpDownCounterAdapter.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongUpDownCounterAdapter.java
new file mode 100644
index 0000000000000..e5af85e4ed192
--- /dev/null
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/LongUpDownCounterAdapter.java
@@ -0,0 +1,42 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.apm.internal.metrics;
+
+import io.opentelemetry.api.metrics.Meter;
+
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * LongUpDownCounterAdapter wraps an otel LongUpDownCounter
+ */
+public class LongUpDownCounterAdapter extends AbstractInstrument<io.opentelemetry.api.metrics.LongUpDownCounter>
+    implements
+        org.elasticsearch.telemetry.metric.LongUpDownCounter {
+
+    public LongUpDownCounterAdapter(Meter meter, String name, String description, String unit) {
+        super(meter, name, description, unit);
+    }
+
+    @Override
+    io.opentelemetry.api.metrics.LongUpDownCounter buildInstrument(Meter meter) {
+        var builder = Objects.requireNonNull(meter).upDownCounterBuilder(getName());
+        return builder.setDescription(getDescription()).setUnit(getUnit()).build();
+    }
+
+    @Override
+    public void add(long inc) {
+        getInstrument().add(inc);
+    }
+
+    @Override
+    public void add(long inc, Map<String, Object> attributes) {
+        getInstrument().add(inc, OtelHelper.fromMap(attributes));
+    }
+}
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/OtelHelper.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/OtelHelper.java
new file mode 100644
index 0000000000000..673025a1a41f4
--- /dev/null
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/metrics/OtelHelper.java
@@ -0,0 +1,36 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.apm.internal.metrics;
+
+import io.opentelemetry.api.common.Attributes;
+
+import java.util.Map;
+
+class OtelHelper {
+    static Attributes fromMap(Map<String, Object> attributes) {
+        if (attributes == null || attributes.isEmpty()) {
+            return Attributes.empty();
+        }
+        var builder = Attributes.builder();
+        attributes.forEach((k, v) -> {
+            if (v instanceof String value) {
+                builder.put(k, value);
+            } else if (v instanceof Long value) {
+                builder.put(k, value);
+            } else if (v instanceof Double value) {
+                builder.put(k, value);
+            } else if (v instanceof Boolean value) {
+                builder.put(k, value);
+            } else {
+                throw new IllegalArgumentException("attributes do not support value type of [" + v.getClass().getCanonicalName() + "]");
+            }
+        });
+        return builder.build();
+    }
+}
diff --git a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/tracing/APMTracer.java b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/tracing/APMTracer.java
index daedb90047975..9f9fdb3dc26ef 100644
--- a/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/tracing/APMTracer.java
+++ b/modules/apm/src/main/java/org/elasticsearch/telemetry/apm/internal/tracing/APMTracer.java
@@ -150,7 +150,6 @@ APMServices createApmServices() {
         return AccessController.doPrivileged((PrivilegedAction<APMServices>) () -> {
             var openTelemetry = GlobalOpenTelemetry.get();
             var tracer = openTelemetry.getTracer("elasticsearch", Version.CURRENT.toString());
-
             return new APMServices(tracer, openTelemetry);
         });
     }
@@ -452,4 +451,5 @@ private static Automaton patternsToAutomaton(List<String> patterns) {
         }
         return Operations.union(automata);
     }
+
 }
diff --git a/modules/apm/src/main/plugin-metadata/plugin-security.policy b/modules/apm/src/main/plugin-metadata/plugin-security.policy
index b85d3ec05c277..57da3a2efd301 100644
--- a/modules/apm/src/main/plugin-metadata/plugin-security.policy
+++ b/modules/apm/src/main/plugin-metadata/plugin-security.policy
@@ -11,6 +11,8 @@ grant {
     permission java.lang.RuntimePermission "createClassLoader";
     permission java.lang.RuntimePermission "getClassLoader";
     permission java.util.PropertyPermission "elastic.apm.*", "write";
+    permission java.util.PropertyPermission "*", "read,write";
+    permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
 };
 
 grant codeBase "${codebase.elastic-apm-agent}" {
diff --git a/modules/apm/src/test/java/org/elasticsearch/telemetry/apm/internal/metrics/APMMeterTests.java b/modules/apm/src/test/java/org/elasticsearch/telemetry/apm/internal/metrics/APMMeterTests.java
new file mode 100644
index 0000000000000..1064b8820b089
--- /dev/null
+++ b/modules/apm/src/test/java/org/elasticsearch/telemetry/apm/internal/metrics/APMMeterTests.java
@@ -0,0 +1,85 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.apm.internal.metrics;
+
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.api.metrics.Meter;
+
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.telemetry.apm.internal.APMAgentSettings;
+import org.elasticsearch.telemetry.metric.DoubleCounter;
+import org.elasticsearch.test.ESTestCase;
+
+import static org.hamcrest.Matchers.sameInstance;
+
+public class APMMeterTests extends ESTestCase {
+    Meter testOtel = OpenTelemetry.noop().getMeter("test");
+
+    Meter noopOtel = OpenTelemetry.noop().getMeter("noop");
+
+    public void testMeterIsSetUponConstruction() {
+        // test default
+        APMMeter apmMeter = new APMMeter(Settings.EMPTY, () -> testOtel, () -> noopOtel);
+
+        Meter meter = apmMeter.getInstruments().getMeter();
+        assertThat(meter, sameInstance(noopOtel));
+
+        // test explicitly enabled
+        var settings = Settings.builder().put(APMAgentSettings.TELEMETRY_METRICS_ENABLED_SETTING.getKey(), true).build();
+        apmMeter = new APMMeter(settings, () -> testOtel, () -> noopOtel);
+
+        meter = apmMeter.getInstruments().getMeter();
+        assertThat(meter, sameInstance(testOtel));
+
+        // test explicitly disabled
+        settings = Settings.builder().put(APMAgentSettings.TELEMETRY_METRICS_ENABLED_SETTING.getKey(), true).build();
+        apmMeter = new APMMeter(settings, () -> testOtel, () -> noopOtel);
+
+        meter = apmMeter.getInstruments().getMeter();
+        assertThat(meter, sameInstance(noopOtel));
+    }
+
+    public void testMeterIsOverridden() {
+        APMMeter apmMeter = new APMMeter(Settings.EMPTY, () -> testOtel, () -> noopOtel);
+
+        Meter meter = apmMeter.getInstruments().getMeter();
+        assertThat(meter, sameInstance(noopOtel));
+
+        apmMeter.setEnabled(true);
+
+        meter = apmMeter.getInstruments().getMeter();
+        assertThat(meter, sameInstance(testOtel));
+    }
+
+    public void testLookupByName() {
+        var settings = Settings.builder().put(APMAgentSettings.TELEMETRY_METRICS_ENABLED_SETTING.getKey(), true).build();
+
+        var apmMeter = new APMMeter(settings, () -> testOtel, () -> noopOtel);
+
+        DoubleCounter registeredCounter = apmMeter.registerDoubleCounter("name", "desc", "unit");
+        DoubleCounter lookedUpCounter = apmMeter.getDoubleCounter("name");
+
+        assertThat(lookedUpCounter, sameInstance(registeredCounter));
+    }
+
+    public void testNoopIsSetOnStop() {
+        var settings = Settings.builder().put(APMAgentSettings.TELEMETRY_METRICS_ENABLED_SETTING.getKey(), true).build();
+        APMMeter apmMeter = new APMMeter(settings, () -> testOtel, () -> noopOtel);
+        apmMeter.start();
+
+        Meter meter = apmMeter.getInstruments().getMeter();
+        assertThat(meter, sameInstance(testOtel));
+
+        apmMeter.stop();
+
+        meter = apmMeter.getInstruments().getMeter();
+        assertThat(meter, sameInstance(noopOtel));
+    }
+
+}
diff --git a/modules/apm/src/test/java/org/elasticsearch/telemetry/apm/internal/metrics/InstrumentsConcurrencyTests.java b/modules/apm/src/test/java/org/elasticsearch/telemetry/apm/internal/metrics/InstrumentsConcurrencyTests.java
new file mode 100644
index 0000000000000..51285894f27ee
--- /dev/null
+++ b/modules/apm/src/test/java/org/elasticsearch/telemetry/apm/internal/metrics/InstrumentsConcurrencyTests.java
@@ -0,0 +1,112 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.apm.internal.metrics;
+
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.api.metrics.DoubleCounterBuilder;
+import io.opentelemetry.api.metrics.DoubleGaugeBuilder;
+import io.opentelemetry.api.metrics.DoubleHistogramBuilder;
+import io.opentelemetry.api.metrics.LongCounter;
+import io.opentelemetry.api.metrics.LongCounterBuilder;
+import io.opentelemetry.api.metrics.LongUpDownCounterBuilder;
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.api.metrics.ObservableLongCounter;
+import io.opentelemetry.api.metrics.ObservableLongMeasurement;
+
+import org.elasticsearch.test.ESTestCase;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.function.Consumer;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.sameInstance;
+
+public class InstrumentsConcurrencyTests extends ESTestCase {
+    String name = "name";
+    String description = "desc";
+    String unit = "kg";
+    Meter noopMeter = OpenTelemetry.noop().getMeter("noop");
+    CountDownLatch registerLatch = new CountDownLatch(1);
+    Meter lockingMeter = new Meter() {
+        @Override
+        public LongCounterBuilder counterBuilder(String name) {
+            return new LockingLongCounterBuilder();
+        }
+
+        @Override
+        public LongUpDownCounterBuilder upDownCounterBuilder(String name) {
+            return null;
+        }
+
+        @Override
+        public DoubleHistogramBuilder histogramBuilder(String name) {
+            return null;
+        }
+
+        @Override
+        public DoubleGaugeBuilder gaugeBuilder(String name) {
+            return null;
+        }
+    };
+
+    class LockingLongCounterBuilder implements LongCounterBuilder {
+
+        @Override
+        public LongCounterBuilder setDescription(String description) {
+            return this;
+        }
+
+        @Override
+        public LongCounterBuilder setUnit(String unit) {
+            return this;
+        }
+
+        @Override
+        public DoubleCounterBuilder ofDoubles() {
+            return null;
+        }
+
+        @Override
+        public LongCounter build() {
+            try {
+                registerLatch.await();
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+            return null;
+        }
+
+        @Override
+        public ObservableLongCounter buildWithCallback(Consumer<ObservableLongMeasurement> callback) {
+            return null;
+        }
+    }
+
+    public void testLockingWhenRegistering() throws Exception {
+        Instruments instruments = new Instruments(lockingMeter);
+
+        var registerThread = new Thread(() -> instruments.registerLongCounter(name, description, unit));
+        // registerThread has a countDown latch that is simulating a long-running registration
+        registerThread.start();
+        var setProviderThread = new Thread(() -> instruments.setProvider(noopMeter));
+        // a setProviderThread will attempt to override a meter, but will wait to acquireLock
+        setProviderThread.start();
+
+        // assert that a thread is waiting for a lock during long-running registration
+        assertBusy(() -> assertThat(setProviderThread.getState(), equalTo(Thread.State.WAITING)));
+        // assert that the old lockingMeter is still in place
+        assertBusy(() -> assertThat(instruments.getMeter(), sameInstance(lockingMeter)));
+
+        // finish long-running registration
+        registerLatch.countDown();
+        // assert that a meter was overriden
+        assertBusy(() -> assertThat(instruments.getMeter(), sameInstance(lockingMeter)));
+
+    }
+}
diff --git a/modules/apm/src/test/java/org/elasticsearch/telemetry/apm/internal/metrics/InstrumentsTests.java b/modules/apm/src/test/java/org/elasticsearch/telemetry/apm/internal/metrics/InstrumentsTests.java
new file mode 100644
index 0000000000000..daf511fcf7042
--- /dev/null
+++ b/modules/apm/src/test/java/org/elasticsearch/telemetry/apm/internal/metrics/InstrumentsTests.java
@@ -0,0 +1,77 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.apm.internal.metrics;
+
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.api.metrics.Meter;
+
+import org.elasticsearch.test.ESTestCase;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.sameInstance;
+
+public class InstrumentsTests extends ESTestCase {
+    Meter noopMeter = OpenTelemetry.noop().getMeter("noop");
+    Meter someOtherMeter = OpenTelemetry.noop().getMeter("xyz");
+    String name = "name";
+    String description = "desc";
+    String unit = "kg";
+
+    public void testRegistrationAndLookup() {
+        Instruments instruments = new Instruments(noopMeter);
+        {
+            var registered = instruments.registerDoubleCounter(name, description, unit);
+            var lookedUp = instruments.getDoubleCounter(name);
+            assertThat(registered, sameInstance(lookedUp));
+        }
+        {
+            var registered = instruments.registerDoubleUpDownCounter(name, description, unit);
+            var lookedUp = instruments.getDoubleUpDownCounter(name);
+            assertThat(registered, sameInstance(lookedUp));
+        }
+        {
+            var registered = instruments.registerDoubleGauge(name, description, unit);
+            var lookedUp = instruments.getDoubleGauge(name);
+            assertThat(registered, sameInstance(lookedUp));
+        }
+        {
+            var registered = instruments.registerDoubleHistogram(name, description, unit);
+            var lookedUp = instruments.getDoubleHistogram(name);
+            assertThat(registered, sameInstance(lookedUp));
+        }
+        {
+            var registered = instruments.registerLongCounter(name, description, unit);
+            var lookedUp = instruments.getLongCounter(name);
+            assertThat(registered, sameInstance(lookedUp));
+        }
+        {
+            var registered = instruments.registerLongUpDownCounter(name, description, unit);
+            var lookedUp = instruments.getLongUpDownCounter(name);
+            assertThat(registered, sameInstance(lookedUp));
+        }
+        {
+            var registered = instruments.registerLongGauge(name, description, unit);
+            var lookedUp = instruments.getLongGauge(name);
+            assertThat(registered, sameInstance(lookedUp));
+        }
+        {
+            var registered = instruments.registerLongHistogram(name, description, unit);
+            var lookedUp = instruments.getLongHistogram(name);
+            assertThat(registered, sameInstance(lookedUp));
+        }
+    }
+
+    public void testNameValidation() {
+        Instruments instruments = new Instruments(noopMeter);
+
+        instruments.registerLongHistogram(name, description, unit);
+        var e = expectThrows(IllegalStateException.class, () -> instruments.registerLongHistogram(name, description, unit));
+        assertThat(e.getMessage(), equalTo("LongHistogramAdapter[name] already registered"));
+    }
+}
diff --git a/server/src/main/java/module-info.java b/server/src/main/java/module-info.java
index 99ce5910c9775..1a082e7558577 100644
--- a/server/src/main/java/module-info.java
+++ b/server/src/main/java/module-info.java
@@ -385,6 +385,7 @@
             org.elasticsearch.serverless.apifiltering;
     exports org.elasticsearch.telemetry.tracing;
     exports org.elasticsearch.telemetry;
+    exports org.elasticsearch.telemetry.metric;
 
     provides java.util.spi.CalendarDataProvider with org.elasticsearch.common.time.IsoCalendarDataProvider;
     provides org.elasticsearch.xcontent.ErrorOnUnknown with org.elasticsearch.common.xcontent.SuggestingErrorOnUnknown;
diff --git a/server/src/main/java/org/elasticsearch/telemetry/TelemetryProvider.java b/server/src/main/java/org/elasticsearch/telemetry/TelemetryProvider.java
index 0df8aeedac7f8..add994787227f 100644
--- a/server/src/main/java/org/elasticsearch/telemetry/TelemetryProvider.java
+++ b/server/src/main/java/org/elasticsearch/telemetry/TelemetryProvider.java
@@ -8,11 +8,15 @@
 
 package org.elasticsearch.telemetry;
 
+import org.elasticsearch.telemetry.metric.Meter;
 import org.elasticsearch.telemetry.tracing.Tracer;
 
 public interface TelemetryProvider {
+
     Tracer getTracer();
 
+    Meter getMeter();
+
     TelemetryProvider NOOP = new TelemetryProvider() {
 
         @Override
@@ -20,5 +24,9 @@ public Tracer getTracer() {
             return Tracer.NOOP;
         }
 
+        @Override
+        public Meter getMeter() {
+            return Meter.NOOP;
+        }
     };
 }
diff --git a/server/src/main/java/org/elasticsearch/telemetry/metric/DoubleCounter.java b/server/src/main/java/org/elasticsearch/telemetry/metric/DoubleCounter.java
new file mode 100644
index 0000000000000..c98701bb0a1bb
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/telemetry/metric/DoubleCounter.java
@@ -0,0 +1,60 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.metric;
+
+import java.util.Map;
+
+/**
+ * A monotonically increasing metric that uses a double.
+ * Useful for capturing the number of bytes received, number of requests, etc.
+ */
+public interface DoubleCounter extends Instrument {
+    /**
+     * Add one to the current counter.
+     */
+    void increment();
+
+    /**
+     * Increment the counter.
+     * @param inc amount to increment, non-negative
+     */
+    void incrementBy(double inc);
+
+    /**
+     * Increment the counter.
+     * @param inc amount to increment, non-negative
+     * @param attributes key-value pairs to associate with this increment
+     */
+    void incrementBy(double inc, Map<String, Object> attributes);
+
+    /**
+     * Noop counter for use in tests.
+     */
+    DoubleCounter NOOP = new DoubleCounter() {
+        @Override
+        public String getName() {
+            return "noop";
+        }
+
+        @Override
+        public void increment() {
+
+        }
+
+        @Override
+        public void incrementBy(double inc) {
+
+        }
+
+        @Override
+        public void incrementBy(double inc, Map<String, Object> attributes) {
+
+        }
+    };
+}
diff --git a/server/src/main/java/org/elasticsearch/telemetry/metric/DoubleGauge.java b/server/src/main/java/org/elasticsearch/telemetry/metric/DoubleGauge.java
new file mode 100644
index 0000000000000..797c125900bb8
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/telemetry/metric/DoubleGauge.java
@@ -0,0 +1,47 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.metric;
+
+import java.util.Map;
+
+/**
+ * Record non-additive double values. eg number of running threads, current load
+ */
+public interface DoubleGauge extends Instrument {
+    /**
+     * Record the current value for measured item
+     */
+    void record(double value);
+
+    /**
+     * Record the current value
+     * @param attributes key-value pairs to associate with the current measurement
+     */
+    void record(double value, Map<String, Object> attributes);
+
+    /**
+     * Noop gauge for tests
+     */
+    DoubleGauge NOOP = new DoubleGauge() {
+        @Override
+        public String getName() {
+            return "noop";
+        }
+
+        @Override
+        public void record(double value) {
+
+        }
+
+        @Override
+        public void record(double value, Map<String, Object> attributes) {
+
+        }
+    };
+}
diff --git a/server/src/main/java/org/elasticsearch/telemetry/metric/DoubleHistogram.java b/server/src/main/java/org/elasticsearch/telemetry/metric/DoubleHistogram.java
new file mode 100644
index 0000000000000..11958ea36cd3d
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/telemetry/metric/DoubleHistogram.java
@@ -0,0 +1,48 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.metric;
+
+import java.util.Map;
+
+/**
+ * Record arbitrary values that are summarized statistically, useful for percentiles and histograms.
+ */
+public interface DoubleHistogram extends Instrument {
+    /**
+     * Record a sample for the measured item
+     * @param value
+     */
+    void record(double value);
+
+    /**
+     * Record a sample for the measured item
+     * @param attributes key-value pairs to associate with the current sample
+     */
+    void record(double value, Map<String, Object> attributes);
+
+    /**
+     * Noop histogram for tests
+     */
+    DoubleHistogram NOOP = new DoubleHistogram() {
+        @Override
+        public String getName() {
+            return "noop";
+        }
+
+        @Override
+        public void record(double value) {
+
+        }
+
+        @Override
+        public void record(double value, Map<String, Object> attributes) {
+
+        }
+    };
+}
diff --git a/server/src/main/java/org/elasticsearch/telemetry/metric/DoubleUpDownCounter.java b/server/src/main/java/org/elasticsearch/telemetry/metric/DoubleUpDownCounter.java
new file mode 100644
index 0000000000000..7d484ebf07d32
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/telemetry/metric/DoubleUpDownCounter.java
@@ -0,0 +1,50 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.metric;
+
+import java.util.Map;
+
+/**
+ * A counter that supports decreasing and increasing values.
+ * Useful for capturing the number of requests in a queue.
+ */
+public interface DoubleUpDownCounter extends Instrument {
+    /**
+     * Add to the counter
+     * @param inc may be negative.
+     */
+    void add(double inc);
+
+    /**
+     * Add to the counter
+     * @param inc may be negative.
+     * @param attributes key-value pairs to associate with this increment
+     */
+    void add(double inc, Map<String, Object> attributes);
+
+    /**
+     * Noop counter for use in tests
+     */
+    DoubleUpDownCounter NOOP = new DoubleUpDownCounter() {
+        @Override
+        public String getName() {
+            return "noop";
+        }
+
+        @Override
+        public void add(double inc) {
+
+        }
+
+        @Override
+        public void add(double inc, Map<String, Object> attributes) {
+
+        }
+    };
+}
diff --git a/server/src/main/java/org/elasticsearch/telemetry/metric/Instrument.java b/server/src/main/java/org/elasticsearch/telemetry/metric/Instrument.java
new file mode 100644
index 0000000000000..19a7e259120f2
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/telemetry/metric/Instrument.java
@@ -0,0 +1,13 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.metric;
+
+public interface Instrument {
+    String getName();
+}
diff --git a/server/src/main/java/org/elasticsearch/telemetry/metric/LongCounter.java b/server/src/main/java/org/elasticsearch/telemetry/metric/LongCounter.java
new file mode 100644
index 0000000000000..f8f2150163835
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/telemetry/metric/LongCounter.java
@@ -0,0 +1,60 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.metric;
+
+import java.util.Map;
+
+/**
+ * A monotonically increasing metric that uses a long.  Useful for integral values such as the number of bytes received,
+ * number of requests, etc.
+ */
+public interface LongCounter extends Instrument {
+    /**
+     * Add one to the current counter
+     */
+    void increment();
+
+    /**
+     * Increment the counter
+     * @param inc amount to increment
+     */
+    void incrementBy(long inc);
+
+    /**
+     * Increment the counter.
+     * @param inc amount to increment
+     * @param attributes key-value pairs to associate with this increment
+     */
+    void incrementBy(long inc, Map<String, Object> attributes);
+
+    /**
+     * Noop counter for use in tests.
+     */
+    LongCounter NOOP = new LongCounter() {
+        @Override
+        public String getName() {
+            return "noop";
+        }
+
+        @Override
+        public void increment() {
+
+        }
+
+        @Override
+        public void incrementBy(long inc) {
+
+        }
+
+        @Override
+        public void incrementBy(long inc, Map<String, Object> attributes) {
+
+        }
+    };
+}
diff --git a/server/src/main/java/org/elasticsearch/telemetry/metric/LongGauge.java b/server/src/main/java/org/elasticsearch/telemetry/metric/LongGauge.java
new file mode 100644
index 0000000000000..71539064ce53e
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/telemetry/metric/LongGauge.java
@@ -0,0 +1,49 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.metric;
+
+import java.util.Map;
+
+/**
+ * Record non-additive long values.
+ */
+public interface LongGauge extends Instrument {
+
+    /**
+     * Record the current value of the measured item.
+     * @param value
+     */
+    void record(long value);
+
+    /**
+     * Record the current value
+     * @param attributes key-value pairs to associate with the current measurement
+     */
+    void record(long value, Map<String, Object> attributes);
+
+    /**
+     * Noop gauge for tests
+     */
+    LongGauge NOOP = new LongGauge() {
+        @Override
+        public String getName() {
+            return "noop";
+        }
+
+        @Override
+        public void record(long value) {
+
+        }
+
+        @Override
+        public void record(long value, Map<String, Object> attributes) {
+
+        }
+    };
+}
diff --git a/server/src/main/java/org/elasticsearch/telemetry/metric/LongHistogram.java b/server/src/main/java/org/elasticsearch/telemetry/metric/LongHistogram.java
new file mode 100644
index 0000000000000..27d5261f755ef
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/telemetry/metric/LongHistogram.java
@@ -0,0 +1,48 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.metric;
+
+import java.util.Map;
+
+/**
+ * Record arbitrary values that are summarized statistically, useful for percentiles and histograms.
+ */
+public interface LongHistogram extends Instrument {
+    /**
+     * Record a sample for the measured item
+     * @param value
+     */
+    void record(long value);
+
+    /**
+     * Record a sample for the measured item
+     * @param attributes key-value pairs to associate with the current sample
+     */
+    void record(long value, Map<String, Object> attributes);
+
+    /**
+     * Noop histogram for tests
+     */
+    LongHistogram NOOP = new LongHistogram() {
+        @Override
+        public String getName() {
+            return "noop";
+        }
+
+        @Override
+        public void record(long value) {
+
+        }
+
+        @Override
+        public void record(long value, Map<String, Object> attributes) {
+
+        }
+    };
+}
diff --git a/server/src/main/java/org/elasticsearch/telemetry/metric/LongUpDownCounter.java b/server/src/main/java/org/elasticsearch/telemetry/metric/LongUpDownCounter.java
new file mode 100644
index 0000000000000..f62030da8f6bd
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/telemetry/metric/LongUpDownCounter.java
@@ -0,0 +1,50 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.metric;
+
+import java.util.Map;
+
+/**
+ * A counter that supports decreasing and increasing values.
+ * Useful for capturing the number of requests in a queue.
+ */
+public interface LongUpDownCounter extends Instrument {
+    /**
+     * Add to the counter
+     * @param inc may be negative.
+     */
+    void add(long inc);
+
+    /**
+     * Add to the counter
+     * @param inc may be negative.
+     * @param attributes key-value pairs to associate with this increment
+     */
+    void add(long inc, Map<String, Object> attributes);
+
+    /**
+     * Noop counter for use in tests
+     */
+    LongUpDownCounter NOOP = new LongUpDownCounter() {
+        @Override
+        public String getName() {
+            return "noop";
+        }
+
+        @Override
+        public void add(long inc) {
+
+        }
+
+        @Override
+        public void add(long inc, Map<String, Object> attributes) {
+
+        }
+    };
+}
diff --git a/server/src/main/java/org/elasticsearch/telemetry/metric/Meter.java b/server/src/main/java/org/elasticsearch/telemetry/metric/Meter.java
new file mode 100644
index 0000000000000..77bbf6f673fd3
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/telemetry/metric/Meter.java
@@ -0,0 +1,228 @@
+/*
+ * 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 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 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.telemetry.metric;
+
+/**
+ * Container for metering instruments.  Meters with the same name and type (DoubleCounter, etc) can
+ * only be registered once.
+ * TODO(stu): describe name, unit and description
+ */
+public interface Meter {
+    /**
+     * Register a {@link DoubleCounter}.  The returned object may be reused.
+     * @param name name of the counter
+     * @param description description of purpose
+     * @param unit the unit (bytes, sec, hour)
+     * @return the registered meter.
+     */
+    DoubleCounter registerDoubleCounter(String name, String description, String unit);
+
+    /**
+     * Retrieved a previously registered {@link DoubleCounter}.
+     * @param name name of the counter
+     * @return the registered meter.
+     */
+    DoubleCounter getDoubleCounter(String name);
+
+    /**
+     * Register a {@link DoubleUpDownCounter}.  The returned object may be reused.
+     * @param name name of the counter
+     * @param description description of purpose
+     * @param unit the unit (bytes, sec, hour)
+     * @return the registered meter.
+     */
+    DoubleUpDownCounter registerDoubleUpDownCounter(String name, String description, String unit);
+
+    /**
+     * Retrieved a previously registered {@link DoubleUpDownCounter}.
+     * @param name name of the counter
+     * @return the registered meter.
+     */
+    DoubleUpDownCounter getDoubleUpDownCounter(String name);
+
+    /**
+     * Register a {@link DoubleGauge}.  The returned object may be reused.
+     * @param name name of the gauge
+     * @param description description of purpose
+     * @param unit the unit (bytes, sec, hour)
+     * @return the registered meter.
+     */
+    DoubleGauge registerDoubleGauge(String name, String description, String unit);
+
+    /**
+     * Retrieved a previously registered {@link DoubleGauge}.
+     * @param name name of the gauge
+     * @return the registered meter.
+     */
+    DoubleGauge getDoubleGauge(String name);
+
+    /**
+     * Register a {@link DoubleHistogram}.  The returned object may be reused.
+     * @param name name of the histogram
+     * @param description description of purpose
+     * @param unit the unit (bytes, sec, hour)
+     * @return the registered meter.
+     */
+    DoubleHistogram registerDoubleHistogram(String name, String description, String unit);
+
+    /**
+     * Retrieved a previously registered {@link DoubleHistogram}.
+     * @param name name of the histogram
+     * @return the registered meter.
+     */
+    DoubleHistogram getDoubleHistogram(String name);
+
+    /**
+     * Register a {@link LongCounter}.  The returned object may be reused.
+     * @param name name of the counter
+     * @param description description of purpose
+     * @param unit the unit (bytes, sec, hour)
+     * @return the registered meter.
+     */
+    LongCounter registerLongCounter(String name, String description, String unit);
+
+    /**
+     * Retrieved a previously registered {@link LongCounter}.
+     * @param name name of the counter
+     * @return the registered meter.
+     */
+    LongCounter getLongCounter(String name);
+
+    /**
+     * Register a {@link LongUpDownCounter}.  The returned object may be reused.
+     * @param name name of the counter
+     * @param description description of purpose
+     * @param unit the unit (bytes, sec, hour)
+     * @return the registered meter.
+     */
+    LongUpDownCounter registerLongUpDownCounter(String name, String description, String unit);
+
+    /**
+     * Retrieved a previously registered {@link LongUpDownCounter}.
+     * @param name name of the counter
+     * @return the registered meter.
+     */
+    LongUpDownCounter getLongUpDownCounter(String name);
+
+    /**
+     * Register a {@link LongGauge}.  The returned object may be reused.
+     * @param name name of the gauge
+     * @param description description of purpose
+     * @param unit the unit (bytes, sec, hour)
+     * @return the registered meter.
+     */
+    LongGauge registerLongGauge(String name, String description, String unit);
+
+    /**
+     * Retrieved a previously registered {@link LongGauge}.
+     * @param name name of the gauge
+     * @return the registered meter.
+     */
+    LongGauge getLongGauge(String name);
+
+    /**
+     * Register a {@link LongHistogram}.  The returned object may be reused.
+     * @param name name of the histogram
+     * @param description description of purpose
+     * @param unit the unit (bytes, sec, hour)
+     * @return the registered meter.
+     */
+    LongHistogram registerLongHistogram(String name, String description, String unit);
+
+    /**
+     * Retrieved a previously registered {@link LongHistogram}.
+     * @param name name of the histogram
+     * @return the registered meter.
+     */
+    LongHistogram getLongHistogram(String name);
+
+    /**
+     * Noop implementation for tests
+     */
+    Meter NOOP = new Meter() {
+        @Override
+        public DoubleCounter registerDoubleCounter(String name, String description, String unit) {
+            return DoubleCounter.NOOP;
+        }
+
+        @Override
+        public DoubleCounter getDoubleCounter(String name) {
+            return DoubleCounter.NOOP;
+        }
+
+        public DoubleUpDownCounter registerDoubleUpDownCounter(String name, String description, String unit) {
+            return DoubleUpDownCounter.NOOP;
+        }
+
+        @Override
+        public DoubleUpDownCounter getDoubleUpDownCounter(String name) {
+            return DoubleUpDownCounter.NOOP;
+        }
+
+        @Override
+        public DoubleGauge registerDoubleGauge(String name, String description, String unit) {
+            return DoubleGauge.NOOP;
+        }
+
+        @Override
+        public DoubleGauge getDoubleGauge(String name) {
+            return DoubleGauge.NOOP;
+        }
+
+        @Override
+        public DoubleHistogram registerDoubleHistogram(String name, String description, String unit) {
+            return DoubleHistogram.NOOP;
+        }
+
+        @Override
+        public DoubleHistogram getDoubleHistogram(String name) {
+            return DoubleHistogram.NOOP;
+        }
+
+        @Override
+        public LongCounter registerLongCounter(String name, String description, String unit) {
+            return LongCounter.NOOP;
+        }
+
+        @Override
+        public LongCounter getLongCounter(String name) {
+            return LongCounter.NOOP;
+        }
+
+        @Override
+        public LongUpDownCounter registerLongUpDownCounter(String name, String description, String unit) {
+            return LongUpDownCounter.NOOP;
+        }
+
+        @Override
+        public LongUpDownCounter getLongUpDownCounter(String name) {
+            return LongUpDownCounter.NOOP;
+        }
+
+        @Override
+        public LongGauge registerLongGauge(String name, String description, String unit) {
+            return LongGauge.NOOP;
+        }
+
+        @Override
+        public LongGauge getLongGauge(String name) {
+            return LongGauge.NOOP;
+        }
+
+        @Override
+        public LongHistogram registerLongHistogram(String name, String description, String unit) {
+            return LongHistogram.NOOP;
+        }
+
+        @Override
+        public LongHistogram getLongHistogram(String name) {
+            return LongHistogram.NOOP;
+        }
+    };
+}

From 44a2d68f197094dc3af8d053ff166e0228256a71 Mon Sep 17 00:00:00 2001
From: Nhat Nguyen <nhat.nguyen@elastic.co>
Date: Thu, 28 Sep 2023 17:45:17 -0700
Subject: [PATCH 25/32] Replace recursive with loop in PackedValuesBlockHash
 (#99992)

This change replaces the recursion with a loop when packing and hashing
multiple keys. While the recursive version is clever, it may not be as
straightforward for future readers. Using a loop also helps us avoid
StackOverflow when grouping by a large number of keys.
---
 .../blockhash/PackedValuesBlockHash.java      | 192 +++++++++---------
 1 file changed, 95 insertions(+), 97 deletions(-)

diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/PackedValuesBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/PackedValuesBlockHash.java
index 31f65e9b70053..7ecaddf2092fa 100644
--- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/PackedValuesBlockHash.java
+++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/PackedValuesBlockHash.java
@@ -22,8 +22,6 @@
 import org.elasticsearch.compute.operator.BatchEncoder;
 import org.elasticsearch.compute.operator.HashAggregationOperator;
 import org.elasticsearch.compute.operator.MultivalueDedupe;
-import org.elasticsearch.logging.LogManager;
-import org.elasticsearch.logging.Logger;
 
 import java.util.Arrays;
 import java.util.List;
@@ -51,19 +49,20 @@
  * }</pre>
  */
 final class PackedValuesBlockHash extends BlockHash {
-    private static final Logger logger = LogManager.getLogger(PackedValuesBlockHash.class);
     static final int DEFAULT_BATCH_SIZE = Math.toIntExact(ByteSizeValue.ofKb(10).getBytes());
 
-    private final List<HashAggregationOperator.GroupSpec> groups;
     private final int emitBatchSize;
     private final BytesRefHash bytesRefHash;
     private final int nullTrackingBytes;
+    private final BytesRef scratch = new BytesRef();
+    private final BytesRefBuilder bytes = new BytesRefBuilder();
+    private final Group[] groups;
 
-    PackedValuesBlockHash(List<HashAggregationOperator.GroupSpec> groups, BigArrays bigArrays, int emitBatchSize) {
-        this.groups = groups;
+    PackedValuesBlockHash(List<HashAggregationOperator.GroupSpec> specs, BigArrays bigArrays, int emitBatchSize) {
+        this.groups = specs.stream().map(Group::new).toArray(Group[]::new);
         this.emitBatchSize = emitBatchSize;
         this.bytesRefHash = new BytesRefHash(1, bigArrays);
-        this.nullTrackingBytes = groups.size() / 8 + 1;
+        this.nullTrackingBytes = (groups.length + 7) / 8;
     }
 
     @Override
@@ -75,23 +74,28 @@ void add(Page page, GroupingAggregatorFunction.AddInput addInput, int batchSize)
         new AddWork(page, addInput, batchSize).add();
     }
 
+    private static class Group {
+        final HashAggregationOperator.GroupSpec spec;
+        BatchEncoder encoder;
+        int positionOffset;
+        int valueOffset;
+        int loopedIndex;
+        int valueCount;
+        int bytesStart;
+
+        Group(HashAggregationOperator.GroupSpec spec) {
+            this.spec = spec;
+        }
+    }
+
     class AddWork extends LongLongBlockHash.AbstractAddBlock {
-        final BatchEncoder[] encoders = new BatchEncoder[groups.size()];
-        final int[] positionOffsets = new int[groups.size()];
-        final int[] valueOffsets = new int[groups.size()];
-        final BytesRef[] scratches = new BytesRef[groups.size()];
-        final BytesRefBuilder bytes = new BytesRefBuilder();
         final int positionCount;
-
         int position;
-        int count;
-        int bufferedGroup;
 
         AddWork(Page page, GroupingAggregatorFunction.AddInput addInput, int batchSize) {
             super(emitBatchSize, addInput);
-            for (int g = 0; g < groups.size(); g++) {
-                encoders[g] = MultivalueDedupe.batchEncoder(page.getBlock(groups.get(g).channel()), batchSize);
-                scratches[g] = new BytesRef();
+            for (Group group : groups) {
+                group.encoder = MultivalueDedupe.batchEncoder(page.getBlock(group.spec.channel()), batchSize);
             }
             bytes.grow(nullTrackingBytes);
             this.positionCount = page.getPositionCount();
@@ -104,91 +108,86 @@ class AddWork extends LongLongBlockHash.AbstractAddBlock {
          */
         void add() {
             for (position = 0; position < positionCount; position++) {
-                if (logger.isTraceEnabled()) {
-                    logger.trace("position {}", position);
-                }
                 // Make sure all encoders have encoded the current position and the offsets are queued to it's start
-                for (int g = 0; g < encoders.length; g++) {
-                    positionOffsets[g]++;
-                    while (positionOffsets[g] >= encoders[g].positionCount()) {
-                        encoders[g].encodeNextBatch();
-                        positionOffsets[g] = 0;
-                        valueOffsets[g] = 0;
+                boolean singleEntry = true;
+                for (Group g : groups) {
+                    var encoder = g.encoder;
+                    g.positionOffset++;
+                    while (g.positionOffset >= encoder.positionCount()) {
+                        encoder.encodeNextBatch();
+                        g.positionOffset = 0;
+                        g.valueOffset = 0;
                     }
+                    g.valueCount = encoder.valueCount(g.positionOffset);
+                    singleEntry &= (g.valueCount == 1);
                 }
-
-                count = 0;
                 Arrays.fill(bytes.bytes(), 0, nullTrackingBytes, (byte) 0);
                 bytes.setLength(nullTrackingBytes);
-                addPosition(0);
-                switch (count) {
-                    case 0 -> throw new IllegalStateException("didn't find any values");
-                    case 1 -> {
-                        ords.appendInt(bufferedGroup);
-                        addedValue(position);
-                    }
-                    default -> ords.endPositionEntry();
-                }
-                for (int g = 0; g < encoders.length; g++) {
-                    valueOffsets[g] += encoders[g].valueCount(positionOffsets[g]);
+                if (singleEntry) {
+                    addSingleEntry();
+                } else {
+                    addMultipleEntries();
                 }
             }
             emitOrds();
         }
 
-        private void addPosition(int g) {
-            if (g == groups.size()) {
-                addBytes();
-                return;
-            }
-            int start = bytes.length();
-            int count = encoders[g].valueCount(positionOffsets[g]);
-            assert count > 0;
-            int valueOffset = valueOffsets[g];
-            BytesRef v = encoders[g].read(valueOffset++, scratches[g]);
-            if (logger.isTraceEnabled()) {
-                logger.trace("\t".repeat(g + 1) + v);
-            }
-            if (v.length == 0) {
-                assert count == 1 : "null value in non-singleton list";
-                int nullByte = g / 8;
-                int nullShift = g % 8;
-                bytes.bytes()[nullByte] |= (byte) (1 << nullShift);
-            }
-            bytes.setLength(start);
-            bytes.append(v);
-            addPosition(g + 1);  // TODO stack overflow protection
-            for (int i = 1; i < count; i++) {
-                v = encoders[g].read(valueOffset++, scratches[g]);
-                if (logger.isTraceEnabled()) {
-                    logger.trace("\t".repeat(g + 1) + v);
+        private void addSingleEntry() {
+            for (int g = 0; g < groups.length; g++) {
+                Group group = groups[g];
+                BytesRef v = group.encoder.read(group.valueOffset++, scratch);
+                if (v.length == 0) {
+                    int nullByte = g / 8;
+                    int nullShift = g % 8;
+                    bytes.bytes()[nullByte] |= (byte) (1 << nullShift);
+                } else {
+                    bytes.append(v);
                 }
-                assert v.length > 0 : "null value after the first position";
-                bytes.setLength(start);
-                bytes.append(v);
-                addPosition(g + 1);
             }
+            int ord = Math.toIntExact(hashOrdToGroup(bytesRefHash.add(bytes.get())));
+            ords.appendInt(ord);
+            addedValue(position);
         }
 
-        private void addBytes() {
-            int group = Math.toIntExact(hashOrdToGroup(bytesRefHash.add(bytes.get())));
-            switch (count) {
-                case 0 -> bufferedGroup = group;
-                case 1 -> {
-                    ords.beginPositionEntry();
-                    ords.appendInt(bufferedGroup);
-                    addedValueInMultivaluePosition(position);
-                    ords.appendInt(group);
-                    addedValueInMultivaluePosition(position);
+        private void addMultipleEntries() {
+            ords.beginPositionEntry();
+            int g = 0;
+            outer: for (;;) {
+                for (; g < groups.length; g++) {
+                    Group group = groups[g];
+                    group.bytesStart = bytes.length();
+                    BytesRef v = group.encoder.read(group.valueOffset + group.loopedIndex, scratch);
+                    ++group.loopedIndex;
+                    if (v.length == 0) {
+                        assert group.valueCount == 1 : "null value in non-singleton list";
+                        int nullByte = g / 8;
+                        int nullShift = g % 8;
+                        bytes.bytes()[nullByte] |= (byte) (1 << nullShift);
+                    } else {
+                        bytes.append(v);
+                    }
                 }
-                default -> {
-                    ords.appendInt(group);
-                    addedValueInMultivaluePosition(position);
+                // emit ords
+                int ord = Math.toIntExact(hashOrdToGroup(bytesRefHash.add(bytes.get())));
+                ords.appendInt(ord);
+                addedValueInMultivaluePosition(position);
+
+                // rewind
+                Group group = groups[--g];
+                bytes.setLength(group.bytesStart);
+                while (group.loopedIndex == group.valueCount) {
+                    group.loopedIndex = 0;
+                    if (g == 0) {
+                        break outer;
+                    } else {
+                        group = groups[--g];
+                        bytes.setLength(group.bytesStart);
+                    }
                 }
             }
-            count++;
-            if (logger.isTraceEnabled()) {
-                logger.trace("{} = {}", bytes.get(), group);
+            ords.endPositionEntry();
+            for (Group group : groups) {
+                group.valueOffset += group.valueCount;
             }
         }
     }
@@ -196,16 +195,16 @@ private void addBytes() {
     @Override
     public Block[] getKeys() {
         int size = Math.toIntExact(bytesRefHash.size());
-        BatchEncoder.Decoder[] decoders = new BatchEncoder.Decoder[groups.size()];
-        Block.Builder[] builders = new Block.Builder[groups.size()];
+        BatchEncoder.Decoder[] decoders = new BatchEncoder.Decoder[groups.length];
+        Block.Builder[] builders = new Block.Builder[groups.length];
         for (int g = 0; g < builders.length; g++) {
-            ElementType elementType = groups.get(g).elementType();
+            ElementType elementType = groups[g].spec.elementType();
             decoders[g] = BatchEncoder.decoder(elementType);
             builders[g] = elementType.newBlockBuilder(size);
         }
 
-        BytesRef values[] = new BytesRef[(int) Math.min(100, bytesRefHash.size())];
-        BytesRef nulls[] = new BytesRef[values.length];
+        BytesRef[] values = new BytesRef[(int) Math.min(100, bytesRefHash.size())];
+        BytesRef[] nulls = new BytesRef[values.length];
         for (int offset = 0; offset < values.length; offset++) {
             values[offset] = new BytesRef();
             nulls[offset] = new BytesRef();
@@ -231,7 +230,7 @@ public Block[] getKeys() {
             readKeys(decoders, builders, nulls, values, offset);
         }
 
-        Block[] keyBlocks = new Block[groups.size()];
+        Block[] keyBlocks = new Block[groups.length];
         for (int g = 0; g < keyBlocks.length; g++) {
             keyBlocks[g] = builders[g].build();
         }
@@ -271,13 +270,12 @@ public String toString() {
         StringBuilder b = new StringBuilder();
         b.append("PackedValuesBlockHash{groups=[");
         boolean first = true;
-        for (HashAggregationOperator.GroupSpec spec : groups) {
-            if (first) {
-                first = false;
-            } else {
+        for (int i = 0; i < groups.length; i++) {
+            if (i > 0) {
                 b.append(", ");
             }
-            b.append(spec.channel()).append(':').append(spec.elementType());
+            Group group = groups[i];
+            b.append(group.spec.channel()).append(':').append(group.spec.elementType());
         }
         b.append("], entries=").append(bytesRefHash.size());
         b.append(", size=").append(ByteSizeValue.ofBytes(bytesRefHash.ramBytesUsed()));

From 05189ef395e4d28c5fbc5612c7f27954648680bd Mon Sep 17 00:00:00 2001
From: Albert Zaharovits <albert.zaharovits@elastic.co>
Date: Fri, 29 Sep 2023 08:22:20 +0300
Subject: [PATCH 26/32] Debug log OIDC ID token validation exception (#100002)

This ensures we debug log OIDC ID token validation exceptions,
which should help admins with troubleshooting the OIDC realm setup.
---
 .../authc/jwt/JwtSignatureValidator.java      | 25 +++++++------------
 .../xpack/security/authc/jwt/JwtUtil.java     | 23 +++++++++++++++++
 .../oidc/OpenIdConnectAuthenticator.java      |  9 +++++--
 3 files changed, 39 insertions(+), 18 deletions(-)

diff --git a/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/authc/jwt/JwtSignatureValidator.java b/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/authc/jwt/JwtSignatureValidator.java
index 91224a8246169..b1ee1b77998ec 100644
--- a/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/authc/jwt/JwtSignatureValidator.java
+++ b/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/authc/jwt/JwtSignatureValidator.java
@@ -17,7 +17,6 @@
 import com.nimbusds.jose.jwk.JWK;
 import com.nimbusds.jose.jwk.OctetSequenceKey;
 import com.nimbusds.jose.jwk.RSAKey;
-import com.nimbusds.jose.util.Base64URL;
 import com.nimbusds.jwt.SignedJWT;
 
 import org.apache.logging.log4j.LogManager;
@@ -40,9 +39,10 @@
 
 import java.util.Arrays;
 import java.util.List;
-import java.util.function.Supplier;
 import java.util.stream.Stream;
 
+import static org.elasticsearch.xpack.security.authc.jwt.JwtUtil.toStringRedactSignature;
+
 public interface JwtSignatureValidator extends Releasable {
 
     Logger logger = LogManager.getLogger(JwtSignatureValidator.class);
@@ -361,7 +361,7 @@ default void validateSignature(final SignedJWT jwt, final List<JWK> jwks) throws
             final String id = jwt.getHeader().getKeyID();
             final JWSAlgorithm alg = jwt.getHeader().getAlgorithm();
 
-            tracer.append("Filtering [{}] possible JWKs to verifying signature for JWT [{}].", jwks.size(), getSafePrintableJWT(jwt));
+            tracer.append("Filtering [{}] possible JWKs to verifying signature for JWT [{}].", jwks.size(), toStringRedactSignature(jwt));
 
             // If JWT has optional kid header, and realm JWKs have optional kid attribute, any mismatches JWT.kid vs JWK.kid can be ignored.
             // Keep any JWKs if JWK optional kid attribute is missing. Keep all JWKs if JWT optional kid header is missing.
@@ -399,7 +399,11 @@ default void validateSignature(final SignedJWT jwt, final List<JWK> jwks) throws
 
             int attempt = 0;
             int maxAttempts = jwksConfigured.size();
-            tracer.append("Attempting to verify signature for JWT [{}] against [{}] possible JWKs.", getSafePrintableJWT(jwt), maxAttempts);
+            tracer.append(
+                "Attempting to verify signature for JWT [{}] against [{}] possible JWKs.",
+                toStringRedactSignature(jwt),
+                maxAttempts
+            );
             for (final JWK jwk : jwksConfigured) {
                 attempt++;
                 if (jwt.verify(createJwsVerifier(jwk))) {
@@ -429,7 +433,7 @@ default void validateSignature(final SignedJWT jwt, final List<JWK> jwks) throws
                     );
                 }
             }
-            throw new ElasticsearchException("JWT [" + getSafePrintableJWT(jwt).get() + "] signature verification failed.");
+            throw new ElasticsearchException("JWT [" + toStringRedactSignature(jwt).get() + "] signature verification failed.");
         }
     }
 
@@ -458,15 +462,4 @@ interface PkcJwkSetReloadNotifier {
         void reloaded();
     }
 
-    /**
-     * @param jwt The signed JWT
-     * @return A print safe supplier to describe a JWT that redacts the signature. While the signature is not generally sensitive,
-     * we don't want to leak the entire JWT to the log to avoid a possible replay.
-     */
-    private Supplier<String> getSafePrintableJWT(SignedJWT jwt) {
-        Base64URL[] parts = jwt.getParsedParts();
-        assert parts.length == 3;
-        return () -> parts[0].toString() + "." + parts[1].toString() + ".<redacted>";
-    }
-
 }
diff --git a/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/authc/jwt/JwtUtil.java b/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/authc/jwt/JwtUtil.java
index 3e3533f028b38..9168c5c0925bd 100644
--- a/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/authc/jwt/JwtUtil.java
+++ b/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/authc/jwt/JwtUtil.java
@@ -7,9 +7,12 @@
 
 package org.elasticsearch.xpack.security.authc.jwt;
 
+import com.nimbusds.jose.JWSObject;
 import com.nimbusds.jose.jwk.JWK;
 import com.nimbusds.jose.jwk.JWKSet;
+import com.nimbusds.jose.util.Base64URL;
 import com.nimbusds.jose.util.JSONObjectUtils;
+import com.nimbusds.jwt.JWT;
 
 import org.apache.http.HttpEntity;
 import org.apache.http.HttpResponse;
@@ -59,6 +62,7 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Objects;
 import java.util.function.Supplier;
 
 import javax.net.ssl.HostnameVerifier;
@@ -389,4 +393,23 @@ public void close() {
             closed = true;
         }
     }
+
+    /**
+     * @param jwt The signed JWT
+     * @return A print safe supplier to describe a JWT that redacts the signature. While the signature is not generally sensitive,
+     * we don't want to leak the entire JWT to the log to avoid a possible replay.
+     */
+    public static Supplier<String> toStringRedactSignature(JWT jwt) {
+        if (jwt instanceof JWSObject) {
+            Base64URL[] parts = jwt.getParsedParts();
+            assert parts.length == 3;
+            assert parts[0] != null;
+            assert parts[1] != null;
+            assert parts[2] != null;
+            assert Objects.equals(parts[2], ((JWSObject) jwt).getSignature());
+            return () -> parts[0] + "." + parts[1] + ".<redacted-signature>";
+        } else {
+            return jwt::getParsedString;
+        }
+    }
 }
diff --git a/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/authc/oidc/OpenIdConnectAuthenticator.java b/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/authc/oidc/OpenIdConnectAuthenticator.java
index 73bc36c94e2d5..754d2a82dd835 100644
--- a/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/authc/oidc/OpenIdConnectAuthenticator.java
+++ b/x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/authc/oidc/OpenIdConnectAuthenticator.java
@@ -93,6 +93,7 @@
 import org.elasticsearch.xpack.core.security.authc.RealmSettings;
 import org.elasticsearch.xpack.core.security.authc.oidc.OpenIdConnectRealmSettings;
 import org.elasticsearch.xpack.core.ssl.SSLService;
+import org.elasticsearch.xpack.security.authc.jwt.JwtUtil;
 
 import java.io.IOException;
 import java.net.URI;
@@ -293,14 +294,18 @@ void getUserClaims(
                     .triggerReload(ActionListener.wrap(v -> {
                         getUserClaims(accessToken, idToken, expectedNonce, false, claimsListener);
                     }, ex -> {
-                        LOGGER.trace("Attempted and failed to refresh JWK cache upon token validation failure", e);
+                        LOGGER.debug("Attempted and failed to refresh JWK cache upon token validation failure", e);
                         claimsListener.onFailure(ex);
                     }));
             } else {
+                LOGGER.debug("Failed to parse or validate the ID Token", e);
                 claimsListener.onFailure(new ElasticsearchSecurityException("Failed to parse or validate the ID Token", e));
             }
         } catch (com.nimbusds.oauth2.sdk.ParseException | ParseException | JOSEException e) {
-            LOGGER.debug("ID Token: [{}], Nonce: [{}]", idToken.getParsedString(), expectedNonce);
+            LOGGER.debug(
+                () -> format("ID Token: [%s], Nonce: [%s]", JwtUtil.toStringRedactSignature(idToken).get(), expectedNonce.toString()),
+                e
+            );
             claimsListener.onFailure(new ElasticsearchSecurityException("Failed to parse or validate the ID Token", e));
         }
     }

From fc962ff32ba0f48ae539def65e0f44a12c0dfec4 Mon Sep 17 00:00:00 2001
From: Matteo Piergiovanni <134913285+piergm@users.noreply.github.com>
Date: Fri, 29 Sep 2023 08:23:57 +0200
Subject: [PATCH 27/32] [CI] SearchResponseTests#testSerialization failing
 resolved (#100020)

Removed class variables running, partial and failed that are now
calculated when needed.
Having them caused issues due to the fact that they always reflected
the content of the clusterInfo map that could be updated in various
part of the code and the update would not reflect on those counters.
Updated class methods equals and hashCode accordingly.
Unmuted test related to issue
---
 docs/changelog/100020.yaml                    |  6 ++
 .../action/search/SearchResponse.java         | 63 +++++++++----------
 .../action/search/SearchResponseTests.java    |  1 -
 3 files changed, 37 insertions(+), 33 deletions(-)
 create mode 100644 docs/changelog/100020.yaml

diff --git a/docs/changelog/100020.yaml b/docs/changelog/100020.yaml
new file mode 100644
index 0000000000000..9f97778860eef
--- /dev/null
+++ b/docs/changelog/100020.yaml
@@ -0,0 +1,6 @@
+pr: 100020
+summary: "[CI] `SearchResponseTests#testSerialization` failing resolved"
+area: Search
+type: bug
+issues:
+ - 100005
diff --git a/server/src/main/java/org/elasticsearch/action/search/SearchResponse.java b/server/src/main/java/org/elasticsearch/action/search/SearchResponse.java
index f9f5f43494711..ba785fd4d9637 100644
--- a/server/src/main/java/org/elasticsearch/action/search/SearchResponse.java
+++ b/server/src/main/java/org/elasticsearch/action/search/SearchResponse.java
@@ -471,9 +471,6 @@ public static class Clusters implements ToXContentFragment, Writeable {
         private final int total;
         private final int successful;   // not used for minimize_roundtrips=true; dynamically determined from clusterInfo map
         private final int skipped;      // not used for minimize_roundtrips=true; dynamically determined from clusterInfo map
-        private final int running;      // not used for minimize_roundtrips=true; dynamically determined from clusterInfo map
-        private final int partial;      // not used for minimize_roundtrips=true; dynamically determined from clusterInfo map
-        private final int failed;       // not used for minimize_roundtrips=true; dynamically determined from clusterInfo map
 
         // key to map is clusterAlias on the primary querying cluster of a CCS minimize_roundtrips=true query
         // the Map itself is immutable after construction - all Clusters will be accounted for at the start of the search
@@ -503,6 +500,8 @@ public Clusters(
             assert remoteClusterIndices.size() > 0 : "At least one remote cluster must be passed into this Cluster constructor";
             this.total = remoteClusterIndices.size() + (localIndices == null ? 0 : 1);
             assert total >= 1 : "No local indices or remote clusters passed in";
+            this.successful = 0; // calculated from clusterInfo map for minimize_roundtrips
+            this.skipped = 0;    // calculated from clusterInfo map for minimize_roundtrips
             this.ccsMinimizeRoundtrips = ccsMinimizeRoundtrips;
             Map<String, AtomicReference<Cluster>> m = new HashMap<>();
             if (localIndices != null) {
@@ -517,11 +516,6 @@ public Clusters(
                 m.put(clusterAlias, new AtomicReference<>(c));
             }
             this.clusterInfo = Collections.unmodifiableMap(m);
-            this.successful = determineCountFromClusterInfo(cluster -> cluster.getStatus() == Cluster.Status.SUCCESSFUL);
-            this.skipped = determineCountFromClusterInfo(cluster -> cluster.getStatus() == Cluster.Status.SKIPPED);
-            this.running = determineCountFromClusterInfo(cluster -> cluster.getStatus() == Cluster.Status.RUNNING);
-            this.partial = determineCountFromClusterInfo(cluster -> cluster.getStatus() == Cluster.Status.PARTIAL);
-            this.failed = determineCountFromClusterInfo(cluster -> cluster.getStatus() == Cluster.Status.FAILED);
         }
 
         /**
@@ -539,36 +533,39 @@ public Clusters(int total, int successful, int skipped) {
             this.total = total;
             this.successful = successful;
             this.skipped = skipped;
-            this.running = 0;
-            this.partial = 0;
-            this.failed = 0;
             this.ccsMinimizeRoundtrips = false;
             this.clusterInfo = Collections.emptyMap();  // will never be used if created from this constructor
         }
 
         public Clusters(StreamInput in) throws IOException {
             this.total = in.readVInt();
-            this.successful = in.readVInt();
-            this.skipped = in.readVInt();
+            int successfulTemp = in.readVInt();
+            int skippedTemp = in.readVInt();
             if (in.getTransportVersion().onOrAfter(TransportVersions.V_8_500_053)) {
                 List<Cluster> clusterList = in.readCollectionAsList(Cluster::new);
                 if (clusterList.isEmpty()) {
                     this.clusterInfo = Collections.emptyMap();
+                    this.successful = successfulTemp;
+                    this.skipped = skippedTemp;
                 } else {
                     Map<String, AtomicReference<Cluster>> m = new HashMap<>();
                     clusterList.forEach(c -> m.put(c.getClusterAlias(), new AtomicReference<>(c)));
                     this.clusterInfo = Collections.unmodifiableMap(m);
+                    this.successful = getClusterStateCount(Cluster.Status.SUCCESSFUL);
+                    this.skipped = getClusterStateCount(Cluster.Status.SKIPPED);
                 }
             } else {
+                this.successful = successfulTemp;
+                this.skipped = skippedTemp;
                 this.clusterInfo = Collections.emptyMap();
             }
-            this.running = determineCountFromClusterInfo(cluster -> cluster.getStatus() == Cluster.Status.RUNNING);
-            this.partial = determineCountFromClusterInfo(cluster -> cluster.getStatus() == Cluster.Status.PARTIAL);
-            this.failed = determineCountFromClusterInfo(cluster -> cluster.getStatus() == Cluster.Status.FAILED);
+            int running = getClusterStateCount(Cluster.Status.RUNNING);
+            int partial = getClusterStateCount(Cluster.Status.PARTIAL);
+            int failed = getClusterStateCount(Cluster.Status.FAILED);
             this.ccsMinimizeRoundtrips = false;
             assert total >= 0 : "total is negative: " + total;
-            assert total >= successful + skipped + running + partial + failed
-                : "successful + skipped + running + partial + failed is larger than total. total: "
+            assert total == successful + skipped + running + partial + failed
+                : "successful + skipped + running + partial + failed is not equal to total. total: "
                     + total
                     + " successful: "
                     + successful
@@ -586,11 +583,8 @@ private Clusters(Map<String, AtomicReference<Cluster>> clusterInfoMap) {
             assert clusterInfoMap.size() > 0 : "this constructor should not be called with an empty Cluster info map";
             this.total = clusterInfoMap.size();
             this.clusterInfo = clusterInfoMap;
-            this.successful = 0;    // calculated from clusterInfo map for minimize_roundtrips
-            this.skipped = 0;       // calculated from clusterInfo map for minimize_roundtrips
-            this.running = 0;       // calculated from clusterInfo map for minimize_roundtrips
-            this.partial = 0;       // calculated from clusterInfo map for minimize_roundtrips
-            this.failed = 0;        // calculated from clusterInfo map for minimize_roundtrips
+            this.successful = getClusterStateCount(Cluster.Status.SUCCESSFUL);
+            this.skipped = getClusterStateCount(Cluster.Status.SKIPPED);
             // should only be called if "details" section of fromXContent is present (for ccsMinimizeRoundtrips)
             this.ccsMinimizeRoundtrips = true;
         }
@@ -705,11 +699,9 @@ public int getTotal() {
         public int getClusterStateCount(Cluster.Status status) {
             if (clusterInfo.isEmpty()) {
                 return switch (status) {
-                    case RUNNING -> running;
                     case SUCCESSFUL -> successful;
-                    case PARTIAL -> partial;
                     case SKIPPED -> skipped;
-                    case FAILED -> failed;
+                    default -> 0;
                 };
             } else {
                 return determineCountFromClusterInfo(cluster -> cluster.getStatus() == status);
@@ -752,16 +744,23 @@ public boolean equals(Object o) {
             }
             Clusters clusters = (Clusters) o;
             return total == clusters.total
-                && successful == clusters.successful
-                && skipped == clusters.skipped
-                && running == clusters.running
-                && partial == clusters.partial
-                && failed == clusters.failed;
+                && getClusterStateCount(Cluster.Status.SUCCESSFUL) == clusters.getClusterStateCount(Cluster.Status.SUCCESSFUL)
+                && getClusterStateCount(Cluster.Status.SKIPPED) == clusters.getClusterStateCount(Cluster.Status.SKIPPED)
+                && getClusterStateCount(Cluster.Status.RUNNING) == clusters.getClusterStateCount(Cluster.Status.RUNNING)
+                && getClusterStateCount(Cluster.Status.PARTIAL) == clusters.getClusterStateCount(Cluster.Status.PARTIAL)
+                && getClusterStateCount(Cluster.Status.FAILED) == clusters.getClusterStateCount(Cluster.Status.FAILED);
         }
 
         @Override
         public int hashCode() {
-            return Objects.hash(total, successful, skipped, running, partial, failed);
+            return Objects.hash(
+                total,
+                getClusterStateCount(Cluster.Status.SUCCESSFUL),
+                getClusterStateCount(Cluster.Status.SKIPPED),
+                getClusterStateCount(Cluster.Status.RUNNING),
+                getClusterStateCount(Cluster.Status.PARTIAL),
+                getClusterStateCount(Cluster.Status.FAILED)
+            );
         }
 
         @Override
diff --git a/server/src/test/java/org/elasticsearch/action/search/SearchResponseTests.java b/server/src/test/java/org/elasticsearch/action/search/SearchResponseTests.java
index 9acb63db2cc90..befea803e6fa0 100644
--- a/server/src/test/java/org/elasticsearch/action/search/SearchResponseTests.java
+++ b/server/src/test/java/org/elasticsearch/action/search/SearchResponseTests.java
@@ -590,7 +590,6 @@ public void testToXContent() throws IOException {
         }
     }
 
-    @AwaitsFix(bugUrl = "https://github.com/elastic/elasticsearch/issues/100005")
     public void testSerialization() throws IOException {
         SearchResponse searchResponse = createTestItem(false);
         SearchResponse deserialized = copyWriteable(

From 9d01def3dce9349d73f19f23f5b1ad4c41cf1646 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Istv=C3=A1n=20Zolt=C3=A1n=20Szab=C3=B3?=
 <istvan.szabo@elastic.co>
Date: Fri, 29 Sep 2023 09:24:36 +0200
Subject: [PATCH 28/32] [DOCS] Changes semantic search tutorials to use ELSER
 v2 and sparse_vector field type (#100021)

* [DOCS] Changes semantic search tutorials to use ELSER v2 and sparse_vector field type.

* [DOCS] More edits.
---
 .../semantic-search-elser.asciidoc            | 35 ++++++++++---------
 .../semantic-search/field-mappings.asciidoc   | 10 +++---
 .../generate-embeddings.asciidoc              |  2 +-
 .../semantic-search/hybrid-search.asciidoc    |  2 +-
 .../semantic-search/search.asciidoc           |  4 +--
 5 files changed, 27 insertions(+), 26 deletions(-)

diff --git a/docs/reference/search/search-your-data/semantic-search-elser.asciidoc b/docs/reference/search/search-your-data/semantic-search-elser.asciidoc
index 0f07f1f4128fe..082bb2ae2e020 100644
--- a/docs/reference/search/search-your-data/semantic-search-elser.asciidoc
+++ b/docs/reference/search/search-your-data/semantic-search-elser.asciidoc
@@ -14,7 +14,7 @@ The instructions in this tutorial shows you how to use ELSER to perform semantic
 search on your data.
 
 NOTE: Only the first 512 extracted tokens per field are considered during 
-semantic search with ELSER v1. Refer to 
+semantic search with ELSER. Refer to 
 {ml-docs}/ml-nlp-limitations.html#ml-nlp-elser-v1-limit-512[this page] for more 
 information.
 
@@ -44,15 +44,16 @@ you must provide suitably sized nodes yourself.
 
 First, the mapping of the destination index - the index that contains the tokens 
 that the model created based on your text - must be created.  The destination 
-index must have a field with the <<rank-features, `rank_features`>> field type 
-to index the ELSER output.
+index must have a field with the 
+<<rank-features, `sparse_vector` or `rank_features`>> field type to index the 
+ELSER output.
 
-NOTE: ELSER output must be ingested into a field with the `rank_features` field 
-type. Otherwise, {es} interprets the token-weight pairs as a massive amount of 
-fields in a document. If you get an error similar to this 
+NOTE: ELSER output must be ingested into a field with the `sparse_vector` or 
+`rank_features` field type. Otherwise, {es} interprets the token-weight pairs as 
+a massive amount of fields in a document. If you get an error similar to this 
 `"Limit of total fields [1000] has been exceeded while adding new fields"` then 
 the ELSER output field is not mapped properly and it has a field type different 
-than `rank_features`.
+than `sparse_vector` or `rank_features`.
 
 [source,console]
 ----
@@ -61,7 +62,7 @@ PUT my-index
   "mappings": {
     "properties": {
       "ml.tokens": { <1>
-        "type": "rank_features" <2>
+        "type": "sparse_vector" <2>
       },
       "text": { <3>
         "type": "text" <4>
@@ -72,7 +73,7 @@ PUT my-index
 ----
 // TEST[skip:TBD]
 <1> The name of the field to contain the generated tokens.
-<2> The field to contain the tokens is a `rank_features` field.
+<2> The field to contain the tokens is a `sparse_vector` field.
 <3> The name of the field from which to create the sparse vector representation. 
 In this example, the name of the field is `text`.
 <4> The field type which is text in this example.
@@ -90,12 +91,12 @@ that is being ingested in the pipeline.
 
 [source,console]
 ----
-PUT _ingest/pipeline/elser-v1-test
+PUT _ingest/pipeline/elser-v2-test
 {
   "processors": [
     {
       "inference": {
-        "model_id": ".elser_model_1",
+        "model_id": ".elser_model_2",
         "target_field": "ml",
         "field_map": { <1>
           "text": "text_field"
@@ -155,7 +156,7 @@ POST _reindex?wait_for_completion=false
   },
   "dest": {
     "index": "my-index",
-    "pipeline": "elser-v1-test"
+    "pipeline": "elser-v2-test"
   }
 }
 ----
@@ -192,7 +193,7 @@ GET my-index/_search
    "query":{
       "text_expansion":{
          "ml.tokens":{
-            "model_id":".elser_model_1",
+            "model_id":".elser_model_2",
             "model_text":"How to avoid muscle soreness after running?"
          }
       }
@@ -236,7 +237,7 @@ weights.
                "exercises":0.36694175,
                (...)
             },
-            "model_id":".elser_model_1"
+            "model_id":".elser_model_2"
          }
       }
    },
@@ -276,7 +277,7 @@ GET my-index/_search
           "text_expansion": { 
             "ml.tokens": {
               "model_text": "How to avoid muscle soreness after running?",
-              "model_id": ".elser_model_1",
+              "model_id": ".elser_model_2",
               "boost": 1 <2>
             }
           }
@@ -342,7 +343,7 @@ PUT my-index
     },
     "properties": {
       "ml.tokens": {
-        "type": "rank_features" 
+        "type": "sparse_vector" 
       },
       "text": { 
         "type": "text" 
@@ -359,7 +360,7 @@ PUT my-index
 ==== Further reading
 
 * {ml-docs}/ml-nlp-elser.html[How to download and deploy ELSER]
-* {ml-docs}/ml-nlp-limitations.html#ml-nlp-elser-v1-limit-512[ELSER v1 limitation]
+* {ml-docs}/ml-nlp-limitations.html#ml-nlp-elser-v1-limit-512[ELSER limitation]
 * https://www.elastic.co/blog/may-2023-launch-information-retrieval-elasticsearch-ai-model[Improving information retrieval in the Elastic Stack: Introducing Elastic Learned Sparse Encoder, our new retrieval model]
 
 [discrete]
diff --git a/docs/reference/tab-widgets/semantic-search/field-mappings.asciidoc b/docs/reference/tab-widgets/semantic-search/field-mappings.asciidoc
index 228b7a9202341..0228078e8ce39 100644
--- a/docs/reference/tab-widgets/semantic-search/field-mappings.asciidoc
+++ b/docs/reference/tab-widgets/semantic-search/field-mappings.asciidoc
@@ -1,15 +1,15 @@
 // tag::elser[]
 
 ELSER produces token-weight pairs as output from the input text and the query. 
-The {es} <<rank-features,`rank_features`>> field type can store these 
+The {es} <<rank-features,`sparse_vector`>> field type can store these 
 token-weight pairs as numeric feature vectors. The index must have a field with 
-the `rank_features` field type to index the tokens that ELSER generates.
+the `sparse_vector` field type to index the tokens that ELSER generates.
 
 To create a mapping for your ELSER index, refer to the 
 <<elser-mappings,Create the index mapping section>> of the tutorial. The example 
 shows how to create an index mapping for `my-index` that defines the 
 `my_embeddings.tokens` field - which will contain the ELSER output - as a 
-`rank_features` field.
+`sparse_vector` field.
 
 [source,console]
 ----
@@ -18,7 +18,7 @@ PUT my-index
   "mappings": {
     "properties": {
       "my_embeddings.tokens": { <1>
-        "type": "rank_features" <2>
+        "type": "sparse_vector" <2>
       },
       "my_text_field": { <3>
         "type": "text" <4>
@@ -28,7 +28,7 @@ PUT my-index
 }
 ----
 <1> The name of the field that will contain the tokens generated by ELSER.
-<2> The field that contains the tokens must be a `rank_features` field.
+<2> The field that contains the tokens must be a `sparse_vector` field.
 <3> The name of the field from which to create the sparse vector representation. 
 In this example, the name of the field is `my_text_field`.
 <4> The field type is `text` in this example.
diff --git a/docs/reference/tab-widgets/semantic-search/generate-embeddings.asciidoc b/docs/reference/tab-widgets/semantic-search/generate-embeddings.asciidoc
index 0adfda5c2bff9..786f40fe141bd 100644
--- a/docs/reference/tab-widgets/semantic-search/generate-embeddings.asciidoc
+++ b/docs/reference/tab-widgets/semantic-search/generate-embeddings.asciidoc
@@ -21,7 +21,7 @@ PUT _ingest/pipeline/my-text-embeddings-pipeline
   "processors": [
     {
       "inference": {
-        "model_id": ".elser_model_1",
+        "model_id": ".elser_model_2",
         "target_field": "my_embeddings",
         "field_map": { <1>
           "my_text_field": "text_field"
diff --git a/docs/reference/tab-widgets/semantic-search/hybrid-search.asciidoc b/docs/reference/tab-widgets/semantic-search/hybrid-search.asciidoc
index 26fc25c2385c8..a99bdf3c8722b 100644
--- a/docs/reference/tab-widgets/semantic-search/hybrid-search.asciidoc
+++ b/docs/reference/tab-widgets/semantic-search/hybrid-search.asciidoc
@@ -22,7 +22,7 @@ GET my-index/_search
       "query": {
         "text_expansion": {
           "my_embeddings.tokens": {
-            "model_id": ".elser_model_1",
+            "model_id": ".elser_model_2",
             "model_text": "the query string"
           }
         }
diff --git a/docs/reference/tab-widgets/semantic-search/search.asciidoc b/docs/reference/tab-widgets/semantic-search/search.asciidoc
index 425b797789270..d1cd31fbe4309 100644
--- a/docs/reference/tab-widgets/semantic-search/search.asciidoc
+++ b/docs/reference/tab-widgets/semantic-search/search.asciidoc
@@ -12,7 +12,7 @@ GET my-index/_search
    "query":{
       "text_expansion":{
          "my_embeddings.tokens":{ <1>
-            "model_id":".elser_model_1",
+            "model_id":".elser_model_2",
             "model_text":"the query string"
          }
       }
@@ -20,7 +20,7 @@ GET my-index/_search
 }
 ----
 // TEST[skip:TBD]
-<1> The field of type `rank_features`.
+<1> The field of type `sparse_vector`.
 
 // end::elser[]
 

From c7705aa32abc6b5e3ce34c4edde6fb8ee68101bf Mon Sep 17 00:00:00 2001
From: Kostas Krikellas <131142368+kkrik-es@users.noreply.github.com>
Date: Fri, 29 Sep 2023 10:42:01 +0300
Subject: [PATCH 29/32] Improve time-series error and documentation (#100018)

* Improve time-series error and documentation

* spotless fix

* Update docs/changelog/100018.yaml

* Fix changelist

* Change exception type
---
 docs/changelog/100018.yaml                                  | 5 +++++
 .../aggregations/bucket/time-series-aggregation.asciidoc    | 4 ----
 .../search/aggregations/AggregationExecutionContext.java    | 6 ++++++
 3 files changed, 11 insertions(+), 4 deletions(-)
 create mode 100644 docs/changelog/100018.yaml

diff --git a/docs/changelog/100018.yaml b/docs/changelog/100018.yaml
new file mode 100644
index 0000000000000..b39089db568c0
--- /dev/null
+++ b/docs/changelog/100018.yaml
@@ -0,0 +1,5 @@
+pr: 100018
+summary: Improve time-series error and documentation
+area: "TSDB"
+type: enhancement
+issues: []
diff --git a/docs/reference/aggregations/bucket/time-series-aggregation.asciidoc b/docs/reference/aggregations/bucket/time-series-aggregation.asciidoc
index 54638083b1053..d93df55118a8b 100644
--- a/docs/reference/aggregations/bucket/time-series-aggregation.asciidoc
+++ b/docs/reference/aggregations/bucket/time-series-aggregation.asciidoc
@@ -67,8 +67,6 @@ PUT /my-time-series-index-0/_bulk
 --------------------------------------------------
 // NOTCONSOLE
 
-//////////////////////////
-
 To perform a time series aggregation, specify "time_series" as the aggregation type. When the boolean "keyed"
 is true, each bucket is given a unique key.
 
@@ -85,8 +83,6 @@ GET /_search
 --------------------------------------------------
 // NOTCONSOLE
 
-//////////////////////////
-
 This will return all results in the time series, however a more typical query will use sub aggregations to reduce the
 date returned to something more relevant.
 
diff --git a/server/src/main/java/org/elasticsearch/search/aggregations/AggregationExecutionContext.java b/server/src/main/java/org/elasticsearch/search/aggregations/AggregationExecutionContext.java
index 88a78a512d1bd..273df99f6479c 100644
--- a/server/src/main/java/org/elasticsearch/search/aggregations/AggregationExecutionContext.java
+++ b/server/src/main/java/org/elasticsearch/search/aggregations/AggregationExecutionContext.java
@@ -53,6 +53,12 @@ public long getTimestamp() {
     }
 
     public int getTsidOrd() {
+        if (tsidOrdProvider == null) {
+            throw new IllegalArgumentException(
+                "Aggregation on a time-series field is misconfigured, likely due to lack of wrapping "
+                    + "a metric aggregation within a `time-series` aggregation"
+            );
+        }
         return tsidOrdProvider.getAsInt();
     }
 }

From b30813bd37417ea0e01581c1a61b1574200caa2c Mon Sep 17 00:00:00 2001
From: Luigi Dell'Aquila <luigi.dellaquila@gmail.com>
Date: Fri, 29 Sep 2023 09:54:38 +0200
Subject: [PATCH 30/32] ESQL: add driverContext to conversion function
 evaluators and use blockFactory to instantiate blocks (#100016)

Let convert functions (eg. `to_string()`, `to_int()`, `to_ip()` and so
on) use DriverContext.blockFactory() to generate new blocks, so that
they are properly attached to the circuit breaker.
---
 .../gen/ConvertEvaluatorImplementer.java      | 68 ++++++-------------
 .../convert/ToBooleanFromDoubleEvaluator.java | 32 ++++-----
 .../convert/ToBooleanFromIntEvaluator.java    | 32 ++++-----
 .../convert/ToBooleanFromLongEvaluator.java   | 32 ++++-----
 .../convert/ToBooleanFromStringEvaluator.java | 32 ++++-----
 .../ToBooleanFromUnsignedLongEvaluator.java   | 32 ++++-----
 .../ToDatetimeFromStringEvaluator.java        | 32 ++++-----
 .../scalar/convert/ToDegreesEvaluator.java    | 32 ++++-----
 .../convert/ToDoubleFromBooleanEvaluator.java | 32 ++++-----
 .../convert/ToDoubleFromIntEvaluator.java     | 32 ++++-----
 .../convert/ToDoubleFromLongEvaluator.java    | 32 ++++-----
 .../convert/ToDoubleFromStringEvaluator.java  | 32 ++++-----
 .../ToDoubleFromUnsignedLongEvaluator.java    | 32 ++++-----
 .../convert/ToIPFromStringEvaluator.java      | 35 ++++------
 .../ToIntegerFromBooleanEvaluator.java        | 32 ++++-----
 .../convert/ToIntegerFromDoubleEvaluator.java | 32 ++++-----
 .../convert/ToIntegerFromLongEvaluator.java   | 32 ++++-----
 .../convert/ToIntegerFromStringEvaluator.java | 32 ++++-----
 .../ToIntegerFromUnsignedLongEvaluator.java   | 32 ++++-----
 .../convert/ToLongFromBooleanEvaluator.java   | 32 ++++-----
 .../convert/ToLongFromDoubleEvaluator.java    | 32 ++++-----
 .../convert/ToLongFromIntEvaluator.java       | 32 ++++-----
 .../convert/ToLongFromStringEvaluator.java    | 32 ++++-----
 .../ToLongFromUnsignedLongEvaluator.java      | 32 ++++-----
 .../scalar/convert/ToRadiansEvaluator.java    | 32 ++++-----
 .../convert/ToStringFromBooleanEvaluator.java | 35 ++++------
 .../ToStringFromDatetimeEvaluator.java        | 35 ++++------
 .../convert/ToStringFromDoubleEvaluator.java  | 35 ++++------
 .../convert/ToStringFromIPEvaluator.java      | 35 ++++------
 .../convert/ToStringFromIntEvaluator.java     | 35 ++++------
 .../convert/ToStringFromLongEvaluator.java    | 35 ++++------
 .../ToStringFromUnsignedLongEvaluator.java    | 35 ++++------
 .../convert/ToStringFromVersionEvaluator.java | 35 ++++------
 .../ToUnsignedLongFromBooleanEvaluator.java   | 32 ++++-----
 .../ToUnsignedLongFromDoubleEvaluator.java    | 32 ++++-----
 .../ToUnsignedLongFromIntEvaluator.java       | 32 ++++-----
 .../ToUnsignedLongFromLongEvaluator.java      | 32 ++++-----
 .../ToUnsignedLongFromStringEvaluator.java    | 32 ++++-----
 .../convert/ToVersionFromStringEvaluator.java | 35 ++++------
 .../convert/AbstractConvertFunction.java      |  7 +-
 .../function/scalar/convert/ToBoolean.java    | 14 ++--
 .../function/scalar/convert/ToDatetime.java   | 16 +++--
 .../function/scalar/convert/ToDegrees.java    | 30 ++++++--
 .../function/scalar/convert/ToDouble.java     | 14 ++--
 .../function/scalar/convert/ToIP.java         | 17 +++--
 .../function/scalar/convert/ToInteger.java    | 14 ++--
 .../function/scalar/convert/ToLong.java       | 16 +++--
 .../function/scalar/convert/ToRadians.java    | 30 ++++++--
 .../function/scalar/convert/ToString.java     | 16 +++--
 .../scalar/convert/ToUnsignedLong.java        | 14 ++--
 .../function/scalar/convert/ToVersion.java    | 14 ++--
 51 files changed, 654 insertions(+), 862 deletions(-)

diff --git a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/ConvertEvaluatorImplementer.java b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/ConvertEvaluatorImplementer.java
index af42d94c236f2..d5e38127cdec7 100644
--- a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/ConvertEvaluatorImplementer.java
+++ b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/ConvertEvaluatorImplementer.java
@@ -13,8 +13,6 @@
 import com.squareup.javapoet.TypeName;
 import com.squareup.javapoet.TypeSpec;
 
-import java.util.BitSet;
-
 import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.Modifier;
 import javax.lang.model.element.TypeElement;
@@ -23,18 +21,13 @@
 import static org.elasticsearch.compute.gen.Methods.appendMethod;
 import static org.elasticsearch.compute.gen.Methods.getMethod;
 import static org.elasticsearch.compute.gen.Types.ABSTRACT_CONVERT_FUNCTION_EVALUATOR;
-import static org.elasticsearch.compute.gen.Types.BIG_ARRAYS;
 import static org.elasticsearch.compute.gen.Types.BLOCK;
 import static org.elasticsearch.compute.gen.Types.BYTES_REF;
-import static org.elasticsearch.compute.gen.Types.BYTES_REF_ARRAY;
-import static org.elasticsearch.compute.gen.Types.BYTES_REF_BLOCK;
+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.SOURCE;
 import static org.elasticsearch.compute.gen.Types.VECTOR;
-import static org.elasticsearch.compute.gen.Types.arrayBlockType;
-import static org.elasticsearch.compute.gen.Types.arrayVectorType;
 import static org.elasticsearch.compute.gen.Types.blockType;
-import static org.elasticsearch.compute.gen.Types.constantVectorType;
 import static org.elasticsearch.compute.gen.Types.vectorType;
 
 public class ConvertEvaluatorImplementer {
@@ -79,6 +72,8 @@ private TypeSpec type() {
         builder.addModifiers(Modifier.PUBLIC, Modifier.FINAL);
         builder.superclass(ABSTRACT_CONVERT_FUNCTION_EVALUATOR);
 
+        builder.addField(DRIVER_CONTEXT, "driverContext", Modifier.PRIVATE, Modifier.FINAL);
+
         builder.addMethod(ctor());
         builder.addMethod(name());
         builder.addMethod(evalVector());
@@ -92,7 +87,9 @@ private MethodSpec ctor() {
         MethodSpec.Builder builder = MethodSpec.constructorBuilder().addModifiers(Modifier.PUBLIC);
         builder.addParameter(EXPRESSION_EVALUATOR, "field");
         builder.addParameter(SOURCE, "source");
+        builder.addParameter(DRIVER_CONTEXT, "driverContext");
         builder.addStatement("super($N, $N)", "field", "source");
+        builder.addStatement("this.driverContext = driverContext");
         return builder.build();
     }
 
@@ -121,9 +118,9 @@ private MethodSpec evalVector() {
         {
             builder.beginControlFlow("try");
             {
-                var constVectType = constantVectorType(resultType);
+                var constVectType = blockType(resultType);
                 builder.addStatement(
-                    "return new $T($N, positionCount).asBlock()",
+                    "return driverContext.blockFactory().newConstant$TWith($N, positionCount)",
                     constVectType,
                     evalValueCall("vector", "0", scratchPadName)
                 );
@@ -131,59 +128,34 @@ private MethodSpec evalVector() {
             builder.nextControlFlow("catch (Exception e)");
             {
                 builder.addStatement("registerException(e)");
-                builder.addStatement("return Block.constantNullBlock(positionCount)");
+                builder.addStatement("return Block.constantNullBlock(positionCount, driverContext.blockFactory())");
             }
             builder.endControlFlow();
         }
         builder.endControlFlow();
 
-        builder.addStatement("$T nullsMask = null", BitSet.class);
-        if (resultType.equals(BYTES_REF)) {
-            builder.addStatement(
-                "$T values = new $T(positionCount, $T.NON_RECYCLING_INSTANCE)", // TODO: see note in MvEvaluatorImplementer
-                BYTES_REF_ARRAY,
-                BYTES_REF_ARRAY,
-                BIG_ARRAYS
-            );
-        } else {
-            builder.addStatement("$T[] values = new $T[positionCount]", resultType, resultType);
-        }
+        ClassName returnBlockType = blockType(resultType);
+        builder.addStatement(
+            "$T.Builder builder = $T.newBlockBuilder(positionCount, driverContext.blockFactory())",
+            returnBlockType,
+            returnBlockType
+        );
         builder.beginControlFlow("for (int p = 0; p < positionCount; p++)");
         {
             builder.beginControlFlow("try");
             {
-                if (resultType.equals(BYTES_REF)) {
-                    builder.addStatement("values.append($N)", evalValueCall("vector", "p", scratchPadName));
-                } else {
-                    builder.addStatement("values[p] = $N", evalValueCall("vector", "p", scratchPadName));
-                }
+                builder.addStatement("builder.$L($N)", appendMethod(resultType), evalValueCall("vector", "p", scratchPadName));
             }
             builder.nextControlFlow("catch (Exception e)");
             {
                 builder.addStatement("registerException(e)");
-                builder.beginControlFlow("if (nullsMask == null)");
-                {
-                    builder.addStatement("nullsMask = new BitSet(positionCount)");
-                }
-                builder.endControlFlow();
-                builder.addStatement("nullsMask.set(p)");
-                if (resultType.equals(BYTES_REF)) {
-                    builder.addStatement("values.append($T.NULL_VALUE)", BYTES_REF_BLOCK);
-                }
+                builder.addStatement("builder.appendNull()");
             }
             builder.endControlFlow();
         }
         builder.endControlFlow();
 
-        builder.addStatement(
-            """
-                return nullsMask == null
-                  ? new $T(values, positionCount).asBlock()
-                  // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-                  : new $T(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED)""",
-            arrayVectorType(resultType),
-            arrayBlockType(resultType)
-        );
+        builder.addStatement("return builder.build()");
 
         return builder.build();
     }
@@ -196,7 +168,11 @@ private MethodSpec evalBlock() {
         builder.addStatement("$T block = ($T) b", blockType, blockType);
         builder.addStatement("int positionCount = block.getPositionCount()");
         TypeName resultBlockType = blockType(resultType);
-        builder.addStatement("$T.Builder builder = $T.newBlockBuilder(positionCount)", resultBlockType, resultBlockType);
+        builder.addStatement(
+            "$T.Builder builder = $T.newBlockBuilder(positionCount, driverContext.blockFactory())",
+            resultBlockType,
+            resultBlockType
+        );
         String scratchPadName = null;
         if (argumentType.equals(BYTES_REF)) {
             scratchPadName = "scratchPad";
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromDoubleEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromDoubleEvaluator.java
index dba115f4f7c29..0b8b444a2b6a3 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromDoubleEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromDoubleEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.BooleanArrayBlock;
-import org.elasticsearch.compute.data.BooleanArrayVector;
 import org.elasticsearch.compute.data.BooleanBlock;
-import org.elasticsearch.compute.data.ConstantBooleanVector;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.DoubleVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToBooleanFromDoubleEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToBooleanFromDoubleEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToBooleanFromDoubleEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantBooleanVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantBooleanBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    boolean[] values = new boolean[positionCount];
+    BooleanBlock.Builder builder = BooleanBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendBoolean(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new BooleanArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new BooleanArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static boolean evalValue(DoubleVector container, int index) {
@@ -72,7 +66,7 @@ private static boolean evalValue(DoubleVector container, int index) {
   public Block evalBlock(Block b) {
     DoubleBlock block = (DoubleBlock) b;
     int positionCount = block.getPositionCount();
-    BooleanBlock.Builder builder = BooleanBlock.newBlockBuilder(positionCount);
+    BooleanBlock.Builder builder = BooleanBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromIntEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromIntEvaluator.java
index d20179fd7baed..1295956645a6f 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromIntEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromIntEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.BooleanArrayBlock;
-import org.elasticsearch.compute.data.BooleanArrayVector;
 import org.elasticsearch.compute.data.BooleanBlock;
-import org.elasticsearch.compute.data.ConstantBooleanVector;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.data.IntVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToBooleanFromIntEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToBooleanFromIntEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToBooleanFromIntEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantBooleanVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantBooleanBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    boolean[] values = new boolean[positionCount];
+    BooleanBlock.Builder builder = BooleanBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendBoolean(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new BooleanArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new BooleanArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static boolean evalValue(IntVector container, int index) {
@@ -72,7 +66,7 @@ private static boolean evalValue(IntVector container, int index) {
   public Block evalBlock(Block b) {
     IntBlock block = (IntBlock) b;
     int positionCount = block.getPositionCount();
-    BooleanBlock.Builder builder = BooleanBlock.newBlockBuilder(positionCount);
+    BooleanBlock.Builder builder = BooleanBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromLongEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromLongEvaluator.java
index 7ab2d656a59cb..be01f122f9a8f 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromLongEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromLongEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.BooleanArrayBlock;
-import org.elasticsearch.compute.data.BooleanArrayVector;
 import org.elasticsearch.compute.data.BooleanBlock;
-import org.elasticsearch.compute.data.ConstantBooleanVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.LongVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToBooleanFromLongEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToBooleanFromLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToBooleanFromLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantBooleanVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantBooleanBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    boolean[] values = new boolean[positionCount];
+    BooleanBlock.Builder builder = BooleanBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendBoolean(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new BooleanArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new BooleanArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static boolean evalValue(LongVector container, int index) {
@@ -72,7 +66,7 @@ private static boolean evalValue(LongVector container, int index) {
   public Block evalBlock(Block b) {
     LongBlock block = (LongBlock) b;
     int positionCount = block.getPositionCount();
-    BooleanBlock.Builder builder = BooleanBlock.newBlockBuilder(positionCount);
+    BooleanBlock.Builder builder = BooleanBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromStringEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromStringEvaluator.java
index d70d0365aaf4d..7b83995bf0933 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromStringEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromStringEvaluator.java
@@ -6,16 +6,13 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.BooleanArrayBlock;
-import org.elasticsearch.compute.data.BooleanArrayVector;
 import org.elasticsearch.compute.data.BooleanBlock;
 import org.elasticsearch.compute.data.BytesRefBlock;
 import org.elasticsearch.compute.data.BytesRefVector;
-import org.elasticsearch.compute.data.ConstantBooleanVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -24,8 +21,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToBooleanFromStringEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToBooleanFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToBooleanFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -40,29 +41,22 @@ public Block evalVector(Vector v) {
     BytesRef scratchPad = new BytesRef();
     if (vector.isConstant()) {
       try {
-        return new ConstantBooleanVector(evalValue(vector, 0, scratchPad), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantBooleanBlockWith(evalValue(vector, 0, scratchPad), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    boolean[] values = new boolean[positionCount];
+    BooleanBlock.Builder builder = BooleanBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p, scratchPad);
+        builder.appendBoolean(evalValue(vector, p, scratchPad));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new BooleanArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new BooleanArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static boolean evalValue(BytesRefVector container, int index, BytesRef scratchPad) {
@@ -74,7 +68,7 @@ private static boolean evalValue(BytesRefVector container, int index, BytesRef s
   public Block evalBlock(Block b) {
     BytesRefBlock block = (BytesRefBlock) b;
     int positionCount = block.getPositionCount();
-    BooleanBlock.Builder builder = BooleanBlock.newBlockBuilder(positionCount);
+    BooleanBlock.Builder builder = BooleanBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     BytesRef scratchPad = new BytesRef();
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromUnsignedLongEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromUnsignedLongEvaluator.java
index d2cf4b41770ce..4a8aebe9cd8ab 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromUnsignedLongEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBooleanFromUnsignedLongEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.BooleanArrayBlock;
-import org.elasticsearch.compute.data.BooleanArrayVector;
 import org.elasticsearch.compute.data.BooleanBlock;
-import org.elasticsearch.compute.data.ConstantBooleanVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.LongVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToBooleanFromUnsignedLongEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToBooleanFromUnsignedLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToBooleanFromUnsignedLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantBooleanVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantBooleanBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    boolean[] values = new boolean[positionCount];
+    BooleanBlock.Builder builder = BooleanBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendBoolean(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new BooleanArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new BooleanArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static boolean evalValue(LongVector container, int index) {
@@ -72,7 +66,7 @@ private static boolean evalValue(LongVector container, int index) {
   public Block evalBlock(Block b) {
     LongBlock block = (LongBlock) b;
     int positionCount = block.getPositionCount();
-    BooleanBlock.Builder builder = BooleanBlock.newBlockBuilder(positionCount);
+    BooleanBlock.Builder builder = BooleanBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDatetimeFromStringEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDatetimeFromStringEvaluator.java
index 98310bb390392..ca237c1dcc4a7 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDatetimeFromStringEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDatetimeFromStringEvaluator.java
@@ -6,16 +6,13 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.BytesRefBlock;
 import org.elasticsearch.compute.data.BytesRefVector;
-import org.elasticsearch.compute.data.ConstantLongVector;
-import org.elasticsearch.compute.data.LongArrayBlock;
-import org.elasticsearch.compute.data.LongArrayVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -24,8 +21,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToDatetimeFromStringEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToDatetimeFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToDatetimeFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -40,29 +41,22 @@ public Block evalVector(Vector v) {
     BytesRef scratchPad = new BytesRef();
     if (vector.isConstant()) {
       try {
-        return new ConstantLongVector(evalValue(vector, 0, scratchPad), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantLongBlockWith(evalValue(vector, 0, scratchPad), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    long[] values = new long[positionCount];
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p, scratchPad);
+        builder.appendLong(evalValue(vector, p, scratchPad));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new LongArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new LongArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static long evalValue(BytesRefVector container, int index, BytesRef scratchPad) {
@@ -74,7 +68,7 @@ private static long evalValue(BytesRefVector container, int index, BytesRef scra
   public Block evalBlock(Block b) {
     BytesRefBlock block = (BytesRefBlock) b;
     int positionCount = block.getPositionCount();
-    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount);
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     BytesRef scratchPad = new BytesRef();
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDegreesEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDegreesEvaluator.java
index a168d93e73ba3..27509a4a18e56 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDegreesEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDegreesEvaluator.java
@@ -6,14 +6,11 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.ConstantDoubleVector;
-import org.elasticsearch.compute.data.DoubleArrayBlock;
-import org.elasticsearch.compute.data.DoubleArrayVector;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.DoubleVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -22,8 +19,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToDegreesEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToDegreesEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToDegreesEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -37,29 +38,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantDoubleVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantDoubleBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    double[] values = new double[positionCount];
+    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendDouble(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new DoubleArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new DoubleArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static double evalValue(DoubleVector container, int index) {
@@ -71,7 +65,7 @@ private static double evalValue(DoubleVector container, int index) {
   public Block evalBlock(Block b) {
     DoubleBlock block = (DoubleBlock) b;
     int positionCount = block.getPositionCount();
-    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount);
+    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromBooleanEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromBooleanEvaluator.java
index d2b16e4b722cb..a6ab12763ddc2 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromBooleanEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromBooleanEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.BooleanBlock;
 import org.elasticsearch.compute.data.BooleanVector;
-import org.elasticsearch.compute.data.ConstantDoubleVector;
-import org.elasticsearch.compute.data.DoubleArrayBlock;
-import org.elasticsearch.compute.data.DoubleArrayVector;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToDoubleFromBooleanEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToDoubleFromBooleanEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToDoubleFromBooleanEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantDoubleVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantDoubleBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    double[] values = new double[positionCount];
+    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendDouble(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new DoubleArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new DoubleArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static double evalValue(BooleanVector container, int index) {
@@ -72,7 +66,7 @@ private static double evalValue(BooleanVector container, int index) {
   public Block evalBlock(Block b) {
     BooleanBlock block = (BooleanBlock) b;
     int positionCount = block.getPositionCount();
-    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount);
+    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromIntEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromIntEvaluator.java
index 53e8edac3c5b3..5889cf151f0fa 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromIntEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromIntEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.ConstantDoubleVector;
-import org.elasticsearch.compute.data.DoubleArrayBlock;
-import org.elasticsearch.compute.data.DoubleArrayVector;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.data.IntVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToDoubleFromIntEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToDoubleFromIntEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToDoubleFromIntEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantDoubleVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantDoubleBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    double[] values = new double[positionCount];
+    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendDouble(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new DoubleArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new DoubleArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static double evalValue(IntVector container, int index) {
@@ -72,7 +66,7 @@ private static double evalValue(IntVector container, int index) {
   public Block evalBlock(Block b) {
     IntBlock block = (IntBlock) b;
     int positionCount = block.getPositionCount();
-    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount);
+    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromLongEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromLongEvaluator.java
index 9be5f1f2456b1..ff1c81f3f544f 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromLongEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromLongEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.ConstantDoubleVector;
-import org.elasticsearch.compute.data.DoubleArrayBlock;
-import org.elasticsearch.compute.data.DoubleArrayVector;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.LongVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToDoubleFromLongEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToDoubleFromLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToDoubleFromLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantDoubleVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantDoubleBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    double[] values = new double[positionCount];
+    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendDouble(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new DoubleArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new DoubleArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static double evalValue(LongVector container, int index) {
@@ -72,7 +66,7 @@ private static double evalValue(LongVector container, int index) {
   public Block evalBlock(Block b) {
     LongBlock block = (LongBlock) b;
     int positionCount = block.getPositionCount();
-    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount);
+    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromStringEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromStringEvaluator.java
index 653034f0c3bc9..197e5e5f2db36 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromStringEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromStringEvaluator.java
@@ -6,16 +6,13 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.BytesRefBlock;
 import org.elasticsearch.compute.data.BytesRefVector;
-import org.elasticsearch.compute.data.ConstantDoubleVector;
-import org.elasticsearch.compute.data.DoubleArrayBlock;
-import org.elasticsearch.compute.data.DoubleArrayVector;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -24,8 +21,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToDoubleFromStringEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToDoubleFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToDoubleFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -40,29 +41,22 @@ public Block evalVector(Vector v) {
     BytesRef scratchPad = new BytesRef();
     if (vector.isConstant()) {
       try {
-        return new ConstantDoubleVector(evalValue(vector, 0, scratchPad), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantDoubleBlockWith(evalValue(vector, 0, scratchPad), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    double[] values = new double[positionCount];
+    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p, scratchPad);
+        builder.appendDouble(evalValue(vector, p, scratchPad));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new DoubleArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new DoubleArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static double evalValue(BytesRefVector container, int index, BytesRef scratchPad) {
@@ -74,7 +68,7 @@ private static double evalValue(BytesRefVector container, int index, BytesRef sc
   public Block evalBlock(Block b) {
     BytesRefBlock block = (BytesRefBlock) b;
     int positionCount = block.getPositionCount();
-    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount);
+    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     BytesRef scratchPad = new BytesRef();
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromUnsignedLongEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromUnsignedLongEvaluator.java
index 54cc374c758fb..018517ae61d36 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromUnsignedLongEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDoubleFromUnsignedLongEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.ConstantDoubleVector;
-import org.elasticsearch.compute.data.DoubleArrayBlock;
-import org.elasticsearch.compute.data.DoubleArrayVector;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.LongVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToDoubleFromUnsignedLongEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToDoubleFromUnsignedLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToDoubleFromUnsignedLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantDoubleVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantDoubleBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    double[] values = new double[positionCount];
+    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendDouble(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new DoubleArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new DoubleArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static double evalValue(LongVector container, int index) {
@@ -72,7 +66,7 @@ private static double evalValue(LongVector container, int index) {
   public Block evalBlock(Block b) {
     LongBlock block = (LongBlock) b;
     int positionCount = block.getPositionCount();
-    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount);
+    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIPFromStringEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIPFromStringEvaluator.java
index 76d5c58961970..b62fa771e492c 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIPFromStringEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIPFromStringEvaluator.java
@@ -6,17 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
-import org.elasticsearch.common.util.BigArrays;
-import org.elasticsearch.common.util.BytesRefArray;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.BytesRefArrayBlock;
-import org.elasticsearch.compute.data.BytesRefArrayVector;
 import org.elasticsearch.compute.data.BytesRefBlock;
 import org.elasticsearch.compute.data.BytesRefVector;
-import org.elasticsearch.compute.data.ConstantBytesRefVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -25,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToIPFromStringEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToIPFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToIPFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -41,30 +40,22 @@ public Block evalVector(Vector v) {
     BytesRef scratchPad = new BytesRef();
     if (vector.isConstant()) {
       try {
-        return new ConstantBytesRefVector(evalValue(vector, 0, scratchPad), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantBytesRefBlockWith(evalValue(vector, 0, scratchPad), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    BytesRefArray values = new BytesRefArray(positionCount, BigArrays.NON_RECYCLING_INSTANCE);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values.append(evalValue(vector, p, scratchPad));
+        builder.appendBytesRef(evalValue(vector, p, scratchPad));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
-        values.append(BytesRefBlock.NULL_VALUE);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new BytesRefArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new BytesRefArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static BytesRef evalValue(BytesRefVector container, int index, BytesRef scratchPad) {
@@ -76,7 +67,7 @@ private static BytesRef evalValue(BytesRefVector container, int index, BytesRef
   public Block evalBlock(Block b) {
     BytesRefBlock block = (BytesRefBlock) b;
     int positionCount = block.getPositionCount();
-    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     BytesRef scratchPad = new BytesRef();
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromBooleanEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromBooleanEvaluator.java
index 49f79cd0bcd3e..9529769a02200 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromBooleanEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromBooleanEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.BooleanBlock;
 import org.elasticsearch.compute.data.BooleanVector;
-import org.elasticsearch.compute.data.ConstantIntVector;
-import org.elasticsearch.compute.data.IntArrayBlock;
-import org.elasticsearch.compute.data.IntArrayVector;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToIntegerFromBooleanEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToIntegerFromBooleanEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToIntegerFromBooleanEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantIntVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantIntBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    int[] values = new int[positionCount];
+    IntBlock.Builder builder = IntBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendInt(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new IntArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new IntArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static int evalValue(BooleanVector container, int index) {
@@ -72,7 +66,7 @@ private static int evalValue(BooleanVector container, int index) {
   public Block evalBlock(Block b) {
     BooleanBlock block = (BooleanBlock) b;
     int positionCount = block.getPositionCount();
-    IntBlock.Builder builder = IntBlock.newBlockBuilder(positionCount);
+    IntBlock.Builder builder = IntBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromDoubleEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromDoubleEvaluator.java
index e1b0db72ad7d9..7af8bdbf083ef 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromDoubleEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromDoubleEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.ConstantIntVector;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.DoubleVector;
-import org.elasticsearch.compute.data.IntArrayBlock;
-import org.elasticsearch.compute.data.IntArrayVector;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToIntegerFromDoubleEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToIntegerFromDoubleEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToIntegerFromDoubleEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantIntVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantIntBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    int[] values = new int[positionCount];
+    IntBlock.Builder builder = IntBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendInt(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new IntArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new IntArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static int evalValue(DoubleVector container, int index) {
@@ -72,7 +66,7 @@ private static int evalValue(DoubleVector container, int index) {
   public Block evalBlock(Block b) {
     DoubleBlock block = (DoubleBlock) b;
     int positionCount = block.getPositionCount();
-    IntBlock.Builder builder = IntBlock.newBlockBuilder(positionCount);
+    IntBlock.Builder builder = IntBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromLongEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromLongEvaluator.java
index 9a1394b9c02cf..a84367ab27a30 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromLongEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromLongEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.ConstantIntVector;
-import org.elasticsearch.compute.data.IntArrayBlock;
-import org.elasticsearch.compute.data.IntArrayVector;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.LongVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToIntegerFromLongEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToIntegerFromLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToIntegerFromLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantIntVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantIntBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    int[] values = new int[positionCount];
+    IntBlock.Builder builder = IntBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendInt(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new IntArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new IntArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static int evalValue(LongVector container, int index) {
@@ -72,7 +66,7 @@ private static int evalValue(LongVector container, int index) {
   public Block evalBlock(Block b) {
     LongBlock block = (LongBlock) b;
     int positionCount = block.getPositionCount();
-    IntBlock.Builder builder = IntBlock.newBlockBuilder(positionCount);
+    IntBlock.Builder builder = IntBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromStringEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromStringEvaluator.java
index 180e64f97e63b..bd7085764e341 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromStringEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromStringEvaluator.java
@@ -6,16 +6,13 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.BytesRefBlock;
 import org.elasticsearch.compute.data.BytesRefVector;
-import org.elasticsearch.compute.data.ConstantIntVector;
-import org.elasticsearch.compute.data.IntArrayBlock;
-import org.elasticsearch.compute.data.IntArrayVector;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -24,8 +21,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToIntegerFromStringEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToIntegerFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToIntegerFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -40,29 +41,22 @@ public Block evalVector(Vector v) {
     BytesRef scratchPad = new BytesRef();
     if (vector.isConstant()) {
       try {
-        return new ConstantIntVector(evalValue(vector, 0, scratchPad), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantIntBlockWith(evalValue(vector, 0, scratchPad), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    int[] values = new int[positionCount];
+    IntBlock.Builder builder = IntBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p, scratchPad);
+        builder.appendInt(evalValue(vector, p, scratchPad));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new IntArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new IntArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static int evalValue(BytesRefVector container, int index, BytesRef scratchPad) {
@@ -74,7 +68,7 @@ private static int evalValue(BytesRefVector container, int index, BytesRef scrat
   public Block evalBlock(Block b) {
     BytesRefBlock block = (BytesRefBlock) b;
     int positionCount = block.getPositionCount();
-    IntBlock.Builder builder = IntBlock.newBlockBuilder(positionCount);
+    IntBlock.Builder builder = IntBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     BytesRef scratchPad = new BytesRef();
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromUnsignedLongEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromUnsignedLongEvaluator.java
index 698db22c0ecc6..2312f94fec83e 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromUnsignedLongEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIntegerFromUnsignedLongEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.ConstantIntVector;
-import org.elasticsearch.compute.data.IntArrayBlock;
-import org.elasticsearch.compute.data.IntArrayVector;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.LongVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToIntegerFromUnsignedLongEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToIntegerFromUnsignedLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToIntegerFromUnsignedLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantIntVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantIntBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    int[] values = new int[positionCount];
+    IntBlock.Builder builder = IntBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendInt(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new IntArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new IntArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static int evalValue(LongVector container, int index) {
@@ -72,7 +66,7 @@ private static int evalValue(LongVector container, int index) {
   public Block evalBlock(Block b) {
     LongBlock block = (LongBlock) b;
     int positionCount = block.getPositionCount();
-    IntBlock.Builder builder = IntBlock.newBlockBuilder(positionCount);
+    IntBlock.Builder builder = IntBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromBooleanEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromBooleanEvaluator.java
index bf76fb0eb8a59..48e3e45d42f46 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromBooleanEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromBooleanEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.BooleanBlock;
 import org.elasticsearch.compute.data.BooleanVector;
-import org.elasticsearch.compute.data.ConstantLongVector;
-import org.elasticsearch.compute.data.LongArrayBlock;
-import org.elasticsearch.compute.data.LongArrayVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToLongFromBooleanEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToLongFromBooleanEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToLongFromBooleanEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantLongVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantLongBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    long[] values = new long[positionCount];
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendLong(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new LongArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new LongArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static long evalValue(BooleanVector container, int index) {
@@ -72,7 +66,7 @@ private static long evalValue(BooleanVector container, int index) {
   public Block evalBlock(Block b) {
     BooleanBlock block = (BooleanBlock) b;
     int positionCount = block.getPositionCount();
-    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount);
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromDoubleEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromDoubleEvaluator.java
index 116be245e3191..14ec5e41a04e5 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromDoubleEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromDoubleEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.ConstantLongVector;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.DoubleVector;
-import org.elasticsearch.compute.data.LongArrayBlock;
-import org.elasticsearch.compute.data.LongArrayVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToLongFromDoubleEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToLongFromDoubleEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToLongFromDoubleEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantLongVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantLongBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    long[] values = new long[positionCount];
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendLong(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new LongArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new LongArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static long evalValue(DoubleVector container, int index) {
@@ -72,7 +66,7 @@ private static long evalValue(DoubleVector container, int index) {
   public Block evalBlock(Block b) {
     DoubleBlock block = (DoubleBlock) b;
     int positionCount = block.getPositionCount();
-    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount);
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromIntEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromIntEvaluator.java
index 02d043c641cb0..f0eae8bfccc44 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromIntEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromIntEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.ConstantLongVector;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.data.IntVector;
-import org.elasticsearch.compute.data.LongArrayBlock;
-import org.elasticsearch.compute.data.LongArrayVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToLongFromIntEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToLongFromIntEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToLongFromIntEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantLongVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantLongBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    long[] values = new long[positionCount];
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendLong(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new LongArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new LongArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static long evalValue(IntVector container, int index) {
@@ -72,7 +66,7 @@ private static long evalValue(IntVector container, int index) {
   public Block evalBlock(Block b) {
     IntBlock block = (IntBlock) b;
     int positionCount = block.getPositionCount();
-    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount);
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromStringEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromStringEvaluator.java
index cc825664cc331..8af9a14fd81be 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromStringEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromStringEvaluator.java
@@ -6,16 +6,13 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.BytesRefBlock;
 import org.elasticsearch.compute.data.BytesRefVector;
-import org.elasticsearch.compute.data.ConstantLongVector;
-import org.elasticsearch.compute.data.LongArrayBlock;
-import org.elasticsearch.compute.data.LongArrayVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -24,8 +21,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToLongFromStringEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToLongFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToLongFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -40,29 +41,22 @@ public Block evalVector(Vector v) {
     BytesRef scratchPad = new BytesRef();
     if (vector.isConstant()) {
       try {
-        return new ConstantLongVector(evalValue(vector, 0, scratchPad), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantLongBlockWith(evalValue(vector, 0, scratchPad), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    long[] values = new long[positionCount];
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p, scratchPad);
+        builder.appendLong(evalValue(vector, p, scratchPad));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new LongArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new LongArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static long evalValue(BytesRefVector container, int index, BytesRef scratchPad) {
@@ -74,7 +68,7 @@ private static long evalValue(BytesRefVector container, int index, BytesRef scra
   public Block evalBlock(Block b) {
     BytesRefBlock block = (BytesRefBlock) b;
     int positionCount = block.getPositionCount();
-    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount);
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     BytesRef scratchPad = new BytesRef();
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromUnsignedLongEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromUnsignedLongEvaluator.java
index 02bef2f9f9c2d..569df205855d3 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromUnsignedLongEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLongFromUnsignedLongEvaluator.java
@@ -6,14 +6,11 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.ConstantLongVector;
-import org.elasticsearch.compute.data.LongArrayBlock;
-import org.elasticsearch.compute.data.LongArrayVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.LongVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -22,8 +19,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToLongFromUnsignedLongEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToLongFromUnsignedLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToLongFromUnsignedLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -37,29 +38,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantLongVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantLongBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    long[] values = new long[positionCount];
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendLong(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new LongArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new LongArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static long evalValue(LongVector container, int index) {
@@ -71,7 +65,7 @@ private static long evalValue(LongVector container, int index) {
   public Block evalBlock(Block b) {
     LongBlock block = (LongBlock) b;
     int positionCount = block.getPositionCount();
-    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount);
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToRadiansEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToRadiansEvaluator.java
index 33ae94093dd85..6aa373e69b7cd 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToRadiansEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToRadiansEvaluator.java
@@ -6,14 +6,11 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.ConstantDoubleVector;
-import org.elasticsearch.compute.data.DoubleArrayBlock;
-import org.elasticsearch.compute.data.DoubleArrayVector;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.DoubleVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -22,8 +19,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToRadiansEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToRadiansEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToRadiansEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -37,29 +38,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantDoubleVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantDoubleBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    double[] values = new double[positionCount];
+    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendDouble(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new DoubleArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new DoubleArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static double evalValue(DoubleVector container, int index) {
@@ -71,7 +65,7 @@ private static double evalValue(DoubleVector container, int index) {
   public Block evalBlock(Block b) {
     DoubleBlock block = (DoubleBlock) b;
     int positionCount = block.getPositionCount();
-    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount);
+    DoubleBlock.Builder builder = DoubleBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromBooleanEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromBooleanEvaluator.java
index 876344b1c35bc..8507395c6153a 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromBooleanEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromBooleanEvaluator.java
@@ -6,18 +6,13 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
-import org.elasticsearch.common.util.BigArrays;
-import org.elasticsearch.common.util.BytesRefArray;
 import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.BooleanBlock;
 import org.elasticsearch.compute.data.BooleanVector;
-import org.elasticsearch.compute.data.BytesRefArrayBlock;
-import org.elasticsearch.compute.data.BytesRefArrayVector;
 import org.elasticsearch.compute.data.BytesRefBlock;
-import org.elasticsearch.compute.data.ConstantBytesRefVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -26,8 +21,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToStringFromBooleanEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToStringFromBooleanEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToStringFromBooleanEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -41,30 +40,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantBytesRefVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantBytesRefBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    BytesRefArray values = new BytesRefArray(positionCount, BigArrays.NON_RECYCLING_INSTANCE);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values.append(evalValue(vector, p));
+        builder.appendBytesRef(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
-        values.append(BytesRefBlock.NULL_VALUE);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new BytesRefArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new BytesRefArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static BytesRef evalValue(BooleanVector container, int index) {
@@ -76,7 +67,7 @@ private static BytesRef evalValue(BooleanVector container, int index) {
   public Block evalBlock(Block b) {
     BooleanBlock block = (BooleanBlock) b;
     int positionCount = block.getPositionCount();
-    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromDatetimeEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromDatetimeEvaluator.java
index 8aa5148b21de4..7d6bf029fe80b 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromDatetimeEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromDatetimeEvaluator.java
@@ -6,18 +6,13 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
-import org.elasticsearch.common.util.BigArrays;
-import org.elasticsearch.common.util.BytesRefArray;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.BytesRefArrayBlock;
-import org.elasticsearch.compute.data.BytesRefArrayVector;
 import org.elasticsearch.compute.data.BytesRefBlock;
-import org.elasticsearch.compute.data.ConstantBytesRefVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.LongVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -26,8 +21,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToStringFromDatetimeEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToStringFromDatetimeEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToStringFromDatetimeEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -41,30 +40,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantBytesRefVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantBytesRefBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    BytesRefArray values = new BytesRefArray(positionCount, BigArrays.NON_RECYCLING_INSTANCE);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values.append(evalValue(vector, p));
+        builder.appendBytesRef(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
-        values.append(BytesRefBlock.NULL_VALUE);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new BytesRefArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new BytesRefArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static BytesRef evalValue(LongVector container, int index) {
@@ -76,7 +67,7 @@ private static BytesRef evalValue(LongVector container, int index) {
   public Block evalBlock(Block b) {
     LongBlock block = (LongBlock) b;
     int positionCount = block.getPositionCount();
-    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromDoubleEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromDoubleEvaluator.java
index 8c7994a3c0a68..e0aa134286723 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromDoubleEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromDoubleEvaluator.java
@@ -6,18 +6,13 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
-import org.elasticsearch.common.util.BigArrays;
-import org.elasticsearch.common.util.BytesRefArray;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.BytesRefArrayBlock;
-import org.elasticsearch.compute.data.BytesRefArrayVector;
 import org.elasticsearch.compute.data.BytesRefBlock;
-import org.elasticsearch.compute.data.ConstantBytesRefVector;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.DoubleVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -26,8 +21,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToStringFromDoubleEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToStringFromDoubleEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToStringFromDoubleEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -41,30 +40,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantBytesRefVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantBytesRefBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    BytesRefArray values = new BytesRefArray(positionCount, BigArrays.NON_RECYCLING_INSTANCE);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values.append(evalValue(vector, p));
+        builder.appendBytesRef(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
-        values.append(BytesRefBlock.NULL_VALUE);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new BytesRefArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new BytesRefArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static BytesRef evalValue(DoubleVector container, int index) {
@@ -76,7 +67,7 @@ private static BytesRef evalValue(DoubleVector container, int index) {
   public Block evalBlock(Block b) {
     DoubleBlock block = (DoubleBlock) b;
     int positionCount = block.getPositionCount();
-    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromIPEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromIPEvaluator.java
index 4e0249939cc91..7ef6c3df27025 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromIPEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromIPEvaluator.java
@@ -6,17 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
-import org.elasticsearch.common.util.BigArrays;
-import org.elasticsearch.common.util.BytesRefArray;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.BytesRefArrayBlock;
-import org.elasticsearch.compute.data.BytesRefArrayVector;
 import org.elasticsearch.compute.data.BytesRefBlock;
 import org.elasticsearch.compute.data.BytesRefVector;
-import org.elasticsearch.compute.data.ConstantBytesRefVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -25,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToStringFromIPEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToStringFromIPEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToStringFromIPEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -41,30 +40,22 @@ public Block evalVector(Vector v) {
     BytesRef scratchPad = new BytesRef();
     if (vector.isConstant()) {
       try {
-        return new ConstantBytesRefVector(evalValue(vector, 0, scratchPad), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantBytesRefBlockWith(evalValue(vector, 0, scratchPad), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    BytesRefArray values = new BytesRefArray(positionCount, BigArrays.NON_RECYCLING_INSTANCE);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values.append(evalValue(vector, p, scratchPad));
+        builder.appendBytesRef(evalValue(vector, p, scratchPad));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
-        values.append(BytesRefBlock.NULL_VALUE);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new BytesRefArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new BytesRefArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static BytesRef evalValue(BytesRefVector container, int index, BytesRef scratchPad) {
@@ -76,7 +67,7 @@ private static BytesRef evalValue(BytesRefVector container, int index, BytesRef
   public Block evalBlock(Block b) {
     BytesRefBlock block = (BytesRefBlock) b;
     int positionCount = block.getPositionCount();
-    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     BytesRef scratchPad = new BytesRef();
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromIntEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromIntEvaluator.java
index d076b38f49b91..abe206d5a5152 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromIntEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromIntEvaluator.java
@@ -6,18 +6,13 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
-import org.elasticsearch.common.util.BigArrays;
-import org.elasticsearch.common.util.BytesRefArray;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.BytesRefArrayBlock;
-import org.elasticsearch.compute.data.BytesRefArrayVector;
 import org.elasticsearch.compute.data.BytesRefBlock;
-import org.elasticsearch.compute.data.ConstantBytesRefVector;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.data.IntVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -26,8 +21,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToStringFromIntEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToStringFromIntEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToStringFromIntEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -41,30 +40,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantBytesRefVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantBytesRefBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    BytesRefArray values = new BytesRefArray(positionCount, BigArrays.NON_RECYCLING_INSTANCE);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values.append(evalValue(vector, p));
+        builder.appendBytesRef(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
-        values.append(BytesRefBlock.NULL_VALUE);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new BytesRefArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new BytesRefArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static BytesRef evalValue(IntVector container, int index) {
@@ -76,7 +67,7 @@ private static BytesRef evalValue(IntVector container, int index) {
   public Block evalBlock(Block b) {
     IntBlock block = (IntBlock) b;
     int positionCount = block.getPositionCount();
-    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromLongEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromLongEvaluator.java
index 90448cb992cd2..be6c2648f9eb4 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromLongEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromLongEvaluator.java
@@ -6,18 +6,13 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
-import org.elasticsearch.common.util.BigArrays;
-import org.elasticsearch.common.util.BytesRefArray;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.BytesRefArrayBlock;
-import org.elasticsearch.compute.data.BytesRefArrayVector;
 import org.elasticsearch.compute.data.BytesRefBlock;
-import org.elasticsearch.compute.data.ConstantBytesRefVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.LongVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -26,8 +21,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToStringFromLongEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToStringFromLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToStringFromLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -41,30 +40,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantBytesRefVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantBytesRefBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    BytesRefArray values = new BytesRefArray(positionCount, BigArrays.NON_RECYCLING_INSTANCE);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values.append(evalValue(vector, p));
+        builder.appendBytesRef(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
-        values.append(BytesRefBlock.NULL_VALUE);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new BytesRefArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new BytesRefArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static BytesRef evalValue(LongVector container, int index) {
@@ -76,7 +67,7 @@ private static BytesRef evalValue(LongVector container, int index) {
   public Block evalBlock(Block b) {
     LongBlock block = (LongBlock) b;
     int positionCount = block.getPositionCount();
-    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromUnsignedLongEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromUnsignedLongEvaluator.java
index 91e31c9626b5e..9ba24301875d2 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromUnsignedLongEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromUnsignedLongEvaluator.java
@@ -6,18 +6,13 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
-import org.elasticsearch.common.util.BigArrays;
-import org.elasticsearch.common.util.BytesRefArray;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.BytesRefArrayBlock;
-import org.elasticsearch.compute.data.BytesRefArrayVector;
 import org.elasticsearch.compute.data.BytesRefBlock;
-import org.elasticsearch.compute.data.ConstantBytesRefVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.LongVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -26,8 +21,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToStringFromUnsignedLongEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToStringFromUnsignedLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToStringFromUnsignedLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -41,30 +40,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantBytesRefVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantBytesRefBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    BytesRefArray values = new BytesRefArray(positionCount, BigArrays.NON_RECYCLING_INSTANCE);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values.append(evalValue(vector, p));
+        builder.appendBytesRef(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
-        values.append(BytesRefBlock.NULL_VALUE);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new BytesRefArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new BytesRefArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static BytesRef evalValue(LongVector container, int index) {
@@ -76,7 +67,7 @@ private static BytesRef evalValue(LongVector container, int index) {
   public Block evalBlock(Block b) {
     LongBlock block = (LongBlock) b;
     int positionCount = block.getPositionCount();
-    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromVersionEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromVersionEvaluator.java
index 281b881bd6141..69d2e0e106fa0 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromVersionEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToStringFromVersionEvaluator.java
@@ -6,17 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
-import org.elasticsearch.common.util.BigArrays;
-import org.elasticsearch.common.util.BytesRefArray;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.BytesRefArrayBlock;
-import org.elasticsearch.compute.data.BytesRefArrayVector;
 import org.elasticsearch.compute.data.BytesRefBlock;
 import org.elasticsearch.compute.data.BytesRefVector;
-import org.elasticsearch.compute.data.ConstantBytesRefVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -25,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToStringFromVersionEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToStringFromVersionEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToStringFromVersionEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -41,30 +40,22 @@ public Block evalVector(Vector v) {
     BytesRef scratchPad = new BytesRef();
     if (vector.isConstant()) {
       try {
-        return new ConstantBytesRefVector(evalValue(vector, 0, scratchPad), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantBytesRefBlockWith(evalValue(vector, 0, scratchPad), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    BytesRefArray values = new BytesRefArray(positionCount, BigArrays.NON_RECYCLING_INSTANCE);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values.append(evalValue(vector, p, scratchPad));
+        builder.appendBytesRef(evalValue(vector, p, scratchPad));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
-        values.append(BytesRefBlock.NULL_VALUE);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new BytesRefArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new BytesRefArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static BytesRef evalValue(BytesRefVector container, int index, BytesRef scratchPad) {
@@ -76,7 +67,7 @@ private static BytesRef evalValue(BytesRefVector container, int index, BytesRef
   public Block evalBlock(Block b) {
     BytesRefBlock block = (BytesRefBlock) b;
     int positionCount = block.getPositionCount();
-    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     BytesRef scratchPad = new BytesRef();
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromBooleanEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromBooleanEvaluator.java
index ec8b16568c380..541e5b8c7af11 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromBooleanEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromBooleanEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.BooleanBlock;
 import org.elasticsearch.compute.data.BooleanVector;
-import org.elasticsearch.compute.data.ConstantLongVector;
-import org.elasticsearch.compute.data.LongArrayBlock;
-import org.elasticsearch.compute.data.LongArrayVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToUnsignedLongFromBooleanEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToUnsignedLongFromBooleanEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToUnsignedLongFromBooleanEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantLongVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantLongBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    long[] values = new long[positionCount];
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendLong(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new LongArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new LongArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static long evalValue(BooleanVector container, int index) {
@@ -72,7 +66,7 @@ private static long evalValue(BooleanVector container, int index) {
   public Block evalBlock(Block b) {
     BooleanBlock block = (BooleanBlock) b;
     int positionCount = block.getPositionCount();
-    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount);
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromDoubleEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromDoubleEvaluator.java
index 2ada365ce848e..89c896ccf1f43 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromDoubleEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromDoubleEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.ConstantLongVector;
 import org.elasticsearch.compute.data.DoubleBlock;
 import org.elasticsearch.compute.data.DoubleVector;
-import org.elasticsearch.compute.data.LongArrayBlock;
-import org.elasticsearch.compute.data.LongArrayVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToUnsignedLongFromDoubleEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToUnsignedLongFromDoubleEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToUnsignedLongFromDoubleEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantLongVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantLongBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    long[] values = new long[positionCount];
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendLong(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new LongArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new LongArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static long evalValue(DoubleVector container, int index) {
@@ -72,7 +66,7 @@ private static long evalValue(DoubleVector container, int index) {
   public Block evalBlock(Block b) {
     DoubleBlock block = (DoubleBlock) b;
     int positionCount = block.getPositionCount();
-    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount);
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromIntEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromIntEvaluator.java
index 9acad2f9481a6..3c78c24ea7b01 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromIntEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromIntEvaluator.java
@@ -6,15 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.ConstantLongVector;
 import org.elasticsearch.compute.data.IntBlock;
 import org.elasticsearch.compute.data.IntVector;
-import org.elasticsearch.compute.data.LongArrayBlock;
-import org.elasticsearch.compute.data.LongArrayVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -23,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToUnsignedLongFromIntEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToUnsignedLongFromIntEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToUnsignedLongFromIntEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -38,29 +39,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantLongVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantLongBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    long[] values = new long[positionCount];
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendLong(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new LongArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new LongArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static long evalValue(IntVector container, int index) {
@@ -72,7 +66,7 @@ private static long evalValue(IntVector container, int index) {
   public Block evalBlock(Block b) {
     IntBlock block = (IntBlock) b;
     int positionCount = block.getPositionCount();
-    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount);
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromLongEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromLongEvaluator.java
index 0cb7da2ed230f..0c0cb9ebfb525 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromLongEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromLongEvaluator.java
@@ -6,14 +6,11 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.ConstantLongVector;
-import org.elasticsearch.compute.data.LongArrayBlock;
-import org.elasticsearch.compute.data.LongArrayVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.LongVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -22,8 +19,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToUnsignedLongFromLongEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToUnsignedLongFromLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToUnsignedLongFromLongEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -37,29 +38,22 @@ public Block evalVector(Vector v) {
     int positionCount = v.getPositionCount();
     if (vector.isConstant()) {
       try {
-        return new ConstantLongVector(evalValue(vector, 0), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantLongBlockWith(evalValue(vector, 0), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    long[] values = new long[positionCount];
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p);
+        builder.appendLong(evalValue(vector, p));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new LongArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new LongArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static long evalValue(LongVector container, int index) {
@@ -71,7 +65,7 @@ private static long evalValue(LongVector container, int index) {
   public Block evalBlock(Block b) {
     LongBlock block = (LongBlock) b;
     int positionCount = block.getPositionCount();
-    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount);
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
       int start = block.getFirstValueIndex(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromStringEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromStringEvaluator.java
index 3297fcffbe73b..38056be01487c 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromStringEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLongFromStringEvaluator.java
@@ -6,16 +6,13 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.BytesRefBlock;
 import org.elasticsearch.compute.data.BytesRefVector;
-import org.elasticsearch.compute.data.ConstantLongVector;
-import org.elasticsearch.compute.data.LongArrayBlock;
-import org.elasticsearch.compute.data.LongArrayVector;
 import org.elasticsearch.compute.data.LongBlock;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -24,8 +21,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToUnsignedLongFromStringEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToUnsignedLongFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToUnsignedLongFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -40,29 +41,22 @@ public Block evalVector(Vector v) {
     BytesRef scratchPad = new BytesRef();
     if (vector.isConstant()) {
       try {
-        return new ConstantLongVector(evalValue(vector, 0, scratchPad), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantLongBlockWith(evalValue(vector, 0, scratchPad), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    long[] values = new long[positionCount];
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values[p] = evalValue(vector, p, scratchPad);
+        builder.appendLong(evalValue(vector, p, scratchPad));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new LongArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new LongArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static long evalValue(BytesRefVector container, int index, BytesRef scratchPad) {
@@ -74,7 +68,7 @@ private static long evalValue(BytesRefVector container, int index, BytesRef scra
   public Block evalBlock(Block b) {
     BytesRefBlock block = (BytesRefBlock) b;
     int positionCount = block.getPositionCount();
-    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount);
+    LongBlock.Builder builder = LongBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     BytesRef scratchPad = new BytesRef();
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
diff --git a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToVersionFromStringEvaluator.java b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToVersionFromStringEvaluator.java
index 5f6b62e16de52..bead25f13dd6a 100644
--- a/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToVersionFromStringEvaluator.java
+++ b/x-pack/plugin/esql/src/main/java/generated/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToVersionFromStringEvaluator.java
@@ -6,17 +6,12 @@
 
 import java.lang.Override;
 import java.lang.String;
-import java.util.BitSet;
 import org.apache.lucene.util.BytesRef;
-import org.elasticsearch.common.util.BigArrays;
-import org.elasticsearch.common.util.BytesRefArray;
 import org.elasticsearch.compute.data.Block;
-import org.elasticsearch.compute.data.BytesRefArrayBlock;
-import org.elasticsearch.compute.data.BytesRefArrayVector;
 import org.elasticsearch.compute.data.BytesRefBlock;
 import org.elasticsearch.compute.data.BytesRefVector;
-import org.elasticsearch.compute.data.ConstantBytesRefVector;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.tree.Source;
 
@@ -25,8 +20,12 @@
  * This class is generated. Do not edit it.
  */
 public final class ToVersionFromStringEvaluator extends AbstractConvertFunction.AbstractEvaluator {
-  public ToVersionFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source) {
+  private final DriverContext driverContext;
+
+  public ToVersionFromStringEvaluator(EvalOperator.ExpressionEvaluator field, Source source,
+      DriverContext driverContext) {
     super(field, source);
+    this.driverContext = driverContext;
   }
 
   @Override
@@ -41,30 +40,22 @@ public Block evalVector(Vector v) {
     BytesRef scratchPad = new BytesRef();
     if (vector.isConstant()) {
       try {
-        return new ConstantBytesRefVector(evalValue(vector, 0, scratchPad), positionCount).asBlock();
+        return driverContext.blockFactory().newConstantBytesRefBlockWith(evalValue(vector, 0, scratchPad), positionCount);
       } catch (Exception e) {
         registerException(e);
-        return Block.constantNullBlock(positionCount);
+        return Block.constantNullBlock(positionCount, driverContext.blockFactory());
       }
     }
-    BitSet nullsMask = null;
-    BytesRefArray values = new BytesRefArray(positionCount, BigArrays.NON_RECYCLING_INSTANCE);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     for (int p = 0; p < positionCount; p++) {
       try {
-        values.append(evalValue(vector, p, scratchPad));
+        builder.appendBytesRef(evalValue(vector, p, scratchPad));
       } catch (Exception e) {
         registerException(e);
-        if (nullsMask == null) {
-          nullsMask = new BitSet(positionCount);
-        }
-        nullsMask.set(p);
-        values.append(BytesRefBlock.NULL_VALUE);
+        builder.appendNull();
       }
     }
-    return nullsMask == null
-          ? new BytesRefArrayVector(values, positionCount).asBlock()
-          // UNORDERED, since whatever ordering there is, it isn't necessarily preserved
-          : new BytesRefArrayBlock(values, positionCount, null, nullsMask, Block.MvOrdering.UNORDERED);
+    return builder.build();
   }
 
   private static BytesRef evalValue(BytesRefVector container, int index, BytesRef scratchPad) {
@@ -76,7 +67,7 @@ private static BytesRef evalValue(BytesRefVector container, int index, BytesRef
   public Block evalBlock(Block b) {
     BytesRefBlock block = (BytesRefBlock) b;
     int positionCount = block.getPositionCount();
-    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount);
+    BytesRefBlock.Builder builder = BytesRefBlock.newBlockBuilder(positionCount, driverContext.blockFactory());
     BytesRef scratchPad = new BytesRef();
     for (int p = 0; p < positionCount; p++) {
       int valueCount = block.getValueCount(p);
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/AbstractConvertFunction.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/AbstractConvertFunction.java
index 1af66cb4f50b0..de24b049ea575 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/AbstractConvertFunction.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/AbstractConvertFunction.java
@@ -9,9 +9,11 @@
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+import org.elasticsearch.common.TriFunction;
 import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.data.Vector;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.compute.operator.EvalOperator.ExpressionEvaluator;
 import org.elasticsearch.core.Releasables;
@@ -25,7 +27,6 @@
 
 import java.util.Locale;
 import java.util.Map;
-import java.util.function.BiFunction;
 import java.util.function.Function;
 
 import static org.elasticsearch.xpack.ql.expression.TypeResolutions.isType;
@@ -48,7 +49,7 @@ protected ExpressionEvaluator.Factory evaluator(ExpressionEvaluator.Factory fiel
         if (evaluator == null) {
             throw EsqlIllegalArgumentException.illegalDataType(sourceType);
         }
-        return dvrCtx -> evaluator.apply(fieldEval.get(dvrCtx), source());
+        return dvrCtx -> evaluator.apply(fieldEval.get(dvrCtx), source(), dvrCtx);
     }
 
     @Override
@@ -65,7 +66,7 @@ protected final TypeResolution resolveType() {
         );
     }
 
-    protected abstract Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> evaluators();
+    protected abstract Map<DataType, TriFunction<ExpressionEvaluator, Source, DriverContext, ExpressionEvaluator>> evaluators();
 
     @Override
     public final Object fold() {
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBoolean.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBoolean.java
index 3ec6492ef0d8c..701b3fa67732c 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBoolean.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToBoolean.java
@@ -8,7 +8,9 @@
 package org.elasticsearch.xpack.esql.expression.function.scalar.convert;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.common.TriFunction;
 import org.elasticsearch.compute.ann.ConvertEvaluator;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.expression.Expression;
 import org.elasticsearch.xpack.ql.tree.NodeInfo;
@@ -18,7 +20,6 @@
 import java.math.BigInteger;
 import java.util.List;
 import java.util.Map;
-import java.util.function.BiFunction;
 
 import static org.elasticsearch.xpack.ql.type.DataTypes.BOOLEAN;
 import static org.elasticsearch.xpack.ql.type.DataTypes.DOUBLE;
@@ -30,10 +31,11 @@
 
 public class ToBoolean extends AbstractConvertFunction {
 
-    private static final Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> EVALUATORS =
-        Map.of(
+    private static final Map<
+        DataType,
+        TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>> EVALUATORS = Map.of(
             BOOLEAN,
-            (fieldEval, source) -> fieldEval,
+            (fieldEval, source, driverContext) -> fieldEval,
             KEYWORD,
             ToBooleanFromStringEvaluator::new,
             DOUBLE,
@@ -51,7 +53,9 @@ public ToBoolean(Source source, Expression field) {
     }
 
     @Override
-    protected Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> evaluators() {
+    protected
+        Map<DataType, TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>>
+        evaluators() {
         return EVALUATORS;
     }
 
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDatetime.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDatetime.java
index 5049a80d075f9..eb23e460b88ff 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDatetime.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDatetime.java
@@ -8,7 +8,9 @@
 package org.elasticsearch.xpack.esql.expression.function.scalar.convert;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.common.TriFunction;
 import org.elasticsearch.compute.ann.ConvertEvaluator;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.esql.expression.function.scalar.date.DateParse;
 import org.elasticsearch.xpack.ql.expression.Expression;
@@ -18,7 +20,6 @@
 
 import java.util.List;
 import java.util.Map;
-import java.util.function.BiFunction;
 
 import static org.elasticsearch.xpack.ql.type.DataTypes.DATETIME;
 import static org.elasticsearch.xpack.ql.type.DataTypes.DOUBLE;
@@ -29,12 +30,13 @@
 
 public class ToDatetime extends AbstractConvertFunction {
 
-    private static final Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> EVALUATORS =
-        Map.of(
+    private static final Map<
+        DataType,
+        TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>> EVALUATORS = Map.of(
             DATETIME,
-            (fieldEval, source) -> fieldEval,
+            (fieldEval, source, driverContext) -> fieldEval,
             LONG,
-            (fieldEval, source) -> fieldEval,
+            (fieldEval, source, driverContext) -> fieldEval,
             KEYWORD,
             ToDatetimeFromStringEvaluator::new,
             DOUBLE,
@@ -50,7 +52,9 @@ public ToDatetime(Source source, Expression field) {
     }
 
     @Override
-    protected Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> evaluators() {
+    protected
+        Map<DataType, TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>>
+        evaluators() {
         return EVALUATORS;
     }
 
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDegrees.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDegrees.java
index ec59446989bca..299e8cfe8643e 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDegrees.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDegrees.java
@@ -7,7 +7,9 @@
 
 package org.elasticsearch.xpack.esql.expression.function.scalar.convert;
 
+import org.elasticsearch.common.TriFunction;
 import org.elasticsearch.compute.ann.ConvertEvaluator;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.esql.evaluator.mapper.EvaluatorMapper;
 import org.elasticsearch.xpack.ql.expression.Expression;
@@ -17,7 +19,6 @@
 
 import java.util.List;
 import java.util.Map;
-import java.util.function.BiFunction;
 
 import static org.elasticsearch.xpack.ql.type.DataTypes.DOUBLE;
 import static org.elasticsearch.xpack.ql.type.DataTypes.INTEGER;
@@ -29,16 +30,29 @@
  * to <a href="https://en.wikipedia.org/wiki/Degree_(angle)">degrees</a>.
  */
 public class ToDegrees extends AbstractConvertFunction implements EvaluatorMapper {
-    private static final Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> EVALUATORS =
-        Map.of(
+    private static final Map<
+        DataType,
+        TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>> EVALUATORS = Map.of(
             DOUBLE,
             ToDegreesEvaluator::new,
             INTEGER,
-            (field, source) -> new ToDegreesEvaluator(new ToDoubleFromIntEvaluator(field, source), source),
+            (field, source, driverContext) -> new ToDegreesEvaluator(
+                new ToDoubleFromIntEvaluator(field, source, driverContext),
+                source,
+                driverContext
+            ),
             LONG,
-            (field, source) -> new ToDegreesEvaluator(new ToDoubleFromLongEvaluator(field, source), source),
+            (field, source, driverContext) -> new ToDegreesEvaluator(
+                new ToDoubleFromLongEvaluator(field, source, driverContext),
+                source,
+                driverContext
+            ),
             UNSIGNED_LONG,
-            (field, source) -> new ToDegreesEvaluator(new ToDoubleFromUnsignedLongEvaluator(field, source), source)
+            (field, source, driverContext) -> new ToDegreesEvaluator(
+                new ToDoubleFromUnsignedLongEvaluator(field, source, driverContext),
+                source,
+                driverContext
+            )
         );
 
     public ToDegrees(Source source, Expression field) {
@@ -46,7 +60,9 @@ public ToDegrees(Source source, Expression field) {
     }
 
     @Override
-    protected Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> evaluators() {
+    protected
+        Map<DataType, TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>>
+        evaluators() {
         return EVALUATORS;
     }
 
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDouble.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDouble.java
index dc8527637c7a3..690f7a66cbece 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDouble.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToDouble.java
@@ -8,7 +8,9 @@
 package org.elasticsearch.xpack.esql.expression.function.scalar.convert;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.common.TriFunction;
 import org.elasticsearch.compute.ann.ConvertEvaluator;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.expression.Expression;
 import org.elasticsearch.xpack.ql.tree.NodeInfo;
@@ -17,7 +19,6 @@
 
 import java.util.List;
 import java.util.Map;
-import java.util.function.BiFunction;
 
 import static org.elasticsearch.xpack.ql.type.DataTypes.BOOLEAN;
 import static org.elasticsearch.xpack.ql.type.DataTypes.DATETIME;
@@ -30,10 +31,11 @@
 
 public class ToDouble extends AbstractConvertFunction {
 
-    private static final Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> EVALUATORS =
-        Map.of(
+    private static final Map<
+        DataType,
+        TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>> EVALUATORS = Map.of(
             DOUBLE,
-            (fieldEval, source) -> fieldEval,
+            (fieldEval, source, driverContext) -> fieldEval,
             BOOLEAN,
             ToDoubleFromBooleanEvaluator::new,
             DATETIME,
@@ -53,7 +55,9 @@ public ToDouble(Source source, Expression field) {
     }
 
     @Override
-    protected Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> evaluators() {
+    protected
+        Map<DataType, TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>>
+        evaluators() {
         return EVALUATORS;
     }
 
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIP.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIP.java
index 0931033758dbb..d55b9d23975e1 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIP.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToIP.java
@@ -8,7 +8,9 @@
 package org.elasticsearch.xpack.esql.expression.function.scalar.convert;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.common.TriFunction;
 import org.elasticsearch.compute.ann.ConvertEvaluator;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.expression.Expression;
 import org.elasticsearch.xpack.ql.tree.NodeInfo;
@@ -17,7 +19,6 @@
 
 import java.util.List;
 import java.util.Map;
-import java.util.function.BiFunction;
 
 import static org.elasticsearch.xpack.ql.type.DataTypes.IP;
 import static org.elasticsearch.xpack.ql.type.DataTypes.KEYWORD;
@@ -25,15 +26,23 @@
 
 public class ToIP extends AbstractConvertFunction {
 
-    private static final Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> EVALUATORS =
-        Map.of(IP, (fieldEval, source) -> fieldEval, KEYWORD, ToIPFromStringEvaluator::new);
+    private static final Map<
+        DataType,
+        TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>> EVALUATORS = Map.of(
+            IP,
+            (fieldEval, source, driverContext) -> fieldEval,
+            KEYWORD,
+            ToIPFromStringEvaluator::new
+        );
 
     public ToIP(Source source, Expression field) {
         super(source, field);
     }
 
     @Override
-    protected Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> evaluators() {
+    protected
+        Map<DataType, TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>>
+        evaluators() {
         return EVALUATORS;
     }
 
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToInteger.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToInteger.java
index 1d26c4724a423..0fcf62ed3864a 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToInteger.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToInteger.java
@@ -8,7 +8,9 @@
 package org.elasticsearch.xpack.esql.expression.function.scalar.convert;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.common.TriFunction;
 import org.elasticsearch.compute.ann.ConvertEvaluator;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.expression.Expression;
 import org.elasticsearch.xpack.ql.tree.NodeInfo;
@@ -17,7 +19,6 @@
 
 import java.util.List;
 import java.util.Map;
-import java.util.function.BiFunction;
 
 import static org.elasticsearch.xpack.ql.type.DataTypeConverter.safeDoubleToLong;
 import static org.elasticsearch.xpack.ql.type.DataTypeConverter.safeToInt;
@@ -31,10 +32,11 @@
 
 public class ToInteger extends AbstractConvertFunction {
 
-    private static final Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> EVALUATORS =
-        Map.of(
+    private static final Map<
+        DataType,
+        TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>> EVALUATORS = Map.of(
             INTEGER,
-            (fieldEval, source) -> fieldEval,
+            (fieldEval, source, driverContext) -> fieldEval,
             BOOLEAN,
             ToIntegerFromBooleanEvaluator::new,
             DATETIME,
@@ -54,7 +56,9 @@ public ToInteger(Source source, Expression field) {
     }
 
     @Override
-    protected Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> evaluators() {
+    protected
+        Map<DataType, TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>>
+        evaluators() {
         return EVALUATORS;
     }
 
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLong.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLong.java
index ffb31a77cb1fc..8e50dd8540ffd 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLong.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToLong.java
@@ -8,7 +8,9 @@
 package org.elasticsearch.xpack.esql.expression.function.scalar.convert;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.common.TriFunction;
 import org.elasticsearch.compute.ann.ConvertEvaluator;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.expression.Expression;
 import org.elasticsearch.xpack.ql.tree.NodeInfo;
@@ -17,7 +19,6 @@
 
 import java.util.List;
 import java.util.Map;
-import java.util.function.BiFunction;
 
 import static org.elasticsearch.xpack.ql.type.DataTypeConverter.safeDoubleToLong;
 import static org.elasticsearch.xpack.ql.type.DataTypeConverter.safeToLong;
@@ -32,12 +33,13 @@
 
 public class ToLong extends AbstractConvertFunction {
 
-    private static final Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> EVALUATORS =
-        Map.of(
+    private static final Map<
+        DataType,
+        TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>> EVALUATORS = Map.of(
             LONG,
-            (fieldEval, source) -> fieldEval,
+            (fieldEval, source, driverContext) -> fieldEval,
             DATETIME,
-            (fieldEval, source) -> fieldEval,
+            (fieldEval, source, driverContext) -> fieldEval,
             BOOLEAN,
             ToLongFromBooleanEvaluator::new,
             KEYWORD,
@@ -55,7 +57,9 @@ public ToLong(Source source, Expression field) {
     }
 
     @Override
-    protected Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> evaluators() {
+    protected
+        Map<DataType, TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>>
+        evaluators() {
         return EVALUATORS;
     }
 
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToRadians.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToRadians.java
index 8064303e204d5..8bb5180e09752 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToRadians.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToRadians.java
@@ -7,7 +7,9 @@
 
 package org.elasticsearch.xpack.esql.expression.function.scalar.convert;
 
+import org.elasticsearch.common.TriFunction;
 import org.elasticsearch.compute.ann.ConvertEvaluator;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.esql.evaluator.mapper.EvaluatorMapper;
 import org.elasticsearch.xpack.ql.expression.Expression;
@@ -17,7 +19,6 @@
 
 import java.util.List;
 import java.util.Map;
-import java.util.function.BiFunction;
 
 import static org.elasticsearch.xpack.ql.type.DataTypes.DOUBLE;
 import static org.elasticsearch.xpack.ql.type.DataTypes.INTEGER;
@@ -29,16 +30,29 @@
  * to <a href="https://en.wikipedia.org/wiki/Radian">radians</a>.
  */
 public class ToRadians extends AbstractConvertFunction implements EvaluatorMapper {
-    private static final Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> EVALUATORS =
-        Map.of(
+    private static final Map<
+        DataType,
+        TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>> EVALUATORS = Map.of(
             DOUBLE,
             ToRadiansEvaluator::new,
             INTEGER,
-            (field, source) -> new ToRadiansEvaluator(new ToDoubleFromIntEvaluator(field, source), source),
+            (field, source, driverContext) -> new ToRadiansEvaluator(
+                new ToDoubleFromIntEvaluator(field, source, driverContext),
+                source,
+                driverContext
+            ),
             LONG,
-            (field, source) -> new ToRadiansEvaluator(new ToDoubleFromLongEvaluator(field, source), source),
+            (field, source, driverContext) -> new ToRadiansEvaluator(
+                new ToDoubleFromLongEvaluator(field, source, driverContext),
+                source,
+                driverContext
+            ),
             UNSIGNED_LONG,
-            (field, source) -> new ToRadiansEvaluator(new ToDoubleFromUnsignedLongEvaluator(field, source), source)
+            (field, source, driverContext) -> new ToRadiansEvaluator(
+                new ToDoubleFromUnsignedLongEvaluator(field, source, driverContext),
+                source,
+                driverContext
+            )
         );
 
     public ToRadians(Source source, Expression field) {
@@ -46,7 +60,9 @@ public ToRadians(Source source, Expression field) {
     }
 
     @Override
-    protected Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> evaluators() {
+    protected
+        Map<DataType, TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>>
+        evaluators() {
         return EVALUATORS;
     }
 
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToString.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToString.java
index 428c1f32b1fc7..af895ab7c56cf 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToString.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToString.java
@@ -8,7 +8,9 @@
 package org.elasticsearch.xpack.esql.expression.function.scalar.convert;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.common.TriFunction;
 import org.elasticsearch.compute.ann.ConvertEvaluator;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.search.DocValueFormat;
 import org.elasticsearch.xpack.esql.evaluator.mapper.EvaluatorMapper;
@@ -21,7 +23,6 @@
 
 import java.util.List;
 import java.util.Map;
-import java.util.function.BiFunction;
 
 import static org.elasticsearch.xpack.ql.type.DataTypes.BOOLEAN;
 import static org.elasticsearch.xpack.ql.type.DataTypes.DATETIME;
@@ -38,10 +39,11 @@
 
 public class ToString extends AbstractConvertFunction implements EvaluatorMapper {
 
-    private static final Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> EVALUATORS =
-        Map.of(
+    private static final Map<
+        DataType,
+        TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>> EVALUATORS = Map.of(
             KEYWORD,
-            (fieldEval, source) -> fieldEval,
+            (fieldEval, source, driverContext) -> fieldEval,
             BOOLEAN,
             ToStringFromBooleanEvaluator::new,
             DATETIME,
@@ -55,7 +57,7 @@ public class ToString extends AbstractConvertFunction implements EvaluatorMapper
             INTEGER,
             ToStringFromIntEvaluator::new,
             TEXT,
-            (fieldEval, source) -> fieldEval,
+            (fieldEval, source, driverContext) -> fieldEval,
             VERSION,
             ToStringFromVersionEvaluator::new,
             UNSIGNED_LONG,
@@ -67,7 +69,9 @@ public ToString(Source source, @Named("v") Expression v) {
     }
 
     @Override
-    protected Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> evaluators() {
+    protected
+        Map<DataType, TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>>
+        evaluators() {
         return EVALUATORS;
     }
 
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLong.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLong.java
index 83deed6b18490..396aa03f39dc6 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLong.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToUnsignedLong.java
@@ -8,7 +8,9 @@
 package org.elasticsearch.xpack.esql.expression.function.scalar.convert;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.common.TriFunction;
 import org.elasticsearch.compute.ann.ConvertEvaluator;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.ql.expression.Expression;
 import org.elasticsearch.xpack.ql.tree.NodeInfo;
@@ -17,7 +19,6 @@
 
 import java.util.List;
 import java.util.Map;
-import java.util.function.BiFunction;
 
 import static org.elasticsearch.xpack.ql.type.DataTypeConverter.safeToUnsignedLong;
 import static org.elasticsearch.xpack.ql.type.DataTypes.BOOLEAN;
@@ -33,10 +34,11 @@
 
 public class ToUnsignedLong extends AbstractConvertFunction {
 
-    private static final Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> EVALUATORS =
-        Map.of(
+    private static final Map<
+        DataType,
+        TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>> EVALUATORS = Map.of(
             UNSIGNED_LONG,
-            (fieldEval, source) -> fieldEval,
+            (fieldEval, source, driverContext) -> fieldEval,
             DATETIME,
             ToUnsignedLongFromLongEvaluator::new,
             BOOLEAN,
@@ -56,7 +58,9 @@ public ToUnsignedLong(Source source, Expression field) {
     }
 
     @Override
-    protected Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> evaluators() {
+    protected
+        Map<DataType, TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>>
+        evaluators() {
         return EVALUATORS;
     }
 
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToVersion.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToVersion.java
index 0051bee45eead..559e2fc4f89fa 100644
--- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToVersion.java
+++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/convert/ToVersion.java
@@ -8,7 +8,9 @@
 package org.elasticsearch.xpack.esql.expression.function.scalar.convert;
 
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.common.TriFunction;
 import org.elasticsearch.compute.ann.ConvertEvaluator;
+import org.elasticsearch.compute.operator.DriverContext;
 import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.xpack.esql.expression.function.Named;
 import org.elasticsearch.xpack.ql.expression.Expression;
@@ -19,7 +21,6 @@
 
 import java.util.List;
 import java.util.Map;
-import java.util.function.BiFunction;
 
 import static org.elasticsearch.xpack.ql.type.DataTypes.KEYWORD;
 import static org.elasticsearch.xpack.ql.type.DataTypes.TEXT;
@@ -27,9 +28,10 @@
 
 public class ToVersion extends AbstractConvertFunction {
 
-    private static final Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> EVALUATORS =
-        Map.ofEntries(
-            Map.entry(VERSION, (fieldEval, source) -> fieldEval),
+    private static final Map<
+        DataType,
+        TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>> EVALUATORS = Map.ofEntries(
+            Map.entry(VERSION, (fieldEval, source, driverContext) -> fieldEval),
             Map.entry(KEYWORD, ToVersionFromStringEvaluator::new),
             Map.entry(TEXT, ToVersionFromStringEvaluator::new)
         );
@@ -39,7 +41,9 @@ public ToVersion(Source source, @Named("v") Expression v) {
     }
 
     @Override
-    protected Map<DataType, BiFunction<EvalOperator.ExpressionEvaluator, Source, EvalOperator.ExpressionEvaluator>> evaluators() {
+    protected
+        Map<DataType, TriFunction<EvalOperator.ExpressionEvaluator, Source, DriverContext, EvalOperator.ExpressionEvaluator>>
+        evaluators() {
         return EVALUATORS;
     }
 

From c2072fc4d369d76c2f78024dcc31548ec4789721 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Istv=C3=A1n=20Zolt=C3=A1n=20Szab=C3=B3?=
 <istvan.szabo@elastic.co>
Date: Fri, 29 Sep 2023 10:12:07 +0200
Subject: [PATCH 31/32] [DOCS] Adds reference documentation for inference API
 (#99658)

* [DOCS] Creates documentation structure.

* [DOCS] Adds PUT inference API docs and part of GET inference API docs.

* [DOCS] Fixes complaining CI.

* [DOCS] Adds GET and DELETE API docs for inference API.

* [DOCS] Adds POST inference API docs.

* Apply suggestions from code review
---
 .../inference/delete-inference.asciidoc       |  57 ++++++++++
 .../inference/get-inference.asciidoc          |  79 +++++++++++++
 .../inference/inference-apis.asciidoc         |  16 +++
 .../inference/post-inference.asciidoc         |  97 ++++++++++++++++
 .../inference/put-inference.asciidoc          | 104 ++++++++++++++++++
 docs/reference/rest-api/index.asciidoc        |   6 +-
 6 files changed, 357 insertions(+), 2 deletions(-)
 create mode 100644 docs/reference/inference/delete-inference.asciidoc
 create mode 100644 docs/reference/inference/get-inference.asciidoc
 create mode 100644 docs/reference/inference/inference-apis.asciidoc
 create mode 100644 docs/reference/inference/post-inference.asciidoc
 create mode 100644 docs/reference/inference/put-inference.asciidoc

diff --git a/docs/reference/inference/delete-inference.asciidoc b/docs/reference/inference/delete-inference.asciidoc
new file mode 100644
index 0000000000000..874bfa64d3551
--- /dev/null
+++ b/docs/reference/inference/delete-inference.asciidoc
@@ -0,0 +1,57 @@
+[role="xpack"]
+[[delete-inference-api]]
+=== Delete {infer} API
+
+Deletes an {infer} model deployment.
+
+
+[discrete]
+[[delete-inference-api-request]]
+==== {api-request-title}
+
+`DELETE /_inference/<task_type>/<model_id>`
+
+[discrete]
+[[delete-inference-api-prereqs]]
+==== {api-prereq-title}
+
+* Requires the `manage` <<privileges-list-cluster,cluster privilege>>.
+
+
+[discrete]
+[[delete-inference-api-path-params]]
+==== {api-path-parms-title}
+
+<model_id>::
+(Required, string)
+The unique identifier of the {infer} model to delete.
+
+<task_type>::
+(Required, string)
+The type of {infer} task that the model performs.
+
+
+[discrete]
+[[delete-inference-api-example]]
+==== {api-examples-title}
+
+The following API call deletes the `my-elser-model` {infer} model that can 
+perform `sparse_embedding` tasks.
+
+
+[source,console]
+------------------------------------------------------------
+DELETE /_inference/sparse_embedding/my-elser-model
+------------------------------------------------------------
+// TEST[skip:TBD]
+
+
+The API returns the following response:
+
+[source,console-result]
+------------------------------------------------------------
+{
+  "acknowledged": true
+}
+------------------------------------------------------------
+// NOTCONSOLE
\ No newline at end of file
diff --git a/docs/reference/inference/get-inference.asciidoc b/docs/reference/inference/get-inference.asciidoc
new file mode 100644
index 0000000000000..7e32bd05b5f56
--- /dev/null
+++ b/docs/reference/inference/get-inference.asciidoc
@@ -0,0 +1,79 @@
+[role="xpack"]
+[[get-inference-api]]
+=== Get {infer} API
+
+Retrieves {infer} model information.
+
+[discrete]
+[[get-inference-api-request]]
+==== {api-request-title}
+
+`GET /_inference/_all`
+
+`GET /_inference/<task_type>/_all`
+
+`GET /_inference/<task_type>/<model_id>`
+
+[discrete]
+[[get-inference-api-prereqs]]
+==== {api-prereq-title}
+
+* Requires the `manage` <<privileges-list-cluster,cluster privilege>>.
+
+[discrete]
+[[get-inference-api-desc]]
+==== {api-description-title}
+
+You can get information in a single API request for: 
+
+* a single {infer} model by providing the task type and the model ID,
+* all of the {infer} models for a certain task type by providing the task type 
+and a wildcard expression,
+* all of the {infer} models by using a wildcard expression.
+
+
+[discrete]
+[[get-inference-api-path-params]]
+==== {api-path-parms-title}
+
+`<model_id>`::
+(Optional, string)
+The unique identifier of the {infer} model.
+
+
+`<task_type>`::
+(Optional, string)
+The type of {infer} task that the model performs.
+
+
+[discrete]
+[[get-inference-api-example]]
+==== {api-examples-title}
+
+The following API call retrives information about the `my-elser-model` {infer} 
+model that can perform `sparse_embedding` tasks.
+
+
+[source,console]
+------------------------------------------------------------
+GET _inference/sparse_embedding/my-elser-model
+------------------------------------------------------------
+// TEST[skip:TBD]
+
+
+The API returns the following response:
+
+[source,console-result]
+------------------------------------------------------------
+{
+  "model_id": "my-elser-model",
+  "task_type": "sparse_embedding",
+  "service": "elser_mlnode",
+  "service_settings": {
+    "num_allocations": 1,
+    "num_threads": 1
+  },
+  "task_settings": {}
+}
+------------------------------------------------------------
+// NOTCONSOLE
\ No newline at end of file
diff --git a/docs/reference/inference/inference-apis.asciidoc b/docs/reference/inference/inference-apis.asciidoc
new file mode 100644
index 0000000000000..ec1f01bc4d093
--- /dev/null
+++ b/docs/reference/inference/inference-apis.asciidoc
@@ -0,0 +1,16 @@
+[role="xpack"]
+[[inference-apis]]
+== {infer-cap} APIs
+
+You can use the following APIs to manage {infer} models and perform {infer}:
+
+* <<delete-inference-api>>
+* <<get-inference-api>>
+* <<post-inference-api>>
+* <<put-inference-api>>
+
+
+include::delete-inference.asciidoc[]
+include::get-inference.asciidoc[]
+include::post-inference.asciidoc[]
+include::put-inference.asciidoc[]
\ No newline at end of file
diff --git a/docs/reference/inference/post-inference.asciidoc b/docs/reference/inference/post-inference.asciidoc
new file mode 100644
index 0000000000000..99dd4a059519f
--- /dev/null
+++ b/docs/reference/inference/post-inference.asciidoc
@@ -0,0 +1,97 @@
+[role="xpack"]
+[[post-inference-api]]
+=== Perform inference API
+
+Performs an inference task on an input text by using an {infer} model.
+
+
+[discrete]
+[[post-inference-api-request]]
+==== {api-request-title}
+
+`POST /_inference/<task_type>/<model_id>`
+
+
+[discrete]
+[[post-inference-api-prereqs]]
+==== {api-prereq-title}
+
+* Requires the `manage` <<privileges-list-cluster,cluster privilege>>.
+
+
+[discrete]
+[[post-inference-api-desc]]
+==== {api-description-title}
+
+The perform {infer} API enables you to use {infer} models to perform specific 
+tasks on data that you provide as an input. The API returns a response with the 
+resutls of the tasks. The {infer} model you use can perform one specific task 
+that has been defined when the model was created with the <<put-inference-api>>.
+
+
+[discrete]
+[[post-inference-api-path-params]]
+==== {api-path-parms-title}
+
+`<model_id>`::
+(Required, string)
+The unique identifier of the {infer} model.
+
+
+`<task_type>`::
+(Required, string)
+The type of {infer} task that the model performs.
+
+
+[discrete]
+[[post-inference-api-request-body]]
+== {api-request-body-title}
+
+`input`::
+(Required, string)
+The text on which you want to perform the {infer} task.
+
+
+[discrete]
+[[post-inference-api-example]]
+==== {api-examples-title}
+
+The following example performs sparse embedding on the example sentence.
+
+
+[source,console]
+------------------------------------------------------------
+POST _inference/sparse_embedding/my-elser-model
+{
+  "input": "The sky above the port was the color of television tuned to a dead channel."
+}
+------------------------------------------------------------
+// TEST[skip:TBD]
+
+
+The API returns the following response:
+
+
+[source,console-result]
+------------------------------------------------------------
+{
+  "sparse_embedding": {
+    "port": 2.1259406,
+    "sky": 1.7073475,
+    "color": 1.6922266,
+    "dead": 1.6247464,
+    "television": 1.3525393,
+    "above": 1.2425821,
+    "tuned": 1.1440028,
+    "colors": 1.1218185,
+    "tv": 1.0111054,
+    "ports": 1.0067928,
+    "poem": 1.0042328,
+    "channel": 0.99471164,
+    "tune": 0.96235967,
+    "scene": 0.9020516,
+    (...)
+  }
+}
+------------------------------------------------------------
+// NOTCONSOLE
\ No newline at end of file
diff --git a/docs/reference/inference/put-inference.asciidoc b/docs/reference/inference/put-inference.asciidoc
new file mode 100644
index 0000000000000..c5ccd6a57a8dd
--- /dev/null
+++ b/docs/reference/inference/put-inference.asciidoc
@@ -0,0 +1,104 @@
+[role="xpack"]
+[[put-inference-api]]
+=== Create {infer} API
+
+Creates a model to perform an {infer} task.
+
+
+[discrete]
+[[put-inference-api-request]]
+==== {api-request-title}
+
+`PUT /_inference/<task_type>/<model_id>`
+
+
+[discrete]
+[[put-inference-api-prereqs]]
+==== {api-prereq-title}
+
+* Requires the `manage` <<privileges-list-cluster,cluster privilege>>.
+
+[discrete]
+[[put-inference-api-desc]]
+==== {api-description-title}
+
+The create {infer} API enables you to create and configure an {infer} model to 
+perform a specific {infer} task. 
+
+
+[discrete]
+[[put-inference-api-path-params]]
+==== {api-path-parms-title}
+
+
+`<model_id>`::
+(Required, string)
+The unique identifier of the model.
+
+`<task_type>`::
+(Required, string)
+The type of the {infer} task that the model will perform. Available task types:
+* `sparse_embedding`,
+* `text_embedding`.
+
+
+[discrete]
+[[put-inference-api-request-body]]
+== {api-request-body-title}
+
+`service`::
+(Required, string)
+The type of service supported for the specified task type.
+Available services:
+* `elser`,
+* `elser_mlnode`.
+
+`service_settings`::
+(Required, object)
+Settings used to install the {infer} model. These settings are specific to the 
+`service` you specified.
+
+`task_settings`::
+(Optional, object)
+Settings to configure the {infer} task. These settings are specific to the 
+`<task_type>` you specified.
+
+
+[discrete]
+[[put-inference-api-example]]
+==== {api-examples-title}
+
+The following example shows how to create an {infer} model called 
+`my-elser-model` to perform a `sparse_embedding` task type.
+
+[source,console]
+------------------------------------------------------------
+PUT _inference/sparse_embedding/my-elser-model
+{
+  "service": "elser_mlnode",
+  "service_settings": {
+    "num_allocations": 1,
+    "num_threads": 1
+  },
+  "task_settings": {}
+}
+------------------------------------------------------------
+// TEST[skip:TBD]
+
+
+Example response:
+
+[source,console-result]
+------------------------------------------------------------
+{
+  "model_id": "my-elser-model",
+  "task_type": "sparse_embedding",
+  "service": "elser_mlnode",
+  "service_settings": {
+    "num_allocations": 1,
+    "num_threads": 1
+  },
+  "task_settings": {}
+}
+------------------------------------------------------------
+// NOTCONSOLE
diff --git a/docs/reference/rest-api/index.asciidoc b/docs/reference/rest-api/index.asciidoc
index 1da39333db43e..b8ad9d9a0736e 100644
--- a/docs/reference/rest-api/index.asciidoc
+++ b/docs/reference/rest-api/index.asciidoc
@@ -28,8 +28,9 @@ not be included yet.
 * <<graph-explore-api,Graph explore API>>
 * <<indices, Index APIs>>
 * <<index-lifecycle-management-api,Index lifecycle management APIs>>
-* <<ingest-apis,Ingest APIs>>
+* <<inference-apis,Inference APIs>>
 * <<info-api,Info API>>
+* <<ingest-apis,Ingest APIs>>
 * <<licensing-apis,Licensing APIs>>
 * <<logstash-apis,Logstash APIs>>
 * <<ml-apis,{ml-cap} APIs>>
@@ -74,8 +75,9 @@ include::{es-repo-dir}/text-structure/apis/find-structure.asciidoc[leveloffset=+
 include::{es-repo-dir}/graph/explore.asciidoc[]
 include::{es-repo-dir}/indices.asciidoc[]
 include::{es-repo-dir}/ilm/apis/ilm-api.asciidoc[]
-include::{es-repo-dir}/ingest/apis/index.asciidoc[]
+include::{es-repo-dir}/inference/inference-apis.asciidoc[]
 include::info.asciidoc[]
+include::{es-repo-dir}/ingest/apis/index.asciidoc[]
 include::{es-repo-dir}/licensing/index.asciidoc[]
 include::{es-repo-dir}/rest-api/logstash/index.asciidoc[]
 include::{es-repo-dir}/ml/common/apis/index.asciidoc[]

From e23fd3269c07e322f0fd112582edb6c131f93066 Mon Sep 17 00:00:00 2001
From: David Turner <david.turner@elastic.co>
Date: Fri, 29 Sep 2023 09:45:33 +0100
Subject: [PATCH 32/32] Move SLM eligibility check (#100044)

A small refactoring to make #99953 a little simpler: combine the logic
for retrieving the snapshot info and filtering out the ineligible ones
into a single function so we can replace it with a call to a dedicated
client action in a followup.
---
 .../xpack/slm/SnapshotRetentionTask.java      | 74 ++++++++++---------
 .../xpack/slm/SnapshotRetentionTaskTests.java | 60 ++++++---------
 2 files changed, 63 insertions(+), 71 deletions(-)

diff --git a/x-pack/plugin/slm/src/main/java/org/elasticsearch/xpack/slm/SnapshotRetentionTask.java b/x-pack/plugin/slm/src/main/java/org/elasticsearch/xpack/slm/SnapshotRetentionTask.java
index ac1b2f30ec06d..708621ee4a6c8 100644
--- a/x-pack/plugin/slm/src/main/java/org/elasticsearch/xpack/slm/SnapshotRetentionTask.java
+++ b/x-pack/plugin/slm/src/main/java/org/elasticsearch/xpack/slm/SnapshotRetentionTask.java
@@ -91,15 +91,6 @@ public SnapshotRetentionTask(
         this.historyStore = historyStore;
     }
 
-    private static String formatSnapshots(Map<String, List<SnapshotInfo>> snapshotMap) {
-        return snapshotMap.entrySet()
-            .stream()
-            .map(
-                e -> e.getKey() + ": [" + e.getValue().stream().map(si -> si.snapshotId().getName()).collect(Collectors.joining(",")) + "]"
-            )
-            .collect(Collectors.joining(","));
-    }
-
     @Override
     public void triggered(SchedulerEngine.Event event) {
         assert event.getJobName().equals(SnapshotRetentionService.SLM_RETENTION_JOB_ID)
@@ -156,28 +147,9 @@ public void triggered(SchedulerEngine.Event event) {
             // Finally, asynchronously retrieve all the snapshots, deleting them serially,
             // before updating the cluster state with the new metrics and setting 'running'
             // back to false
-            getAllRetainableSnapshots(repositioriesToFetch, policiesWithRetention.keySet(), new ActionListener<>() {
+            getSnapshotsEligibleForDeletion(repositioriesToFetch, policiesWithRetention, new ActionListener<>() {
                 @Override
-                public void onResponse(Map<String, List<SnapshotInfo>> allSnapshots) {
-                    if (logger.isTraceEnabled()) {
-                        logger.trace("retrieved snapshots: [{}]", formatSnapshots(allSnapshots));
-                    }
-                    // Find all the snapshots that are past their retention date
-                    final Map<String, List<Tuple<SnapshotId, String>>> snapshotsToBeDeleted = allSnapshots.entrySet()
-                        .stream()
-                        .collect(
-                            Collectors.toMap(
-                                Map.Entry::getKey,
-                                e -> e.getValue()
-                                    .stream()
-                                    .filter(snapshot -> snapshotEligibleForDeletion(snapshot, allSnapshots, policiesWithRetention))
-                                    // SnapshotInfo instances can be quite large in case they contain e.g. a large collection of
-                                    // exceptions so we extract the only two things (id + policy id) here so they can be GCed
-                                    .map(snapshotInfo -> Tuple.tuple(snapshotInfo.snapshotId(), getPolicyId(snapshotInfo)))
-                                    .toList()
-                            )
-                        );
-
+                public void onResponse(Map<String, List<Tuple<SnapshotId, String>>> snapshotsToBeDeleted) {
                     if (logger.isTraceEnabled()) {
                         logger.trace("snapshots eligible for deletion: [{}]", snapshotsToBeDeleted);
                     }
@@ -256,10 +228,10 @@ static boolean snapshotEligibleForDeletion(
         return eligible;
     }
 
-    void getAllRetainableSnapshots(
+    void getSnapshotsEligibleForDeletion(
         Collection<String> repositories,
-        Set<String> policies,
-        ActionListener<Map<String, List<SnapshotInfo>>> listener
+        Map<String, SnapshotLifecyclePolicy> policies,
+        ActionListener<Map<String, List<Tuple<SnapshotId, String>>>> listener
     ) {
         if (repositories.isEmpty()) {
             // Skip retrieving anything if there are no repositories to fetch
@@ -273,7 +245,7 @@ void getAllRetainableSnapshots(
             // don't time out on this request to not produce failed SLM runs in case of a temporarily slow master node
             .setMasterNodeTimeout(TimeValue.MAX_VALUE)
             .setIgnoreUnavailable(true)
-            .setPolicies(policies.toArray(Strings.EMPTY_ARRAY))
+            .setPolicies(policies.keySet().toArray(Strings.EMPTY_ARRAY))
             .setIncludeIndexNames(false)
             .execute(ActionListener.wrap(resp -> {
                 if (logger.isTraceEnabled()) {
@@ -300,7 +272,39 @@ void getAllRetainableSnapshots(
                         logger.debug(() -> "unable to retrieve snapshots for [" + repo + "] repositories: ", resp.getFailures().get(repo));
                     }
                 }
-                listener.onResponse(snapshots);
+
+                if (logger.isTraceEnabled()) {
+                    logger.trace(
+                        "retrieved snapshots: [{}]",
+                        snapshots.entrySet()
+                            .stream()
+                            .map(
+                                e -> e.getKey()
+                                    + ": ["
+                                    + e.getValue().stream().map(si -> si.snapshotId().getName()).collect(Collectors.joining(","))
+                                    + "]"
+                            )
+                            .collect(Collectors.joining(","))
+                    );
+                }
+
+                // Find all the snapshots that are past their retention date
+                final Map<String, List<Tuple<SnapshotId, String>>> snapshotsToBeDeleted = snapshots.entrySet()
+                    .stream()
+                    .collect(
+                        Collectors.toMap(
+                            Map.Entry::getKey,
+                            e -> e.getValue()
+                                .stream()
+                                .filter(snapshot -> snapshotEligibleForDeletion(snapshot, snapshots, policies))
+                                // SnapshotInfo instances can be quite large in case they contain e.g. a large collection of
+                                // exceptions so we extract the only two things (id + policy id) here so they can be GCed
+                                .map(snapshotInfo -> Tuple.tuple(snapshotInfo.snapshotId(), getPolicyId(snapshotInfo)))
+                                .toList()
+                        )
+                    );
+
+                listener.onResponse(snapshotsToBeDeleted);
             }, e -> {
                 logger.debug(() -> "unable to retrieve snapshots for [" + repositories + "] repositories: ", e);
                 listener.onFailure(e);
diff --git a/x-pack/plugin/slm/src/test/java/org/elasticsearch/xpack/slm/SnapshotRetentionTaskTests.java b/x-pack/plugin/slm/src/test/java/org/elasticsearch/xpack/slm/SnapshotRetentionTaskTests.java
index 15badabf3689a..b120b49c63654 100644
--- a/x-pack/plugin/slm/src/test/java/org/elasticsearch/xpack/slm/SnapshotRetentionTaskTests.java
+++ b/x-pack/plugin/slm/src/test/java/org/elasticsearch/xpack/slm/SnapshotRetentionTaskTests.java
@@ -26,6 +26,7 @@
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.util.set.Sets;
 import org.elasticsearch.core.TimeValue;
+import org.elasticsearch.core.Tuple;
 import org.elasticsearch.snapshots.Snapshot;
 import org.elasticsearch.snapshots.SnapshotId;
 import org.elasticsearch.snapshots.SnapshotInfo;
@@ -42,7 +43,6 @@
 import org.elasticsearch.xpack.core.slm.SnapshotRetentionConfiguration;
 import org.elasticsearch.xpack.slm.history.SnapshotHistoryStore;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
@@ -238,20 +238,6 @@ private void retentionTaskTest(final boolean deletionSuccess) throws Exception {
                 0L,
                 Collections.emptyMap()
             );
-            final SnapshotInfo ineligibleSnapshot = new SnapshotInfo(
-                new Snapshot(repoId, new SnapshotId("name2", "uuid2")),
-                Collections.singletonList("index"),
-                Collections.emptyList(),
-                Collections.emptyList(),
-                null,
-                System.currentTimeMillis() + 1,
-                1,
-                Collections.emptyList(),
-                true,
-                Collections.singletonMap("policy", policyId),
-                System.currentTimeMillis(),
-                Collections.emptyMap()
-            );
 
             Set<SnapshotId> deleted = ConcurrentHashMap.newKeySet();
             Set<String> deletedSnapshotsInHistory = ConcurrentHashMap.newKeySet();
@@ -273,11 +259,9 @@ private void retentionTaskTest(final boolean deletionSuccess) throws Exception {
                     historyLatch.countDown();
                 }),
                 () -> {
-                    List<SnapshotInfo> snaps = new ArrayList<>(2);
-                    snaps.add(eligibleSnapshot);
-                    snaps.add(ineligibleSnapshot);
-                    logger.info("--> retrieving snapshots [{}]", snaps);
-                    return Collections.singletonMap(repoId, snaps);
+                    final var result = Collections.singletonMap(repoId, List.of(Tuple.tuple(eligibleSnapshot.snapshotId(), policyId)));
+                    logger.info("--> retrieving snapshots [{}]", result);
+                    return result;
                 },
                 (deletionPolicyId, repo, snapId, slmStats, listener) -> {
                     logger.info("--> deleting {} from repo {}", snapId, repo);
@@ -295,7 +279,7 @@ private void retentionTaskTest(final boolean deletionSuccess) throws Exception {
             long time = System.currentTimeMillis();
             retentionTask.triggered(new SchedulerEngine.Event(SnapshotRetentionService.SLM_RETENTION_JOB_ID, time, time));
 
-            deletionLatch.await(10, TimeUnit.SECONDS);
+            safeAwait(deletionLatch);
 
             assertThat("something should have been deleted", deleted, not(empty()));
             assertThat("one snapshot should have been deleted", deleted, hasSize(1));
@@ -364,18 +348,22 @@ protected <Request extends ActionRequest, Response extends ActionResponse> void
             );
 
             AtomicReference<Exception> errHandlerCalled = new AtomicReference<>(null);
-            task.getAllRetainableSnapshots(Collections.singleton(repoId), Collections.singleton(policyId), new ActionListener<>() {
-                @Override
-                public void onResponse(Map<String, List<SnapshotInfo>> stringListMap) {
-                    logger.info("--> forcing failure");
-                    throw new ElasticsearchException("forced failure");
-                }
+            task.getSnapshotsEligibleForDeletion(
+                Collections.singleton(repoId),
+                Map.of(policyId, new SnapshotLifecyclePolicy(policyId, "test", "* * * * *", repoId, null, null)),
+                new ActionListener<>() {
+                    @Override
+                    public void onResponse(Map<String, List<Tuple<SnapshotId, String>>> snapshotsToBeDeleted) {
+                        logger.info("--> forcing failure");
+                        throw new ElasticsearchException("forced failure");
+                    }
 
-                @Override
-                public void onFailure(Exception e) {
-                    errHandlerCalled.set(e);
+                    @Override
+                    public void onFailure(Exception e) {
+                        errHandlerCalled.set(e);
+                    }
                 }
-            });
+            );
 
             assertNotNull(errHandlerCalled.get());
             assertThat(errHandlerCalled.get().getMessage(), equalTo("forced failure"));
@@ -597,14 +585,14 @@ public ClusterState createState(OperationMode mode, SnapshotLifecyclePolicy... p
     }
 
     private static class MockSnapshotRetentionTask extends SnapshotRetentionTask {
-        private final Supplier<Map<String, List<SnapshotInfo>>> snapshotRetriever;
+        private final Supplier<Map<String, List<Tuple<SnapshotId, String>>>> snapshotRetriever;
         private final DeleteSnapshotMock deleteRunner;
 
         MockSnapshotRetentionTask(
             Client client,
             ClusterService clusterService,
             SnapshotHistoryStore historyStore,
-            Supplier<Map<String, List<SnapshotInfo>>> snapshotRetriever,
+            Supplier<Map<String, List<Tuple<SnapshotId, String>>>> snapshotRetriever,
             DeleteSnapshotMock deleteRunner,
             LongSupplier nanoSupplier
         ) {
@@ -614,10 +602,10 @@ private static class MockSnapshotRetentionTask extends SnapshotRetentionTask {
         }
 
         @Override
-        void getAllRetainableSnapshots(
+        void getSnapshotsEligibleForDeletion(
             Collection<String> repositories,
-            Set<String> policies,
-            ActionListener<Map<String, List<SnapshotInfo>>> listener
+            Map<String, SnapshotLifecyclePolicy> policies,
+            ActionListener<Map<String, List<Tuple<SnapshotId, String>>>> listener
         ) {
             listener.onResponse(this.snapshotRetriever.get());
         }