diff --git a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/AggregatorImplementer.java b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/AggregatorImplementer.java
index 83fd3459f9dee..3358f29a43643 100644
--- a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/AggregatorImplementer.java
+++ b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/AggregatorImplementer.java
@@ -19,6 +19,7 @@
 import org.elasticsearch.compute.ann.IntermediateState;
 import org.elasticsearch.compute.gen.Methods.TypeMatcher;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;
@@ -29,6 +30,7 @@
 import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.Modifier;
 import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
 import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
 import javax.lang.model.util.Elements;
@@ -55,8 +57,6 @@
 import static org.elasticsearch.compute.gen.Types.INTERMEDIATE_STATE_DESC;
 import static org.elasticsearch.compute.gen.Types.LIST_AGG_FUNC_DESC;
 import static org.elasticsearch.compute.gen.Types.LIST_INTEGER;
-import static org.elasticsearch.compute.gen.Types.LONG_BLOCK;
-import static org.elasticsearch.compute.gen.Types.LONG_VECTOR;
 import static org.elasticsearch.compute.gen.Types.PAGE;
 import static org.elasticsearch.compute.gen.Types.WARNINGS;
 import static org.elasticsearch.compute.gen.Types.blockType;
@@ -79,10 +79,9 @@ public class AggregatorImplementer {
     private final List<Parameter> createParameters;
     private final ClassName implementation;
     private final List<IntermediateStateDesc> intermediateState;
-    private final boolean includeTimestampVector;
 
     private final AggregationState aggState;
-    private final AggregationParameter aggParam;
+    private final List<AggregationParameter> aggParams;
 
     public AggregatorImplementer(
         Elements elements,
@@ -107,18 +106,8 @@ public AggregatorImplementer(
             requireName("combine"),
             requireArgsStartsWith(requireType(aggState.declaredType()), requireAnyType("<aggregation input column type>"))
         );
-        switch (combine.getParameters().size()) {
-            case 2 -> includeTimestampVector = false;
-            case 3 -> {
-                if (false == TypeName.get(combine.getParameters().get(1).asType()).equals(TypeName.LONG)) {
-                    throw new IllegalArgumentException("combine/3's second parameter must be long but was: " + combine);
-                }
-                includeTimestampVector = true;
-            }
-            default -> throw new IllegalArgumentException("combine must have 2 or 3 parameters but was: " + combine);
-        }
-        // TODO support multiple parameters
-        this.aggParam = AggregationParameter.create(combine.getParameters().getLast().asType());
+
+        this.aggParams = combine.getParameters().stream().skip(1).map(AggregationParameter::create).toList();
 
         this.createParameters = init.getParameters()
             .stream()
@@ -184,6 +173,8 @@ private TypeSpec type() {
         builder.addMethod(intermediateStateDesc());
         builder.addMethod(intermediateBlockCount());
         builder.addMethod(addRawInput());
+        builder.addMethod(addRawInputExploded(true));
+        builder.addMethod(addRawInputExploded(false));
         builder.addMethod(addRawVector(false));
         builder.addMethod(addRawVector(true));
         builder.addMethod(addRawBlock(false));
@@ -298,191 +289,181 @@ private MethodSpec addRawInput() {
             builder.endControlFlow();
         }
         builder.beginControlFlow("if (mask.allFalse())");
-        {
-            builder.addComment("Entire page masked away");
-            builder.addStatement("return");
-        }
-        builder.endControlFlow();
-        builder.beginControlFlow("if (mask.allTrue())");
-        {
-            builder.addComment("No masking");
-            builder.addStatement("$T block = page.getBlock(channels.get(0))", blockType(aggParam.type()));
-            builder.addStatement("$T vector = block.asVector()", vectorType(aggParam.type()));
-            if (includeTimestampVector) {
-                builder.addStatement("$T timestampsBlock = page.getBlock(channels.get(1))", LONG_BLOCK);
-                builder.addStatement("$T timestampsVector = timestampsBlock.asVector()", LONG_VECTOR);
-
-                builder.beginControlFlow("if (timestampsVector == null) ");
-                builder.addStatement("throw new IllegalStateException($S)", "expected @timestamp vector; but got a block");
-                builder.endControlFlow();
-            }
-            builder.beginControlFlow("if (vector != null)");
-            builder.addStatement(includeTimestampVector ? "addRawVector(vector, timestampsVector)" : "addRawVector(vector)");
-            builder.nextControlFlow("else");
-            builder.addStatement(includeTimestampVector ? "addRawBlock(block, timestampsVector)" : "addRawBlock(block)");
-            builder.endControlFlow();
-            builder.addStatement("return");
-        }
+        builder.addComment("Entire page masked away");
+        builder.nextControlFlow("else if (mask.allTrue())");
+        builder.addStatement("$L(page)", addRawInputExplodedName(false));
+        builder.nextControlFlow("else");
+        builder.addStatement("$L(page, mask)", addRawInputExplodedName(true));
         builder.endControlFlow();
+        return builder.build();
+    }
+
+    private String addRawInputExplodedName(boolean hasMask) {
+        return hasMask ? "addRawInputMasked" : "addRawInputNotMasked";
+    }
 
-        builder.addComment("Some positions masked away, others kept");
-        builder.addStatement("$T block = page.getBlock(channels.get(0))", blockType(aggParam.type()));
-        builder.addStatement("$T vector = block.asVector()", vectorType(aggParam.type()));
-        if (includeTimestampVector) {
-            builder.addStatement("$T timestampsBlock = page.getBlock(channels.get(1))", LONG_BLOCK);
-            builder.addStatement("$T timestampsVector = timestampsBlock.asVector()", LONG_VECTOR);
+    private MethodSpec addRawInputExploded(boolean hasMask) {
+        MethodSpec.Builder builder = MethodSpec.methodBuilder(addRawInputExplodedName(hasMask));
+        builder.addModifiers(Modifier.PRIVATE).addParameter(PAGE, "page");
+        if (hasMask) {
+            builder.addParameter(BOOLEAN_VECTOR, "mask");
+        }
 
-            builder.beginControlFlow("if (timestampsVector == null) ");
-            builder.addStatement("throw new IllegalStateException($S)", "expected @timestamp vector; but got a block");
+        for (int i = 0; i < aggParams.size(); i++) {
+            AggregationParameter p = aggParams.get(i);
+            builder.addStatement("$T $L = page.getBlock(channels.get($L))", blockType(p.type()), p.blockName(), i);
+        }
+        for (AggregationParameter p : aggParams) {
+            builder.addStatement("$T $L = $L.asVector()", vectorType(p.type()), p.vectorName(), p.blockName());
+            builder.beginControlFlow("if ($L == null)", p.vectorName());
+            builder.addStatement(
+                "addRawBlock("
+                    + aggParams.stream().map(AggregationParameter::blockName).collect(joining(", "))
+                    + (hasMask ? ", mask" : "")
+                    + ")"
+            );
+            builder.addStatement("return");
             builder.endControlFlow();
         }
-        builder.beginControlFlow("if (vector != null)");
-        builder.addStatement(includeTimestampVector ? "addRawVector(vector, timestampsVector, mask)" : "addRawVector(vector, mask)");
-        builder.nextControlFlow("else");
-        builder.addStatement(includeTimestampVector ? "addRawBlock(block, timestampsVector, mask)" : "addRawBlock(block, mask)");
-        builder.endControlFlow();
+        builder.addStatement(
+            "addRawVector("
+                + aggParams.stream().map(AggregationParameter::vectorName).collect(joining(", "))
+                + (hasMask ? ", mask" : "")
+                + ")"
+        );
         return builder.build();
     }
 
     private MethodSpec addRawVector(boolean masked) {
-        MethodSpec.Builder builder = MethodSpec.methodBuilder("addRawVector");
-        builder.addModifiers(Modifier.PRIVATE).addParameter(vectorType(aggParam.type()), "vector");
-        if (includeTimestampVector) {
-            builder.addParameter(LONG_VECTOR, "timestamps");
-        }
-        if (masked) {
-            builder.addParameter(BOOLEAN_VECTOR, "mask");
-        }
-        if (aggParam.isArray()) {
+        MethodSpec.Builder builder = initAddRaw(true, masked);
+        if (aggParams.getFirst().isArray()) {
             builder.addComment("This type does not support vectors because all values are multi-valued");
             return builder.build();
         }
-
         if (aggState.hasSeen()) {
             builder.addStatement("state.seen(true)");
         }
-        if (aggParam.isBytesRef()) {
-            // Add bytes_ref scratch var that will be used for bytes_ref blocks/vectors
-            builder.addStatement("$T scratch = new $T()", BYTES_REF, BYTES_REF);
-        }
 
-        builder.beginControlFlow("for (int i = 0; i < vector.getPositionCount(); i++)");
+        builder.beginControlFlow("for (int i = 0; i < $L.getPositionCount(); i++)", aggParams.getFirst().vectorName());
         {
             if (masked) {
                 builder.beginControlFlow("if (mask.getBoolean(i) == false)").addStatement("continue").endControlFlow();
             }
-            combineRawInput(builder, "vector");
+            for (AggregationParameter p : aggParams) {
+                p.read(builder, true);
+            }
+            combineRawInput(builder);
+
         }
         builder.endControlFlow();
         return builder.build();
     }
 
     private MethodSpec addRawBlock(boolean masked) {
-        MethodSpec.Builder builder = MethodSpec.methodBuilder("addRawBlock");
-        builder.addModifiers(Modifier.PRIVATE).addParameter(blockType(aggParam.type()), "block");
-        if (includeTimestampVector) {
-            builder.addParameter(LONG_VECTOR, "timestamps");
-        }
-        if (masked) {
-            builder.addParameter(BOOLEAN_VECTOR, "mask");
-        }
+        MethodSpec.Builder builder = initAddRaw(false, masked);
 
-        if (aggParam.isBytesRef()) {
-            // Add bytes_ref scratch var that will only be used for bytes_ref blocks/vectors
-            builder.addStatement("$T scratch = new $T()", BYTES_REF, BYTES_REF);
-        }
-        builder.beginControlFlow("for (int p = 0; p < block.getPositionCount(); p++)");
+        builder.beginControlFlow("for (int p = 0; p < $L.getPositionCount(); p++)", aggParams.getFirst().blockName());
         {
             if (masked) {
                 builder.beginControlFlow("if (mask.getBoolean(p) == false)").addStatement("continue").endControlFlow();
             }
-            builder.beginControlFlow("if (block.isNull(p))");
-            builder.addStatement("continue");
-            builder.endControlFlow();
+            for (AggregationParameter p : aggParams) {
+                builder.beginControlFlow("if ($L.isNull(p))", p.blockName());
+                builder.addStatement("continue");
+                builder.endControlFlow();
+            }
             if (aggState.hasSeen()) {
                 builder.addStatement("state.seen(true)");
             }
-            builder.addStatement("int start = block.getFirstValueIndex(p)");
-            builder.addStatement("int end = start + block.getValueCount(p)");
-            if (aggParam.isArray()) {
-                String arrayType = aggParam.type().toString().replace("[]", "");
-                builder.addStatement("$L[] valuesArray = new $L[end - start]", arrayType, arrayType);
+
+            if (aggParams.getFirst().isArray()) {
+                if (aggParams.size() > 1) {
+                    throw new IllegalArgumentException("array mode not supported for multiple args");
+                }
+                builder.addStatement("int start = $L.getFirstValueIndex(p)", aggParams.getFirst().blockName());
+                builder.addStatement("int end = start + $L.getValueCount(p)", aggParams.getFirst().blockName());
+                // TODO move this to the top of the loop
+                builder.addStatement(
+                    "$L[] valuesArray = new $L[end - start]",
+                    aggParams.getFirst().arrayType(),
+                    aggParams.getFirst().arrayType()
+                );
                 builder.beginControlFlow("for (int i = start; i < end; i++)");
-                builder.addStatement("valuesArray[i-start] = $L.get$L(i)", "block", capitalize(arrayType));
+                builder.addStatement(
+                    "valuesArray[i-start] = $L.get$L(i)",
+                    aggParams.getFirst().blockName(),
+                    capitalize(aggParams.getFirst().arrayType())
+                );
                 builder.endControlFlow();
                 combineRawInputForArray(builder, "valuesArray");
             } else {
-                builder.beginControlFlow("for (int i = start; i < end; i++)");
-                combineRawInput(builder, "block");
-                builder.endControlFlow();
+                for (AggregationParameter p : aggParams) {
+                    builder.addStatement("int $L = $L.getFirstValueIndex(p)", p.startName(), p.blockName());
+                    builder.addStatement("int $L = $L + $L.getValueCount(p)", p.endName(), p.startName(), p.blockName());
+                    builder.beginControlFlow(
+                        "for (int $L = $L; $L < $L; $L++)",
+                        p.offsetName(),
+                        p.startName(),
+                        p.offsetName(),
+                        p.endName(),
+                        p.offsetName()
+                    );
+                    p.read(builder, false);
+                }
+                combineRawInput(builder);
+                for (AggregationParameter p : aggParams) {
+                    builder.endControlFlow();
+                }
             }
         }
         builder.endControlFlow();
         return builder.build();
     }
 
-    private void combineRawInput(MethodSpec.Builder builder, String blockVariable) {
-        TypeName returnType = TypeName.get(combine.getReturnType());
-        warningsBlock(builder, () -> {
-            if (aggParam.isBytesRef()) {
-                combineRawInputForBytesRef(builder, blockVariable);
-            } else if (returnType.isPrimitive()) {
-                combineRawInputForPrimitive(returnType, builder, blockVariable);
-            } else if (returnType == TypeName.VOID) {
-                combineRawInputForVoid(builder, blockVariable);
-            } else {
-                throw new IllegalArgumentException("combine must return void or a primitive");
+    private MethodSpec.Builder initAddRaw(boolean isVector, boolean masked) {
+        MethodSpec.Builder builder = MethodSpec.methodBuilder(isVector ? "addRawVector" : "addRawBlock");
+        builder.addModifiers(Modifier.PRIVATE);
+        for (AggregationParameter p : aggParams) {
+            builder.addParameter(isVector ? vectorType(p.type) : blockType(p.type), isVector ? p.vectorName() : p.blockName());
+        }
+        if (masked) {
+            builder.addParameter(BOOLEAN_VECTOR, "mask");
+        }
+        for (AggregationParameter p : aggParams) {
+            if (p.isBytesRef()) {
+                // Add bytes_ref scratch var that will be used for bytes_ref blocks/vectors
+                builder.addStatement("$T $L = new $T()", BYTES_REF, p.scratchName(), BYTES_REF);
             }
-        });
-    }
-
-    private void combineRawInputForBytesRef(MethodSpec.Builder builder, String blockVariable) {
-        // scratch is a BytesRef var that must have been defined before the iteration starts
-        if (includeTimestampVector) {
-            builder.addStatement("$T.combine(state, timestamps.getLong(i), $L.getBytesRef(i, scratch))", declarationType, blockVariable);
-        } else {
-            builder.addStatement("$T.combine(state, $L.getBytesRef(i, scratch))", declarationType, blockVariable);
         }
+        return builder;
     }
 
-    private void combineRawInputForPrimitive(TypeName returnType, MethodSpec.Builder builder, String blockVariable) {
-        if (includeTimestampVector) {
-            builder.addStatement(
-                "state.$TValue($T.combine(state.$TValue(), timestamps.getLong(i), $L.get$L(i)))",
-                returnType,
-                declarationType,
-                returnType,
-                blockVariable,
-                capitalize(combine.getParameters().get(1).asType().toString())
-            );
-        } else {
-            builder.addStatement(
-                "state.$TValue($T.combine(state.$TValue(), $L.get$L(i)))",
-                returnType,
-                declarationType,
-                returnType,
-                blockVariable,
-                capitalize(combine.getParameters().get(1).asType().toString())
-            );
-        }
+    private void combineRawInput(MethodSpec.Builder builder) {
+        TypeName returnType = TypeName.get(combine.getReturnType());
+        warningsBlock(builder, () -> { invokeCombineRawInput(returnType, builder); });
     }
 
-    private void combineRawInputForVoid(MethodSpec.Builder builder, String blockVariable) {
-        if (includeTimestampVector) {
-            builder.addStatement(
-                "$T.combine(state, timestamps.getLong(i), $L.get$L(i))",
-                declarationType,
-                blockVariable,
-                capitalize(combine.getParameters().get(1).asType().toString())
-            );
+    private void invokeCombineRawInput(TypeName returnType, MethodSpec.Builder builder) {
+        StringBuilder pattern = new StringBuilder();
+        List<Object> params = new ArrayList<>();
+        if (returnType.isPrimitive()) {
+            pattern.append("state.$TValue($T.combine(state.$TValue()");
+            params.add(returnType);
+            params.add(declarationType);
+            params.add(returnType);
         } else {
-            builder.addStatement(
-                "$T.combine(state, $L.get$L(i))",
-                declarationType,
-                blockVariable,
-                capitalize(combine.getParameters().get(1).asType().toString())
-            );
+            pattern.append("$T.combine(state");
+            params.add(declarationType);
+        }
+        for (AggregationParameter p : aggParams) {
+            pattern.append(", $L");
+            params.add(p.valueName());
         }
+        if (returnType.isPrimitive()) {
+            pattern.append(")");
+        }
+        pattern.append(")");
+        builder.addStatement(pattern.toString(), params.toArray());
     }
 
     private void combineRawInputForArray(MethodSpec.Builder builder, String arrayVariable) {
@@ -714,10 +695,75 @@ private static String primitiveStateStoreClassname(TypeName declaredType, boolea
         }
     }
 
-    public record AggregationParameter(TypeName type, boolean isArray) {
+    public record AggregationParameter(String name, TypeName type, boolean isArray) {
+        public static AggregationParameter create(VariableElement v) {
+            return new AggregationParameter(
+                v.getSimpleName().toString(),
+                TypeName.get(v.asType()),
+                Objects.equals(v.asType().getKind(), TypeKind.ARRAY)
+            );
+        }
+
+        public String blockName() {
+            return name + "Block";
+        }
+
+        public String vectorName() {
+            return name + "Vector";
+        }
 
-        public static AggregationParameter create(TypeMirror mirror) {
-            return new AggregationParameter(TypeName.get(mirror), Objects.equals(mirror.getKind(), TypeKind.ARRAY));
+        public String scratchName() {
+            if (isBytesRef() == false) {
+                throw new IllegalStateException("can't build scratch for non-BytesRef");
+            }
+            return name + "Scratch";
+        }
+
+        public String valueName() {
+            return name + "Value";
+        }
+
+        public String startName() {
+            return name + "Start";
+        }
+
+        public String endName() {
+            return name + "End";
+        }
+
+        public String offsetName() {
+            return name + "Offset";
+        }
+
+        public String arrayType() {
+            return type.toString().replace("[]", "");
+        }
+
+        public String readMethod() {
+            String type = this.type.toString();
+            int lastDot = type.lastIndexOf('.');
+            return "get" + capitalize(lastDot >= 0 ? type.substring(lastDot + 1) : type);
+        }
+
+        public void read(MethodSpec.Builder builder, boolean vector) {
+            StringBuilder pattern = new StringBuilder("$T $L = $L.$L(");
+            List<Object> params = new ArrayList<>();
+            params.add(type);
+            params.add(valueName());
+            params.add(vector ? vectorName() : blockName());
+            params.add(readMethod());
+            if (vector) {
+                pattern.append("i");
+            } else {
+                pattern.append("$L");
+                params.add(offsetName());
+            }
+            if (isBytesRef()) {
+                pattern.append(", $L");
+                params.add(scratchName());
+            }
+            pattern.append(")");
+            builder.addStatement(pattern.toString(), params.toArray());
         }
 
         public boolean isBytesRef() {
diff --git a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/GroupingAggregatorImplementer.java b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/GroupingAggregatorImplementer.java
index db1b10e8d244e..7a0afafbff8cf 100644
--- a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/GroupingAggregatorImplementer.java
+++ b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/GroupingAggregatorImplementer.java
@@ -129,7 +129,7 @@ public GroupingAggregatorImplementer(
             default -> throw new IllegalArgumentException("combine must have 2, 3, or 4 parameters but was: " + combine);
         }
         // TODO support multiple parameters
-        this.aggParam = AggregationParameter.create(combine.getParameters().getLast().asType());
+        this.aggParam = AggregationParameter.create(combine.getParameters().getLast());
 
         this.createParameters = init.getParameters()
             .stream()
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBooleanAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBooleanAggregatorFunction.java
index 90ca8e567e8be..b8e7c94aa895c 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBooleanAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBooleanAggregatorFunction.java
@@ -56,69 +56,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BooleanBlock block = page.getBlock(channels.get(0));
-      BooleanVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BooleanBlock vBlock = page.getBlock(channels.get(0));
+    BooleanVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BooleanBlock block = page.getBlock(channels.get(0));
-    BooleanVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BooleanBlock vBlock = page.getBlock(channels.get(0));
+    BooleanVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(BooleanVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      CountDistinctBooleanAggregator.combine(state, vector.getBoolean(i));
+  private void addRawVector(BooleanVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      boolean vValue = vVector.getBoolean(i);
+      CountDistinctBooleanAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(BooleanVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BooleanVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      CountDistinctBooleanAggregator.combine(state, vector.getBoolean(i));
+      boolean vValue = vVector.getBoolean(i);
+      CountDistinctBooleanAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(BooleanBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BooleanBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        CountDistinctBooleanAggregator.combine(state, block.getBoolean(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        boolean vValue = vBlock.getBoolean(vOffset);
+        CountDistinctBooleanAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(BooleanBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BooleanBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        CountDistinctBooleanAggregator.combine(state, block.getBoolean(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        boolean vValue = vBlock.getBoolean(vOffset);
+        CountDistinctBooleanAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBytesRefAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBytesRefAggregatorFunction.java
index 77c386bd99175..bf796fc9a2f41 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBytesRefAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBytesRefAggregatorFunction.java
@@ -60,73 +60,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BytesRefBlock block = page.getBlock(channels.get(0));
-      BytesRefVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BytesRefBlock vBlock = page.getBlock(channels.get(0));
+    BytesRefVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BytesRefBlock block = page.getBlock(channels.get(0));
-    BytesRefVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BytesRefBlock vBlock = page.getBlock(channels.get(0));
+    BytesRefVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(BytesRefVector vector) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      CountDistinctBytesRefAggregator.combine(state, vector.getBytesRef(i, scratch));
+  private void addRawVector(BytesRefVector vVector) {
+    BytesRef vScratch = new BytesRef();
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      BytesRef vValue = vVector.getBytesRef(i, vScratch);
+      CountDistinctBytesRefAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(BytesRefVector vector, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BytesRefVector vVector, BooleanVector mask) {
+    BytesRef vScratch = new BytesRef();
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      CountDistinctBytesRefAggregator.combine(state, vector.getBytesRef(i, scratch));
+      BytesRef vValue = vVector.getBytesRef(i, vScratch);
+      CountDistinctBytesRefAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(BytesRefBlock block) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BytesRefBlock vBlock) {
+    BytesRef vScratch = new BytesRef();
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        CountDistinctBytesRefAggregator.combine(state, block.getBytesRef(i, scratch));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch);
+        CountDistinctBytesRefAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(BytesRefBlock block, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BytesRefBlock vBlock, BooleanVector mask) {
+    BytesRef vScratch = new BytesRef();
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        CountDistinctBytesRefAggregator.combine(state, block.getBytesRef(i, scratch));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch);
+        CountDistinctBytesRefAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctDoubleAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctDoubleAggregatorFunction.java
index f42fcfafef2d7..489cde3308448 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctDoubleAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctDoubleAggregatorFunction.java
@@ -62,69 +62,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      DoubleBlock block = page.getBlock(channels.get(0));
-      DoubleVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    DoubleBlock block = page.getBlock(channels.get(0));
-    DoubleVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(DoubleVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      CountDistinctDoubleAggregator.combine(state, vector.getDouble(i));
+  private void addRawVector(DoubleVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      double vValue = vVector.getDouble(i);
+      CountDistinctDoubleAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(DoubleVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(DoubleVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      CountDistinctDoubleAggregator.combine(state, vector.getDouble(i));
+      double vValue = vVector.getDouble(i);
+      CountDistinctDoubleAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(DoubleBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(DoubleBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        CountDistinctDoubleAggregator.combine(state, block.getDouble(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        CountDistinctDoubleAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(DoubleBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(DoubleBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        CountDistinctDoubleAggregator.combine(state, block.getDouble(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        CountDistinctDoubleAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctFloatAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctFloatAggregatorFunction.java
index 5a65d460ad27e..59bde7207cf7b 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctFloatAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctFloatAggregatorFunction.java
@@ -62,69 +62,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      FloatBlock block = page.getBlock(channels.get(0));
-      FloatVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    FloatBlock block = page.getBlock(channels.get(0));
-    FloatVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(FloatVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      CountDistinctFloatAggregator.combine(state, vector.getFloat(i));
+  private void addRawVector(FloatVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      float vValue = vVector.getFloat(i);
+      CountDistinctFloatAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(FloatVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(FloatVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      CountDistinctFloatAggregator.combine(state, vector.getFloat(i));
+      float vValue = vVector.getFloat(i);
+      CountDistinctFloatAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(FloatBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(FloatBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        CountDistinctFloatAggregator.combine(state, block.getFloat(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        CountDistinctFloatAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(FloatBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(FloatBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        CountDistinctFloatAggregator.combine(state, block.getFloat(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        CountDistinctFloatAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctIntAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctIntAggregatorFunction.java
index 44c9751f2bee7..86815a5bf6b80 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctIntAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctIntAggregatorFunction.java
@@ -62,69 +62,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      IntBlock block = page.getBlock(channels.get(0));
-      IntVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    IntBlock block = page.getBlock(channels.get(0));
-    IntVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(IntVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      CountDistinctIntAggregator.combine(state, vector.getInt(i));
+  private void addRawVector(IntVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      int vValue = vVector.getInt(i);
+      CountDistinctIntAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(IntVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(IntVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      CountDistinctIntAggregator.combine(state, vector.getInt(i));
+      int vValue = vVector.getInt(i);
+      CountDistinctIntAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(IntBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(IntBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        CountDistinctIntAggregator.combine(state, block.getInt(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        CountDistinctIntAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(IntBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(IntBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        CountDistinctIntAggregator.combine(state, block.getInt(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        CountDistinctIntAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctLongAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctLongAggregatorFunction.java
index 864051e7b3197..e3881139a8af7 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctLongAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctLongAggregatorFunction.java
@@ -62,69 +62,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      LongBlock block = page.getBlock(channels.get(0));
-      LongVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    LongBlock block = page.getBlock(channels.get(0));
-    LongVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(LongVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      CountDistinctLongAggregator.combine(state, vector.getLong(i));
+  private void addRawVector(LongVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      long vValue = vVector.getLong(i);
+      CountDistinctLongAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(LongVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(LongVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      CountDistinctLongAggregator.combine(state, vector.getLong(i));
+      long vValue = vVector.getLong(i);
+      CountDistinctLongAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(LongBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(LongBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        CountDistinctLongAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        CountDistinctLongAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(LongBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(LongBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        CountDistinctLongAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        CountDistinctLongAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBooleanAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBooleanAggregatorFunction.java
index 30d61d45f0759..a1846a197cf6d 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBooleanAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBooleanAggregatorFunction.java
@@ -56,73 +56,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BooleanBlock block = page.getBlock(channels.get(0));
-      BooleanVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BooleanBlock vBlock = page.getBlock(channels.get(0));
+    BooleanVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BooleanBlock block = page.getBlock(channels.get(0));
-    BooleanVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BooleanBlock vBlock = page.getBlock(channels.get(0));
+    BooleanVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(BooleanVector vector) {
+  private void addRawVector(BooleanVector vVector) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      state.booleanValue(MaxBooleanAggregator.combine(state.booleanValue(), vector.getBoolean(i)));
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      boolean vValue = vVector.getBoolean(i);
+      state.booleanValue(MaxBooleanAggregator.combine(state.booleanValue(), vValue));
     }
   }
 
-  private void addRawVector(BooleanVector vector, BooleanVector mask) {
+  private void addRawVector(BooleanVector vVector, BooleanVector mask) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      state.booleanValue(MaxBooleanAggregator.combine(state.booleanValue(), vector.getBoolean(i)));
+      boolean vValue = vVector.getBoolean(i);
+      state.booleanValue(MaxBooleanAggregator.combine(state.booleanValue(), vValue));
     }
   }
 
-  private void addRawBlock(BooleanBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BooleanBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.booleanValue(MaxBooleanAggregator.combine(state.booleanValue(), block.getBoolean(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        boolean vValue = vBlock.getBoolean(vOffset);
+        state.booleanValue(MaxBooleanAggregator.combine(state.booleanValue(), vValue));
       }
     }
   }
 
-  private void addRawBlock(BooleanBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BooleanBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.booleanValue(MaxBooleanAggregator.combine(state.booleanValue(), block.getBoolean(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        boolean vValue = vBlock.getBoolean(vOffset);
+        state.booleanValue(MaxBooleanAggregator.combine(state.booleanValue(), vValue));
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBytesRefAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBytesRefAggregatorFunction.java
index 936b18f35aae0..1291beb3660c0 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBytesRefAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBytesRefAggregatorFunction.java
@@ -59,73 +59,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BytesRefBlock block = page.getBlock(channels.get(0));
-      BytesRefVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BytesRefBlock valueBlock = page.getBlock(channels.get(0));
+    BytesRefVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BytesRefBlock block = page.getBlock(channels.get(0));
-    BytesRefVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(valueVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BytesRefBlock valueBlock = page.getBlock(channels.get(0));
+    BytesRefVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock);
+      return;
     }
+    addRawVector(valueVector);
   }
 
-  private void addRawVector(BytesRefVector vector) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      MaxBytesRefAggregator.combine(state, vector.getBytesRef(i, scratch));
+  private void addRawVector(BytesRefVector valueVector) {
+    BytesRef valueScratch = new BytesRef();
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
+      BytesRef valueValue = valueVector.getBytesRef(i, valueScratch);
+      MaxBytesRefAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawVector(BytesRefVector vector, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BytesRefVector valueVector, BooleanVector mask) {
+    BytesRef valueScratch = new BytesRef();
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      MaxBytesRefAggregator.combine(state, vector.getBytesRef(i, scratch));
+      BytesRef valueValue = valueVector.getBytesRef(i, valueScratch);
+      MaxBytesRefAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawBlock(BytesRefBlock block) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BytesRefBlock valueBlock) {
+    BytesRef valueScratch = new BytesRef();
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MaxBytesRefAggregator.combine(state, block.getBytesRef(i, scratch));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch);
+        MaxBytesRefAggregator.combine(state, valueValue);
       }
     }
   }
 
-  private void addRawBlock(BytesRefBlock block, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BytesRefBlock valueBlock, BooleanVector mask) {
+    BytesRef valueScratch = new BytesRef();
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MaxBytesRefAggregator.combine(state, block.getBytesRef(i, scratch));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch);
+        MaxBytesRefAggregator.combine(state, valueValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxDoubleAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxDoubleAggregatorFunction.java
index 3af21d1c19dff..e62d51e3feac7 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxDoubleAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxDoubleAggregatorFunction.java
@@ -58,73 +58,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      DoubleBlock block = page.getBlock(channels.get(0));
-      DoubleVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    DoubleBlock block = page.getBlock(channels.get(0));
-    DoubleVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(DoubleVector vector) {
+  private void addRawVector(DoubleVector vVector) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      state.doubleValue(MaxDoubleAggregator.combine(state.doubleValue(), vector.getDouble(i)));
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      double vValue = vVector.getDouble(i);
+      state.doubleValue(MaxDoubleAggregator.combine(state.doubleValue(), vValue));
     }
   }
 
-  private void addRawVector(DoubleVector vector, BooleanVector mask) {
+  private void addRawVector(DoubleVector vVector, BooleanVector mask) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      state.doubleValue(MaxDoubleAggregator.combine(state.doubleValue(), vector.getDouble(i)));
+      double vValue = vVector.getDouble(i);
+      state.doubleValue(MaxDoubleAggregator.combine(state.doubleValue(), vValue));
     }
   }
 
-  private void addRawBlock(DoubleBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(DoubleBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.doubleValue(MaxDoubleAggregator.combine(state.doubleValue(), block.getDouble(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        state.doubleValue(MaxDoubleAggregator.combine(state.doubleValue(), vValue));
       }
     }
   }
 
-  private void addRawBlock(DoubleBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(DoubleBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.doubleValue(MaxDoubleAggregator.combine(state.doubleValue(), block.getDouble(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        state.doubleValue(MaxDoubleAggregator.combine(state.doubleValue(), vValue));
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxFloatAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxFloatAggregatorFunction.java
index e16e28e182aaa..5f95e55b9e4e6 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxFloatAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxFloatAggregatorFunction.java
@@ -58,73 +58,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      FloatBlock block = page.getBlock(channels.get(0));
-      FloatVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    FloatBlock block = page.getBlock(channels.get(0));
-    FloatVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(FloatVector vector) {
+  private void addRawVector(FloatVector vVector) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      state.floatValue(MaxFloatAggregator.combine(state.floatValue(), vector.getFloat(i)));
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      float vValue = vVector.getFloat(i);
+      state.floatValue(MaxFloatAggregator.combine(state.floatValue(), vValue));
     }
   }
 
-  private void addRawVector(FloatVector vector, BooleanVector mask) {
+  private void addRawVector(FloatVector vVector, BooleanVector mask) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      state.floatValue(MaxFloatAggregator.combine(state.floatValue(), vector.getFloat(i)));
+      float vValue = vVector.getFloat(i);
+      state.floatValue(MaxFloatAggregator.combine(state.floatValue(), vValue));
     }
   }
 
-  private void addRawBlock(FloatBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(FloatBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.floatValue(MaxFloatAggregator.combine(state.floatValue(), block.getFloat(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        state.floatValue(MaxFloatAggregator.combine(state.floatValue(), vValue));
       }
     }
   }
 
-  private void addRawBlock(FloatBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(FloatBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.floatValue(MaxFloatAggregator.combine(state.floatValue(), block.getFloat(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        state.floatValue(MaxFloatAggregator.combine(state.floatValue(), vValue));
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIntAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIntAggregatorFunction.java
index a4c0fbfb75b9a..0da56585430b4 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIntAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIntAggregatorFunction.java
@@ -58,73 +58,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      IntBlock block = page.getBlock(channels.get(0));
-      IntVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    IntBlock block = page.getBlock(channels.get(0));
-    IntVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(IntVector vector) {
+  private void addRawVector(IntVector vVector) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      state.intValue(MaxIntAggregator.combine(state.intValue(), vector.getInt(i)));
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      int vValue = vVector.getInt(i);
+      state.intValue(MaxIntAggregator.combine(state.intValue(), vValue));
     }
   }
 
-  private void addRawVector(IntVector vector, BooleanVector mask) {
+  private void addRawVector(IntVector vVector, BooleanVector mask) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      state.intValue(MaxIntAggregator.combine(state.intValue(), vector.getInt(i)));
+      int vValue = vVector.getInt(i);
+      state.intValue(MaxIntAggregator.combine(state.intValue(), vValue));
     }
   }
 
-  private void addRawBlock(IntBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(IntBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.intValue(MaxIntAggregator.combine(state.intValue(), block.getInt(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        state.intValue(MaxIntAggregator.combine(state.intValue(), vValue));
       }
     }
   }
 
-  private void addRawBlock(IntBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(IntBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.intValue(MaxIntAggregator.combine(state.intValue(), block.getInt(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        state.intValue(MaxIntAggregator.combine(state.intValue(), vValue));
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIpAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIpAggregatorFunction.java
index c0beac5a31aa8..4d8c2d4a84741 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIpAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIpAggregatorFunction.java
@@ -59,73 +59,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BytesRefBlock block = page.getBlock(channels.get(0));
-      BytesRefVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BytesRefBlock valueBlock = page.getBlock(channels.get(0));
+    BytesRefVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BytesRefBlock block = page.getBlock(channels.get(0));
-    BytesRefVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(valueVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BytesRefBlock valueBlock = page.getBlock(channels.get(0));
+    BytesRefVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock);
+      return;
     }
+    addRawVector(valueVector);
   }
 
-  private void addRawVector(BytesRefVector vector) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      MaxIpAggregator.combine(state, vector.getBytesRef(i, scratch));
+  private void addRawVector(BytesRefVector valueVector) {
+    BytesRef valueScratch = new BytesRef();
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
+      BytesRef valueValue = valueVector.getBytesRef(i, valueScratch);
+      MaxIpAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawVector(BytesRefVector vector, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BytesRefVector valueVector, BooleanVector mask) {
+    BytesRef valueScratch = new BytesRef();
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      MaxIpAggregator.combine(state, vector.getBytesRef(i, scratch));
+      BytesRef valueValue = valueVector.getBytesRef(i, valueScratch);
+      MaxIpAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawBlock(BytesRefBlock block) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BytesRefBlock valueBlock) {
+    BytesRef valueScratch = new BytesRef();
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MaxIpAggregator.combine(state, block.getBytesRef(i, scratch));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch);
+        MaxIpAggregator.combine(state, valueValue);
       }
     }
   }
 
-  private void addRawBlock(BytesRefBlock block, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BytesRefBlock valueBlock, BooleanVector mask) {
+    BytesRef valueScratch = new BytesRef();
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MaxIpAggregator.combine(state, block.getBytesRef(i, scratch));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch);
+        MaxIpAggregator.combine(state, valueValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxLongAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxLongAggregatorFunction.java
index 71fa9b04b4937..c1a26825960db 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxLongAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxLongAggregatorFunction.java
@@ -58,73 +58,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      LongBlock block = page.getBlock(channels.get(0));
-      LongVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    LongBlock block = page.getBlock(channels.get(0));
-    LongVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(LongVector vector) {
+  private void addRawVector(LongVector vVector) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      state.longValue(MaxLongAggregator.combine(state.longValue(), vector.getLong(i)));
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      long vValue = vVector.getLong(i);
+      state.longValue(MaxLongAggregator.combine(state.longValue(), vValue));
     }
   }
 
-  private void addRawVector(LongVector vector, BooleanVector mask) {
+  private void addRawVector(LongVector vVector, BooleanVector mask) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      state.longValue(MaxLongAggregator.combine(state.longValue(), vector.getLong(i)));
+      long vValue = vVector.getLong(i);
+      state.longValue(MaxLongAggregator.combine(state.longValue(), vValue));
     }
   }
 
-  private void addRawBlock(LongBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(LongBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.longValue(MaxLongAggregator.combine(state.longValue(), block.getLong(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        state.longValue(MaxLongAggregator.combine(state.longValue(), vValue));
       }
     }
   }
 
-  private void addRawBlock(LongBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(LongBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.longValue(MaxLongAggregator.combine(state.longValue(), block.getLong(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        state.longValue(MaxLongAggregator.combine(state.longValue(), vValue));
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleAggregatorFunction.java
index a442e49a8ad6e..e40883797ebf7 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleAggregatorFunction.java
@@ -59,69 +59,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      DoubleBlock block = page.getBlock(channels.get(0));
-      DoubleVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    DoubleBlock block = page.getBlock(channels.get(0));
-    DoubleVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(DoubleVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      MedianAbsoluteDeviationDoubleAggregator.combine(state, vector.getDouble(i));
+  private void addRawVector(DoubleVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      double vValue = vVector.getDouble(i);
+      MedianAbsoluteDeviationDoubleAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(DoubleVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(DoubleVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      MedianAbsoluteDeviationDoubleAggregator.combine(state, vector.getDouble(i));
+      double vValue = vVector.getDouble(i);
+      MedianAbsoluteDeviationDoubleAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(DoubleBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(DoubleBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MedianAbsoluteDeviationDoubleAggregator.combine(state, block.getDouble(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        MedianAbsoluteDeviationDoubleAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(DoubleBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(DoubleBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MedianAbsoluteDeviationDoubleAggregator.combine(state, block.getDouble(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        MedianAbsoluteDeviationDoubleAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationFloatAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationFloatAggregatorFunction.java
index 2bcd5be4fd0d3..18abdd7b7411a 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationFloatAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationFloatAggregatorFunction.java
@@ -59,69 +59,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      FloatBlock block = page.getBlock(channels.get(0));
-      FloatVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    FloatBlock block = page.getBlock(channels.get(0));
-    FloatVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(FloatVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      MedianAbsoluteDeviationFloatAggregator.combine(state, vector.getFloat(i));
+  private void addRawVector(FloatVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      float vValue = vVector.getFloat(i);
+      MedianAbsoluteDeviationFloatAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(FloatVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(FloatVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      MedianAbsoluteDeviationFloatAggregator.combine(state, vector.getFloat(i));
+      float vValue = vVector.getFloat(i);
+      MedianAbsoluteDeviationFloatAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(FloatBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(FloatBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MedianAbsoluteDeviationFloatAggregator.combine(state, block.getFloat(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        MedianAbsoluteDeviationFloatAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(FloatBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(FloatBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MedianAbsoluteDeviationFloatAggregator.combine(state, block.getFloat(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        MedianAbsoluteDeviationFloatAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntAggregatorFunction.java
index 058eba52c6cdd..0be32be05ef88 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntAggregatorFunction.java
@@ -59,69 +59,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      IntBlock block = page.getBlock(channels.get(0));
-      IntVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    IntBlock block = page.getBlock(channels.get(0));
-    IntVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(IntVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      MedianAbsoluteDeviationIntAggregator.combine(state, vector.getInt(i));
+  private void addRawVector(IntVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      int vValue = vVector.getInt(i);
+      MedianAbsoluteDeviationIntAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(IntVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(IntVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      MedianAbsoluteDeviationIntAggregator.combine(state, vector.getInt(i));
+      int vValue = vVector.getInt(i);
+      MedianAbsoluteDeviationIntAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(IntBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(IntBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MedianAbsoluteDeviationIntAggregator.combine(state, block.getInt(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        MedianAbsoluteDeviationIntAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(IntBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(IntBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MedianAbsoluteDeviationIntAggregator.combine(state, block.getInt(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        MedianAbsoluteDeviationIntAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongAggregatorFunction.java
index 56d21b5877c73..cffb084a02e70 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongAggregatorFunction.java
@@ -59,69 +59,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      LongBlock block = page.getBlock(channels.get(0));
-      LongVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    LongBlock block = page.getBlock(channels.get(0));
-    LongVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(LongVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      MedianAbsoluteDeviationLongAggregator.combine(state, vector.getLong(i));
+  private void addRawVector(LongVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      long vValue = vVector.getLong(i);
+      MedianAbsoluteDeviationLongAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(LongVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(LongVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      MedianAbsoluteDeviationLongAggregator.combine(state, vector.getLong(i));
+      long vValue = vVector.getLong(i);
+      MedianAbsoluteDeviationLongAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(LongBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(LongBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MedianAbsoluteDeviationLongAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        MedianAbsoluteDeviationLongAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(LongBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(LongBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MedianAbsoluteDeviationLongAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        MedianAbsoluteDeviationLongAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBooleanAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBooleanAggregatorFunction.java
index c6645a1945783..55dc5fa93f0fb 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBooleanAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBooleanAggregatorFunction.java
@@ -56,73 +56,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BooleanBlock block = page.getBlock(channels.get(0));
-      BooleanVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BooleanBlock vBlock = page.getBlock(channels.get(0));
+    BooleanVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BooleanBlock block = page.getBlock(channels.get(0));
-    BooleanVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BooleanBlock vBlock = page.getBlock(channels.get(0));
+    BooleanVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(BooleanVector vector) {
+  private void addRawVector(BooleanVector vVector) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      state.booleanValue(MinBooleanAggregator.combine(state.booleanValue(), vector.getBoolean(i)));
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      boolean vValue = vVector.getBoolean(i);
+      state.booleanValue(MinBooleanAggregator.combine(state.booleanValue(), vValue));
     }
   }
 
-  private void addRawVector(BooleanVector vector, BooleanVector mask) {
+  private void addRawVector(BooleanVector vVector, BooleanVector mask) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      state.booleanValue(MinBooleanAggregator.combine(state.booleanValue(), vector.getBoolean(i)));
+      boolean vValue = vVector.getBoolean(i);
+      state.booleanValue(MinBooleanAggregator.combine(state.booleanValue(), vValue));
     }
   }
 
-  private void addRawBlock(BooleanBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BooleanBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.booleanValue(MinBooleanAggregator.combine(state.booleanValue(), block.getBoolean(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        boolean vValue = vBlock.getBoolean(vOffset);
+        state.booleanValue(MinBooleanAggregator.combine(state.booleanValue(), vValue));
       }
     }
   }
 
-  private void addRawBlock(BooleanBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BooleanBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.booleanValue(MinBooleanAggregator.combine(state.booleanValue(), block.getBoolean(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        boolean vValue = vBlock.getBoolean(vOffset);
+        state.booleanValue(MinBooleanAggregator.combine(state.booleanValue(), vValue));
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBytesRefAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBytesRefAggregatorFunction.java
index 5a421b5c1fe4f..1669e31dda1b9 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBytesRefAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBytesRefAggregatorFunction.java
@@ -59,73 +59,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BytesRefBlock block = page.getBlock(channels.get(0));
-      BytesRefVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BytesRefBlock valueBlock = page.getBlock(channels.get(0));
+    BytesRefVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BytesRefBlock block = page.getBlock(channels.get(0));
-    BytesRefVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(valueVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BytesRefBlock valueBlock = page.getBlock(channels.get(0));
+    BytesRefVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock);
+      return;
     }
+    addRawVector(valueVector);
   }
 
-  private void addRawVector(BytesRefVector vector) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      MinBytesRefAggregator.combine(state, vector.getBytesRef(i, scratch));
+  private void addRawVector(BytesRefVector valueVector) {
+    BytesRef valueScratch = new BytesRef();
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
+      BytesRef valueValue = valueVector.getBytesRef(i, valueScratch);
+      MinBytesRefAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawVector(BytesRefVector vector, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BytesRefVector valueVector, BooleanVector mask) {
+    BytesRef valueScratch = new BytesRef();
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      MinBytesRefAggregator.combine(state, vector.getBytesRef(i, scratch));
+      BytesRef valueValue = valueVector.getBytesRef(i, valueScratch);
+      MinBytesRefAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawBlock(BytesRefBlock block) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BytesRefBlock valueBlock) {
+    BytesRef valueScratch = new BytesRef();
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MinBytesRefAggregator.combine(state, block.getBytesRef(i, scratch));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch);
+        MinBytesRefAggregator.combine(state, valueValue);
       }
     }
   }
 
-  private void addRawBlock(BytesRefBlock block, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BytesRefBlock valueBlock, BooleanVector mask) {
+    BytesRef valueScratch = new BytesRef();
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MinBytesRefAggregator.combine(state, block.getBytesRef(i, scratch));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch);
+        MinBytesRefAggregator.combine(state, valueValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinDoubleAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinDoubleAggregatorFunction.java
index a92183e3e7af7..544cad0c06b72 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinDoubleAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinDoubleAggregatorFunction.java
@@ -58,73 +58,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      DoubleBlock block = page.getBlock(channels.get(0));
-      DoubleVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    DoubleBlock block = page.getBlock(channels.get(0));
-    DoubleVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(DoubleVector vector) {
+  private void addRawVector(DoubleVector vVector) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      state.doubleValue(MinDoubleAggregator.combine(state.doubleValue(), vector.getDouble(i)));
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      double vValue = vVector.getDouble(i);
+      state.doubleValue(MinDoubleAggregator.combine(state.doubleValue(), vValue));
     }
   }
 
-  private void addRawVector(DoubleVector vector, BooleanVector mask) {
+  private void addRawVector(DoubleVector vVector, BooleanVector mask) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      state.doubleValue(MinDoubleAggregator.combine(state.doubleValue(), vector.getDouble(i)));
+      double vValue = vVector.getDouble(i);
+      state.doubleValue(MinDoubleAggregator.combine(state.doubleValue(), vValue));
     }
   }
 
-  private void addRawBlock(DoubleBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(DoubleBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.doubleValue(MinDoubleAggregator.combine(state.doubleValue(), block.getDouble(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        state.doubleValue(MinDoubleAggregator.combine(state.doubleValue(), vValue));
       }
     }
   }
 
-  private void addRawBlock(DoubleBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(DoubleBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.doubleValue(MinDoubleAggregator.combine(state.doubleValue(), block.getDouble(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        state.doubleValue(MinDoubleAggregator.combine(state.doubleValue(), vValue));
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinFloatAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinFloatAggregatorFunction.java
index 439f463ce5665..8e2ac63914544 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinFloatAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinFloatAggregatorFunction.java
@@ -58,73 +58,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      FloatBlock block = page.getBlock(channels.get(0));
-      FloatVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    FloatBlock block = page.getBlock(channels.get(0));
-    FloatVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(FloatVector vector) {
+  private void addRawVector(FloatVector vVector) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      state.floatValue(MinFloatAggregator.combine(state.floatValue(), vector.getFloat(i)));
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      float vValue = vVector.getFloat(i);
+      state.floatValue(MinFloatAggregator.combine(state.floatValue(), vValue));
     }
   }
 
-  private void addRawVector(FloatVector vector, BooleanVector mask) {
+  private void addRawVector(FloatVector vVector, BooleanVector mask) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      state.floatValue(MinFloatAggregator.combine(state.floatValue(), vector.getFloat(i)));
+      float vValue = vVector.getFloat(i);
+      state.floatValue(MinFloatAggregator.combine(state.floatValue(), vValue));
     }
   }
 
-  private void addRawBlock(FloatBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(FloatBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.floatValue(MinFloatAggregator.combine(state.floatValue(), block.getFloat(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        state.floatValue(MinFloatAggregator.combine(state.floatValue(), vValue));
       }
     }
   }
 
-  private void addRawBlock(FloatBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(FloatBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.floatValue(MinFloatAggregator.combine(state.floatValue(), block.getFloat(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        state.floatValue(MinFloatAggregator.combine(state.floatValue(), vValue));
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIntAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIntAggregatorFunction.java
index 4fbb44cca85a5..804ab7bacc819 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIntAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIntAggregatorFunction.java
@@ -58,73 +58,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      IntBlock block = page.getBlock(channels.get(0));
-      IntVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    IntBlock block = page.getBlock(channels.get(0));
-    IntVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(IntVector vector) {
+  private void addRawVector(IntVector vVector) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      state.intValue(MinIntAggregator.combine(state.intValue(), vector.getInt(i)));
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      int vValue = vVector.getInt(i);
+      state.intValue(MinIntAggregator.combine(state.intValue(), vValue));
     }
   }
 
-  private void addRawVector(IntVector vector, BooleanVector mask) {
+  private void addRawVector(IntVector vVector, BooleanVector mask) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      state.intValue(MinIntAggregator.combine(state.intValue(), vector.getInt(i)));
+      int vValue = vVector.getInt(i);
+      state.intValue(MinIntAggregator.combine(state.intValue(), vValue));
     }
   }
 
-  private void addRawBlock(IntBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(IntBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.intValue(MinIntAggregator.combine(state.intValue(), block.getInt(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        state.intValue(MinIntAggregator.combine(state.intValue(), vValue));
       }
     }
   }
 
-  private void addRawBlock(IntBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(IntBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.intValue(MinIntAggregator.combine(state.intValue(), block.getInt(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        state.intValue(MinIntAggregator.combine(state.intValue(), vValue));
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIpAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIpAggregatorFunction.java
index ec20f57699760..3d9b7639f3d16 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIpAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIpAggregatorFunction.java
@@ -59,73 +59,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BytesRefBlock block = page.getBlock(channels.get(0));
-      BytesRefVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BytesRefBlock valueBlock = page.getBlock(channels.get(0));
+    BytesRefVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BytesRefBlock block = page.getBlock(channels.get(0));
-    BytesRefVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(valueVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BytesRefBlock valueBlock = page.getBlock(channels.get(0));
+    BytesRefVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock);
+      return;
     }
+    addRawVector(valueVector);
   }
 
-  private void addRawVector(BytesRefVector vector) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      MinIpAggregator.combine(state, vector.getBytesRef(i, scratch));
+  private void addRawVector(BytesRefVector valueVector) {
+    BytesRef valueScratch = new BytesRef();
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
+      BytesRef valueValue = valueVector.getBytesRef(i, valueScratch);
+      MinIpAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawVector(BytesRefVector vector, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BytesRefVector valueVector, BooleanVector mask) {
+    BytesRef valueScratch = new BytesRef();
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      MinIpAggregator.combine(state, vector.getBytesRef(i, scratch));
+      BytesRef valueValue = valueVector.getBytesRef(i, valueScratch);
+      MinIpAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawBlock(BytesRefBlock block) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BytesRefBlock valueBlock) {
+    BytesRef valueScratch = new BytesRef();
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MinIpAggregator.combine(state, block.getBytesRef(i, scratch));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch);
+        MinIpAggregator.combine(state, valueValue);
       }
     }
   }
 
-  private void addRawBlock(BytesRefBlock block, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BytesRefBlock valueBlock, BooleanVector mask) {
+    BytesRef valueScratch = new BytesRef();
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        MinIpAggregator.combine(state, block.getBytesRef(i, scratch));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch);
+        MinIpAggregator.combine(state, valueValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinLongAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinLongAggregatorFunction.java
index 20852b134ea32..24aba4a060c3e 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinLongAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinLongAggregatorFunction.java
@@ -58,73 +58,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      LongBlock block = page.getBlock(channels.get(0));
-      LongVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    LongBlock block = page.getBlock(channels.get(0));
-    LongVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(LongVector vector) {
+  private void addRawVector(LongVector vVector) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      state.longValue(MinLongAggregator.combine(state.longValue(), vector.getLong(i)));
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      long vValue = vVector.getLong(i);
+      state.longValue(MinLongAggregator.combine(state.longValue(), vValue));
     }
   }
 
-  private void addRawVector(LongVector vector, BooleanVector mask) {
+  private void addRawVector(LongVector vVector, BooleanVector mask) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      state.longValue(MinLongAggregator.combine(state.longValue(), vector.getLong(i)));
+      long vValue = vVector.getLong(i);
+      state.longValue(MinLongAggregator.combine(state.longValue(), vValue));
     }
   }
 
-  private void addRawBlock(LongBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(LongBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.longValue(MinLongAggregator.combine(state.longValue(), block.getLong(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        state.longValue(MinLongAggregator.combine(state.longValue(), vValue));
       }
     }
   }
 
-  private void addRawBlock(LongBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(LongBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.longValue(MinLongAggregator.combine(state.longValue(), block.getLong(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        state.longValue(MinLongAggregator.combine(state.longValue(), vValue));
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileDoubleAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileDoubleAggregatorFunction.java
index 51cbd31e56b85..6be17326820b9 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileDoubleAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileDoubleAggregatorFunction.java
@@ -62,69 +62,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      DoubleBlock block = page.getBlock(channels.get(0));
-      DoubleVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    DoubleBlock block = page.getBlock(channels.get(0));
-    DoubleVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(DoubleVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      PercentileDoubleAggregator.combine(state, vector.getDouble(i));
+  private void addRawVector(DoubleVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      double vValue = vVector.getDouble(i);
+      PercentileDoubleAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(DoubleVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(DoubleVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      PercentileDoubleAggregator.combine(state, vector.getDouble(i));
+      double vValue = vVector.getDouble(i);
+      PercentileDoubleAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(DoubleBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(DoubleBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        PercentileDoubleAggregator.combine(state, block.getDouble(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        PercentileDoubleAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(DoubleBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(DoubleBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        PercentileDoubleAggregator.combine(state, block.getDouble(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        PercentileDoubleAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileFloatAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileFloatAggregatorFunction.java
index b4b36ec039b72..70e8dd79c9d2a 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileFloatAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileFloatAggregatorFunction.java
@@ -62,69 +62,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      FloatBlock block = page.getBlock(channels.get(0));
-      FloatVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    FloatBlock block = page.getBlock(channels.get(0));
-    FloatVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(FloatVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      PercentileFloatAggregator.combine(state, vector.getFloat(i));
+  private void addRawVector(FloatVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      float vValue = vVector.getFloat(i);
+      PercentileFloatAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(FloatVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(FloatVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      PercentileFloatAggregator.combine(state, vector.getFloat(i));
+      float vValue = vVector.getFloat(i);
+      PercentileFloatAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(FloatBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(FloatBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        PercentileFloatAggregator.combine(state, block.getFloat(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        PercentileFloatAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(FloatBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(FloatBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        PercentileFloatAggregator.combine(state, block.getFloat(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        PercentileFloatAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileIntAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileIntAggregatorFunction.java
index 730c27ea27bf7..eea8f58d615b2 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileIntAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileIntAggregatorFunction.java
@@ -62,69 +62,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      IntBlock block = page.getBlock(channels.get(0));
-      IntVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    IntBlock block = page.getBlock(channels.get(0));
-    IntVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(IntVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      PercentileIntAggregator.combine(state, vector.getInt(i));
+  private void addRawVector(IntVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      int vValue = vVector.getInt(i);
+      PercentileIntAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(IntVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(IntVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      PercentileIntAggregator.combine(state, vector.getInt(i));
+      int vValue = vVector.getInt(i);
+      PercentileIntAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(IntBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(IntBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        PercentileIntAggregator.combine(state, block.getInt(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        PercentileIntAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(IntBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(IntBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        PercentileIntAggregator.combine(state, block.getInt(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        PercentileIntAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileLongAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileLongAggregatorFunction.java
index 510b69cb6fc89..1cf820a23a162 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileLongAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileLongAggregatorFunction.java
@@ -62,69 +62,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      LongBlock block = page.getBlock(channels.get(0));
-      LongVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    LongBlock block = page.getBlock(channels.get(0));
-    LongVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(LongVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      PercentileLongAggregator.combine(state, vector.getLong(i));
+  private void addRawVector(LongVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      long vValue = vVector.getLong(i);
+      PercentileLongAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(LongVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(LongVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      PercentileLongAggregator.combine(state, vector.getLong(i));
+      long vValue = vVector.getLong(i);
+      PercentileLongAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(LongBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(LongBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        PercentileLongAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        PercentileLongAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(LongBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(LongBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        PercentileLongAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        PercentileLongAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBooleanAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBooleanAggregatorFunction.java
index 45a6a2d060813..852c8e7c7afc4 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBooleanAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBooleanAggregatorFunction.java
@@ -60,69 +60,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BooleanBlock block = page.getBlock(channels.get(0));
-      BooleanVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BooleanBlock valueBlock = page.getBlock(channels.get(0));
+    BooleanVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BooleanBlock block = page.getBlock(channels.get(0));
-    BooleanVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(valueVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BooleanBlock valueBlock = page.getBlock(channels.get(0));
+    BooleanVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock);
+      return;
     }
+    addRawVector(valueVector);
   }
 
-  private void addRawVector(BooleanVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SampleBooleanAggregator.combine(state, vector.getBoolean(i));
+  private void addRawVector(BooleanVector valueVector) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
+      boolean valueValue = valueVector.getBoolean(i);
+      SampleBooleanAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawVector(BooleanVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BooleanVector valueVector, BooleanVector mask) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SampleBooleanAggregator.combine(state, vector.getBoolean(i));
+      boolean valueValue = valueVector.getBoolean(i);
+      SampleBooleanAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawBlock(BooleanBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BooleanBlock valueBlock) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SampleBooleanAggregator.combine(state, block.getBoolean(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        boolean valueValue = valueBlock.getBoolean(valueOffset);
+        SampleBooleanAggregator.combine(state, valueValue);
       }
     }
   }
 
-  private void addRawBlock(BooleanBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BooleanBlock valueBlock, BooleanVector mask) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SampleBooleanAggregator.combine(state, block.getBoolean(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        boolean valueValue = valueBlock.getBoolean(valueOffset);
+        SampleBooleanAggregator.combine(state, valueValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBytesRefAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBytesRefAggregatorFunction.java
index 9b3a7718d9898..d3787ff5e1762 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBytesRefAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBytesRefAggregatorFunction.java
@@ -60,73 +60,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BytesRefBlock block = page.getBlock(channels.get(0));
-      BytesRefVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BytesRefBlock valueBlock = page.getBlock(channels.get(0));
+    BytesRefVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BytesRefBlock block = page.getBlock(channels.get(0));
-    BytesRefVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(valueVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BytesRefBlock valueBlock = page.getBlock(channels.get(0));
+    BytesRefVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock);
+      return;
     }
+    addRawVector(valueVector);
   }
 
-  private void addRawVector(BytesRefVector vector) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SampleBytesRefAggregator.combine(state, vector.getBytesRef(i, scratch));
+  private void addRawVector(BytesRefVector valueVector) {
+    BytesRef valueScratch = new BytesRef();
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
+      BytesRef valueValue = valueVector.getBytesRef(i, valueScratch);
+      SampleBytesRefAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawVector(BytesRefVector vector, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BytesRefVector valueVector, BooleanVector mask) {
+    BytesRef valueScratch = new BytesRef();
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SampleBytesRefAggregator.combine(state, vector.getBytesRef(i, scratch));
+      BytesRef valueValue = valueVector.getBytesRef(i, valueScratch);
+      SampleBytesRefAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawBlock(BytesRefBlock block) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BytesRefBlock valueBlock) {
+    BytesRef valueScratch = new BytesRef();
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SampleBytesRefAggregator.combine(state, block.getBytesRef(i, scratch));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch);
+        SampleBytesRefAggregator.combine(state, valueValue);
       }
     }
   }
 
-  private void addRawBlock(BytesRefBlock block, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BytesRefBlock valueBlock, BooleanVector mask) {
+    BytesRef valueScratch = new BytesRef();
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SampleBytesRefAggregator.combine(state, block.getBytesRef(i, scratch));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch);
+        SampleBytesRefAggregator.combine(state, valueValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleDoubleAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleDoubleAggregatorFunction.java
index b308b4cff4860..ab0a292729409 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleDoubleAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleDoubleAggregatorFunction.java
@@ -61,69 +61,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      DoubleBlock block = page.getBlock(channels.get(0));
-      DoubleVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    DoubleBlock valueBlock = page.getBlock(channels.get(0));
+    DoubleVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    DoubleBlock block = page.getBlock(channels.get(0));
-    DoubleVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(valueVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    DoubleBlock valueBlock = page.getBlock(channels.get(0));
+    DoubleVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock);
+      return;
     }
+    addRawVector(valueVector);
   }
 
-  private void addRawVector(DoubleVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SampleDoubleAggregator.combine(state, vector.getDouble(i));
+  private void addRawVector(DoubleVector valueVector) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
+      double valueValue = valueVector.getDouble(i);
+      SampleDoubleAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawVector(DoubleVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(DoubleVector valueVector, BooleanVector mask) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SampleDoubleAggregator.combine(state, vector.getDouble(i));
+      double valueValue = valueVector.getDouble(i);
+      SampleDoubleAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawBlock(DoubleBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(DoubleBlock valueBlock) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SampleDoubleAggregator.combine(state, block.getDouble(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        double valueValue = valueBlock.getDouble(valueOffset);
+        SampleDoubleAggregator.combine(state, valueValue);
       }
     }
   }
 
-  private void addRawBlock(DoubleBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(DoubleBlock valueBlock, BooleanVector mask) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SampleDoubleAggregator.combine(state, block.getDouble(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        double valueValue = valueBlock.getDouble(valueOffset);
+        SampleDoubleAggregator.combine(state, valueValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleIntAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleIntAggregatorFunction.java
index 97f31295e829e..abd52a8463c73 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleIntAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleIntAggregatorFunction.java
@@ -61,69 +61,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      IntBlock block = page.getBlock(channels.get(0));
-      IntVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    IntBlock valueBlock = page.getBlock(channels.get(0));
+    IntVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    IntBlock block = page.getBlock(channels.get(0));
-    IntVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(valueVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    IntBlock valueBlock = page.getBlock(channels.get(0));
+    IntVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock);
+      return;
     }
+    addRawVector(valueVector);
   }
 
-  private void addRawVector(IntVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SampleIntAggregator.combine(state, vector.getInt(i));
+  private void addRawVector(IntVector valueVector) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
+      int valueValue = valueVector.getInt(i);
+      SampleIntAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawVector(IntVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(IntVector valueVector, BooleanVector mask) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SampleIntAggregator.combine(state, vector.getInt(i));
+      int valueValue = valueVector.getInt(i);
+      SampleIntAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawBlock(IntBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(IntBlock valueBlock) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SampleIntAggregator.combine(state, block.getInt(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        int valueValue = valueBlock.getInt(valueOffset);
+        SampleIntAggregator.combine(state, valueValue);
       }
     }
   }
 
-  private void addRawBlock(IntBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(IntBlock valueBlock, BooleanVector mask) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SampleIntAggregator.combine(state, block.getInt(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        int valueValue = valueBlock.getInt(valueOffset);
+        SampleIntAggregator.combine(state, valueValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleLongAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleLongAggregatorFunction.java
index 269f0f14f166a..590d29dee9864 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleLongAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleLongAggregatorFunction.java
@@ -61,69 +61,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      LongBlock block = page.getBlock(channels.get(0));
-      LongVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    LongBlock valueBlock = page.getBlock(channels.get(0));
+    LongVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    LongBlock block = page.getBlock(channels.get(0));
-    LongVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(valueVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    LongBlock valueBlock = page.getBlock(channels.get(0));
+    LongVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock);
+      return;
     }
+    addRawVector(valueVector);
   }
 
-  private void addRawVector(LongVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SampleLongAggregator.combine(state, vector.getLong(i));
+  private void addRawVector(LongVector valueVector) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
+      long valueValue = valueVector.getLong(i);
+      SampleLongAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawVector(LongVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(LongVector valueVector, BooleanVector mask) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SampleLongAggregator.combine(state, vector.getLong(i));
+      long valueValue = valueVector.getLong(i);
+      SampleLongAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawBlock(LongBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(LongBlock valueBlock) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SampleLongAggregator.combine(state, block.getLong(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        long valueValue = valueBlock.getLong(valueOffset);
+        SampleLongAggregator.combine(state, valueValue);
       }
     }
   }
 
-  private void addRawBlock(LongBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(LongBlock valueBlock, BooleanVector mask) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SampleLongAggregator.combine(state, block.getLong(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        long valueValue = valueBlock.getLong(valueOffset);
+        SampleLongAggregator.combine(state, valueValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevDoubleAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevDoubleAggregatorFunction.java
index 3b08c42b7acbf..a1bccaa9f1d3b 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevDoubleAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevDoubleAggregatorFunction.java
@@ -60,69 +60,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      DoubleBlock block = page.getBlock(channels.get(0));
-      DoubleVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    DoubleBlock valueBlock = page.getBlock(channels.get(0));
+    DoubleVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    DoubleBlock block = page.getBlock(channels.get(0));
-    DoubleVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(valueVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    DoubleBlock valueBlock = page.getBlock(channels.get(0));
+    DoubleVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock);
+      return;
     }
+    addRawVector(valueVector);
   }
 
-  private void addRawVector(DoubleVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      StdDevDoubleAggregator.combine(state, vector.getDouble(i));
+  private void addRawVector(DoubleVector valueVector) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
+      double valueValue = valueVector.getDouble(i);
+      StdDevDoubleAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawVector(DoubleVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(DoubleVector valueVector, BooleanVector mask) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      StdDevDoubleAggregator.combine(state, vector.getDouble(i));
+      double valueValue = valueVector.getDouble(i);
+      StdDevDoubleAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawBlock(DoubleBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(DoubleBlock valueBlock) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        StdDevDoubleAggregator.combine(state, block.getDouble(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        double valueValue = valueBlock.getDouble(valueOffset);
+        StdDevDoubleAggregator.combine(state, valueValue);
       }
     }
   }
 
-  private void addRawBlock(DoubleBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(DoubleBlock valueBlock, BooleanVector mask) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        StdDevDoubleAggregator.combine(state, block.getDouble(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        double valueValue = valueBlock.getDouble(valueOffset);
+        StdDevDoubleAggregator.combine(state, valueValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevFloatAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevFloatAggregatorFunction.java
index 4f2937c2db07d..4ece85c8dcec1 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevFloatAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevFloatAggregatorFunction.java
@@ -62,69 +62,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      FloatBlock block = page.getBlock(channels.get(0));
-      FloatVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    FloatBlock valueBlock = page.getBlock(channels.get(0));
+    FloatVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    FloatBlock block = page.getBlock(channels.get(0));
-    FloatVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(valueVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    FloatBlock valueBlock = page.getBlock(channels.get(0));
+    FloatVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock);
+      return;
     }
+    addRawVector(valueVector);
   }
 
-  private void addRawVector(FloatVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      StdDevFloatAggregator.combine(state, vector.getFloat(i));
+  private void addRawVector(FloatVector valueVector) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
+      float valueValue = valueVector.getFloat(i);
+      StdDevFloatAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawVector(FloatVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(FloatVector valueVector, BooleanVector mask) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      StdDevFloatAggregator.combine(state, vector.getFloat(i));
+      float valueValue = valueVector.getFloat(i);
+      StdDevFloatAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawBlock(FloatBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(FloatBlock valueBlock) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        StdDevFloatAggregator.combine(state, block.getFloat(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        float valueValue = valueBlock.getFloat(valueOffset);
+        StdDevFloatAggregator.combine(state, valueValue);
       }
     }
   }
 
-  private void addRawBlock(FloatBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(FloatBlock valueBlock, BooleanVector mask) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        StdDevFloatAggregator.combine(state, block.getFloat(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        float valueValue = valueBlock.getFloat(valueOffset);
+        StdDevFloatAggregator.combine(state, valueValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevIntAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevIntAggregatorFunction.java
index 9fe0798f53d76..2c927a35cb1a6 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevIntAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevIntAggregatorFunction.java
@@ -62,69 +62,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      IntBlock block = page.getBlock(channels.get(0));
-      IntVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    IntBlock valueBlock = page.getBlock(channels.get(0));
+    IntVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    IntBlock block = page.getBlock(channels.get(0));
-    IntVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(valueVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    IntBlock valueBlock = page.getBlock(channels.get(0));
+    IntVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock);
+      return;
     }
+    addRawVector(valueVector);
   }
 
-  private void addRawVector(IntVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      StdDevIntAggregator.combine(state, vector.getInt(i));
+  private void addRawVector(IntVector valueVector) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
+      int valueValue = valueVector.getInt(i);
+      StdDevIntAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawVector(IntVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(IntVector valueVector, BooleanVector mask) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      StdDevIntAggregator.combine(state, vector.getInt(i));
+      int valueValue = valueVector.getInt(i);
+      StdDevIntAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawBlock(IntBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(IntBlock valueBlock) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        StdDevIntAggregator.combine(state, block.getInt(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        int valueValue = valueBlock.getInt(valueOffset);
+        StdDevIntAggregator.combine(state, valueValue);
       }
     }
   }
 
-  private void addRawBlock(IntBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(IntBlock valueBlock, BooleanVector mask) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        StdDevIntAggregator.combine(state, block.getInt(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        int valueValue = valueBlock.getInt(valueOffset);
+        StdDevIntAggregator.combine(state, valueValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevLongAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevLongAggregatorFunction.java
index 60cee4bca2c14..db256f56f7d2e 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevLongAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevLongAggregatorFunction.java
@@ -60,69 +60,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      LongBlock block = page.getBlock(channels.get(0));
-      LongVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    LongBlock valueBlock = page.getBlock(channels.get(0));
+    LongVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    LongBlock block = page.getBlock(channels.get(0));
-    LongVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(valueVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    LongBlock valueBlock = page.getBlock(channels.get(0));
+    LongVector valueVector = valueBlock.asVector();
+    if (valueVector == null) {
+      addRawBlock(valueBlock);
+      return;
     }
+    addRawVector(valueVector);
   }
 
-  private void addRawVector(LongVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      StdDevLongAggregator.combine(state, vector.getLong(i));
+  private void addRawVector(LongVector valueVector) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
+      long valueValue = valueVector.getLong(i);
+      StdDevLongAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawVector(LongVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(LongVector valueVector, BooleanVector mask) {
+    for (int i = 0; i < valueVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      StdDevLongAggregator.combine(state, vector.getLong(i));
+      long valueValue = valueVector.getLong(i);
+      StdDevLongAggregator.combine(state, valueValue);
     }
   }
 
-  private void addRawBlock(LongBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(LongBlock valueBlock) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        StdDevLongAggregator.combine(state, block.getLong(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        long valueValue = valueBlock.getLong(valueOffset);
+        StdDevLongAggregator.combine(state, valueValue);
       }
     }
   }
 
-  private void addRawBlock(LongBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(LongBlock valueBlock, BooleanVector mask) {
+    for (int p = 0; p < valueBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (valueBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        StdDevLongAggregator.combine(state, block.getLong(i));
+      int valueStart = valueBlock.getFirstValueIndex(p);
+      int valueEnd = valueStart + valueBlock.getValueCount(p);
+      for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) {
+        long valueValue = valueBlock.getLong(valueOffset);
+        StdDevLongAggregator.combine(state, valueValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumDoubleAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumDoubleAggregatorFunction.java
index 70c3191a2236b..432b58f190410 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumDoubleAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumDoubleAggregatorFunction.java
@@ -59,73 +59,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      DoubleBlock block = page.getBlock(channels.get(0));
-      DoubleVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    DoubleBlock block = page.getBlock(channels.get(0));
-    DoubleVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(DoubleVector vector) {
+  private void addRawVector(DoubleVector vVector) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SumDoubleAggregator.combine(state, vector.getDouble(i));
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      double vValue = vVector.getDouble(i);
+      SumDoubleAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(DoubleVector vector, BooleanVector mask) {
+  private void addRawVector(DoubleVector vVector, BooleanVector mask) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SumDoubleAggregator.combine(state, vector.getDouble(i));
+      double vValue = vVector.getDouble(i);
+      SumDoubleAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(DoubleBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(DoubleBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SumDoubleAggregator.combine(state, block.getDouble(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        SumDoubleAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(DoubleBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(DoubleBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SumDoubleAggregator.combine(state, block.getDouble(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        SumDoubleAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumFloatAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumFloatAggregatorFunction.java
index d2259391a2b43..ebd61094c2d91 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumFloatAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumFloatAggregatorFunction.java
@@ -61,73 +61,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      FloatBlock block = page.getBlock(channels.get(0));
-      FloatVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    FloatBlock block = page.getBlock(channels.get(0));
-    FloatVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(FloatVector vector) {
+  private void addRawVector(FloatVector vVector) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SumFloatAggregator.combine(state, vector.getFloat(i));
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      float vValue = vVector.getFloat(i);
+      SumFloatAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(FloatVector vector, BooleanVector mask) {
+  private void addRawVector(FloatVector vVector, BooleanVector mask) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SumFloatAggregator.combine(state, vector.getFloat(i));
+      float vValue = vVector.getFloat(i);
+      SumFloatAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(FloatBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(FloatBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SumFloatAggregator.combine(state, block.getFloat(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        SumFloatAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(FloatBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(FloatBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SumFloatAggregator.combine(state, block.getFloat(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        SumFloatAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumIntAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumIntAggregatorFunction.java
index 6d645c5e5c1ce..e99d4afd606d1 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumIntAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumIntAggregatorFunction.java
@@ -60,73 +60,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      IntBlock block = page.getBlock(channels.get(0));
-      IntVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    IntBlock block = page.getBlock(channels.get(0));
-    IntVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(IntVector vector) {
+  private void addRawVector(IntVector vVector) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      state.longValue(SumIntAggregator.combine(state.longValue(), vector.getInt(i)));
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      int vValue = vVector.getInt(i);
+      state.longValue(SumIntAggregator.combine(state.longValue(), vValue));
     }
   }
 
-  private void addRawVector(IntVector vector, BooleanVector mask) {
+  private void addRawVector(IntVector vVector, BooleanVector mask) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      state.longValue(SumIntAggregator.combine(state.longValue(), vector.getInt(i)));
+      int vValue = vVector.getInt(i);
+      state.longValue(SumIntAggregator.combine(state.longValue(), vValue));
     }
   }
 
-  private void addRawBlock(IntBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(IntBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.longValue(SumIntAggregator.combine(state.longValue(), block.getInt(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        state.longValue(SumIntAggregator.combine(state.longValue(), vValue));
       }
     }
   }
 
-  private void addRawBlock(IntBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(IntBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.longValue(SumIntAggregator.combine(state.longValue(), block.getInt(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        state.longValue(SumIntAggregator.combine(state.longValue(), vValue));
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumLongAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumLongAggregatorFunction.java
index 5852a590d265d..c588348680615 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumLongAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumLongAggregatorFunction.java
@@ -58,73 +58,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      LongBlock block = page.getBlock(channels.get(0));
-      LongVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    LongBlock block = page.getBlock(channels.get(0));
-    LongVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(LongVector vector) {
+  private void addRawVector(LongVector vVector) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      state.longValue(SumLongAggregator.combine(state.longValue(), vector.getLong(i)));
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      long vValue = vVector.getLong(i);
+      state.longValue(SumLongAggregator.combine(state.longValue(), vValue));
     }
   }
 
-  private void addRawVector(LongVector vector, BooleanVector mask) {
+  private void addRawVector(LongVector vVector, BooleanVector mask) {
     state.seen(true);
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      state.longValue(SumLongAggregator.combine(state.longValue(), vector.getLong(i)));
+      long vValue = vVector.getLong(i);
+      state.longValue(SumLongAggregator.combine(state.longValue(), vValue));
     }
   }
 
-  private void addRawBlock(LongBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(LongBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.longValue(SumLongAggregator.combine(state.longValue(), block.getLong(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        state.longValue(SumLongAggregator.combine(state.longValue(), vValue));
       }
     }
   }
 
-  private void addRawBlock(LongBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(LongBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
       state.seen(true);
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        state.longValue(SumLongAggregator.combine(state.longValue(), block.getLong(i)));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        state.longValue(SumLongAggregator.combine(state.longValue(), vValue));
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBooleanAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBooleanAggregatorFunction.java
index c3424b6c982b5..fa69a07bc0ec0 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBooleanAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBooleanAggregatorFunction.java
@@ -61,69 +61,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BooleanBlock block = page.getBlock(channels.get(0));
-      BooleanVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BooleanBlock vBlock = page.getBlock(channels.get(0));
+    BooleanVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BooleanBlock block = page.getBlock(channels.get(0));
-    BooleanVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BooleanBlock vBlock = page.getBlock(channels.get(0));
+    BooleanVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(BooleanVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      TopBooleanAggregator.combine(state, vector.getBoolean(i));
+  private void addRawVector(BooleanVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      boolean vValue = vVector.getBoolean(i);
+      TopBooleanAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(BooleanVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BooleanVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      TopBooleanAggregator.combine(state, vector.getBoolean(i));
+      boolean vValue = vVector.getBoolean(i);
+      TopBooleanAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(BooleanBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BooleanBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        TopBooleanAggregator.combine(state, block.getBoolean(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        boolean vValue = vBlock.getBoolean(vOffset);
+        TopBooleanAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(BooleanBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BooleanBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        TopBooleanAggregator.combine(state, block.getBoolean(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        boolean vValue = vBlock.getBoolean(vOffset);
+        TopBooleanAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBytesRefAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBytesRefAggregatorFunction.java
index a0927f5835a8d..41a3492d22349 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBytesRefAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBytesRefAggregatorFunction.java
@@ -63,73 +63,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BytesRefBlock block = page.getBlock(channels.get(0));
-      BytesRefVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BytesRefBlock vBlock = page.getBlock(channels.get(0));
+    BytesRefVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BytesRefBlock block = page.getBlock(channels.get(0));
-    BytesRefVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BytesRefBlock vBlock = page.getBlock(channels.get(0));
+    BytesRefVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(BytesRefVector vector) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      TopBytesRefAggregator.combine(state, vector.getBytesRef(i, scratch));
+  private void addRawVector(BytesRefVector vVector) {
+    BytesRef vScratch = new BytesRef();
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      BytesRef vValue = vVector.getBytesRef(i, vScratch);
+      TopBytesRefAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(BytesRefVector vector, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BytesRefVector vVector, BooleanVector mask) {
+    BytesRef vScratch = new BytesRef();
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      TopBytesRefAggregator.combine(state, vector.getBytesRef(i, scratch));
+      BytesRef vValue = vVector.getBytesRef(i, vScratch);
+      TopBytesRefAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(BytesRefBlock block) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BytesRefBlock vBlock) {
+    BytesRef vScratch = new BytesRef();
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        TopBytesRefAggregator.combine(state, block.getBytesRef(i, scratch));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch);
+        TopBytesRefAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(BytesRefBlock block, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BytesRefBlock vBlock, BooleanVector mask) {
+    BytesRef vScratch = new BytesRef();
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        TopBytesRefAggregator.combine(state, block.getBytesRef(i, scratch));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch);
+        TopBytesRefAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopDoubleAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopDoubleAggregatorFunction.java
index ca80c91c58cb0..679cb5a52de87 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopDoubleAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopDoubleAggregatorFunction.java
@@ -62,69 +62,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      DoubleBlock block = page.getBlock(channels.get(0));
-      DoubleVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    DoubleBlock block = page.getBlock(channels.get(0));
-    DoubleVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(DoubleVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      TopDoubleAggregator.combine(state, vector.getDouble(i));
+  private void addRawVector(DoubleVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      double vValue = vVector.getDouble(i);
+      TopDoubleAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(DoubleVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(DoubleVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      TopDoubleAggregator.combine(state, vector.getDouble(i));
+      double vValue = vVector.getDouble(i);
+      TopDoubleAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(DoubleBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(DoubleBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        TopDoubleAggregator.combine(state, block.getDouble(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        TopDoubleAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(DoubleBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(DoubleBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        TopDoubleAggregator.combine(state, block.getDouble(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        TopDoubleAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopFloatAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopFloatAggregatorFunction.java
index b569590b781bd..dfb328ec3edc7 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopFloatAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopFloatAggregatorFunction.java
@@ -62,69 +62,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      FloatBlock block = page.getBlock(channels.get(0));
-      FloatVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    FloatBlock block = page.getBlock(channels.get(0));
-    FloatVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(FloatVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      TopFloatAggregator.combine(state, vector.getFloat(i));
+  private void addRawVector(FloatVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      float vValue = vVector.getFloat(i);
+      TopFloatAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(FloatVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(FloatVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      TopFloatAggregator.combine(state, vector.getFloat(i));
+      float vValue = vVector.getFloat(i);
+      TopFloatAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(FloatBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(FloatBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        TopFloatAggregator.combine(state, block.getFloat(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        TopFloatAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(FloatBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(FloatBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        TopFloatAggregator.combine(state, block.getFloat(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        TopFloatAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIntAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIntAggregatorFunction.java
index 0d279e672dd9d..1c5b1fcc91509 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIntAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIntAggregatorFunction.java
@@ -62,69 +62,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      IntBlock block = page.getBlock(channels.get(0));
-      IntVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    IntBlock block = page.getBlock(channels.get(0));
-    IntVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(IntVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      TopIntAggregator.combine(state, vector.getInt(i));
+  private void addRawVector(IntVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      int vValue = vVector.getInt(i);
+      TopIntAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(IntVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(IntVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      TopIntAggregator.combine(state, vector.getInt(i));
+      int vValue = vVector.getInt(i);
+      TopIntAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(IntBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(IntBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        TopIntAggregator.combine(state, block.getInt(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        TopIntAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(IntBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(IntBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        TopIntAggregator.combine(state, block.getInt(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        TopIntAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIpAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIpAggregatorFunction.java
index e723dc2451b5e..a0a4988d0ec14 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIpAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIpAggregatorFunction.java
@@ -63,73 +63,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BytesRefBlock block = page.getBlock(channels.get(0));
-      BytesRefVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BytesRefBlock vBlock = page.getBlock(channels.get(0));
+    BytesRefVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BytesRefBlock block = page.getBlock(channels.get(0));
-    BytesRefVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BytesRefBlock vBlock = page.getBlock(channels.get(0));
+    BytesRefVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(BytesRefVector vector) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      TopIpAggregator.combine(state, vector.getBytesRef(i, scratch));
+  private void addRawVector(BytesRefVector vVector) {
+    BytesRef vScratch = new BytesRef();
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      BytesRef vValue = vVector.getBytesRef(i, vScratch);
+      TopIpAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(BytesRefVector vector, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BytesRefVector vVector, BooleanVector mask) {
+    BytesRef vScratch = new BytesRef();
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      TopIpAggregator.combine(state, vector.getBytesRef(i, scratch));
+      BytesRef vValue = vVector.getBytesRef(i, vScratch);
+      TopIpAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(BytesRefBlock block) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BytesRefBlock vBlock) {
+    BytesRef vScratch = new BytesRef();
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        TopIpAggregator.combine(state, block.getBytesRef(i, scratch));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch);
+        TopIpAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(BytesRefBlock block, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BytesRefBlock vBlock, BooleanVector mask) {
+    BytesRef vScratch = new BytesRef();
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        TopIpAggregator.combine(state, block.getBytesRef(i, scratch));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch);
+        TopIpAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopLongAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopLongAggregatorFunction.java
index 30f115c85ba1b..85908cb98ad8a 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopLongAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopLongAggregatorFunction.java
@@ -62,69 +62,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      LongBlock block = page.getBlock(channels.get(0));
-      LongVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    LongBlock block = page.getBlock(channels.get(0));
-    LongVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(LongVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      TopLongAggregator.combine(state, vector.getLong(i));
+  private void addRawVector(LongVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      long vValue = vVector.getLong(i);
+      TopLongAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(LongVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(LongVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      TopLongAggregator.combine(state, vector.getLong(i));
+      long vValue = vVector.getLong(i);
+      TopLongAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(LongBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(LongBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        TopLongAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        TopLongAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(LongBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(LongBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        TopLongAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        TopLongAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBooleanAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBooleanAggregatorFunction.java
index d3dfad9786561..b958bd78eedd3 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBooleanAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBooleanAggregatorFunction.java
@@ -55,69 +55,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BooleanBlock block = page.getBlock(channels.get(0));
-      BooleanVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BooleanBlock vBlock = page.getBlock(channels.get(0));
+    BooleanVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BooleanBlock block = page.getBlock(channels.get(0));
-    BooleanVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BooleanBlock vBlock = page.getBlock(channels.get(0));
+    BooleanVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(BooleanVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      ValuesBooleanAggregator.combine(state, vector.getBoolean(i));
+  private void addRawVector(BooleanVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      boolean vValue = vVector.getBoolean(i);
+      ValuesBooleanAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(BooleanVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BooleanVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      ValuesBooleanAggregator.combine(state, vector.getBoolean(i));
+      boolean vValue = vVector.getBoolean(i);
+      ValuesBooleanAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(BooleanBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BooleanBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        ValuesBooleanAggregator.combine(state, block.getBoolean(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        boolean vValue = vBlock.getBoolean(vOffset);
+        ValuesBooleanAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(BooleanBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BooleanBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        ValuesBooleanAggregator.combine(state, block.getBoolean(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        boolean vValue = vBlock.getBoolean(vOffset);
+        ValuesBooleanAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBytesRefAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBytesRefAggregatorFunction.java
index 6a4d7ad713f46..8a82cc317cfd1 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBytesRefAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBytesRefAggregatorFunction.java
@@ -57,73 +57,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BytesRefBlock block = page.getBlock(channels.get(0));
-      BytesRefVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BytesRefBlock vBlock = page.getBlock(channels.get(0));
+    BytesRefVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BytesRefBlock block = page.getBlock(channels.get(0));
-    BytesRefVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BytesRefBlock vBlock = page.getBlock(channels.get(0));
+    BytesRefVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(BytesRefVector vector) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      ValuesBytesRefAggregator.combine(state, vector.getBytesRef(i, scratch));
+  private void addRawVector(BytesRefVector vVector) {
+    BytesRef vScratch = new BytesRef();
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      BytesRef vValue = vVector.getBytesRef(i, vScratch);
+      ValuesBytesRefAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(BytesRefVector vector, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BytesRefVector vVector, BooleanVector mask) {
+    BytesRef vScratch = new BytesRef();
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      ValuesBytesRefAggregator.combine(state, vector.getBytesRef(i, scratch));
+      BytesRef vValue = vVector.getBytesRef(i, vScratch);
+      ValuesBytesRefAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(BytesRefBlock block) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BytesRefBlock vBlock) {
+    BytesRef vScratch = new BytesRef();
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        ValuesBytesRefAggregator.combine(state, block.getBytesRef(i, scratch));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch);
+        ValuesBytesRefAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(BytesRefBlock block, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BytesRefBlock vBlock, BooleanVector mask) {
+    BytesRef vScratch = new BytesRef();
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        ValuesBytesRefAggregator.combine(state, block.getBytesRef(i, scratch));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch);
+        ValuesBytesRefAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesDoubleAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesDoubleAggregatorFunction.java
index 17252bd237f49..cda945d592d92 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesDoubleAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesDoubleAggregatorFunction.java
@@ -56,69 +56,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      DoubleBlock block = page.getBlock(channels.get(0));
-      DoubleVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    DoubleBlock block = page.getBlock(channels.get(0));
-    DoubleVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    DoubleBlock vBlock = page.getBlock(channels.get(0));
+    DoubleVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(DoubleVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      ValuesDoubleAggregator.combine(state, vector.getDouble(i));
+  private void addRawVector(DoubleVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      double vValue = vVector.getDouble(i);
+      ValuesDoubleAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(DoubleVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(DoubleVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      ValuesDoubleAggregator.combine(state, vector.getDouble(i));
+      double vValue = vVector.getDouble(i);
+      ValuesDoubleAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(DoubleBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(DoubleBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        ValuesDoubleAggregator.combine(state, block.getDouble(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        ValuesDoubleAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(DoubleBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(DoubleBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        ValuesDoubleAggregator.combine(state, block.getDouble(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        double vValue = vBlock.getDouble(vOffset);
+        ValuesDoubleAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesFloatAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesFloatAggregatorFunction.java
index 55c58fbc2af16..3dcb011aea7fe 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesFloatAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesFloatAggregatorFunction.java
@@ -56,69 +56,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      FloatBlock block = page.getBlock(channels.get(0));
-      FloatVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    FloatBlock block = page.getBlock(channels.get(0));
-    FloatVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    FloatBlock vBlock = page.getBlock(channels.get(0));
+    FloatVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(FloatVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      ValuesFloatAggregator.combine(state, vector.getFloat(i));
+  private void addRawVector(FloatVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      float vValue = vVector.getFloat(i);
+      ValuesFloatAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(FloatVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(FloatVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      ValuesFloatAggregator.combine(state, vector.getFloat(i));
+      float vValue = vVector.getFloat(i);
+      ValuesFloatAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(FloatBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(FloatBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        ValuesFloatAggregator.combine(state, block.getFloat(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        ValuesFloatAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(FloatBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(FloatBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        ValuesFloatAggregator.combine(state, block.getFloat(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        float vValue = vBlock.getFloat(vOffset);
+        ValuesFloatAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesIntAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesIntAggregatorFunction.java
index a65e8b1db8fe7..21094f2c4f039 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesIntAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesIntAggregatorFunction.java
@@ -56,69 +56,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      IntBlock block = page.getBlock(channels.get(0));
-      IntVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    IntBlock block = page.getBlock(channels.get(0));
-    IntVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    IntBlock vBlock = page.getBlock(channels.get(0));
+    IntVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(IntVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      ValuesIntAggregator.combine(state, vector.getInt(i));
+  private void addRawVector(IntVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      int vValue = vVector.getInt(i);
+      ValuesIntAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(IntVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(IntVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      ValuesIntAggregator.combine(state, vector.getInt(i));
+      int vValue = vVector.getInt(i);
+      ValuesIntAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(IntBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(IntBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        ValuesIntAggregator.combine(state, block.getInt(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        ValuesIntAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(IntBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(IntBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        ValuesIntAggregator.combine(state, block.getInt(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        int vValue = vBlock.getInt(vOffset);
+        ValuesIntAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesLongAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesLongAggregatorFunction.java
index 7781392f8c29c..d3c7f3f34be6f 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesLongAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesLongAggregatorFunction.java
@@ -56,69 +56,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      LongBlock block = page.getBlock(channels.get(0));
-      LongVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    LongBlock block = page.getBlock(channels.get(0));
-    LongVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(LongVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      ValuesLongAggregator.combine(state, vector.getLong(i));
+  private void addRawVector(LongVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      long vValue = vVector.getLong(i);
+      ValuesLongAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(LongVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(LongVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      ValuesLongAggregator.combine(state, vector.getLong(i));
+      long vValue = vVector.getLong(i);
+      ValuesLongAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(LongBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(LongBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        ValuesLongAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        ValuesLongAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(LongBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(LongBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        ValuesLongAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        ValuesLongAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointDocValuesAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointDocValuesAggregatorFunction.java
index 5beffde65284e..0988ab23faaa0 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointDocValuesAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointDocValuesAggregatorFunction.java
@@ -64,69 +64,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      LongBlock block = page.getBlock(channels.get(0));
-      LongVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    LongBlock block = page.getBlock(channels.get(0));
-    LongVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(LongVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SpatialCentroidCartesianPointDocValuesAggregator.combine(state, vector.getLong(i));
+  private void addRawVector(LongVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      long vValue = vVector.getLong(i);
+      SpatialCentroidCartesianPointDocValuesAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(LongVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(LongVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SpatialCentroidCartesianPointDocValuesAggregator.combine(state, vector.getLong(i));
+      long vValue = vVector.getLong(i);
+      SpatialCentroidCartesianPointDocValuesAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(LongBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(LongBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialCentroidCartesianPointDocValuesAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        SpatialCentroidCartesianPointDocValuesAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(LongBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(LongBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialCentroidCartesianPointDocValuesAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        SpatialCentroidCartesianPointDocValuesAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointSourceValuesAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointSourceValuesAggregatorFunction.java
index fd5b519bc3d53..cf2d54b487e7e 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointSourceValuesAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointSourceValuesAggregatorFunction.java
@@ -67,73 +67,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BytesRefBlock block = page.getBlock(channels.get(0));
-      BytesRefVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BytesRefBlock wkbBlock = page.getBlock(channels.get(0));
+    BytesRefVector wkbVector = wkbBlock.asVector();
+    if (wkbVector == null) {
+      addRawBlock(wkbBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BytesRefBlock block = page.getBlock(channels.get(0));
-    BytesRefVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(wkbVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BytesRefBlock wkbBlock = page.getBlock(channels.get(0));
+    BytesRefVector wkbVector = wkbBlock.asVector();
+    if (wkbVector == null) {
+      addRawBlock(wkbBlock);
+      return;
     }
+    addRawVector(wkbVector);
   }
 
-  private void addRawVector(BytesRefVector vector) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, vector.getBytesRef(i, scratch));
+  private void addRawVector(BytesRefVector wkbVector) {
+    BytesRef wkbScratch = new BytesRef();
+    for (int i = 0; i < wkbVector.getPositionCount(); i++) {
+      BytesRef wkbValue = wkbVector.getBytesRef(i, wkbScratch);
+      SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, wkbValue);
     }
   }
 
-  private void addRawVector(BytesRefVector vector, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BytesRefVector wkbVector, BooleanVector mask) {
+    BytesRef wkbScratch = new BytesRef();
+    for (int i = 0; i < wkbVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, vector.getBytesRef(i, scratch));
+      BytesRef wkbValue = wkbVector.getBytesRef(i, wkbScratch);
+      SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, wkbValue);
     }
   }
 
-  private void addRawBlock(BytesRefBlock block) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BytesRefBlock wkbBlock) {
+    BytesRef wkbScratch = new BytesRef();
+    for (int p = 0; p < wkbBlock.getPositionCount(); p++) {
+      if (wkbBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, block.getBytesRef(i, scratch));
+      int wkbStart = wkbBlock.getFirstValueIndex(p);
+      int wkbEnd = wkbStart + wkbBlock.getValueCount(p);
+      for (int wkbOffset = wkbStart; wkbOffset < wkbEnd; wkbOffset++) {
+        BytesRef wkbValue = wkbBlock.getBytesRef(wkbOffset, wkbScratch);
+        SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, wkbValue);
       }
     }
   }
 
-  private void addRawBlock(BytesRefBlock block, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BytesRefBlock wkbBlock, BooleanVector mask) {
+    BytesRef wkbScratch = new BytesRef();
+    for (int p = 0; p < wkbBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (wkbBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, block.getBytesRef(i, scratch));
+      int wkbStart = wkbBlock.getFirstValueIndex(p);
+      int wkbEnd = wkbStart + wkbBlock.getValueCount(p);
+      for (int wkbOffset = wkbStart; wkbOffset < wkbEnd; wkbOffset++) {
+        BytesRef wkbValue = wkbBlock.getBytesRef(wkbOffset, wkbScratch);
+        SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, wkbValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointDocValuesAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointDocValuesAggregatorFunction.java
index 22e3a6fa69801..d39f286f5386a 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointDocValuesAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointDocValuesAggregatorFunction.java
@@ -64,69 +64,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      LongBlock block = page.getBlock(channels.get(0));
-      LongVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    LongBlock block = page.getBlock(channels.get(0));
-    LongVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(LongVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SpatialCentroidGeoPointDocValuesAggregator.combine(state, vector.getLong(i));
+  private void addRawVector(LongVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      long vValue = vVector.getLong(i);
+      SpatialCentroidGeoPointDocValuesAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(LongVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(LongVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SpatialCentroidGeoPointDocValuesAggregator.combine(state, vector.getLong(i));
+      long vValue = vVector.getLong(i);
+      SpatialCentroidGeoPointDocValuesAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(LongBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(LongBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialCentroidGeoPointDocValuesAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        SpatialCentroidGeoPointDocValuesAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(LongBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(LongBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialCentroidGeoPointDocValuesAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        SpatialCentroidGeoPointDocValuesAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointSourceValuesAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointSourceValuesAggregatorFunction.java
index f583accfb9f71..2550e9e690959 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointSourceValuesAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointSourceValuesAggregatorFunction.java
@@ -67,73 +67,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BytesRefBlock block = page.getBlock(channels.get(0));
-      BytesRefVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BytesRefBlock wkbBlock = page.getBlock(channels.get(0));
+    BytesRefVector wkbVector = wkbBlock.asVector();
+    if (wkbVector == null) {
+      addRawBlock(wkbBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BytesRefBlock block = page.getBlock(channels.get(0));
-    BytesRefVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(wkbVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BytesRefBlock wkbBlock = page.getBlock(channels.get(0));
+    BytesRefVector wkbVector = wkbBlock.asVector();
+    if (wkbVector == null) {
+      addRawBlock(wkbBlock);
+      return;
     }
+    addRawVector(wkbVector);
   }
 
-  private void addRawVector(BytesRefVector vector) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SpatialCentroidGeoPointSourceValuesAggregator.combine(state, vector.getBytesRef(i, scratch));
+  private void addRawVector(BytesRefVector wkbVector) {
+    BytesRef wkbScratch = new BytesRef();
+    for (int i = 0; i < wkbVector.getPositionCount(); i++) {
+      BytesRef wkbValue = wkbVector.getBytesRef(i, wkbScratch);
+      SpatialCentroidGeoPointSourceValuesAggregator.combine(state, wkbValue);
     }
   }
 
-  private void addRawVector(BytesRefVector vector, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BytesRefVector wkbVector, BooleanVector mask) {
+    BytesRef wkbScratch = new BytesRef();
+    for (int i = 0; i < wkbVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SpatialCentroidGeoPointSourceValuesAggregator.combine(state, vector.getBytesRef(i, scratch));
+      BytesRef wkbValue = wkbVector.getBytesRef(i, wkbScratch);
+      SpatialCentroidGeoPointSourceValuesAggregator.combine(state, wkbValue);
     }
   }
 
-  private void addRawBlock(BytesRefBlock block) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BytesRefBlock wkbBlock) {
+    BytesRef wkbScratch = new BytesRef();
+    for (int p = 0; p < wkbBlock.getPositionCount(); p++) {
+      if (wkbBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialCentroidGeoPointSourceValuesAggregator.combine(state, block.getBytesRef(i, scratch));
+      int wkbStart = wkbBlock.getFirstValueIndex(p);
+      int wkbEnd = wkbStart + wkbBlock.getValueCount(p);
+      for (int wkbOffset = wkbStart; wkbOffset < wkbEnd; wkbOffset++) {
+        BytesRef wkbValue = wkbBlock.getBytesRef(wkbOffset, wkbScratch);
+        SpatialCentroidGeoPointSourceValuesAggregator.combine(state, wkbValue);
       }
     }
   }
 
-  private void addRawBlock(BytesRefBlock block, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BytesRefBlock wkbBlock, BooleanVector mask) {
+    BytesRef wkbScratch = new BytesRef();
+    for (int p = 0; p < wkbBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (wkbBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialCentroidGeoPointSourceValuesAggregator.combine(state, block.getBytesRef(i, scratch));
+      int wkbStart = wkbBlock.getFirstValueIndex(p);
+      int wkbEnd = wkbStart + wkbBlock.getValueCount(p);
+      for (int wkbOffset = wkbStart; wkbOffset < wkbEnd; wkbOffset++) {
+        BytesRef wkbValue = wkbBlock.getBytesRef(wkbOffset, wkbScratch);
+        SpatialCentroidGeoPointSourceValuesAggregator.combine(state, wkbValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointDocValuesAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointDocValuesAggregatorFunction.java
index 18d466442f750..8eba05ba85d06 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointDocValuesAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointDocValuesAggregatorFunction.java
@@ -63,69 +63,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      LongBlock block = page.getBlock(channels.get(0));
-      LongVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    LongBlock block = page.getBlock(channels.get(0));
-    LongVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(vVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    LongBlock vBlock = page.getBlock(channels.get(0));
+    LongVector vVector = vBlock.asVector();
+    if (vVector == null) {
+      addRawBlock(vBlock);
+      return;
     }
+    addRawVector(vVector);
   }
 
-  private void addRawVector(LongVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SpatialExtentCartesianPointDocValuesAggregator.combine(state, vector.getLong(i));
+  private void addRawVector(LongVector vVector) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
+      long vValue = vVector.getLong(i);
+      SpatialExtentCartesianPointDocValuesAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawVector(LongVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(LongVector vVector, BooleanVector mask) {
+    for (int i = 0; i < vVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SpatialExtentCartesianPointDocValuesAggregator.combine(state, vector.getLong(i));
+      long vValue = vVector.getLong(i);
+      SpatialExtentCartesianPointDocValuesAggregator.combine(state, vValue);
     }
   }
 
-  private void addRawBlock(LongBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(LongBlock vBlock) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialExtentCartesianPointDocValuesAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        SpatialExtentCartesianPointDocValuesAggregator.combine(state, vValue);
       }
     }
   }
 
-  private void addRawBlock(LongBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(LongBlock vBlock, BooleanVector mask) {
+    for (int p = 0; p < vBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (vBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialExtentCartesianPointDocValuesAggregator.combine(state, block.getLong(i));
+      int vStart = vBlock.getFirstValueIndex(p);
+      int vEnd = vStart + vBlock.getValueCount(p);
+      for (int vOffset = vStart; vOffset < vEnd; vOffset++) {
+        long vValue = vBlock.getLong(vOffset);
+        SpatialExtentCartesianPointDocValuesAggregator.combine(state, vValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointSourceValuesAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointSourceValuesAggregatorFunction.java
index e7068b708a984..f3355a9a4bace 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointSourceValuesAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointSourceValuesAggregatorFunction.java
@@ -64,73 +64,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BytesRefBlock block = page.getBlock(channels.get(0));
-      BytesRefVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BytesRefBlock bytesBlock = page.getBlock(channels.get(0));
+    BytesRefVector bytesVector = bytesBlock.asVector();
+    if (bytesVector == null) {
+      addRawBlock(bytesBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BytesRefBlock block = page.getBlock(channels.get(0));
-    BytesRefVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(bytesVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BytesRefBlock bytesBlock = page.getBlock(channels.get(0));
+    BytesRefVector bytesVector = bytesBlock.asVector();
+    if (bytesVector == null) {
+      addRawBlock(bytesBlock);
+      return;
     }
+    addRawVector(bytesVector);
   }
 
-  private void addRawVector(BytesRefVector vector) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SpatialExtentCartesianPointSourceValuesAggregator.combine(state, vector.getBytesRef(i, scratch));
+  private void addRawVector(BytesRefVector bytesVector) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int i = 0; i < bytesVector.getPositionCount(); i++) {
+      BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch);
+      SpatialExtentCartesianPointSourceValuesAggregator.combine(state, bytesValue);
     }
   }
 
-  private void addRawVector(BytesRefVector vector, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BytesRefVector bytesVector, BooleanVector mask) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int i = 0; i < bytesVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SpatialExtentCartesianPointSourceValuesAggregator.combine(state, vector.getBytesRef(i, scratch));
+      BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch);
+      SpatialExtentCartesianPointSourceValuesAggregator.combine(state, bytesValue);
     }
   }
 
-  private void addRawBlock(BytesRefBlock block) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BytesRefBlock bytesBlock) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int p = 0; p < bytesBlock.getPositionCount(); p++) {
+      if (bytesBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialExtentCartesianPointSourceValuesAggregator.combine(state, block.getBytesRef(i, scratch));
+      int bytesStart = bytesBlock.getFirstValueIndex(p);
+      int bytesEnd = bytesStart + bytesBlock.getValueCount(p);
+      for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) {
+        BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch);
+        SpatialExtentCartesianPointSourceValuesAggregator.combine(state, bytesValue);
       }
     }
   }
 
-  private void addRawBlock(BytesRefBlock block, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BytesRefBlock bytesBlock, BooleanVector mask) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int p = 0; p < bytesBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (bytesBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialExtentCartesianPointSourceValuesAggregator.combine(state, block.getBytesRef(i, scratch));
+      int bytesStart = bytesBlock.getFirstValueIndex(p);
+      int bytesEnd = bytesStart + bytesBlock.getValueCount(p);
+      for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) {
+        BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch);
+        SpatialExtentCartesianPointSourceValuesAggregator.combine(state, bytesValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeDocValuesAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeDocValuesAggregatorFunction.java
index 4d1bd972434b1..0a4fdd3cd1e55 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeDocValuesAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeDocValuesAggregatorFunction.java
@@ -61,65 +61,69 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      IntBlock block = page.getBlock(channels.get(0));
-      IntVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    IntBlock valuesBlock = page.getBlock(channels.get(0));
+    IntVector valuesVector = valuesBlock.asVector();
+    if (valuesVector == null) {
+      addRawBlock(valuesBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    IntBlock block = page.getBlock(channels.get(0));
-    IntVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(valuesVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    IntBlock valuesBlock = page.getBlock(channels.get(0));
+    IntVector valuesVector = valuesBlock.asVector();
+    if (valuesVector == null) {
+      addRawBlock(valuesBlock);
+      return;
     }
+    addRawVector(valuesVector);
   }
 
-  private void addRawVector(IntVector vector) {
+  private void addRawVector(IntVector valuesVector) {
     // This type does not support vectors because all values are multi-valued
   }
 
-  private void addRawVector(IntVector vector, BooleanVector mask) {
+  private void addRawVector(IntVector valuesVector, BooleanVector mask) {
     // This type does not support vectors because all values are multi-valued
   }
 
-  private void addRawBlock(IntBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(IntBlock valuesBlock) {
+    for (int p = 0; p < valuesBlock.getPositionCount(); p++) {
+      if (valuesBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
+      int start = valuesBlock.getFirstValueIndex(p);
+      int end = start + valuesBlock.getValueCount(p);
       int[] valuesArray = new int[end - start];
       for (int i = start; i < end; i++) {
-        valuesArray[i-start] = block.getInt(i);
+        valuesArray[i-start] = valuesBlock.getInt(i);
       }
       SpatialExtentCartesianShapeDocValuesAggregator.combine(state, valuesArray);
     }
   }
 
-  private void addRawBlock(IntBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(IntBlock valuesBlock, BooleanVector mask) {
+    for (int p = 0; p < valuesBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (valuesBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
+      int start = valuesBlock.getFirstValueIndex(p);
+      int end = start + valuesBlock.getValueCount(p);
       int[] valuesArray = new int[end - start];
       for (int i = start; i < end; i++) {
-        valuesArray[i-start] = block.getInt(i);
+        valuesArray[i-start] = valuesBlock.getInt(i);
       }
       SpatialExtentCartesianShapeDocValuesAggregator.combine(state, valuesArray);
     }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeSourceValuesAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeSourceValuesAggregatorFunction.java
index 62440eba29355..620317539c77c 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeSourceValuesAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeSourceValuesAggregatorFunction.java
@@ -64,73 +64,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BytesRefBlock block = page.getBlock(channels.get(0));
-      BytesRefVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BytesRefBlock bytesBlock = page.getBlock(channels.get(0));
+    BytesRefVector bytesVector = bytesBlock.asVector();
+    if (bytesVector == null) {
+      addRawBlock(bytesBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BytesRefBlock block = page.getBlock(channels.get(0));
-    BytesRefVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(bytesVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BytesRefBlock bytesBlock = page.getBlock(channels.get(0));
+    BytesRefVector bytesVector = bytesBlock.asVector();
+    if (bytesVector == null) {
+      addRawBlock(bytesBlock);
+      return;
     }
+    addRawVector(bytesVector);
   }
 
-  private void addRawVector(BytesRefVector vector) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, vector.getBytesRef(i, scratch));
+  private void addRawVector(BytesRefVector bytesVector) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int i = 0; i < bytesVector.getPositionCount(); i++) {
+      BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch);
+      SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, bytesValue);
     }
   }
 
-  private void addRawVector(BytesRefVector vector, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BytesRefVector bytesVector, BooleanVector mask) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int i = 0; i < bytesVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, vector.getBytesRef(i, scratch));
+      BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch);
+      SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, bytesValue);
     }
   }
 
-  private void addRawBlock(BytesRefBlock block) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BytesRefBlock bytesBlock) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int p = 0; p < bytesBlock.getPositionCount(); p++) {
+      if (bytesBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, block.getBytesRef(i, scratch));
+      int bytesStart = bytesBlock.getFirstValueIndex(p);
+      int bytesEnd = bytesStart + bytesBlock.getValueCount(p);
+      for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) {
+        BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch);
+        SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, bytesValue);
       }
     }
   }
 
-  private void addRawBlock(BytesRefBlock block, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BytesRefBlock bytesBlock, BooleanVector mask) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int p = 0; p < bytesBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (bytesBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, block.getBytesRef(i, scratch));
+      int bytesStart = bytesBlock.getFirstValueIndex(p);
+      int bytesEnd = bytesStart + bytesBlock.getValueCount(p);
+      for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) {
+        BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch);
+        SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, bytesValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointDocValuesAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointDocValuesAggregatorFunction.java
index 49b9ca1bad69d..4ab150c3325f0 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointDocValuesAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointDocValuesAggregatorFunction.java
@@ -65,69 +65,77 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      LongBlock block = page.getBlock(channels.get(0));
-      LongVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    LongBlock encodedBlock = page.getBlock(channels.get(0));
+    LongVector encodedVector = encodedBlock.asVector();
+    if (encodedVector == null) {
+      addRawBlock(encodedBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    LongBlock block = page.getBlock(channels.get(0));
-    LongVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(encodedVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    LongBlock encodedBlock = page.getBlock(channels.get(0));
+    LongVector encodedVector = encodedBlock.asVector();
+    if (encodedVector == null) {
+      addRawBlock(encodedBlock);
+      return;
     }
+    addRawVector(encodedVector);
   }
 
-  private void addRawVector(LongVector vector) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SpatialExtentGeoPointDocValuesAggregator.combine(state, vector.getLong(i));
+  private void addRawVector(LongVector encodedVector) {
+    for (int i = 0; i < encodedVector.getPositionCount(); i++) {
+      long encodedValue = encodedVector.getLong(i);
+      SpatialExtentGeoPointDocValuesAggregator.combine(state, encodedValue);
     }
   }
 
-  private void addRawVector(LongVector vector, BooleanVector mask) {
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(LongVector encodedVector, BooleanVector mask) {
+    for (int i = 0; i < encodedVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SpatialExtentGeoPointDocValuesAggregator.combine(state, vector.getLong(i));
+      long encodedValue = encodedVector.getLong(i);
+      SpatialExtentGeoPointDocValuesAggregator.combine(state, encodedValue);
     }
   }
 
-  private void addRawBlock(LongBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(LongBlock encodedBlock) {
+    for (int p = 0; p < encodedBlock.getPositionCount(); p++) {
+      if (encodedBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialExtentGeoPointDocValuesAggregator.combine(state, block.getLong(i));
+      int encodedStart = encodedBlock.getFirstValueIndex(p);
+      int encodedEnd = encodedStart + encodedBlock.getValueCount(p);
+      for (int encodedOffset = encodedStart; encodedOffset < encodedEnd; encodedOffset++) {
+        long encodedValue = encodedBlock.getLong(encodedOffset);
+        SpatialExtentGeoPointDocValuesAggregator.combine(state, encodedValue);
       }
     }
   }
 
-  private void addRawBlock(LongBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(LongBlock encodedBlock, BooleanVector mask) {
+    for (int p = 0; p < encodedBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (encodedBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialExtentGeoPointDocValuesAggregator.combine(state, block.getLong(i));
+      int encodedStart = encodedBlock.getFirstValueIndex(p);
+      int encodedEnd = encodedStart + encodedBlock.getValueCount(p);
+      for (int encodedOffset = encodedStart; encodedOffset < encodedEnd; encodedOffset++) {
+        long encodedValue = encodedBlock.getLong(encodedOffset);
+        SpatialExtentGeoPointDocValuesAggregator.combine(state, encodedValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointSourceValuesAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointSourceValuesAggregatorFunction.java
index 7d31bea612321..40e9374291903 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointSourceValuesAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointSourceValuesAggregatorFunction.java
@@ -66,73 +66,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BytesRefBlock block = page.getBlock(channels.get(0));
-      BytesRefVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BytesRefBlock bytesBlock = page.getBlock(channels.get(0));
+    BytesRefVector bytesVector = bytesBlock.asVector();
+    if (bytesVector == null) {
+      addRawBlock(bytesBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BytesRefBlock block = page.getBlock(channels.get(0));
-    BytesRefVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(bytesVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BytesRefBlock bytesBlock = page.getBlock(channels.get(0));
+    BytesRefVector bytesVector = bytesBlock.asVector();
+    if (bytesVector == null) {
+      addRawBlock(bytesBlock);
+      return;
     }
+    addRawVector(bytesVector);
   }
 
-  private void addRawVector(BytesRefVector vector) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SpatialExtentGeoPointSourceValuesAggregator.combine(state, vector.getBytesRef(i, scratch));
+  private void addRawVector(BytesRefVector bytesVector) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int i = 0; i < bytesVector.getPositionCount(); i++) {
+      BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch);
+      SpatialExtentGeoPointSourceValuesAggregator.combine(state, bytesValue);
     }
   }
 
-  private void addRawVector(BytesRefVector vector, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BytesRefVector bytesVector, BooleanVector mask) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int i = 0; i < bytesVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SpatialExtentGeoPointSourceValuesAggregator.combine(state, vector.getBytesRef(i, scratch));
+      BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch);
+      SpatialExtentGeoPointSourceValuesAggregator.combine(state, bytesValue);
     }
   }
 
-  private void addRawBlock(BytesRefBlock block) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BytesRefBlock bytesBlock) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int p = 0; p < bytesBlock.getPositionCount(); p++) {
+      if (bytesBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialExtentGeoPointSourceValuesAggregator.combine(state, block.getBytesRef(i, scratch));
+      int bytesStart = bytesBlock.getFirstValueIndex(p);
+      int bytesEnd = bytesStart + bytesBlock.getValueCount(p);
+      for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) {
+        BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch);
+        SpatialExtentGeoPointSourceValuesAggregator.combine(state, bytesValue);
       }
     }
   }
 
-  private void addRawBlock(BytesRefBlock block, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BytesRefBlock bytesBlock, BooleanVector mask) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int p = 0; p < bytesBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (bytesBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialExtentGeoPointSourceValuesAggregator.combine(state, block.getBytesRef(i, scratch));
+      int bytesStart = bytesBlock.getFirstValueIndex(p);
+      int bytesEnd = bytesStart + bytesBlock.getValueCount(p);
+      for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) {
+        BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch);
+        SpatialExtentGeoPointSourceValuesAggregator.combine(state, bytesValue);
       }
     }
   }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeDocValuesAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeDocValuesAggregatorFunction.java
index d181ae1305c7e..f9ab34a775263 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeDocValuesAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeDocValuesAggregatorFunction.java
@@ -63,65 +63,69 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      IntBlock block = page.getBlock(channels.get(0));
-      IntVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    IntBlock valuesBlock = page.getBlock(channels.get(0));
+    IntVector valuesVector = valuesBlock.asVector();
+    if (valuesVector == null) {
+      addRawBlock(valuesBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    IntBlock block = page.getBlock(channels.get(0));
-    IntVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(valuesVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    IntBlock valuesBlock = page.getBlock(channels.get(0));
+    IntVector valuesVector = valuesBlock.asVector();
+    if (valuesVector == null) {
+      addRawBlock(valuesBlock);
+      return;
     }
+    addRawVector(valuesVector);
   }
 
-  private void addRawVector(IntVector vector) {
+  private void addRawVector(IntVector valuesVector) {
     // This type does not support vectors because all values are multi-valued
   }
 
-  private void addRawVector(IntVector vector, BooleanVector mask) {
+  private void addRawVector(IntVector valuesVector, BooleanVector mask) {
     // This type does not support vectors because all values are multi-valued
   }
 
-  private void addRawBlock(IntBlock block) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(IntBlock valuesBlock) {
+    for (int p = 0; p < valuesBlock.getPositionCount(); p++) {
+      if (valuesBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
+      int start = valuesBlock.getFirstValueIndex(p);
+      int end = start + valuesBlock.getValueCount(p);
       int[] valuesArray = new int[end - start];
       for (int i = start; i < end; i++) {
-        valuesArray[i-start] = block.getInt(i);
+        valuesArray[i-start] = valuesBlock.getInt(i);
       }
       SpatialExtentGeoShapeDocValuesAggregator.combine(state, valuesArray);
     }
   }
 
-  private void addRawBlock(IntBlock block, BooleanVector mask) {
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(IntBlock valuesBlock, BooleanVector mask) {
+    for (int p = 0; p < valuesBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (valuesBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
+      int start = valuesBlock.getFirstValueIndex(p);
+      int end = start + valuesBlock.getValueCount(p);
       int[] valuesArray = new int[end - start];
       for (int i = start; i < end; i++) {
-        valuesArray[i-start] = block.getInt(i);
+        valuesArray[i-start] = valuesBlock.getInt(i);
       }
       SpatialExtentGeoShapeDocValuesAggregator.combine(state, valuesArray);
     }
diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeSourceValuesAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeSourceValuesAggregatorFunction.java
index b72a8f23eb5ca..1be574713e12e 100644
--- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeSourceValuesAggregatorFunction.java
+++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeSourceValuesAggregatorFunction.java
@@ -66,73 +66,81 @@ public int intermediateBlockCount() {
   public void addRawInput(Page page, BooleanVector mask) {
     if (mask.allFalse()) {
       // Entire page masked away
-      return;
+    } else if (mask.allTrue()) {
+      addRawInputNotMasked(page);
+    } else {
+      addRawInputMasked(page, mask);
     }
-    if (mask.allTrue()) {
-      // No masking
-      BytesRefBlock block = page.getBlock(channels.get(0));
-      BytesRefVector vector = block.asVector();
-      if (vector != null) {
-        addRawVector(vector);
-      } else {
-        addRawBlock(block);
-      }
+  }
+
+  private void addRawInputMasked(Page page, BooleanVector mask) {
+    BytesRefBlock bytesBlock = page.getBlock(channels.get(0));
+    BytesRefVector bytesVector = bytesBlock.asVector();
+    if (bytesVector == null) {
+      addRawBlock(bytesBlock, mask);
       return;
     }
-    // Some positions masked away, others kept
-    BytesRefBlock block = page.getBlock(channels.get(0));
-    BytesRefVector vector = block.asVector();
-    if (vector != null) {
-      addRawVector(vector, mask);
-    } else {
-      addRawBlock(block, mask);
+    addRawVector(bytesVector, mask);
+  }
+
+  private void addRawInputNotMasked(Page page) {
+    BytesRefBlock bytesBlock = page.getBlock(channels.get(0));
+    BytesRefVector bytesVector = bytesBlock.asVector();
+    if (bytesVector == null) {
+      addRawBlock(bytesBlock);
+      return;
     }
+    addRawVector(bytesVector);
   }
 
-  private void addRawVector(BytesRefVector vector) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
-      SpatialExtentGeoShapeSourceValuesAggregator.combine(state, vector.getBytesRef(i, scratch));
+  private void addRawVector(BytesRefVector bytesVector) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int i = 0; i < bytesVector.getPositionCount(); i++) {
+      BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch);
+      SpatialExtentGeoShapeSourceValuesAggregator.combine(state, bytesValue);
     }
   }
 
-  private void addRawVector(BytesRefVector vector, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int i = 0; i < vector.getPositionCount(); i++) {
+  private void addRawVector(BytesRefVector bytesVector, BooleanVector mask) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int i = 0; i < bytesVector.getPositionCount(); i++) {
       if (mask.getBoolean(i) == false) {
         continue;
       }
-      SpatialExtentGeoShapeSourceValuesAggregator.combine(state, vector.getBytesRef(i, scratch));
+      BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch);
+      SpatialExtentGeoShapeSourceValuesAggregator.combine(state, bytesValue);
     }
   }
 
-  private void addRawBlock(BytesRefBlock block) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
-      if (block.isNull(p)) {
+  private void addRawBlock(BytesRefBlock bytesBlock) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int p = 0; p < bytesBlock.getPositionCount(); p++) {
+      if (bytesBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialExtentGeoShapeSourceValuesAggregator.combine(state, block.getBytesRef(i, scratch));
+      int bytesStart = bytesBlock.getFirstValueIndex(p);
+      int bytesEnd = bytesStart + bytesBlock.getValueCount(p);
+      for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) {
+        BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch);
+        SpatialExtentGeoShapeSourceValuesAggregator.combine(state, bytesValue);
       }
     }
   }
 
-  private void addRawBlock(BytesRefBlock block, BooleanVector mask) {
-    BytesRef scratch = new BytesRef();
-    for (int p = 0; p < block.getPositionCount(); p++) {
+  private void addRawBlock(BytesRefBlock bytesBlock, BooleanVector mask) {
+    BytesRef bytesScratch = new BytesRef();
+    for (int p = 0; p < bytesBlock.getPositionCount(); p++) {
       if (mask.getBoolean(p) == false) {
         continue;
       }
-      if (block.isNull(p)) {
+      if (bytesBlock.isNull(p)) {
         continue;
       }
-      int start = block.getFirstValueIndex(p);
-      int end = start + block.getValueCount(p);
-      for (int i = start; i < end; i++) {
-        SpatialExtentGeoShapeSourceValuesAggregator.combine(state, block.getBytesRef(i, scratch));
+      int bytesStart = bytesBlock.getFirstValueIndex(p);
+      int bytesEnd = bytesStart + bytesBlock.getValueCount(p);
+      for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) {
+        BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch);
+        SpatialExtentGeoShapeSourceValuesAggregator.combine(state, bytesValue);
       }
     }
   }