From 78b37f0fb3202e69522a2c906df7787a4bd69b20 Mon Sep 17 00:00:00 2001 From: Nik Everett Date: Mon, 4 Aug 2025 18:28:21 -0400 Subject: [PATCH] ESQL: Support for multi-argument aggs Adds support for multi-argument grouped aggs. Previously we only had support for aggs with a value and a timestamp. Now we can support any number of fields. This change is mostly mechanical and mostly in generated code. The only production code changes are: 1. Rename things like `block` and `vector` to `fooBlock` so names are unique with multi-argument fields. `foo` comes from the name of the argument to `combine`. 2. Support for passing `Block`s of `long`s in `FirstOverTime` and `LastOverTime`. This will allow it to function outside of TSDB. 3. Flip the order of the arguments in the `combine` methods for `FirstOverTime` and `LastOverTime` so they line up with how the ESQL code orders the arguments. This shouldn't change the runtime at all. 4. Rename the offset variable we use for reading from vectors in non-grouped code so it's the same name as we use in grouped code. This just keeps the code gen a little more consistent. --- .../compute/gen/AggregatorImplementer.java | 25 +- .../gen/GroupingAggregatorImplementer.java | 333 ++++++++---------- .../FirstOverTimeDoubleAggregator.java | 8 +- .../FirstOverTimeFloatAggregator.java | 8 +- .../FirstOverTimeIntAggregator.java | 8 +- .../FirstOverTimeLongAggregator.java | 8 +- .../LastOverTimeDoubleAggregator.java | 8 +- .../LastOverTimeFloatAggregator.java | 8 +- .../LastOverTimeIntAggregator.java | 8 +- .../LastOverTimeLongAggregator.java | 8 +- .../aggregation/RateDoubleAggregator.java | 2 +- .../aggregation/RateFloatAggregator.java | 2 +- .../aggregation/RateIntAggregator.java | 2 +- .../aggregation/RateLongAggregator.java | 2 +- ...ountDistinctBooleanAggregatorFunction.java | 10 +- ...inctBooleanGroupingAggregatorFunction.java | 95 +++-- ...untDistinctBytesRefAggregatorFunction.java | 10 +- ...nctBytesRefGroupingAggregatorFunction.java | 107 +++--- ...CountDistinctDoubleAggregatorFunction.java | 10 +- ...tinctDoubleGroupingAggregatorFunction.java | 95 +++-- .../CountDistinctFloatAggregatorFunction.java | 10 +- ...stinctFloatGroupingAggregatorFunction.java | 95 +++-- .../CountDistinctIntAggregatorFunction.java | 10 +- ...DistinctIntGroupingAggregatorFunction.java | 95 +++-- .../CountDistinctLongAggregatorFunction.java | 10 +- ...istinctLongGroupingAggregatorFunction.java | 95 +++-- ...rTimeDoubleGroupingAggregatorFunction.java | 167 ++++++--- ...erTimeFloatGroupingAggregatorFunction.java | 167 ++++++--- ...OverTimeIntGroupingAggregatorFunction.java | 167 ++++++--- ...verTimeLongGroupingAggregatorFunction.java | 167 ++++++--- ...rTimeDoubleGroupingAggregatorFunction.java | 167 ++++++--- ...erTimeFloatGroupingAggregatorFunction.java | 167 ++++++--- ...OverTimeIntGroupingAggregatorFunction.java | 167 ++++++--- ...verTimeLongGroupingAggregatorFunction.java | 167 ++++++--- .../MaxBooleanAggregatorFunction.java | 10 +- .../MaxBooleanGroupingAggregatorFunction.java | 101 +++--- .../MaxBytesRefAggregatorFunction.java | 10 +- ...MaxBytesRefGroupingAggregatorFunction.java | 108 +++--- .../MaxDoubleAggregatorFunction.java | 10 +- .../MaxDoubleGroupingAggregatorFunction.java | 101 +++--- .../MaxFloatAggregatorFunction.java | 10 +- .../MaxFloatGroupingAggregatorFunction.java | 101 +++--- .../aggregation/MaxIntAggregatorFunction.java | 10 +- .../MaxIntGroupingAggregatorFunction.java | 101 +++--- .../aggregation/MaxIpAggregatorFunction.java | 10 +- .../MaxIpGroupingAggregatorFunction.java | 108 +++--- .../MaxLongAggregatorFunction.java | 10 +- .../MaxLongGroupingAggregatorFunction.java | 101 +++--- ...luteDeviationDoubleAggregatorFunction.java | 10 +- ...ationDoubleGroupingAggregatorFunction.java | 95 +++-- ...oluteDeviationFloatAggregatorFunction.java | 10 +- ...iationFloatGroupingAggregatorFunction.java | 95 +++-- ...bsoluteDeviationIntAggregatorFunction.java | 10 +- ...eviationIntGroupingAggregatorFunction.java | 95 +++-- ...soluteDeviationLongAggregatorFunction.java | 10 +- ...viationLongGroupingAggregatorFunction.java | 95 +++-- .../MinBooleanAggregatorFunction.java | 10 +- .../MinBooleanGroupingAggregatorFunction.java | 101 +++--- .../MinBytesRefAggregatorFunction.java | 10 +- ...MinBytesRefGroupingAggregatorFunction.java | 108 +++--- .../MinDoubleAggregatorFunction.java | 10 +- .../MinDoubleGroupingAggregatorFunction.java | 101 +++--- .../MinFloatAggregatorFunction.java | 10 +- .../MinFloatGroupingAggregatorFunction.java | 101 +++--- .../aggregation/MinIntAggregatorFunction.java | 10 +- .../MinIntGroupingAggregatorFunction.java | 101 +++--- .../aggregation/MinIpAggregatorFunction.java | 10 +- .../MinIpGroupingAggregatorFunction.java | 108 +++--- .../MinLongAggregatorFunction.java | 10 +- .../MinLongGroupingAggregatorFunction.java | 101 +++--- .../PercentileDoubleAggregatorFunction.java | 10 +- ...ntileDoubleGroupingAggregatorFunction.java | 95 +++-- .../PercentileFloatAggregatorFunction.java | 10 +- ...entileFloatGroupingAggregatorFunction.java | 95 +++-- .../PercentileIntAggregatorFunction.java | 10 +- ...rcentileIntGroupingAggregatorFunction.java | 95 +++-- .../PercentileLongAggregatorFunction.java | 10 +- ...centileLongGroupingAggregatorFunction.java | 95 +++-- .../RateDoubleGroupingAggregatorFunction.java | 167 ++++++--- .../RateFloatGroupingAggregatorFunction.java | 167 ++++++--- .../RateIntGroupingAggregatorFunction.java | 167 ++++++--- .../RateLongGroupingAggregatorFunction.java | 167 ++++++--- .../SampleBooleanAggregatorFunction.java | 10 +- ...mpleBooleanGroupingAggregatorFunction.java | 95 +++-- .../SampleBytesRefAggregatorFunction.java | 10 +- ...pleBytesRefGroupingAggregatorFunction.java | 108 +++--- .../SampleDoubleAggregatorFunction.java | 10 +- ...ampleDoubleGroupingAggregatorFunction.java | 95 +++-- .../SampleIntAggregatorFunction.java | 10 +- .../SampleIntGroupingAggregatorFunction.java | 95 +++-- .../SampleLongAggregatorFunction.java | 10 +- .../SampleLongGroupingAggregatorFunction.java | 95 +++-- .../StdDevDoubleAggregatorFunction.java | 10 +- ...tdDevDoubleGroupingAggregatorFunction.java | 95 +++-- .../StdDevFloatAggregatorFunction.java | 10 +- ...StdDevFloatGroupingAggregatorFunction.java | 95 +++-- .../StdDevIntAggregatorFunction.java | 10 +- .../StdDevIntGroupingAggregatorFunction.java | 95 +++-- .../StdDevLongAggregatorFunction.java | 10 +- .../StdDevLongGroupingAggregatorFunction.java | 95 +++-- .../SumDoubleAggregatorFunction.java | 10 +- .../SumDoubleGroupingAggregatorFunction.java | 95 +++-- .../SumFloatAggregatorFunction.java | 10 +- .../SumFloatGroupingAggregatorFunction.java | 95 +++-- .../aggregation/SumIntAggregatorFunction.java | 10 +- .../SumIntGroupingAggregatorFunction.java | 101 +++--- .../SumLongAggregatorFunction.java | 10 +- .../SumLongGroupingAggregatorFunction.java | 101 +++--- .../TopBooleanAggregatorFunction.java | 10 +- .../TopBooleanGroupingAggregatorFunction.java | 95 +++-- .../TopBytesRefAggregatorFunction.java | 10 +- ...TopBytesRefGroupingAggregatorFunction.java | 107 +++--- .../TopDoubleAggregatorFunction.java | 10 +- .../TopDoubleGroupingAggregatorFunction.java | 95 +++-- .../TopFloatAggregatorFunction.java | 10 +- .../TopFloatGroupingAggregatorFunction.java | 95 +++-- .../aggregation/TopIntAggregatorFunction.java | 10 +- .../TopIntGroupingAggregatorFunction.java | 95 +++-- .../aggregation/TopIpAggregatorFunction.java | 10 +- .../TopIpGroupingAggregatorFunction.java | 107 +++--- .../TopLongAggregatorFunction.java | 10 +- .../TopLongGroupingAggregatorFunction.java | 95 +++-- .../ValuesBooleanAggregatorFunction.java | 10 +- ...luesBooleanGroupingAggregatorFunction.java | 95 +++-- .../ValuesBytesRefAggregatorFunction.java | 10 +- ...uesBytesRefGroupingAggregatorFunction.java | 102 +++--- .../ValuesDoubleAggregatorFunction.java | 10 +- ...aluesDoubleGroupingAggregatorFunction.java | 95 +++-- .../ValuesFloatAggregatorFunction.java | 10 +- ...ValuesFloatGroupingAggregatorFunction.java | 95 +++-- .../ValuesIntAggregatorFunction.java | 10 +- .../ValuesIntGroupingAggregatorFunction.java | 95 +++-- .../ValuesLongAggregatorFunction.java | 10 +- .../ValuesLongGroupingAggregatorFunction.java | 95 +++-- ...esianPointDocValuesAggregatorFunction.java | 10 +- ...ntDocValuesGroupingAggregatorFunction.java | 95 +++-- ...anPointSourceValuesAggregatorFunction.java | 10 +- ...ourceValuesGroupingAggregatorFunction.java | 107 +++--- ...idGeoPointDocValuesAggregatorFunction.java | 10 +- ...ntDocValuesGroupingAggregatorFunction.java | 95 +++-- ...eoPointSourceValuesAggregatorFunction.java | 10 +- ...ourceValuesGroupingAggregatorFunction.java | 107 +++--- ...esianPointDocValuesAggregatorFunction.java | 10 +- ...ntDocValuesGroupingAggregatorFunction.java | 95 +++-- ...anPointSourceValuesAggregatorFunction.java | 10 +- ...ourceValuesGroupingAggregatorFunction.java | 108 +++--- ...peDocValuesGroupingAggregatorFunction.java | 54 +-- ...anShapeSourceValuesAggregatorFunction.java | 10 +- ...ourceValuesGroupingAggregatorFunction.java | 108 +++--- ...ntGeoPointDocValuesAggregatorFunction.java | 10 +- ...ntDocValuesGroupingAggregatorFunction.java | 95 +++-- ...eoPointSourceValuesAggregatorFunction.java | 10 +- ...ourceValuesGroupingAggregatorFunction.java | 108 +++--- ...peDocValuesGroupingAggregatorFunction.java | 54 +-- ...eoShapeSourceValuesAggregatorFunction.java | 10 +- ...ourceValuesGroupingAggregatorFunction.java | 108 +++--- .../aggregation/X-RateAggregator.java.st | 2 +- .../X-ValueOverTimeAggregator.java.st | 8 +- 158 files changed, 5853 insertions(+), 3675 deletions(-) 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 3358f29a43643..2edc567f6e744 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 @@ -106,7 +106,6 @@ public AggregatorImplementer( requireName("combine"), requireArgsStartsWith(requireType(aggState.declaredType()), requireAnyType("")) ); - this.aggParams = combine.getParameters().stream().skip(1).map(AggregationParameter::create).toList(); this.createParameters = init.getParameters() @@ -344,10 +343,13 @@ private MethodSpec addRawVector(boolean masked) { builder.addStatement("state.seen(true)"); } - builder.beginControlFlow("for (int i = 0; i < $L.getPositionCount(); i++)", aggParams.getFirst().vectorName()); + builder.beginControlFlow( + "for (int valuesPosition = 0; valuesPosition < $L.getPositionCount(); valuesPosition++)", + aggParams.getFirst().vectorName() + ); { if (masked) { - builder.beginControlFlow("if (mask.getBoolean(i) == false)").addStatement("continue").endControlFlow(); + builder.beginControlFlow("if (mask.getBoolean(valuesPosition) == false)").addStatement("continue").endControlFlow(); } for (AggregationParameter p : aggParams) { p.read(builder, true); @@ -420,11 +422,14 @@ private MethodSpec addRawBlock(boolean masked) { return builder.build(); } - private MethodSpec.Builder initAddRaw(boolean isVector, boolean masked) { - MethodSpec.Builder builder = MethodSpec.methodBuilder(isVector ? "addRawVector" : "addRawBlock"); + private MethodSpec.Builder initAddRaw(boolean valuesAreVector, boolean masked) { + MethodSpec.Builder builder = MethodSpec.methodBuilder(valuesAreVector ? "addRawVector" : "addRawBlock"); builder.addModifiers(Modifier.PRIVATE); for (AggregationParameter p : aggParams) { - builder.addParameter(isVector ? vectorType(p.type) : blockType(p.type), isVector ? p.vectorName() : p.blockName()); + builder.addParameter( + valuesAreVector ? vectorType(p.type) : blockType(p.type), + valuesAreVector ? p.vectorName() : p.blockName() + ); } if (masked) { builder.addParameter(BOOLEAN_VECTOR, "mask"); @@ -440,7 +445,7 @@ private MethodSpec.Builder initAddRaw(boolean isVector, boolean masked) { private void combineRawInput(MethodSpec.Builder builder) { TypeName returnType = TypeName.get(combine.getReturnType()); - warningsBlock(builder, () -> { invokeCombineRawInput(returnType, builder); }); + warningsBlock(builder, () -> invokeCombineRawInput(returnType, builder)); } private void invokeCombineRawInput(TypeName returnType, MethodSpec.Builder builder) { @@ -451,9 +456,11 @@ private void invokeCombineRawInput(TypeName returnType, MethodSpec.Builder build params.add(returnType); params.add(declarationType); params.add(returnType); - } else { + } else if (returnType == TypeName.VOID) { pattern.append("$T.combine(state"); params.add(declarationType); + } else { + throw new IllegalArgumentException("combine must return void or a primitive"); } for (AggregationParameter p : aggParams) { pattern.append(", $L"); @@ -753,7 +760,7 @@ public void read(MethodSpec.Builder builder, boolean vector) { params.add(vector ? vectorName() : blockName()); params.add(readMethod()); if (vector) { - pattern.append("i"); + pattern.append("valuesPosition"); } else { pattern.append("$L"); params.add(offsetName()); 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 7a0afafbff8cf..fe65800ce9c38 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 @@ -20,10 +20,9 @@ import org.elasticsearch.compute.gen.AggregatorImplementer.AggregationParameter; import org.elasticsearch.compute.gen.AggregatorImplementer.AggregationState; +import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import java.util.Objects; -import java.util.function.Consumer; import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -63,8 +62,6 @@ import static org.elasticsearch.compute.gen.Types.INT_VECTOR; 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.SEEN_GROUP_IDS; import static org.elasticsearch.compute.gen.Types.WARNINGS; @@ -90,10 +87,9 @@ public class GroupingAggregatorImplementer { private final List createParameters; private final ClassName implementation; private final List intermediateState; - private final boolean timseries; private final AggregationState aggState; - private final AggregationParameter aggParam; + private final List aggParams; public GroupingAggregatorImplementer( Elements elements, @@ -118,18 +114,11 @@ public GroupingAggregatorImplementer( requireName("combine"), combineArgs(aggState) ); - switch (combine.getParameters().size()) { - case 2, 3 -> timseries = false; - case 4 -> { - if (false == TypeName.get(combine.getParameters().get(2).asType()).equals(TypeName.LONG)) { - throw new IllegalArgumentException("combine/4's third parameter must be long but was: " + combine); - } - timseries = true; - } - 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()); + this.aggParams = combine.getParameters() + .stream() + .skip(aggState.declaredType().isPrimitive() ? 1 : 2) + .map(AggregationParameter::create) + .toList(); this.createParameters = init.getParameters() .stream() @@ -205,8 +194,8 @@ private TypeSpec type() { builder.addMethod(intermediateBlockCount()); builder.addMethod(prepareProcessRawInputPage()); for (ClassName groupIdClass : GROUP_IDS_CLASSES) { - builder.addMethod(addRawInputLoop(groupIdClass, blockType(aggParam.type()))); - builder.addMethod(addRawInputLoop(groupIdClass, vectorType(aggParam.type()))); + builder.addMethod(addRawInputLoop(groupIdClass, false)); + builder.addMethod(addRawInputLoop(groupIdClass, true)); builder.addMethod(addIntermediateInput(groupIdClass)); } builder.addMethod(selectedMayContainUnseenGroups()); @@ -324,105 +313,117 @@ private MethodSpec prepareProcessRawInputPage() { builder.addAnnotation(Override.class).addModifiers(Modifier.PUBLIC).returns(GROUPING_AGGREGATOR_FUNCTION_ADD_INPUT); builder.addParameter(SEEN_GROUP_IDS, "seenGroupIds").addParameter(PAGE, "page"); - builder.addStatement("$T valuesBlock = page.getBlock(channels.get(0))", blockType(aggParam.type())); - builder.addStatement("$T valuesVector = valuesBlock.asVector()", vectorType(aggParam.type())); - if (timseries) { - 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(); + 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); } - builder.beginControlFlow("if (valuesVector == null)"); - String extra = timseries ? ", timestampsVector" : ""; - { - builder.beginControlFlow("if (valuesBlock.mayHaveNulls())"); - builder.addStatement("state.enableGroupIdTracking(seenGroupIds)"); - builder.endControlFlow(); - if (shouldWrapAddInput(blockType(aggParam.type()))) { - builder.addStatement( - "var addInput = $L", - addInput(b -> b.addStatement("addRawInput(positionOffset, groupIds, valuesBlock$L)", extra)) - ); - builder.addStatement("return $T.wrapAddInput(addInput, state, valuesBlock)", declarationType); - } else { - builder.addStatement( - "return $L", - addInput(b -> b.addStatement("addRawInput(positionOffset, groupIds, valuesBlock$L)", extra)) - ); + 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.beginControlFlow("if ($L.mayHaveNulls())", p.blockName()); + builder.addStatement("state.enableGroupIdTracking(seenGroupIds)"); + builder.endControlFlow(); + returnAddInput(builder, false); } + builder.endControlFlow(); } - builder.endControlFlow(); - if (shouldWrapAddInput(vectorType(aggParam.type()))) { - builder.addStatement( - "var addInput = $L", - addInput(b -> b.addStatement("addRawInput(positionOffset, groupIds, valuesVector$L)", extra)) - ); - builder.addStatement("return $T.wrapAddInput(addInput, state, valuesVector)", declarationType); + + returnAddInput(builder, true); + return builder.build(); + } + + private void returnAddInput(MethodSpec.Builder builder, boolean valuesAreVector) { + if (shouldWrapAddInput(valuesAreVector)) { + builder.addStatement("var addInput = $L", addInput(valuesAreVector)); + + StringBuilder pattern = new StringBuilder("return $T.wrapAddInput(addInput, state"); + List params = new ArrayList<>(); + params.add(declarationType); + for (AggregationParameter p : aggParams) { + pattern.append(", $L"); + params.add(valuesAreVector ? p.vectorName() : p.blockName()); + } + pattern.append(")"); + builder.addStatement(pattern.toString(), params.toArray()); } else { - builder.addStatement( - "return $L", - addInput(b -> b.addStatement("addRawInput(positionOffset, groupIds, valuesVector$L)", extra)) - ); + builder.addStatement("return $L", addInput(valuesAreVector)); } - return builder.build(); } /** * Generate an {@code AddInput} implementation. That's a collection path optimized for the input data. */ - private TypeSpec addInput(Consumer addBlock) { - TypeSpec.Builder builder = TypeSpec.anonymousClassBuilder(""); - builder.addSuperinterface(GROUPING_AGGREGATOR_FUNCTION_ADD_INPUT); + private TypeSpec addInput(boolean valuesAreVector) { + TypeSpec.Builder typeBuilder = TypeSpec.anonymousClassBuilder(""); + typeBuilder.addSuperinterface(GROUPING_AGGREGATOR_FUNCTION_ADD_INPUT); for (ClassName groupIdsType : GROUP_IDS_CLASSES) { - MethodSpec.Builder vector = MethodSpec.methodBuilder("add").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC); - vector.addParameter(TypeName.INT, "positionOffset").addParameter(groupIdsType, "groupIds"); - addBlock.accept(vector); - builder.addMethod(vector.build()); + MethodSpec.Builder builder = MethodSpec.methodBuilder("add").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC); + builder.addParameter(TypeName.INT, "positionOffset").addParameter(groupIdsType, "groupIds"); + + StringBuilder pattern = new StringBuilder("addRawInput(positionOffset, groupIds"); + List params = new ArrayList<>(); + for (AggregationParameter p : aggParams) { + pattern.append(", $L"); + params.add(valuesAreVector ? p.vectorName() : p.blockName()); + } + pattern.append(")"); + builder.addStatement(pattern.toString(), params.toArray()); + + typeBuilder.addMethod(builder.build()); } MethodSpec.Builder close = MethodSpec.methodBuilder("close").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC); - builder.addMethod(close.build()); + typeBuilder.addMethod(close.build()); - return builder.build(); + return typeBuilder.build(); } /** * Generate an {@code addRawInput} method to perform the actual aggregation. * @param groupsType The type of the group key, always {@code IntBlock} or {@code IntVector} - * @param valuesType The type of the values to consume, always a subclass of {@code Block} or a subclass of {@code Vector} + * @param valuesAreVector Are the value a {@code Vector} (true) or a {@code Block} (false) */ - private MethodSpec addRawInputLoop(TypeName groupsType, TypeName valuesType) { + private MethodSpec addRawInputLoop(TypeName groupsType, boolean valuesAreVector) { boolean groupsIsBlock = groupsType.toString().endsWith("Block"); - boolean valuesIsBlock = valuesType.toString().endsWith("Block"); MethodSpec.Builder builder = MethodSpec.methodBuilder("addRawInput"); builder.addModifiers(Modifier.PRIVATE); - builder.addParameter(TypeName.INT, "positionOffset").addParameter(groupsType, "groups").addParameter(valuesType, "values"); - if (timseries) { - builder.addParameter(LONG_VECTOR, "timestamps"); + builder.addParameter(TypeName.INT, "positionOffset").addParameter(groupsType, "groups"); + + for (AggregationParameter p : aggParams) { + builder.addParameter( + valuesAreVector ? vectorType(p.type()) : blockType(p.type()), + valuesAreVector ? p.vectorName() : p.blockName() + ); } - 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); + 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); + } } - if (aggParam.isArray() && valuesIsBlock == false) { + + if (aggParams.getFirst().isArray() && valuesAreVector) { builder.addComment("This type does not support vectors because all values are multi-valued"); return builder.build(); } builder.beginControlFlow("for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++)"); { - if (groupsIsBlock || valuesIsBlock) { - String conditions = Stream.of( - groupsIsBlock ? "groups.isNull(groupPosition)" : null, - valuesIsBlock ? "values.isNull(groupPosition + positionOffset)" : null - ).filter(Objects::nonNull).collect(Collectors.joining(" || ")); - builder.beginControlFlow("if (" + conditions + ")"); + if (groupsIsBlock) { + builder.beginControlFlow("if (groups.isNull(groupPosition))"); builder.addStatement("continue"); builder.endControlFlow(); } + builder.addStatement("int valuesPosition = groupPosition + positionOffset"); + if (valuesAreVector == false) { + for (AggregationParameter p : aggParams) { + builder.beginControlFlow("if ($L.isNull(valuesPosition))", p.blockName()); + builder.addStatement("continue"); + builder.endControlFlow(); + } + } if (groupsIsBlock) { builder.addStatement("int groupStart = groups.getFirstValueIndex(groupPosition)"); builder.addStatement("int groupEnd = groupStart + groups.getValueCount(groupPosition)"); @@ -438,23 +439,50 @@ private MethodSpec addRawInputLoop(TypeName groupsType, TypeName valuesType) { builder.endControlFlow(); } - if (valuesIsBlock) { - builder.addStatement("int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset)"); - builder.addStatement("int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset)"); - if (aggParam.isArray()) { - String arrayType = aggParam.type().toString().replace("[]", ""); + if (valuesAreVector) { + for (AggregationParameter a : aggParams) { + a.read(builder, true); + } + combineRawInput(builder); + } else { + if (aggParams.getFirst().isArray()) { + if (aggParams.size() > 1) { + throw new IllegalArgumentException("array mode not supported for multiple args"); + } + String arrayType = aggParams.getFirst().type().toString().replace("[]", ""); + builder.addStatement("int valuesStart = $L.getFirstValueIndex(valuesPosition)", aggParams.getFirst().blockName()); + builder.addStatement( + "int valuesEnd = valuesStart + $L.getValueCount(valuesPosition)", + aggParams.getFirst().blockName() + ); builder.addStatement("$L[] valuesArray = new $L[valuesEnd - valuesStart]", arrayType, arrayType); builder.beginControlFlow("for (int v = valuesStart; v < valuesEnd; v++)"); - builder.addStatement("valuesArray[v-valuesStart] = $L.get$L(v)", "values", capitalize(arrayType)); + builder.addStatement( + "valuesArray[v-valuesStart] = $L.get$L(v)", + aggParams.getFirst().blockName(), + capitalize(aggParams.getFirst().arrayType()) + ); builder.endControlFlow(); combineRawInputForArray(builder, "valuesArray"); } else { - builder.beginControlFlow("for (int v = valuesStart; v < valuesEnd; v++)"); - combineRawInput(builder, "values", "v"); - builder.endControlFlow(); + for (AggregationParameter p : aggParams) { + builder.addStatement("int $L = $L.getFirstValueIndex(valuesPosition)", p.startName(), p.blockName()); + builder.addStatement("int $L = $L + $L.getValueCount(valuesPosition)", 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 a : aggParams) { + builder.endControlFlow(); + } } - } else { - combineRawInput(builder, "values", "groupPosition + positionOffset"); } if (groupsIsBlock) { @@ -465,102 +493,48 @@ private MethodSpec addRawInputLoop(TypeName groupsType, TypeName valuesType) { return builder.build(); } - private void combineRawInput(MethodSpec.Builder builder, String blockVariable, String offsetVariable) { - TypeName valueType = aggParam.type(); + private void combineRawInput(MethodSpec.Builder builder) { TypeName returnType = TypeName.get(combine.getReturnType()); - - warningsBlock(builder, () -> { - if (aggParam.isBytesRef()) { - combineRawInputForBytesRef(builder, blockVariable, offsetVariable); - } else if (valueType.isPrimitive() == false) { - throw new IllegalArgumentException("second parameter to combine must be a primitive, array or BytesRef: " + valueType); - } else if (returnType.isPrimitive()) { - combineRawInputForPrimitive(builder, blockVariable, offsetVariable); - } else if (returnType == TypeName.VOID) { - combineRawInputForVoid(builder, blockVariable, offsetVariable); - } else { - throw new IllegalArgumentException("combine must return void or a primitive"); - } - }); + warningsBlock(builder, () -> invokeCombineRawInput(returnType, builder)); } - private void combineRawInputForBytesRef(MethodSpec.Builder builder, String blockVariable, String offsetVariable) { - // scratch is a BytesRef var that must have been defined before the iteration starts - if (timseries) { - if (offsetVariable.contains(" + ")) { - builder.addStatement("var valuePosition = $L", offsetVariable); - offsetVariable = "valuePosition"; - } - builder.addStatement( - "$T.combine(state, groupId, timestamps.getLong($L), $L.getBytesRef($L, scratch))", - declarationType, - offsetVariable, - blockVariable, - offsetVariable - ); - } else { - builder.addStatement("$T.combine(state, groupId, $L.getBytesRef($L, scratch))", declarationType, blockVariable, offsetVariable); - } - } + private void invokeCombineRawInput(TypeName returnType, MethodSpec.Builder builder) { + StringBuilder pattern = new StringBuilder(); + List params = new ArrayList<>(); - private void combineRawInputForPrimitive(MethodSpec.Builder builder, String blockVariable, String offsetVariable) { - if (timseries) { - if (offsetVariable.contains(" + ")) { - builder.addStatement("var valuePosition = $L", offsetVariable); - offsetVariable = "valuePosition"; - } - builder.addStatement( - "$T.combine(state, groupId, timestamps.getLong($L), values.get$L($L))", - declarationType, - offsetVariable, - capitalize(aggParam.type().toString()), - offsetVariable - ); + if (returnType.isPrimitive()) { + pattern.append("state.set(groupId, $T.combine(state.getOrDefault(groupId)"); + params.add(declarationType); } else { - builder.addStatement( - "state.set(groupId, $T.combine(state.getOrDefault(groupId), $L.get$L($L)))", - declarationType, - blockVariable, - capitalize(aggParam.type().toString()), - offsetVariable - ); + pattern.append("$T.combine(state, groupId"); + params.add(declarationType); } - } - - private void combineRawInputForVoid(MethodSpec.Builder builder, String blockVariable, String offsetVariable) { - if (timseries) { - if (offsetVariable.contains(" + ")) { - builder.addStatement("var valuePosition = $L", offsetVariable); - offsetVariable = "valuePosition"; - } - builder.addStatement( - "$T.combine(state, groupId, timestamps.getLong($L), values.get$L($L))", - declarationType, - offsetVariable, - capitalize(aggParam.type().toString()), - offsetVariable - ); - } else { - builder.addStatement( - "$T.combine(state, groupId, $L.get$L($L))", - declarationType, - blockVariable, - capitalize(aggParam.type().toString()), - offsetVariable - ); + 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) { warningsBlock(builder, () -> builder.addStatement("$T.combine(state, groupId, $L)", declarationType, arrayVariable)); } - private boolean shouldWrapAddInput(TypeName valuesType) { + private boolean shouldWrapAddInput(boolean valuesAreVector) { return optionalStaticMethod( declarationType, requireType(GROUPING_AGGREGATOR_FUNCTION_ADD_INPUT), requireName("wrapAddInput"), - requireArgs(requireType(GROUPING_AGGREGATOR_FUNCTION_ADD_INPUT), requireType(aggState.declaredType()), requireType(valuesType)) + requireArgs( + Stream.concat( + Stream.of(requireType(GROUPING_AGGREGATOR_FUNCTION_ADD_INPUT), requireType(aggState.declaredType())), + aggParams.stream().map(p -> requireType(valuesAreVector ? vectorType(p.type()) : blockType(p.type()))) + ).toArray(Methods.TypeMatcher[]::new) + ) ) != null; } @@ -649,27 +623,28 @@ private MethodSpec addIntermediateInput(TypeName groupsType) { builder.addStatement("int groupId = groups.getInt(groupPosition)"); } + builder.addStatement("int valuesPosition = groupPosition + positionOffset"); if (aggState.declaredType().isPrimitive()) { if (warnExceptions.isEmpty()) { assert intermediateState.size() == 2; assert intermediateState.get(1).name().equals("seen"); - builder.beginControlFlow("if (seen.getBoolean(groupPosition + positionOffset))"); + builder.beginControlFlow("if (seen.getBoolean(valuesPosition))"); } else { assert intermediateState.size() == 3; assert intermediateState.get(1).name().equals("seen"); assert intermediateState.get(2).name().equals("failed"); - builder.beginControlFlow("if (failed.getBoolean(groupPosition + positionOffset))"); + builder.beginControlFlow("if (failed.getBoolean(valuesPosition))"); { builder.addStatement("state.setFailed(groupId)"); } - builder.nextControlFlow("else if (seen.getBoolean(groupPosition + positionOffset))"); + builder.nextControlFlow("else if (seen.getBoolean(valuesPosition))"); } warningsBlock(builder, () -> { var name = intermediateState.get(0).name(); var vectorAccessor = vectorAccessorName(intermediateState.get(0).elementType()); builder.addStatement( - "state.set(groupId, $T.combine(state.getOrDefault(groupId), $L.$L(groupPosition + positionOffset)))", + "state.set(groupId, $T.combine(state.getOrDefault(groupId), $L.$L(valuesPosition)))", declarationType, name, vectorAccessor @@ -693,8 +668,8 @@ private MethodSpec addIntermediateInput(TypeName groupsType) { builder.addStatement( "$T.combineIntermediate(state, groupId, " - + intermediateState.stream().map(desc -> desc.access("groupPosition + positionOffset")).collect(joining(", ")) - + (stateHasBlock ? ", groupPosition + positionOffset" : "") + + intermediateState.stream().map(desc -> desc.access("valuesPosition")).collect(joining(", ")) + + (stateHasBlock ? ", valuesPosition" : "") + ")", declarationType ); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeDoubleAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeDoubleAggregator.java index 1f0c09e90cbdd..8f671ab21f130 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeDoubleAggregator.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeDoubleAggregator.java @@ -11,9 +11,11 @@ import org.elasticsearch.common.util.BigArrays; import org.elasticsearch.common.util.DoubleArray; import org.elasticsearch.common.util.LongArray; +import org.elasticsearch.compute.ann.Aggregator; import org.elasticsearch.compute.ann.GroupingAggregator; import org.elasticsearch.compute.ann.IntermediateState; import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.IntVector; import org.elasticsearch.compute.data.LongBlock; @@ -26,17 +28,16 @@ * This class is generated. Edit `X-ValueOverTimeAggregator.java.st` instead. */ @GroupingAggregator( - value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "DOUBLE_BLOCK") } + { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "DOUBLE_BLOCK") } ) public class FirstOverTimeDoubleAggregator { - public static GroupingState initGrouping(DriverContext driverContext) { return new GroupingState(driverContext.bigArrays()); } // TODO: Since data in data_streams is sorted by `_tsid` and timestamp in descending order, // we can read the first encountered value for each group of `_tsid` and time bucket. - public static void combine(GroupingState current, int groupId, long timestamp, double value) { + public static void combine(GroupingState current, int groupId, double value, long timestamp) { current.collectValue(groupId, timestamp, value); } @@ -47,6 +48,7 @@ public static void combineIntermediate( DoubleBlock values, int otherPosition ) { + // TODO seen should probably be part of the intermediate representation int valueCount = values.getValueCount(otherPosition); if (valueCount > 0) { long timestamp = timestamps.getLong(timestamps.getFirstValueIndex(otherPosition)); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeFloatAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeFloatAggregator.java index 2e3f78255b817..83b1bbebca39e 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeFloatAggregator.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeFloatAggregator.java @@ -11,9 +11,11 @@ import org.elasticsearch.common.util.BigArrays; import org.elasticsearch.common.util.FloatArray; import org.elasticsearch.common.util.LongArray; +import org.elasticsearch.compute.ann.Aggregator; import org.elasticsearch.compute.ann.GroupingAggregator; import org.elasticsearch.compute.ann.IntermediateState; import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.FloatBlock; import org.elasticsearch.compute.data.IntVector; import org.elasticsearch.compute.data.LongBlock; @@ -26,17 +28,16 @@ * This class is generated. Edit `X-ValueOverTimeAggregator.java.st` instead. */ @GroupingAggregator( - value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "FLOAT_BLOCK") } + { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "FLOAT_BLOCK") } ) public class FirstOverTimeFloatAggregator { - public static GroupingState initGrouping(DriverContext driverContext) { return new GroupingState(driverContext.bigArrays()); } // TODO: Since data in data_streams is sorted by `_tsid` and timestamp in descending order, // we can read the first encountered value for each group of `_tsid` and time bucket. - public static void combine(GroupingState current, int groupId, long timestamp, float value) { + public static void combine(GroupingState current, int groupId, float value, long timestamp) { current.collectValue(groupId, timestamp, value); } @@ -47,6 +48,7 @@ public static void combineIntermediate( FloatBlock values, int otherPosition ) { + // TODO seen should probably be part of the intermediate representation int valueCount = values.getValueCount(otherPosition); if (valueCount > 0) { long timestamp = timestamps.getLong(timestamps.getFirstValueIndex(otherPosition)); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeIntAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeIntAggregator.java index b88980c302887..994631d163120 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeIntAggregator.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeIntAggregator.java @@ -11,9 +11,11 @@ import org.elasticsearch.common.util.BigArrays; import org.elasticsearch.common.util.IntArray; import org.elasticsearch.common.util.LongArray; +import org.elasticsearch.compute.ann.Aggregator; import org.elasticsearch.compute.ann.GroupingAggregator; import org.elasticsearch.compute.ann.IntermediateState; import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; import org.elasticsearch.compute.data.LongBlock; @@ -26,17 +28,16 @@ * This class is generated. Edit `X-ValueOverTimeAggregator.java.st` instead. */ @GroupingAggregator( - value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "INT_BLOCK") } + { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "INT_BLOCK") } ) public class FirstOverTimeIntAggregator { - public static GroupingState initGrouping(DriverContext driverContext) { return new GroupingState(driverContext.bigArrays()); } // TODO: Since data in data_streams is sorted by `_tsid` and timestamp in descending order, // we can read the first encountered value for each group of `_tsid` and time bucket. - public static void combine(GroupingState current, int groupId, long timestamp, int value) { + public static void combine(GroupingState current, int groupId, int value, long timestamp) { current.collectValue(groupId, timestamp, value); } @@ -47,6 +48,7 @@ public static void combineIntermediate( IntBlock values, int otherPosition ) { + // TODO seen should probably be part of the intermediate representation int valueCount = values.getValueCount(otherPosition); if (valueCount > 0) { long timestamp = timestamps.getLong(timestamps.getFirstValueIndex(otherPosition)); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeLongAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeLongAggregator.java index 62d49005e3f89..0155d633706af 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeLongAggregator.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/FirstOverTimeLongAggregator.java @@ -11,9 +11,11 @@ import org.elasticsearch.common.util.BigArrays; import org.elasticsearch.common.util.LongArray; import org.elasticsearch.common.util.LongArray; +import org.elasticsearch.compute.ann.Aggregator; import org.elasticsearch.compute.ann.GroupingAggregator; import org.elasticsearch.compute.ann.IntermediateState; import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.IntVector; import org.elasticsearch.compute.data.LongBlock; @@ -26,17 +28,16 @@ * This class is generated. Edit `X-ValueOverTimeAggregator.java.st` instead. */ @GroupingAggregator( - value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "LONG_BLOCK") } + { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "LONG_BLOCK") } ) public class FirstOverTimeLongAggregator { - public static GroupingState initGrouping(DriverContext driverContext) { return new GroupingState(driverContext.bigArrays()); } // TODO: Since data in data_streams is sorted by `_tsid` and timestamp in descending order, // we can read the first encountered value for each group of `_tsid` and time bucket. - public static void combine(GroupingState current, int groupId, long timestamp, long value) { + public static void combine(GroupingState current, int groupId, long value, long timestamp) { current.collectValue(groupId, timestamp, value); } @@ -47,6 +48,7 @@ public static void combineIntermediate( LongBlock values, int otherPosition ) { + // TODO seen should probably be part of the intermediate representation int valueCount = values.getValueCount(otherPosition); if (valueCount > 0) { long timestamp = timestamps.getLong(timestamps.getFirstValueIndex(otherPosition)); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeDoubleAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeDoubleAggregator.java index 4dc519f8bef7a..d5c9fbae5dded 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeDoubleAggregator.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeDoubleAggregator.java @@ -11,9 +11,11 @@ import org.elasticsearch.common.util.BigArrays; import org.elasticsearch.common.util.DoubleArray; import org.elasticsearch.common.util.LongArray; +import org.elasticsearch.compute.ann.Aggregator; import org.elasticsearch.compute.ann.GroupingAggregator; import org.elasticsearch.compute.ann.IntermediateState; import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.IntVector; import org.elasticsearch.compute.data.LongBlock; @@ -26,17 +28,16 @@ * This class is generated. Edit `X-ValueOverTimeAggregator.java.st` instead. */ @GroupingAggregator( - value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "DOUBLE_BLOCK") } + { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "DOUBLE_BLOCK") } ) public class LastOverTimeDoubleAggregator { - public static GroupingState initGrouping(DriverContext driverContext) { return new GroupingState(driverContext.bigArrays()); } // TODO: Since data in data_streams is sorted by `_tsid` and timestamp in descending order, // we can read the first encountered value for each group of `_tsid` and time bucket. - public static void combine(GroupingState current, int groupId, long timestamp, double value) { + public static void combine(GroupingState current, int groupId, double value, long timestamp) { current.collectValue(groupId, timestamp, value); } @@ -47,6 +48,7 @@ public static void combineIntermediate( DoubleBlock values, int otherPosition ) { + // TODO seen should probably be part of the intermediate representation int valueCount = values.getValueCount(otherPosition); if (valueCount > 0) { long timestamp = timestamps.getLong(timestamps.getFirstValueIndex(otherPosition)); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeFloatAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeFloatAggregator.java index fe3d8f10332b4..63e5c55f7dc1c 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeFloatAggregator.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeFloatAggregator.java @@ -11,9 +11,11 @@ import org.elasticsearch.common.util.BigArrays; import org.elasticsearch.common.util.FloatArray; import org.elasticsearch.common.util.LongArray; +import org.elasticsearch.compute.ann.Aggregator; import org.elasticsearch.compute.ann.GroupingAggregator; import org.elasticsearch.compute.ann.IntermediateState; import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.FloatBlock; import org.elasticsearch.compute.data.IntVector; import org.elasticsearch.compute.data.LongBlock; @@ -26,17 +28,16 @@ * This class is generated. Edit `X-ValueOverTimeAggregator.java.st` instead. */ @GroupingAggregator( - value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "FLOAT_BLOCK") } + { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "FLOAT_BLOCK") } ) public class LastOverTimeFloatAggregator { - public static GroupingState initGrouping(DriverContext driverContext) { return new GroupingState(driverContext.bigArrays()); } // TODO: Since data in data_streams is sorted by `_tsid` and timestamp in descending order, // we can read the first encountered value for each group of `_tsid` and time bucket. - public static void combine(GroupingState current, int groupId, long timestamp, float value) { + public static void combine(GroupingState current, int groupId, float value, long timestamp) { current.collectValue(groupId, timestamp, value); } @@ -47,6 +48,7 @@ public static void combineIntermediate( FloatBlock values, int otherPosition ) { + // TODO seen should probably be part of the intermediate representation int valueCount = values.getValueCount(otherPosition); if (valueCount > 0) { long timestamp = timestamps.getLong(timestamps.getFirstValueIndex(otherPosition)); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeIntAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeIntAggregator.java index ac040d33c59a1..a4c7c48df6ec3 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeIntAggregator.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeIntAggregator.java @@ -11,9 +11,11 @@ import org.elasticsearch.common.util.BigArrays; import org.elasticsearch.common.util.IntArray; import org.elasticsearch.common.util.LongArray; +import org.elasticsearch.compute.ann.Aggregator; import org.elasticsearch.compute.ann.GroupingAggregator; import org.elasticsearch.compute.ann.IntermediateState; import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; import org.elasticsearch.compute.data.LongBlock; @@ -26,17 +28,16 @@ * This class is generated. Edit `X-ValueOverTimeAggregator.java.st` instead. */ @GroupingAggregator( - value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "INT_BLOCK") } + { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "INT_BLOCK") } ) public class LastOverTimeIntAggregator { - public static GroupingState initGrouping(DriverContext driverContext) { return new GroupingState(driverContext.bigArrays()); } // TODO: Since data in data_streams is sorted by `_tsid` and timestamp in descending order, // we can read the first encountered value for each group of `_tsid` and time bucket. - public static void combine(GroupingState current, int groupId, long timestamp, int value) { + public static void combine(GroupingState current, int groupId, int value, long timestamp) { current.collectValue(groupId, timestamp, value); } @@ -47,6 +48,7 @@ public static void combineIntermediate( IntBlock values, int otherPosition ) { + // TODO seen should probably be part of the intermediate representation int valueCount = values.getValueCount(otherPosition); if (valueCount > 0) { long timestamp = timestamps.getLong(timestamps.getFirstValueIndex(otherPosition)); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeLongAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeLongAggregator.java index c80fbde92f30e..3a45d5f3f1c18 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeLongAggregator.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/LastOverTimeLongAggregator.java @@ -11,9 +11,11 @@ import org.elasticsearch.common.util.BigArrays; import org.elasticsearch.common.util.LongArray; import org.elasticsearch.common.util.LongArray; +import org.elasticsearch.compute.ann.Aggregator; import org.elasticsearch.compute.ann.GroupingAggregator; import org.elasticsearch.compute.ann.IntermediateState; import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.IntVector; import org.elasticsearch.compute.data.LongBlock; @@ -26,17 +28,16 @@ * This class is generated. Edit `X-ValueOverTimeAggregator.java.st` instead. */ @GroupingAggregator( - value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "LONG_BLOCK") } + { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "LONG_BLOCK") } ) public class LastOverTimeLongAggregator { - public static GroupingState initGrouping(DriverContext driverContext) { return new GroupingState(driverContext.bigArrays()); } // TODO: Since data in data_streams is sorted by `_tsid` and timestamp in descending order, // we can read the first encountered value for each group of `_tsid` and time bucket. - public static void combine(GroupingState current, int groupId, long timestamp, long value) { + public static void combine(GroupingState current, int groupId, long value, long timestamp) { current.collectValue(groupId, timestamp, value); } @@ -47,6 +48,7 @@ public static void combineIntermediate( LongBlock values, int otherPosition ) { + // TODO seen should probably be part of the intermediate representation int valueCount = values.getValueCount(otherPosition); if (valueCount > 0) { long timestamp = timestamps.getLong(timestamps.getFirstValueIndex(otherPosition)); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateDoubleAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateDoubleAggregator.java index 9cac056738004..23e6942217e21 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateDoubleAggregator.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateDoubleAggregator.java @@ -45,7 +45,7 @@ public static DoubleRateGroupingState initGrouping(DriverContext driverContext) return new DoubleRateGroupingState(driverContext.bigArrays(), driverContext.breaker()); } - public static void combine(DoubleRateGroupingState current, int groupId, long timestamp, double value) { + public static void combine(DoubleRateGroupingState current, int groupId, double value, long timestamp) { current.append(groupId, timestamp, value); } diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateFloatAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateFloatAggregator.java index 4d134e7977990..11a529b97835e 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateFloatAggregator.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateFloatAggregator.java @@ -45,7 +45,7 @@ public static FloatRateGroupingState initGrouping(DriverContext driverContext) { return new FloatRateGroupingState(driverContext.bigArrays(), driverContext.breaker()); } - public static void combine(FloatRateGroupingState current, int groupId, long timestamp, float value) { + public static void combine(FloatRateGroupingState current, int groupId, float value, long timestamp) { current.append(groupId, timestamp, value); } diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateIntAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateIntAggregator.java index 20aa108ce6747..16f7269e8a4f2 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateIntAggregator.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateIntAggregator.java @@ -45,7 +45,7 @@ public static IntRateGroupingState initGrouping(DriverContext driverContext) { return new IntRateGroupingState(driverContext.bigArrays(), driverContext.breaker()); } - public static void combine(IntRateGroupingState current, int groupId, long timestamp, int value) { + public static void combine(IntRateGroupingState current, int groupId, int value, long timestamp) { current.append(groupId, timestamp, value); } diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateLongAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateLongAggregator.java index e0d07cd76fe9c..f03ba968e9648 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateLongAggregator.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/RateLongAggregator.java @@ -45,7 +45,7 @@ public static LongRateGroupingState initGrouping(DriverContext driverContext) { return new LongRateGroupingState(driverContext.bigArrays(), driverContext.breaker()); } - public static void combine(LongRateGroupingState current, int groupId, long timestamp, long value) { + public static void combine(LongRateGroupingState current, int groupId, long value, long timestamp) { current.append(groupId, timestamp, value); } 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 b8e7c94aa895c..1048cb7579e10 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 @@ -84,18 +84,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(BooleanVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - boolean vValue = vVector.getBoolean(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + boolean vValue = vVector.getBoolean(valuesPosition); CountDistinctBooleanAggregator.combine(state, vValue); } } private void addRawVector(BooleanVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - boolean vValue = vVector.getBoolean(i); + boolean vValue = vVector.getBoolean(valuesPosition); CountDistinctBooleanAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBooleanGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBooleanGroupingAggregatorFunction.java index 1da51bb76ba65..2e0712ef507ca 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBooleanGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBooleanGroupingAggregatorFunction.java @@ -58,26 +58,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BooleanBlock valuesBlock = page.getBlock(channels.get(0)); - BooleanVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BooleanBlock vBlock = page.getBlock(channels.get(0)); + BooleanVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -88,17 +88,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -107,34 +107,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + boolean vValue = vBlock.getBoolean(vOffset); + CountDistinctBooleanAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + boolean vValue = vVector.getBoolean(valuesPosition); + CountDistinctBooleanAggregator.combine(state, groupId, vValue); } } } @@ -162,39 +169,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctBooleanAggregator.combineIntermediate(state, groupId, fbit.getBoolean(groupPosition + positionOffset), tbit.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctBooleanAggregator.combineIntermediate(state, groupId, fbit.getBoolean(valuesPosition), tbit.getBoolean(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + boolean vValue = vBlock.getBoolean(vOffset); + CountDistinctBooleanAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + boolean vValue = vVector.getBoolean(valuesPosition); + CountDistinctBooleanAggregator.combine(state, groupId, vValue); } } } @@ -222,29 +237,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctBooleanAggregator.combineIntermediate(state, groupId, fbit.getBoolean(groupPosition + positionOffset), tbit.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctBooleanAggregator.combineIntermediate(state, groupId, fbit.getBoolean(valuesPosition), tbit.getBoolean(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntVector groups, BooleanBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + boolean vValue = vBlock.getBoolean(vOffset); + CountDistinctBooleanAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntVector groups, BooleanVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + boolean vValue = vVector.getBoolean(valuesPosition); + CountDistinctBooleanAggregator.combine(state, groupId, vValue); } } @@ -265,7 +285,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert fbit.getPositionCount() == tbit.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - CountDistinctBooleanAggregator.combineIntermediate(state, groupId, fbit.getBoolean(groupPosition + positionOffset), tbit.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctBooleanAggregator.combineIntermediate(state, groupId, fbit.getBoolean(valuesPosition), tbit.getBoolean(valuesPosition)); } } 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 bf796fc9a2f41..341c176b5757c 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 @@ -89,19 +89,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BytesRefVector vVector) { BytesRef vScratch = new BytesRef(); - for (int i = 0; i < vVector.getPositionCount(); i++) { - BytesRef vValue = vVector.getBytesRef(i, vScratch); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); CountDistinctBytesRefAggregator.combine(state, vValue); } } private void addRawVector(BytesRefVector vVector, BooleanVector mask) { BytesRef vScratch = new BytesRef(); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - BytesRef vValue = vVector.getBytesRef(i, vScratch); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); CountDistinctBytesRefAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBytesRefGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBytesRefGroupingAggregatorFunction.java index 28e546dc4e0b0..925253b43e0b1 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBytesRefGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBytesRefGroupingAggregatorFunction.java @@ -61,26 +61,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BytesRefBlock valuesBlock = page.getBlock(channels.get(0)); - BytesRefVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BytesRefBlock vBlock = page.getBlock(channels.get(0)); + BytesRefVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -91,17 +91,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -110,36 +110,43 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock vBlock) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch); + CountDistinctBytesRefAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector vVector) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); + CountDistinctBytesRefAggregator.combine(state, groupId, vValue); } } } @@ -162,41 +169,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctBytesRefAggregator.combineIntermediate(state, groupId, hll.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctBytesRefAggregator.combineIntermediate(state, groupId, hll.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock vBlock) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch); + CountDistinctBytesRefAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector vVector) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); + CountDistinctBytesRefAggregator.combine(state, groupId, vValue); } } } @@ -219,31 +234,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctBytesRefAggregator.combineIntermediate(state, groupId, hll.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctBytesRefAggregator.combineIntermediate(state, groupId, hll.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock vBlock) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch); + CountDistinctBytesRefAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector vVector) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); + CountDistinctBytesRefAggregator.combine(state, groupId, vValue); } } @@ -259,7 +279,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - CountDistinctBytesRefAggregator.combineIntermediate(state, groupId, hll.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctBytesRefAggregator.combineIntermediate(state, groupId, hll.getBytesRef(valuesPosition, scratch)); } } 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 489cde3308448..6f8ab0b9806a7 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 @@ -90,18 +90,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(DoubleVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - double vValue = vVector.getDouble(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + double vValue = vVector.getDouble(valuesPosition); CountDistinctDoubleAggregator.combine(state, vValue); } } private void addRawVector(DoubleVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - double vValue = vVector.getDouble(i); + double vValue = vVector.getDouble(valuesPosition); CountDistinctDoubleAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctDoubleGroupingAggregatorFunction.java index 838e9294623f5..e607aeafc5aab 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctDoubleGroupingAggregatorFunction.java @@ -63,26 +63,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - DoubleBlock valuesBlock = page.getBlock(channels.get(0)); - DoubleVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + DoubleBlock vBlock = page.getBlock(channels.get(0)); + DoubleVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -93,17 +93,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -112,34 +112,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + CountDistinctDoubleAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + CountDistinctDoubleAggregator.combine(state, groupId, vValue); } } } @@ -162,39 +169,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctDoubleAggregator.combineIntermediate(state, groupId, hll.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctDoubleAggregator.combineIntermediate(state, groupId, hll.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + CountDistinctDoubleAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + CountDistinctDoubleAggregator.combine(state, groupId, vValue); } } } @@ -217,29 +232,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctDoubleAggregator.combineIntermediate(state, groupId, hll.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctDoubleAggregator.combineIntermediate(state, groupId, hll.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + CountDistinctDoubleAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + CountDistinctDoubleAggregator.combine(state, groupId, vValue); } } @@ -255,7 +275,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - CountDistinctDoubleAggregator.combineIntermediate(state, groupId, hll.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctDoubleAggregator.combineIntermediate(state, groupId, hll.getBytesRef(valuesPosition, scratch)); } } 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 59bde7207cf7b..e8b4377ffc34c 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 @@ -90,18 +90,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(FloatVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - float vValue = vVector.getFloat(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + float vValue = vVector.getFloat(valuesPosition); CountDistinctFloatAggregator.combine(state, vValue); } } private void addRawVector(FloatVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - float vValue = vVector.getFloat(i); + float vValue = vVector.getFloat(valuesPosition); CountDistinctFloatAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctFloatGroupingAggregatorFunction.java index a2fec8d324289..873f63ab3d68b 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctFloatGroupingAggregatorFunction.java @@ -63,26 +63,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - FloatBlock valuesBlock = page.getBlock(channels.get(0)); - FloatVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + FloatBlock vBlock = page.getBlock(channels.get(0)); + FloatVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -93,17 +93,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -112,34 +112,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + CountDistinctFloatAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + CountDistinctFloatAggregator.combine(state, groupId, vValue); } } } @@ -162,39 +169,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctFloatAggregator.combineIntermediate(state, groupId, hll.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctFloatAggregator.combineIntermediate(state, groupId, hll.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + CountDistinctFloatAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + CountDistinctFloatAggregator.combine(state, groupId, vValue); } } } @@ -217,29 +232,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctFloatAggregator.combineIntermediate(state, groupId, hll.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctFloatAggregator.combineIntermediate(state, groupId, hll.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntVector groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + CountDistinctFloatAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntVector groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + CountDistinctFloatAggregator.combine(state, groupId, vValue); } } @@ -255,7 +275,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - CountDistinctFloatAggregator.combineIntermediate(state, groupId, hll.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctFloatAggregator.combineIntermediate(state, groupId, hll.getBytesRef(valuesPosition, scratch)); } } 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 86815a5bf6b80..d0732baa1ac96 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 @@ -90,18 +90,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(IntVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - int vValue = vVector.getInt(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + int vValue = vVector.getInt(valuesPosition); CountDistinctIntAggregator.combine(state, vValue); } } private void addRawVector(IntVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - int vValue = vVector.getInt(i); + int vValue = vVector.getInt(valuesPosition); CountDistinctIntAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctIntGroupingAggregatorFunction.java index 8c03e446b62ce..1b4e7f7f3fd53 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctIntGroupingAggregatorFunction.java @@ -62,26 +62,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - IntBlock valuesBlock = page.getBlock(channels.get(0)); - IntVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + IntBlock vBlock = page.getBlock(channels.get(0)); + IntVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -92,17 +92,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -111,34 +111,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctIntAggregator.combine(state, groupId, values.getInt(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + CountDistinctIntAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int vValue = vVector.getInt(valuesPosition); + CountDistinctIntAggregator.combine(state, groupId, vValue); } } } @@ -161,39 +168,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctIntAggregator.combineIntermediate(state, groupId, hll.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctIntAggregator.combineIntermediate(state, groupId, hll.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctIntAggregator.combine(state, groupId, values.getInt(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + CountDistinctIntAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int vValue = vVector.getInt(valuesPosition); + CountDistinctIntAggregator.combine(state, groupId, vValue); } } } @@ -216,29 +231,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctIntAggregator.combineIntermediate(state, groupId, hll.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctIntAggregator.combineIntermediate(state, groupId, hll.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntVector groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctIntAggregator.combine(state, groupId, values.getInt(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + CountDistinctIntAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntVector groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - CountDistinctIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int vValue = vVector.getInt(valuesPosition); + CountDistinctIntAggregator.combine(state, groupId, vValue); } } @@ -254,7 +274,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - CountDistinctIntAggregator.combineIntermediate(state, groupId, hll.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctIntAggregator.combineIntermediate(state, groupId, hll.getBytesRef(valuesPosition, scratch)); } } 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 e3881139a8af7..2892e58745d14 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 @@ -90,18 +90,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(LongVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - long vValue = vVector.getLong(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + long vValue = vVector.getLong(valuesPosition); CountDistinctLongAggregator.combine(state, vValue); } } private void addRawVector(LongVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - long vValue = vVector.getLong(i); + long vValue = vVector.getLong(valuesPosition); CountDistinctLongAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctLongGroupingAggregatorFunction.java index 9e9e300124382..47608975a8f6b 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctLongGroupingAggregatorFunction.java @@ -63,26 +63,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongBlock vBlock = page.getBlock(channels.get(0)); + LongVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -93,17 +93,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -112,34 +112,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctLongAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + CountDistinctLongAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + CountDistinctLongAggregator.combine(state, groupId, vValue); } } } @@ -162,39 +169,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctLongAggregator.combineIntermediate(state, groupId, hll.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctLongAggregator.combineIntermediate(state, groupId, hll.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctLongAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + CountDistinctLongAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + CountDistinctLongAggregator.combine(state, groupId, vValue); } } } @@ -217,29 +232,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - CountDistinctLongAggregator.combineIntermediate(state, groupId, hll.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctLongAggregator.combineIntermediate(state, groupId, hll.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctLongAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + CountDistinctLongAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntVector groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - CountDistinctLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + CountDistinctLongAggregator.combine(state, groupId, vValue); } } @@ -255,7 +275,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - CountDistinctLongAggregator.combineIntermediate(state, groupId, hll.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + CountDistinctLongAggregator.combineIntermediate(state, groupId, hll.getBytesRef(valuesPosition, scratch)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeDoubleGroupingAggregatorFunction.java index cf7d9d9cee98c..8513042de93ec 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeDoubleGroupingAggregatorFunction.java @@ -60,31 +60,53 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - DoubleBlock valuesBlock = page.getBlock(channels.get(0)); - DoubleVector valuesVector = valuesBlock.asVector(); - LongBlock timestampsBlock = page.getBlock(channels.get(1)); - LongVector timestampsVector = timestampsBlock.asVector(); - if (timestampsVector == null) { - throw new IllegalStateException("expected @timestamp vector; but got a block"); + DoubleBlock valueBlock = page.getBlock(channels.get(0)); + LongBlock timestampBlock = page.getBlock(channels.get(1)); + DoubleVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void close() { + } + }; } - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongVector timestampVector = timestampBlock.asVector(); + if (timestampVector == null) { + if (timestampBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override @@ -95,17 +117,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override @@ -114,37 +136,52 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + double valueValue = valueBlock.getDouble(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + FirstOverTimeDoubleAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + double valueValue = valueVector.getDouble(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + FirstOverTimeDoubleAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -172,42 +209,58 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - FirstOverTimeDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + FirstOverTimeDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + double valueValue = valueBlock.getDouble(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + FirstOverTimeDoubleAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + double valueValue = valueVector.getDouble(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + FirstOverTimeDoubleAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -235,32 +288,45 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - FirstOverTimeDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + FirstOverTimeDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + double valueValue = valueBlock.getDouble(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + FirstOverTimeDoubleAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, DoubleVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + double valueValue = valueVector.getDouble(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + FirstOverTimeDoubleAggregator.combine(state, groupId, valueValue, timestampValue); } } @@ -281,7 +347,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert timestamps.getPositionCount() == values.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - FirstOverTimeDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + FirstOverTimeDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeFloatGroupingAggregatorFunction.java index b1b996f6011bc..09c581c8f291a 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeFloatGroupingAggregatorFunction.java @@ -60,31 +60,53 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - FloatBlock valuesBlock = page.getBlock(channels.get(0)); - FloatVector valuesVector = valuesBlock.asVector(); - LongBlock timestampsBlock = page.getBlock(channels.get(1)); - LongVector timestampsVector = timestampsBlock.asVector(); - if (timestampsVector == null) { - throw new IllegalStateException("expected @timestamp vector; but got a block"); + FloatBlock valueBlock = page.getBlock(channels.get(0)); + LongBlock timestampBlock = page.getBlock(channels.get(1)); + FloatVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void close() { + } + }; } - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongVector timestampVector = timestampBlock.asVector(); + if (timestampVector == null) { + if (timestampBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override @@ -95,17 +117,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override @@ -114,37 +136,52 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + float valueValue = valueBlock.getFloat(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + FirstOverTimeFloatAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + float valueValue = valueVector.getFloat(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + FirstOverTimeFloatAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -172,42 +209,58 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - FirstOverTimeFloatAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + FirstOverTimeFloatAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + float valueValue = valueBlock.getFloat(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + FirstOverTimeFloatAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + float valueValue = valueVector.getFloat(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + FirstOverTimeFloatAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -235,32 +288,45 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - FirstOverTimeFloatAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + FirstOverTimeFloatAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, FloatBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + float valueValue = valueBlock.getFloat(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + FirstOverTimeFloatAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, FloatVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + float valueValue = valueVector.getFloat(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + FirstOverTimeFloatAggregator.combine(state, groupId, valueValue, timestampValue); } } @@ -281,7 +347,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert timestamps.getPositionCount() == values.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - FirstOverTimeFloatAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + FirstOverTimeFloatAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeIntGroupingAggregatorFunction.java index 8370c554c1b61..da035e8110315 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeIntGroupingAggregatorFunction.java @@ -59,31 +59,53 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - IntBlock valuesBlock = page.getBlock(channels.get(0)); - IntVector valuesVector = valuesBlock.asVector(); - LongBlock timestampsBlock = page.getBlock(channels.get(1)); - LongVector timestampsVector = timestampsBlock.asVector(); - if (timestampsVector == null) { - throw new IllegalStateException("expected @timestamp vector; but got a block"); + IntBlock valueBlock = page.getBlock(channels.get(0)); + LongBlock timestampBlock = page.getBlock(channels.get(1)); + IntVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void close() { + } + }; } - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongVector timestampVector = timestampBlock.asVector(); + if (timestampVector == null) { + if (timestampBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override @@ -94,17 +116,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override @@ -113,37 +135,52 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + int valueValue = valueBlock.getInt(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + FirstOverTimeIntAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + int valueValue = valueVector.getInt(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + FirstOverTimeIntAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -171,42 +208,58 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - FirstOverTimeIntAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + FirstOverTimeIntAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + int valueValue = valueBlock.getInt(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + FirstOverTimeIntAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + int valueValue = valueVector.getInt(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + FirstOverTimeIntAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -234,32 +287,45 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - FirstOverTimeIntAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + FirstOverTimeIntAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, IntBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + int valueValue = valueBlock.getInt(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + FirstOverTimeIntAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, IntVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + int valueValue = valueVector.getInt(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + FirstOverTimeIntAggregator.combine(state, groupId, valueValue, timestampValue); } } @@ -280,7 +346,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert timestamps.getPositionCount() == values.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - FirstOverTimeIntAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + FirstOverTimeIntAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeLongGroupingAggregatorFunction.java index e69156f197b17..7425aba3f430d 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeLongGroupingAggregatorFunction.java @@ -58,31 +58,53 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - LongBlock timestampsBlock = page.getBlock(channels.get(1)); - LongVector timestampsVector = timestampsBlock.asVector(); - if (timestampsVector == null) { - throw new IllegalStateException("expected @timestamp vector; but got a block"); + LongBlock valueBlock = page.getBlock(channels.get(0)); + LongBlock timestampBlock = page.getBlock(channels.get(1)); + LongVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void close() { + } + }; } - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongVector timestampVector = timestampBlock.asVector(); + if (timestampVector == null) { + if (timestampBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override @@ -93,17 +115,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override @@ -112,37 +134,52 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + long valueValue = valueBlock.getLong(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + FirstOverTimeLongAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + long valueValue = valueVector.getLong(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + FirstOverTimeLongAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -170,42 +207,58 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - FirstOverTimeLongAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + FirstOverTimeLongAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + long valueValue = valueBlock.getLong(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + FirstOverTimeLongAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + long valueValue = valueVector.getLong(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + FirstOverTimeLongAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -233,32 +286,45 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - FirstOverTimeLongAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + FirstOverTimeLongAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + long valueValue = valueBlock.getLong(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + FirstOverTimeLongAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, LongVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + long valueValue = valueVector.getLong(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + FirstOverTimeLongAggregator.combine(state, groupId, valueValue, timestampValue); } } @@ -279,7 +345,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert timestamps.getPositionCount() == values.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - FirstOverTimeLongAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + FirstOverTimeLongAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeDoubleGroupingAggregatorFunction.java index 39ad6361f2343..90c63e4feecb2 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeDoubleGroupingAggregatorFunction.java @@ -60,31 +60,53 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - DoubleBlock valuesBlock = page.getBlock(channels.get(0)); - DoubleVector valuesVector = valuesBlock.asVector(); - LongBlock timestampsBlock = page.getBlock(channels.get(1)); - LongVector timestampsVector = timestampsBlock.asVector(); - if (timestampsVector == null) { - throw new IllegalStateException("expected @timestamp vector; but got a block"); + DoubleBlock valueBlock = page.getBlock(channels.get(0)); + LongBlock timestampBlock = page.getBlock(channels.get(1)); + DoubleVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void close() { + } + }; } - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongVector timestampVector = timestampBlock.asVector(); + if (timestampVector == null) { + if (timestampBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override @@ -95,17 +117,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override @@ -114,37 +136,52 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + double valueValue = valueBlock.getDouble(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + LastOverTimeDoubleAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - LastOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + double valueValue = valueVector.getDouble(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + LastOverTimeDoubleAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -172,42 +209,58 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - LastOverTimeDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + LastOverTimeDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + double valueValue = valueBlock.getDouble(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + LastOverTimeDoubleAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - LastOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + double valueValue = valueVector.getDouble(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + LastOverTimeDoubleAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -235,32 +288,45 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - LastOverTimeDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + LastOverTimeDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + double valueValue = valueBlock.getDouble(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + LastOverTimeDoubleAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, DoubleVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - LastOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + double valueValue = valueVector.getDouble(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + LastOverTimeDoubleAggregator.combine(state, groupId, valueValue, timestampValue); } } @@ -281,7 +347,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert timestamps.getPositionCount() == values.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - LastOverTimeDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + LastOverTimeDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeFloatGroupingAggregatorFunction.java index 29888cb353af3..0a5a2ec97fe48 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeFloatGroupingAggregatorFunction.java @@ -60,31 +60,53 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - FloatBlock valuesBlock = page.getBlock(channels.get(0)); - FloatVector valuesVector = valuesBlock.asVector(); - LongBlock timestampsBlock = page.getBlock(channels.get(1)); - LongVector timestampsVector = timestampsBlock.asVector(); - if (timestampsVector == null) { - throw new IllegalStateException("expected @timestamp vector; but got a block"); + FloatBlock valueBlock = page.getBlock(channels.get(0)); + LongBlock timestampBlock = page.getBlock(channels.get(1)); + FloatVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void close() { + } + }; } - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongVector timestampVector = timestampBlock.asVector(); + if (timestampVector == null) { + if (timestampBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override @@ -95,17 +117,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override @@ -114,37 +136,52 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + float valueValue = valueBlock.getFloat(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + LastOverTimeFloatAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - LastOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + float valueValue = valueVector.getFloat(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + LastOverTimeFloatAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -172,42 +209,58 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - LastOverTimeFloatAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + LastOverTimeFloatAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + float valueValue = valueBlock.getFloat(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + LastOverTimeFloatAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - LastOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + float valueValue = valueVector.getFloat(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + LastOverTimeFloatAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -235,32 +288,45 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - LastOverTimeFloatAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + LastOverTimeFloatAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, FloatBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + float valueValue = valueBlock.getFloat(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + LastOverTimeFloatAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, FloatVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - LastOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + float valueValue = valueVector.getFloat(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + LastOverTimeFloatAggregator.combine(state, groupId, valueValue, timestampValue); } } @@ -281,7 +347,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert timestamps.getPositionCount() == values.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - LastOverTimeFloatAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + LastOverTimeFloatAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeIntGroupingAggregatorFunction.java index 1406e83125056..def90f4f1885f 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeIntGroupingAggregatorFunction.java @@ -59,31 +59,53 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - IntBlock valuesBlock = page.getBlock(channels.get(0)); - IntVector valuesVector = valuesBlock.asVector(); - LongBlock timestampsBlock = page.getBlock(channels.get(1)); - LongVector timestampsVector = timestampsBlock.asVector(); - if (timestampsVector == null) { - throw new IllegalStateException("expected @timestamp vector; but got a block"); + IntBlock valueBlock = page.getBlock(channels.get(0)); + LongBlock timestampBlock = page.getBlock(channels.get(1)); + IntVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void close() { + } + }; } - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongVector timestampVector = timestampBlock.asVector(); + if (timestampVector == null) { + if (timestampBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override @@ -94,17 +116,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override @@ -113,37 +135,52 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + int valueValue = valueBlock.getInt(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + LastOverTimeIntAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - LastOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + int valueValue = valueVector.getInt(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + LastOverTimeIntAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -171,42 +208,58 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - LastOverTimeIntAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + LastOverTimeIntAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + int valueValue = valueBlock.getInt(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + LastOverTimeIntAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - LastOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + int valueValue = valueVector.getInt(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + LastOverTimeIntAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -234,32 +287,45 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - LastOverTimeIntAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + LastOverTimeIntAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, IntBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + int valueValue = valueBlock.getInt(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + LastOverTimeIntAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, IntVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - LastOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + int valueValue = valueVector.getInt(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + LastOverTimeIntAggregator.combine(state, groupId, valueValue, timestampValue); } } @@ -280,7 +346,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert timestamps.getPositionCount() == values.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - LastOverTimeIntAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + LastOverTimeIntAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeLongGroupingAggregatorFunction.java index 3fb2d371f3db7..918009cd8619f 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeLongGroupingAggregatorFunction.java @@ -58,31 +58,53 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - LongBlock timestampsBlock = page.getBlock(channels.get(1)); - LongVector timestampsVector = timestampsBlock.asVector(); - if (timestampsVector == null) { - throw new IllegalStateException("expected @timestamp vector; but got a block"); + LongBlock valueBlock = page.getBlock(channels.get(0)); + LongBlock timestampBlock = page.getBlock(channels.get(1)); + LongVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void close() { + } + }; } - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongVector timestampVector = timestampBlock.asVector(); + if (timestampVector == null) { + if (timestampBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override @@ -93,17 +115,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override @@ -112,37 +134,52 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + long valueValue = valueBlock.getLong(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + LastOverTimeLongAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - LastOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + long valueValue = valueVector.getLong(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + LastOverTimeLongAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -170,42 +207,58 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - LastOverTimeLongAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + LastOverTimeLongAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + long valueValue = valueBlock.getLong(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + LastOverTimeLongAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - LastOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + long valueValue = valueVector.getLong(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + LastOverTimeLongAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -233,32 +286,45 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - LastOverTimeLongAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + LastOverTimeLongAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + long valueValue = valueBlock.getLong(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + LastOverTimeLongAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, LongVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - LastOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + long valueValue = valueVector.getLong(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + LastOverTimeLongAggregator.combine(state, groupId, valueValue, timestampValue); } } @@ -279,7 +345,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert timestamps.getPositionCount() == values.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - LastOverTimeLongAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + LastOverTimeLongAggregator.combineIntermediate(state, groupId, timestamps, values, valuesPosition); } } 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 a1846a197cf6d..e6558421a49ef 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 @@ -85,19 +85,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BooleanVector vVector) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - boolean vValue = vVector.getBoolean(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + boolean vValue = vVector.getBoolean(valuesPosition); state.booleanValue(MaxBooleanAggregator.combine(state.booleanValue(), vValue)); } } private void addRawVector(BooleanVector vVector, BooleanVector mask) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - boolean vValue = vVector.getBoolean(i); + boolean vValue = vVector.getBoolean(valuesPosition); state.booleanValue(MaxBooleanAggregator.combine(state.booleanValue(), vValue)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBooleanGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBooleanGroupingAggregatorFunction.java index cf864d27cd81c..4a2f0b8b40739 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBooleanGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBooleanGroupingAggregatorFunction.java @@ -58,26 +58,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BooleanBlock valuesBlock = page.getBlock(channels.get(0)); - BooleanVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BooleanBlock vBlock = page.getBlock(channels.get(0)); + BooleanVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -88,17 +88,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -107,34 +107,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + boolean vValue = vBlock.getBoolean(vOffset); + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + boolean vValue = vVector.getBoolean(valuesPosition); + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -162,41 +169,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), max.getBoolean(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), max.getBoolean(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + boolean vValue = vBlock.getBoolean(vOffset); + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + boolean vValue = vVector.getBoolean(valuesPosition); + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -224,31 +239,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), max.getBoolean(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), max.getBoolean(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntVector groups, BooleanBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + boolean vValue = vBlock.getBoolean(vOffset); + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), vValue)); } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntVector groups, BooleanVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + boolean vValue = vVector.getBoolean(valuesPosition); + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), vValue)); } } @@ -269,8 +289,9 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert max.getPositionCount() == seen.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), max.getBoolean(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), max.getBoolean(valuesPosition))); } } } 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 1291beb3660c0..be00d30296d34 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 @@ -88,19 +88,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BytesRefVector valueVector) { BytesRef valueScratch = new BytesRef(); - for (int i = 0; i < valueVector.getPositionCount(); i++) { - BytesRef valueValue = valueVector.getBytesRef(i, valueScratch); + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); MaxBytesRefAggregator.combine(state, valueValue); } } private void addRawVector(BytesRefVector valueVector, BooleanVector mask) { BytesRef valueScratch = new BytesRef(); - for (int i = 0; i < valueVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - BytesRef valueValue = valueVector.getBytesRef(i, valueScratch); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); MaxBytesRefAggregator.combine(state, valueValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBytesRefGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBytesRefGroupingAggregatorFunction.java index 1e5fd4f0c3899..43e5dbfb35ce8 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBytesRefGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBytesRefGroupingAggregatorFunction.java @@ -61,26 +61,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BytesRefBlock valuesBlock = page.getBlock(channels.get(0)); - BytesRefVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BytesRefBlock valueBlock = page.getBlock(channels.get(0)); + BytesRefVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override @@ -91,17 +91,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override @@ -110,36 +110,43 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock valueBlock) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch); + MaxBytesRefAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector valueVector) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); + MaxBytesRefAggregator.combine(state, groupId, valueValue); } } } @@ -168,41 +175,50 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MaxBytesRefAggregator.combineIntermediate(state, groupId, max.getBytesRef(groupPosition + positionOffset, scratch), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + MaxBytesRefAggregator.combineIntermediate(state, groupId, max.getBytesRef(valuesPosition, scratch), seen.getBoolean(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock valueBlock) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch); + MaxBytesRefAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, + BytesRefVector valueVector) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); + MaxBytesRefAggregator.combine(state, groupId, valueValue); } } } @@ -231,31 +247,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MaxBytesRefAggregator.combineIntermediate(state, groupId, max.getBytesRef(groupPosition + positionOffset, scratch), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + MaxBytesRefAggregator.combineIntermediate(state, groupId, max.getBytesRef(valuesPosition, scratch), seen.getBoolean(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock valueBlock) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch); + MaxBytesRefAggregator.combine(state, groupId, valueValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector valueVector) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); + MaxBytesRefAggregator.combine(state, groupId, valueValue); } } @@ -277,7 +298,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - MaxBytesRefAggregator.combineIntermediate(state, groupId, max.getBytesRef(groupPosition + positionOffset, scratch), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + MaxBytesRefAggregator.combineIntermediate(state, groupId, max.getBytesRef(valuesPosition, scratch), seen.getBoolean(valuesPosition)); } } 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 e62d51e3feac7..5f0c48f481b9d 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 @@ -87,19 +87,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(DoubleVector vVector) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - double vValue = vVector.getDouble(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + double vValue = vVector.getDouble(valuesPosition); state.doubleValue(MaxDoubleAggregator.combine(state.doubleValue(), vValue)); } } private void addRawVector(DoubleVector vVector, BooleanVector mask) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - double vValue = vVector.getDouble(i); + double vValue = vVector.getDouble(valuesPosition); state.doubleValue(MaxDoubleAggregator.combine(state.doubleValue(), vValue)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxDoubleGroupingAggregatorFunction.java index 1ccf2e88c017e..2f4814848c152 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxDoubleGroupingAggregatorFunction.java @@ -60,26 +60,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - DoubleBlock valuesBlock = page.getBlock(channels.get(0)); - DoubleVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + DoubleBlock vBlock = page.getBlock(channels.get(0)); + DoubleVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -90,17 +90,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -109,34 +109,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + double vValue = vVector.getDouble(valuesPosition); + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -164,41 +171,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), max.getDouble(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), max.getDouble(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + double vValue = vVector.getDouble(valuesPosition); + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -226,31 +241,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), max.getDouble(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), max.getDouble(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), vValue)); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + double vValue = vVector.getDouble(valuesPosition); + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), vValue)); } } @@ -271,8 +291,9 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert max.getPositionCount() == seen.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), max.getDouble(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), max.getDouble(valuesPosition))); } } } 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 5f95e55b9e4e6..12786f3a64f6e 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 @@ -87,19 +87,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(FloatVector vVector) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - float vValue = vVector.getFloat(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + float vValue = vVector.getFloat(valuesPosition); state.floatValue(MaxFloatAggregator.combine(state.floatValue(), vValue)); } } private void addRawVector(FloatVector vVector, BooleanVector mask) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - float vValue = vVector.getFloat(i); + float vValue = vVector.getFloat(valuesPosition); state.floatValue(MaxFloatAggregator.combine(state.floatValue(), vValue)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxFloatGroupingAggregatorFunction.java index bb01720e0a1bf..5c0d700c6e874 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxFloatGroupingAggregatorFunction.java @@ -60,26 +60,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - FloatBlock valuesBlock = page.getBlock(channels.get(0)); - FloatVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + FloatBlock vBlock = page.getBlock(channels.get(0)); + FloatVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -90,17 +90,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -109,34 +109,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + float vValue = vVector.getFloat(valuesPosition); + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -164,41 +171,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), max.getFloat(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), max.getFloat(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + float vValue = vVector.getFloat(valuesPosition); + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -226,31 +241,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), max.getFloat(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), max.getFloat(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntVector groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), vValue)); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntVector groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + float vValue = vVector.getFloat(valuesPosition); + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), vValue)); } } @@ -271,8 +291,9 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert max.getPositionCount() == seen.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), max.getFloat(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), max.getFloat(valuesPosition))); } } } 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 0da56585430b4..c4a076162fba3 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 @@ -87,19 +87,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(IntVector vVector) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - int vValue = vVector.getInt(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + int vValue = vVector.getInt(valuesPosition); state.intValue(MaxIntAggregator.combine(state.intValue(), vValue)); } } private void addRawVector(IntVector vVector, BooleanVector mask) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - int vValue = vVector.getInt(i); + int vValue = vVector.getInt(valuesPosition); state.intValue(MaxIntAggregator.combine(state.intValue(), vValue)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIntGroupingAggregatorFunction.java index 194a71b696551..1a8cb4b64f704 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIntGroupingAggregatorFunction.java @@ -59,26 +59,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - IntBlock valuesBlock = page.getBlock(channels.get(0)); - IntVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + IntBlock vBlock = page.getBlock(channels.get(0)); + IntVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -89,17 +89,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -108,34 +108,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + int vValue = vVector.getInt(valuesPosition); + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -163,41 +170,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), max.getInt(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), max.getInt(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + int vValue = vVector.getInt(valuesPosition); + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -225,31 +240,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), max.getInt(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), max.getInt(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntVector groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntVector groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + int vValue = vVector.getInt(valuesPosition); + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } @@ -270,8 +290,9 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert max.getPositionCount() == seen.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), max.getInt(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), max.getInt(valuesPosition))); } } } 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 4d8c2d4a84741..bf457eb275800 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 @@ -88,19 +88,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BytesRefVector valueVector) { BytesRef valueScratch = new BytesRef(); - for (int i = 0; i < valueVector.getPositionCount(); i++) { - BytesRef valueValue = valueVector.getBytesRef(i, valueScratch); + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); MaxIpAggregator.combine(state, valueValue); } } private void addRawVector(BytesRefVector valueVector, BooleanVector mask) { BytesRef valueScratch = new BytesRef(); - for (int i = 0; i < valueVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - BytesRef valueValue = valueVector.getBytesRef(i, valueScratch); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); MaxIpAggregator.combine(state, valueValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIpGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIpGroupingAggregatorFunction.java index fb4a57d4c00f2..cb7694d565475 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIpGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIpGroupingAggregatorFunction.java @@ -61,26 +61,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BytesRefBlock valuesBlock = page.getBlock(channels.get(0)); - BytesRefVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BytesRefBlock valueBlock = page.getBlock(channels.get(0)); + BytesRefVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override @@ -91,17 +91,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override @@ -110,36 +110,43 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock valueBlock) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MaxIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch); + MaxIpAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector valueVector) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MaxIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); + MaxIpAggregator.combine(state, groupId, valueValue); } } } @@ -168,41 +175,50 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MaxIpAggregator.combineIntermediate(state, groupId, max.getBytesRef(groupPosition + positionOffset, scratch), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + MaxIpAggregator.combineIntermediate(state, groupId, max.getBytesRef(valuesPosition, scratch), seen.getBoolean(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock valueBlock) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MaxIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch); + MaxIpAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, + BytesRefVector valueVector) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MaxIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); + MaxIpAggregator.combine(state, groupId, valueValue); } } } @@ -231,31 +247,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MaxIpAggregator.combineIntermediate(state, groupId, max.getBytesRef(groupPosition + positionOffset, scratch), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + MaxIpAggregator.combineIntermediate(state, groupId, max.getBytesRef(valuesPosition, scratch), seen.getBoolean(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock valueBlock) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MaxIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch); + MaxIpAggregator.combine(state, groupId, valueValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector valueVector) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - MaxIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); + MaxIpAggregator.combine(state, groupId, valueValue); } } @@ -277,7 +298,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - MaxIpAggregator.combineIntermediate(state, groupId, max.getBytesRef(groupPosition + positionOffset, scratch), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + MaxIpAggregator.combineIntermediate(state, groupId, max.getBytesRef(valuesPosition, scratch), seen.getBoolean(valuesPosition)); } } 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 c1a26825960db..46c016454fda4 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 @@ -87,19 +87,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(LongVector vVector) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - long vValue = vVector.getLong(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + long vValue = vVector.getLong(valuesPosition); state.longValue(MaxLongAggregator.combine(state.longValue(), vValue)); } } private void addRawVector(LongVector vVector, BooleanVector mask) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - long vValue = vVector.getLong(i); + long vValue = vVector.getLong(valuesPosition); state.longValue(MaxLongAggregator.combine(state.longValue(), vValue)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxLongGroupingAggregatorFunction.java index d1962bbb85f5d..8b2203efa811b 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxLongGroupingAggregatorFunction.java @@ -60,26 +60,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongBlock vBlock = page.getBlock(channels.get(0)); + LongVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -90,17 +90,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -109,34 +109,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + long vValue = vVector.getLong(valuesPosition); + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -164,41 +171,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), max.getLong(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), max.getLong(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + long vValue = vVector.getLong(valuesPosition); + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -226,31 +241,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), max.getLong(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), max.getLong(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntVector groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + long vValue = vVector.getLong(valuesPosition); + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } @@ -271,8 +291,9 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert max.getPositionCount() == seen.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), max.getLong(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), max.getLong(valuesPosition))); } } } 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 e40883797ebf7..a1079e514643c 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 @@ -87,18 +87,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(DoubleVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - double vValue = vVector.getDouble(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + double vValue = vVector.getDouble(valuesPosition); MedianAbsoluteDeviationDoubleAggregator.combine(state, vValue); } } private void addRawVector(DoubleVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - double vValue = vVector.getDouble(i); + double vValue = vVector.getDouble(valuesPosition); MedianAbsoluteDeviationDoubleAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleGroupingAggregatorFunction.java index 47e08286b18b9..808a325493a80 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleGroupingAggregatorFunction.java @@ -60,26 +60,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - DoubleBlock valuesBlock = page.getBlock(channels.get(0)); - DoubleVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + DoubleBlock vBlock = page.getBlock(channels.get(0)); + DoubleVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -90,17 +90,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -109,34 +109,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, vValue); } } } @@ -159,39 +166,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationDoubleAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + MedianAbsoluteDeviationDoubleAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, vValue); } } } @@ -214,29 +229,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationDoubleAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + MedianAbsoluteDeviationDoubleAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, vValue); } } @@ -252,7 +272,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - MedianAbsoluteDeviationDoubleAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + MedianAbsoluteDeviationDoubleAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } 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 18abdd7b7411a..b1cb3c475e7f3 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 @@ -87,18 +87,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(FloatVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - float vValue = vVector.getFloat(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + float vValue = vVector.getFloat(valuesPosition); MedianAbsoluteDeviationFloatAggregator.combine(state, vValue); } } private void addRawVector(FloatVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - float vValue = vVector.getFloat(i); + float vValue = vVector.getFloat(valuesPosition); MedianAbsoluteDeviationFloatAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationFloatGroupingAggregatorFunction.java index 7351dc858e699..78adf388821d6 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationFloatGroupingAggregatorFunction.java @@ -60,26 +60,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - FloatBlock valuesBlock = page.getBlock(channels.get(0)); - FloatVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + FloatBlock vBlock = page.getBlock(channels.get(0)); + FloatVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -90,17 +90,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -109,34 +109,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, vValue); } } } @@ -159,39 +166,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationFloatAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + MedianAbsoluteDeviationFloatAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, vValue); } } } @@ -214,29 +229,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationFloatAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + MedianAbsoluteDeviationFloatAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntVector groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntVector groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, vValue); } } @@ -252,7 +272,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - MedianAbsoluteDeviationFloatAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + MedianAbsoluteDeviationFloatAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } 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 0be32be05ef88..e0b05be683e3e 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 @@ -87,18 +87,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(IntVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - int vValue = vVector.getInt(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + int vValue = vVector.getInt(valuesPosition); MedianAbsoluteDeviationIntAggregator.combine(state, vValue); } } private void addRawVector(IntVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - int vValue = vVector.getInt(i); + int vValue = vVector.getInt(valuesPosition); MedianAbsoluteDeviationIntAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntGroupingAggregatorFunction.java index ba5dd2deea517..4a391939a0072 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntGroupingAggregatorFunction.java @@ -59,26 +59,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - IntBlock valuesBlock = page.getBlock(channels.get(0)); - IntVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + IntBlock vBlock = page.getBlock(channels.get(0)); + IntVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -89,17 +89,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -108,34 +108,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + MedianAbsoluteDeviationIntAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int vValue = vVector.getInt(valuesPosition); + MedianAbsoluteDeviationIntAggregator.combine(state, groupId, vValue); } } } @@ -158,39 +165,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationIntAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + MedianAbsoluteDeviationIntAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + MedianAbsoluteDeviationIntAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int vValue = vVector.getInt(valuesPosition); + MedianAbsoluteDeviationIntAggregator.combine(state, groupId, vValue); } } } @@ -213,29 +228,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationIntAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + MedianAbsoluteDeviationIntAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntVector groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + MedianAbsoluteDeviationIntAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntVector groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int vValue = vVector.getInt(valuesPosition); + MedianAbsoluteDeviationIntAggregator.combine(state, groupId, vValue); } } @@ -251,7 +271,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - MedianAbsoluteDeviationIntAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + MedianAbsoluteDeviationIntAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } 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 cffb084a02e70..51288bf7aa5d1 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 @@ -87,18 +87,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(LongVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - long vValue = vVector.getLong(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + long vValue = vVector.getLong(valuesPosition); MedianAbsoluteDeviationLongAggregator.combine(state, vValue); } } private void addRawVector(LongVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - long vValue = vVector.getLong(i); + long vValue = vVector.getLong(valuesPosition); MedianAbsoluteDeviationLongAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongGroupingAggregatorFunction.java index 1c2faf0f14ab5..4220ba3a20007 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongGroupingAggregatorFunction.java @@ -60,26 +60,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongBlock vBlock = page.getBlock(channels.get(0)); + LongVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -90,17 +90,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -109,34 +109,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + MedianAbsoluteDeviationLongAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + MedianAbsoluteDeviationLongAggregator.combine(state, groupId, vValue); } } } @@ -159,39 +166,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationLongAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + MedianAbsoluteDeviationLongAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + MedianAbsoluteDeviationLongAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + MedianAbsoluteDeviationLongAggregator.combine(state, groupId, vValue); } } } @@ -214,29 +229,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MedianAbsoluteDeviationLongAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + MedianAbsoluteDeviationLongAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + MedianAbsoluteDeviationLongAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntVector groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + MedianAbsoluteDeviationLongAggregator.combine(state, groupId, vValue); } } @@ -252,7 +272,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - MedianAbsoluteDeviationLongAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + MedianAbsoluteDeviationLongAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } 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 55dc5fa93f0fb..fbc7e4809b1ea 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 @@ -85,19 +85,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BooleanVector vVector) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - boolean vValue = vVector.getBoolean(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + boolean vValue = vVector.getBoolean(valuesPosition); state.booleanValue(MinBooleanAggregator.combine(state.booleanValue(), vValue)); } } private void addRawVector(BooleanVector vVector, BooleanVector mask) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - boolean vValue = vVector.getBoolean(i); + boolean vValue = vVector.getBoolean(valuesPosition); state.booleanValue(MinBooleanAggregator.combine(state.booleanValue(), vValue)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBooleanGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBooleanGroupingAggregatorFunction.java index 0d7f889f28522..3f0398e78f806 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBooleanGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBooleanGroupingAggregatorFunction.java @@ -58,26 +58,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BooleanBlock valuesBlock = page.getBlock(channels.get(0)); - BooleanVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BooleanBlock vBlock = page.getBlock(channels.get(0)); + BooleanVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -88,17 +88,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -107,34 +107,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + boolean vValue = vBlock.getBoolean(vOffset); + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + boolean vValue = vVector.getBoolean(valuesPosition); + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -162,41 +169,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), min.getBoolean(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), min.getBoolean(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + boolean vValue = vBlock.getBoolean(vOffset); + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + boolean vValue = vVector.getBoolean(valuesPosition); + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -224,31 +239,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), min.getBoolean(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), min.getBoolean(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntVector groups, BooleanBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + boolean vValue = vBlock.getBoolean(vOffset); + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), vValue)); } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntVector groups, BooleanVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + boolean vValue = vVector.getBoolean(valuesPosition); + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), vValue)); } } @@ -269,8 +289,9 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert min.getPositionCount() == seen.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), min.getBoolean(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), min.getBoolean(valuesPosition))); } } } 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 1669e31dda1b9..d16c638c6327f 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 @@ -88,19 +88,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BytesRefVector valueVector) { BytesRef valueScratch = new BytesRef(); - for (int i = 0; i < valueVector.getPositionCount(); i++) { - BytesRef valueValue = valueVector.getBytesRef(i, valueScratch); + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); MinBytesRefAggregator.combine(state, valueValue); } } private void addRawVector(BytesRefVector valueVector, BooleanVector mask) { BytesRef valueScratch = new BytesRef(); - for (int i = 0; i < valueVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - BytesRef valueValue = valueVector.getBytesRef(i, valueScratch); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); MinBytesRefAggregator.combine(state, valueValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBytesRefGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBytesRefGroupingAggregatorFunction.java index d1d05590fe3c6..7a282440476d8 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBytesRefGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBytesRefGroupingAggregatorFunction.java @@ -61,26 +61,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BytesRefBlock valuesBlock = page.getBlock(channels.get(0)); - BytesRefVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BytesRefBlock valueBlock = page.getBlock(channels.get(0)); + BytesRefVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override @@ -91,17 +91,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override @@ -110,36 +110,43 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock valueBlock) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch); + MinBytesRefAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector valueVector) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); + MinBytesRefAggregator.combine(state, groupId, valueValue); } } } @@ -168,41 +175,50 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MinBytesRefAggregator.combineIntermediate(state, groupId, min.getBytesRef(groupPosition + positionOffset, scratch), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + MinBytesRefAggregator.combineIntermediate(state, groupId, min.getBytesRef(valuesPosition, scratch), seen.getBoolean(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock valueBlock) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch); + MinBytesRefAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, + BytesRefVector valueVector) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); + MinBytesRefAggregator.combine(state, groupId, valueValue); } } } @@ -231,31 +247,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MinBytesRefAggregator.combineIntermediate(state, groupId, min.getBytesRef(groupPosition + positionOffset, scratch), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + MinBytesRefAggregator.combineIntermediate(state, groupId, min.getBytesRef(valuesPosition, scratch), seen.getBoolean(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock valueBlock) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch); + MinBytesRefAggregator.combine(state, groupId, valueValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector valueVector) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); + MinBytesRefAggregator.combine(state, groupId, valueValue); } } @@ -277,7 +298,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - MinBytesRefAggregator.combineIntermediate(state, groupId, min.getBytesRef(groupPosition + positionOffset, scratch), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + MinBytesRefAggregator.combineIntermediate(state, groupId, min.getBytesRef(valuesPosition, scratch), seen.getBoolean(valuesPosition)); } } 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 544cad0c06b72..411dba0736911 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 @@ -87,19 +87,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(DoubleVector vVector) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - double vValue = vVector.getDouble(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + double vValue = vVector.getDouble(valuesPosition); state.doubleValue(MinDoubleAggregator.combine(state.doubleValue(), vValue)); } } private void addRawVector(DoubleVector vVector, BooleanVector mask) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - double vValue = vVector.getDouble(i); + double vValue = vVector.getDouble(valuesPosition); state.doubleValue(MinDoubleAggregator.combine(state.doubleValue(), vValue)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinDoubleGroupingAggregatorFunction.java index 24fc477a04d9b..31cbc2cb5c860 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinDoubleGroupingAggregatorFunction.java @@ -60,26 +60,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - DoubleBlock valuesBlock = page.getBlock(channels.get(0)); - DoubleVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + DoubleBlock vBlock = page.getBlock(channels.get(0)); + DoubleVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -90,17 +90,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -109,34 +109,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + double vValue = vVector.getDouble(valuesPosition); + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -164,41 +171,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), min.getDouble(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), min.getDouble(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + double vValue = vVector.getDouble(valuesPosition); + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -226,31 +241,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), min.getDouble(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), min.getDouble(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), vValue)); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + double vValue = vVector.getDouble(valuesPosition); + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), vValue)); } } @@ -271,8 +291,9 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert min.getPositionCount() == seen.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), min.getDouble(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), min.getDouble(valuesPosition))); } } } 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 8e2ac63914544..145289a88b1aa 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 @@ -87,19 +87,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(FloatVector vVector) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - float vValue = vVector.getFloat(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + float vValue = vVector.getFloat(valuesPosition); state.floatValue(MinFloatAggregator.combine(state.floatValue(), vValue)); } } private void addRawVector(FloatVector vVector, BooleanVector mask) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - float vValue = vVector.getFloat(i); + float vValue = vVector.getFloat(valuesPosition); state.floatValue(MinFloatAggregator.combine(state.floatValue(), vValue)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinFloatGroupingAggregatorFunction.java index 810ab2601ce9e..b56cfd30ad575 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinFloatGroupingAggregatorFunction.java @@ -60,26 +60,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - FloatBlock valuesBlock = page.getBlock(channels.get(0)); - FloatVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + FloatBlock vBlock = page.getBlock(channels.get(0)); + FloatVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -90,17 +90,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -109,34 +109,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + float vValue = vVector.getFloat(valuesPosition); + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -164,41 +171,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), min.getFloat(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), min.getFloat(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + float vValue = vVector.getFloat(valuesPosition); + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -226,31 +241,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), min.getFloat(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), min.getFloat(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntVector groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), vValue)); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntVector groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + float vValue = vVector.getFloat(valuesPosition); + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), vValue)); } } @@ -271,8 +291,9 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert min.getPositionCount() == seen.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), min.getFloat(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), min.getFloat(valuesPosition))); } } } 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 804ab7bacc819..c61e31c831147 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 @@ -87,19 +87,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(IntVector vVector) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - int vValue = vVector.getInt(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + int vValue = vVector.getInt(valuesPosition); state.intValue(MinIntAggregator.combine(state.intValue(), vValue)); } } private void addRawVector(IntVector vVector, BooleanVector mask) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - int vValue = vVector.getInt(i); + int vValue = vVector.getInt(valuesPosition); state.intValue(MinIntAggregator.combine(state.intValue(), vValue)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIntGroupingAggregatorFunction.java index 6f73116241dd6..e0792edddad89 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIntGroupingAggregatorFunction.java @@ -59,26 +59,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - IntBlock valuesBlock = page.getBlock(channels.get(0)); - IntVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + IntBlock vBlock = page.getBlock(channels.get(0)); + IntVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -89,17 +89,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -108,34 +108,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + int vValue = vVector.getInt(valuesPosition); + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -163,41 +170,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), min.getInt(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), min.getInt(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + int vValue = vVector.getInt(valuesPosition); + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -225,31 +240,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), min.getInt(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), min.getInt(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntVector groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntVector groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + int vValue = vVector.getInt(valuesPosition); + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } @@ -270,8 +290,9 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert min.getPositionCount() == seen.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), min.getInt(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), min.getInt(valuesPosition))); } } } 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 3d9b7639f3d16..e95fa2591a073 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 @@ -88,19 +88,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BytesRefVector valueVector) { BytesRef valueScratch = new BytesRef(); - for (int i = 0; i < valueVector.getPositionCount(); i++) { - BytesRef valueValue = valueVector.getBytesRef(i, valueScratch); + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); MinIpAggregator.combine(state, valueValue); } } private void addRawVector(BytesRefVector valueVector, BooleanVector mask) { BytesRef valueScratch = new BytesRef(); - for (int i = 0; i < valueVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - BytesRef valueValue = valueVector.getBytesRef(i, valueScratch); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); MinIpAggregator.combine(state, valueValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIpGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIpGroupingAggregatorFunction.java index 8192f8d970522..953103bff6589 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIpGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIpGroupingAggregatorFunction.java @@ -61,26 +61,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BytesRefBlock valuesBlock = page.getBlock(channels.get(0)); - BytesRefVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BytesRefBlock valueBlock = page.getBlock(channels.get(0)); + BytesRefVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override @@ -91,17 +91,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override @@ -110,36 +110,43 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock valueBlock) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MinIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch); + MinIpAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector valueVector) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MinIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); + MinIpAggregator.combine(state, groupId, valueValue); } } } @@ -168,41 +175,50 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MinIpAggregator.combineIntermediate(state, groupId, max.getBytesRef(groupPosition + positionOffset, scratch), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + MinIpAggregator.combineIntermediate(state, groupId, max.getBytesRef(valuesPosition, scratch), seen.getBoolean(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock valueBlock) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MinIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch); + MinIpAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, + BytesRefVector valueVector) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MinIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); + MinIpAggregator.combine(state, groupId, valueValue); } } } @@ -231,31 +247,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - MinIpAggregator.combineIntermediate(state, groupId, max.getBytesRef(groupPosition + positionOffset, scratch), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + MinIpAggregator.combineIntermediate(state, groupId, max.getBytesRef(valuesPosition, scratch), seen.getBoolean(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock valueBlock) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MinIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch); + MinIpAggregator.combine(state, groupId, valueValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector valueVector) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - MinIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); + MinIpAggregator.combine(state, groupId, valueValue); } } @@ -277,7 +298,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - MinIpAggregator.combineIntermediate(state, groupId, max.getBytesRef(groupPosition + positionOffset, scratch), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + MinIpAggregator.combineIntermediate(state, groupId, max.getBytesRef(valuesPosition, scratch), seen.getBoolean(valuesPosition)); } } 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 24aba4a060c3e..6209538ed10fc 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 @@ -87,19 +87,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(LongVector vVector) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - long vValue = vVector.getLong(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + long vValue = vVector.getLong(valuesPosition); state.longValue(MinLongAggregator.combine(state.longValue(), vValue)); } } private void addRawVector(LongVector vVector, BooleanVector mask) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - long vValue = vVector.getLong(i); + long vValue = vVector.getLong(valuesPosition); state.longValue(MinLongAggregator.combine(state.longValue(), vValue)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinLongGroupingAggregatorFunction.java index cb5afc294bb1a..b723d4b7e98cb 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinLongGroupingAggregatorFunction.java @@ -60,26 +60,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongBlock vBlock = page.getBlock(channels.get(0)); + LongVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -90,17 +90,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -109,34 +109,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + long vValue = vVector.getLong(valuesPosition); + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -164,41 +171,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), min.getLong(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), min.getLong(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + long vValue = vVector.getLong(valuesPosition); + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -226,31 +241,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), min.getLong(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), min.getLong(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntVector groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + long vValue = vVector.getLong(valuesPosition); + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } @@ -271,8 +291,9 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert min.getPositionCount() == seen.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), min.getLong(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), min.getLong(valuesPosition))); } } } 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 6be17326820b9..22ec1cda2f3cb 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 @@ -90,18 +90,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(DoubleVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - double vValue = vVector.getDouble(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + double vValue = vVector.getDouble(valuesPosition); PercentileDoubleAggregator.combine(state, vValue); } } private void addRawVector(DoubleVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - double vValue = vVector.getDouble(i); + double vValue = vVector.getDouble(valuesPosition); PercentileDoubleAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileDoubleGroupingAggregatorFunction.java index 0639cc0028310..b9f780dd8a5db 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileDoubleGroupingAggregatorFunction.java @@ -63,26 +63,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - DoubleBlock valuesBlock = page.getBlock(channels.get(0)); - DoubleVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + DoubleBlock vBlock = page.getBlock(channels.get(0)); + DoubleVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -93,17 +93,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -112,34 +112,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + PercentileDoubleAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + PercentileDoubleAggregator.combine(state, groupId, vValue); } } } @@ -162,39 +169,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileDoubleAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + PercentileDoubleAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + PercentileDoubleAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + PercentileDoubleAggregator.combine(state, groupId, vValue); } } } @@ -217,29 +232,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileDoubleAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + PercentileDoubleAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + PercentileDoubleAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - PercentileDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + PercentileDoubleAggregator.combine(state, groupId, vValue); } } @@ -255,7 +275,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - PercentileDoubleAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + PercentileDoubleAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } 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 70e8dd79c9d2a..1dcead2057336 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 @@ -90,18 +90,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(FloatVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - float vValue = vVector.getFloat(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + float vValue = vVector.getFloat(valuesPosition); PercentileFloatAggregator.combine(state, vValue); } } private void addRawVector(FloatVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - float vValue = vVector.getFloat(i); + float vValue = vVector.getFloat(valuesPosition); PercentileFloatAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileFloatGroupingAggregatorFunction.java index b66d01b68f229..e3165404615c4 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileFloatGroupingAggregatorFunction.java @@ -63,26 +63,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - FloatBlock valuesBlock = page.getBlock(channels.get(0)); - FloatVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + FloatBlock vBlock = page.getBlock(channels.get(0)); + FloatVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -93,17 +93,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -112,34 +112,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + PercentileFloatAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + PercentileFloatAggregator.combine(state, groupId, vValue); } } } @@ -162,39 +169,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileFloatAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + PercentileFloatAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + PercentileFloatAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + PercentileFloatAggregator.combine(state, groupId, vValue); } } } @@ -217,29 +232,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileFloatAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + PercentileFloatAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntVector groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + PercentileFloatAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntVector groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - PercentileFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + PercentileFloatAggregator.combine(state, groupId, vValue); } } @@ -255,7 +275,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - PercentileFloatAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + PercentileFloatAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } 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 eea8f58d615b2..49601d09cbddc 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 @@ -90,18 +90,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(IntVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - int vValue = vVector.getInt(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + int vValue = vVector.getInt(valuesPosition); PercentileIntAggregator.combine(state, vValue); } } private void addRawVector(IntVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - int vValue = vVector.getInt(i); + int vValue = vVector.getInt(valuesPosition); PercentileIntAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileIntGroupingAggregatorFunction.java index b42d8b5d87709..e12705eeb6eb0 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileIntGroupingAggregatorFunction.java @@ -62,26 +62,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - IntBlock valuesBlock = page.getBlock(channels.get(0)); - IntVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + IntBlock vBlock = page.getBlock(channels.get(0)); + IntVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -92,17 +92,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -111,34 +111,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileIntAggregator.combine(state, groupId, values.getInt(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + PercentileIntAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int vValue = vVector.getInt(valuesPosition); + PercentileIntAggregator.combine(state, groupId, vValue); } } } @@ -161,39 +168,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileIntAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + PercentileIntAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileIntAggregator.combine(state, groupId, values.getInt(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + PercentileIntAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int vValue = vVector.getInt(valuesPosition); + PercentileIntAggregator.combine(state, groupId, vValue); } } } @@ -216,29 +231,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileIntAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + PercentileIntAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntVector groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileIntAggregator.combine(state, groupId, values.getInt(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + PercentileIntAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntVector groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - PercentileIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int vValue = vVector.getInt(valuesPosition); + PercentileIntAggregator.combine(state, groupId, vValue); } } @@ -254,7 +274,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - PercentileIntAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + PercentileIntAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } 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 1cf820a23a162..f0e757d0bdd5d 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 @@ -90,18 +90,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(LongVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - long vValue = vVector.getLong(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + long vValue = vVector.getLong(valuesPosition); PercentileLongAggregator.combine(state, vValue); } } private void addRawVector(LongVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - long vValue = vVector.getLong(i); + long vValue = vVector.getLong(valuesPosition); PercentileLongAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileLongGroupingAggregatorFunction.java index 1adfcadb1150e..069f614a2132d 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileLongGroupingAggregatorFunction.java @@ -63,26 +63,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongBlock vBlock = page.getBlock(channels.get(0)); + LongVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -93,17 +93,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -112,34 +112,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileLongAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + PercentileLongAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + PercentileLongAggregator.combine(state, groupId, vValue); } } } @@ -162,39 +169,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileLongAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + PercentileLongAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileLongAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + PercentileLongAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + PercentileLongAggregator.combine(state, groupId, vValue); } } } @@ -217,29 +232,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - PercentileLongAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + PercentileLongAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileLongAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + PercentileLongAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntVector groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - PercentileLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + PercentileLongAggregator.combine(state, groupId, vValue); } } @@ -255,7 +275,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - PercentileLongAggregator.combineIntermediate(state, groupId, quart.getBytesRef(groupPosition + positionOffset, scratch)); + int valuesPosition = groupPosition + positionOffset; + PercentileLongAggregator.combineIntermediate(state, groupId, quart.getBytesRef(valuesPosition, scratch)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateDoubleGroupingAggregatorFunction.java index 61840a59d6bbb..f630949449fff 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateDoubleGroupingAggregatorFunction.java @@ -63,31 +63,53 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - DoubleBlock valuesBlock = page.getBlock(channels.get(0)); - DoubleVector valuesVector = valuesBlock.asVector(); - LongBlock timestampsBlock = page.getBlock(channels.get(1)); - LongVector timestampsVector = timestampsBlock.asVector(); - if (timestampsVector == null) { - throw new IllegalStateException("expected @timestamp vector; but got a block"); + DoubleBlock valueBlock = page.getBlock(channels.get(0)); + LongBlock timestampBlock = page.getBlock(channels.get(1)); + DoubleVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void close() { + } + }; } - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongVector timestampVector = timestampBlock.asVector(); + if (timestampVector == null) { + if (timestampBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override @@ -98,17 +120,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override @@ -117,37 +139,52 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + double valueValue = valueBlock.getDouble(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + RateDoubleAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - RateDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + double valueValue = valueVector.getDouble(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + RateDoubleAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -185,42 +222,58 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - RateDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(groupPosition + positionOffset), resets.getDouble(groupPosition + positionOffset), groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + RateDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(valuesPosition), resets.getDouble(valuesPosition), valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + double valueValue = valueBlock.getDouble(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + RateDoubleAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - RateDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + double valueValue = valueVector.getDouble(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + RateDoubleAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -258,32 +311,45 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - RateDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(groupPosition + positionOffset), resets.getDouble(groupPosition + positionOffset), groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + RateDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(valuesPosition), resets.getDouble(valuesPosition), valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + double valueValue = valueBlock.getDouble(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + RateDoubleAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, DoubleVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - RateDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + double valueValue = valueVector.getDouble(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + RateDoubleAggregator.combine(state, groupId, valueValue, timestampValue); } } @@ -314,7 +380,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert timestamps.getPositionCount() == values.getPositionCount() && timestamps.getPositionCount() == sampleCounts.getPositionCount() && timestamps.getPositionCount() == resets.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - RateDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(groupPosition + positionOffset), resets.getDouble(groupPosition + positionOffset), groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + RateDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(valuesPosition), resets.getDouble(valuesPosition), valuesPosition); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateFloatGroupingAggregatorFunction.java index 35d6085b495ec..e7a5fb44994c3 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateFloatGroupingAggregatorFunction.java @@ -65,31 +65,53 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - FloatBlock valuesBlock = page.getBlock(channels.get(0)); - FloatVector valuesVector = valuesBlock.asVector(); - LongBlock timestampsBlock = page.getBlock(channels.get(1)); - LongVector timestampsVector = timestampsBlock.asVector(); - if (timestampsVector == null) { - throw new IllegalStateException("expected @timestamp vector; but got a block"); + FloatBlock valueBlock = page.getBlock(channels.get(0)); + LongBlock timestampBlock = page.getBlock(channels.get(1)); + FloatVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void close() { + } + }; } - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongVector timestampVector = timestampBlock.asVector(); + if (timestampVector == null) { + if (timestampBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override @@ -100,17 +122,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override @@ -119,37 +141,52 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + float valueValue = valueBlock.getFloat(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + RateFloatAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - RateFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + float valueValue = valueVector.getFloat(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + RateFloatAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -187,42 +224,58 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - RateFloatAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(groupPosition + positionOffset), resets.getDouble(groupPosition + positionOffset), groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + RateFloatAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(valuesPosition), resets.getDouble(valuesPosition), valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + float valueValue = valueBlock.getFloat(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + RateFloatAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - RateFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + float valueValue = valueVector.getFloat(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + RateFloatAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -260,32 +313,45 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - RateFloatAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(groupPosition + positionOffset), resets.getDouble(groupPosition + positionOffset), groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + RateFloatAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(valuesPosition), resets.getDouble(valuesPosition), valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, FloatBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + float valueValue = valueBlock.getFloat(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + RateFloatAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, FloatVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - RateFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + float valueValue = valueVector.getFloat(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + RateFloatAggregator.combine(state, groupId, valueValue, timestampValue); } } @@ -316,7 +382,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert timestamps.getPositionCount() == values.getPositionCount() && timestamps.getPositionCount() == sampleCounts.getPositionCount() && timestamps.getPositionCount() == resets.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - RateFloatAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(groupPosition + positionOffset), resets.getDouble(groupPosition + positionOffset), groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + RateFloatAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(valuesPosition), resets.getDouble(valuesPosition), valuesPosition); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateIntGroupingAggregatorFunction.java index a3df3a2e48912..1fa1f450ad60f 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateIntGroupingAggregatorFunction.java @@ -63,31 +63,53 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - IntBlock valuesBlock = page.getBlock(channels.get(0)); - IntVector valuesVector = valuesBlock.asVector(); - LongBlock timestampsBlock = page.getBlock(channels.get(1)); - LongVector timestampsVector = timestampsBlock.asVector(); - if (timestampsVector == null) { - throw new IllegalStateException("expected @timestamp vector; but got a block"); + IntBlock valueBlock = page.getBlock(channels.get(0)); + LongBlock timestampBlock = page.getBlock(channels.get(1)); + IntVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void close() { + } + }; } - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongVector timestampVector = timestampBlock.asVector(); + if (timestampVector == null) { + if (timestampBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override @@ -98,17 +120,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override @@ -117,37 +139,52 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + int valueValue = valueBlock.getInt(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + RateIntAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - RateIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + int valueValue = valueVector.getInt(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + RateIntAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -185,42 +222,58 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - RateIntAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(groupPosition + positionOffset), resets.getDouble(groupPosition + positionOffset), groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + RateIntAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(valuesPosition), resets.getDouble(valuesPosition), valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + int valueValue = valueBlock.getInt(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + RateIntAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - RateIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + int valueValue = valueVector.getInt(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + RateIntAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -258,32 +311,45 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - RateIntAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(groupPosition + positionOffset), resets.getDouble(groupPosition + positionOffset), groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + RateIntAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(valuesPosition), resets.getDouble(valuesPosition), valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, IntBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + int valueValue = valueBlock.getInt(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + RateIntAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, IntVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - RateIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + int valueValue = valueVector.getInt(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + RateIntAggregator.combine(state, groupId, valueValue, timestampValue); } } @@ -314,7 +380,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert timestamps.getPositionCount() == values.getPositionCount() && timestamps.getPositionCount() == sampleCounts.getPositionCount() && timestamps.getPositionCount() == resets.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - RateIntAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(groupPosition + positionOffset), resets.getDouble(groupPosition + positionOffset), groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + RateIntAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(valuesPosition), resets.getDouble(valuesPosition), valuesPosition); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateLongGroupingAggregatorFunction.java index 01da3ba8c3f55..498a1340d4bee 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateLongGroupingAggregatorFunction.java @@ -63,31 +63,53 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - LongBlock timestampsBlock = page.getBlock(channels.get(1)); - LongVector timestampsVector = timestampsBlock.asVector(); - if (timestampsVector == null) { - throw new IllegalStateException("expected @timestamp vector; but got a block"); + LongBlock valueBlock = page.getBlock(channels.get(0)); + LongBlock timestampBlock = page.getBlock(channels.get(1)); + LongVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); + } + + @Override + public void close() { + } + }; } - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongVector timestampVector = timestampBlock.asVector(); + if (timestampVector == null) { + if (timestampBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + addRawInput(positionOffset, groupIds, valueBlock, timestampBlock); } @Override @@ -98,17 +120,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + addRawInput(positionOffset, groupIds, valueVector, timestampVector); } @Override @@ -117,37 +139,52 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + long valueValue = valueBlock.getLong(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + RateLongAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - RateLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + long valueValue = valueVector.getLong(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + RateLongAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -185,42 +222,58 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - RateLongAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(groupPosition + positionOffset), resets.getDouble(groupPosition + positionOffset), groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + RateLongAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(valuesPosition), resets.getDouble(valuesPosition), valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + long valueValue = valueBlock.getLong(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + RateLongAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - var valuePosition = groupPosition + positionOffset; - RateLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + long valueValue = valueVector.getLong(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + RateLongAggregator.combine(state, groupId, valueValue, timestampValue); } } } @@ -258,32 +311,45 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - RateLongAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(groupPosition + positionOffset), resets.getDouble(groupPosition + positionOffset), groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + RateLongAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(valuesPosition), resets.getDouble(valuesPosition), valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock valueBlock, + LongBlock timestampBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { + continue; + } + if (timestampBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + long valueValue = valueBlock.getLong(valueOffset); + int timestampStart = timestampBlock.getFirstValueIndex(valuesPosition); + int timestampEnd = timestampStart + timestampBlock.getValueCount(valuesPosition); + for (int timestampOffset = timestampStart; timestampOffset < timestampEnd; timestampOffset++) { + long timestampValue = timestampBlock.getLong(timestampOffset); + RateLongAggregator.combine(state, groupId, valueValue, timestampValue); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values, - LongVector timestamps) { + private void addRawInput(int positionOffset, IntVector groups, LongVector valueVector, + LongVector timestampVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - RateLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + long valueValue = valueVector.getLong(valuesPosition); + long timestampValue = timestampVector.getLong(valuesPosition); + RateLongAggregator.combine(state, groupId, valueValue, timestampValue); } } @@ -314,7 +380,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert timestamps.getPositionCount() == values.getPositionCount() && timestamps.getPositionCount() == sampleCounts.getPositionCount() && timestamps.getPositionCount() == resets.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - RateLongAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(groupPosition + positionOffset), resets.getDouble(groupPosition + positionOffset), groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + RateLongAggregator.combineIntermediate(state, groupId, timestamps, values, sampleCounts.getInt(valuesPosition), resets.getDouble(valuesPosition), valuesPosition); } } 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 852c8e7c7afc4..5081367c26df3 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 @@ -88,18 +88,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(BooleanVector valueVector) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - boolean valueValue = valueVector.getBoolean(i); + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + boolean valueValue = valueVector.getBoolean(valuesPosition); SampleBooleanAggregator.combine(state, valueValue); } } private void addRawVector(BooleanVector valueVector, BooleanVector mask) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - boolean valueValue = valueVector.getBoolean(i); + boolean valueValue = valueVector.getBoolean(valuesPosition); SampleBooleanAggregator.combine(state, valueValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBooleanGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBooleanGroupingAggregatorFunction.java index ff975c662f089..3225bab1e5f15 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBooleanGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBooleanGroupingAggregatorFunction.java @@ -62,26 +62,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BooleanBlock valuesBlock = page.getBlock(channels.get(0)); - BooleanVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BooleanBlock valueBlock = page.getBlock(channels.get(0)); + BooleanVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override @@ -92,17 +92,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override @@ -111,34 +111,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SampleBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + boolean valueValue = valueBlock.getBoolean(valueOffset); + SampleBooleanAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + boolean valueValue = valueVector.getBoolean(valuesPosition); + SampleBooleanAggregator.combine(state, groupId, valueValue); } } } @@ -161,39 +168,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleBooleanAggregator.combineIntermediate(state, groupId, sample, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + SampleBooleanAggregator.combineIntermediate(state, groupId, sample, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SampleBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + boolean valueValue = valueBlock.getBoolean(valueOffset); + SampleBooleanAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + boolean valueValue = valueVector.getBoolean(valuesPosition); + SampleBooleanAggregator.combine(state, groupId, valueValue); } } } @@ -216,29 +231,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleBooleanAggregator.combineIntermediate(state, groupId, sample, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + SampleBooleanAggregator.combineIntermediate(state, groupId, sample, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntVector groups, BooleanBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SampleBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + boolean valueValue = valueBlock.getBoolean(valueOffset); + SampleBooleanAggregator.combine(state, groupId, valueValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntVector groups, BooleanVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SampleBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + boolean valueValue = valueVector.getBoolean(valuesPosition); + SampleBooleanAggregator.combine(state, groupId, valueValue); } } @@ -254,7 +274,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SampleBooleanAggregator.combineIntermediate(state, groupId, sample, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + SampleBooleanAggregator.combineIntermediate(state, groupId, sample, valuesPosition); } } 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 d3787ff5e1762..0e14f22967aa0 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 @@ -89,19 +89,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BytesRefVector valueVector) { BytesRef valueScratch = new BytesRef(); - for (int i = 0; i < valueVector.getPositionCount(); i++) { - BytesRef valueValue = valueVector.getBytesRef(i, valueScratch); + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); SampleBytesRefAggregator.combine(state, valueValue); } } private void addRawVector(BytesRefVector valueVector, BooleanVector mask) { BytesRef valueScratch = new BytesRef(); - for (int i = 0; i < valueVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - BytesRef valueValue = valueVector.getBytesRef(i, valueScratch); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); SampleBytesRefAggregator.combine(state, valueValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBytesRefGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBytesRefGroupingAggregatorFunction.java index efccd08d416ef..c9e0b99c732ab 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBytesRefGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleBytesRefGroupingAggregatorFunction.java @@ -61,26 +61,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BytesRefBlock valuesBlock = page.getBlock(channels.get(0)); - BytesRefVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BytesRefBlock valueBlock = page.getBlock(channels.get(0)); + BytesRefVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override @@ -91,17 +91,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override @@ -110,36 +110,43 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock valueBlock) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SampleBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch); + SampleBytesRefAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector valueVector) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); + SampleBytesRefAggregator.combine(state, groupId, valueValue); } } } @@ -162,41 +169,50 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleBytesRefAggregator.combineIntermediate(state, groupId, sample, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + SampleBytesRefAggregator.combineIntermediate(state, groupId, sample, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock valueBlock) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SampleBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch); + SampleBytesRefAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, + BytesRefVector valueVector) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); + SampleBytesRefAggregator.combine(state, groupId, valueValue); } } } @@ -219,31 +235,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleBytesRefAggregator.combineIntermediate(state, groupId, sample, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + SampleBytesRefAggregator.combineIntermediate(state, groupId, sample, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock valueBlock) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SampleBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + BytesRef valueValue = valueBlock.getBytesRef(valueOffset, valueScratch); + SampleBytesRefAggregator.combine(state, groupId, valueValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector valueVector) { + BytesRef valueScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SampleBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef valueValue = valueVector.getBytesRef(valuesPosition, valueScratch); + SampleBytesRefAggregator.combine(state, groupId, valueValue); } } @@ -259,7 +280,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SampleBytesRefAggregator.combineIntermediate(state, groupId, sample, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + SampleBytesRefAggregator.combineIntermediate(state, groupId, sample, valuesPosition); } } 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 ab0a292729409..4530921f518c6 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 @@ -89,18 +89,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(DoubleVector valueVector) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - double valueValue = valueVector.getDouble(i); + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + double valueValue = valueVector.getDouble(valuesPosition); SampleDoubleAggregator.combine(state, valueValue); } } private void addRawVector(DoubleVector valueVector, BooleanVector mask) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - double valueValue = valueVector.getDouble(i); + double valueValue = valueVector.getDouble(valuesPosition); SampleDoubleAggregator.combine(state, valueValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleDoubleGroupingAggregatorFunction.java index d98332e2b7242..68daf96c54a32 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleDoubleGroupingAggregatorFunction.java @@ -62,26 +62,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - DoubleBlock valuesBlock = page.getBlock(channels.get(0)); - DoubleVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + DoubleBlock valueBlock = page.getBlock(channels.get(0)); + DoubleVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override @@ -92,17 +92,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override @@ -111,34 +111,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SampleDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + double valueValue = valueBlock.getDouble(valueOffset); + SampleDoubleAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double valueValue = valueVector.getDouble(valuesPosition); + SampleDoubleAggregator.combine(state, groupId, valueValue); } } } @@ -161,39 +168,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleDoubleAggregator.combineIntermediate(state, groupId, sample, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + SampleDoubleAggregator.combineIntermediate(state, groupId, sample, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SampleDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + double valueValue = valueBlock.getDouble(valueOffset); + SampleDoubleAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double valueValue = valueVector.getDouble(valuesPosition); + SampleDoubleAggregator.combine(state, groupId, valueValue); } } } @@ -216,29 +231,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleDoubleAggregator.combineIntermediate(state, groupId, sample, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + SampleDoubleAggregator.combineIntermediate(state, groupId, sample, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SampleDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + double valueValue = valueBlock.getDouble(valueOffset); + SampleDoubleAggregator.combine(state, groupId, valueValue); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SampleDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double valueValue = valueVector.getDouble(valuesPosition); + SampleDoubleAggregator.combine(state, groupId, valueValue); } } @@ -254,7 +274,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SampleDoubleAggregator.combineIntermediate(state, groupId, sample, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + SampleDoubleAggregator.combineIntermediate(state, groupId, sample, valuesPosition); } } 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 abd52a8463c73..3e3e316ca39b1 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 @@ -89,18 +89,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(IntVector valueVector) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - int valueValue = valueVector.getInt(i); + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + int valueValue = valueVector.getInt(valuesPosition); SampleIntAggregator.combine(state, valueValue); } } private void addRawVector(IntVector valueVector, BooleanVector mask) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - int valueValue = valueVector.getInt(i); + int valueValue = valueVector.getInt(valuesPosition); SampleIntAggregator.combine(state, valueValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleIntGroupingAggregatorFunction.java index 05d4d0a16801b..01ff1f3cc7ade 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleIntGroupingAggregatorFunction.java @@ -61,26 +61,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - IntBlock valuesBlock = page.getBlock(channels.get(0)); - IntVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + IntBlock valueBlock = page.getBlock(channels.get(0)); + IntVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override @@ -91,17 +91,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override @@ -110,34 +110,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SampleIntAggregator.combine(state, groupId, values.getInt(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + int valueValue = valueBlock.getInt(valueOffset); + SampleIntAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int valueValue = valueVector.getInt(valuesPosition); + SampleIntAggregator.combine(state, groupId, valueValue); } } } @@ -160,39 +167,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleIntAggregator.combineIntermediate(state, groupId, sample, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + SampleIntAggregator.combineIntermediate(state, groupId, sample, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SampleIntAggregator.combine(state, groupId, values.getInt(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + int valueValue = valueBlock.getInt(valueOffset); + SampleIntAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int valueValue = valueVector.getInt(valuesPosition); + SampleIntAggregator.combine(state, groupId, valueValue); } } } @@ -215,29 +230,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleIntAggregator.combineIntermediate(state, groupId, sample, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + SampleIntAggregator.combineIntermediate(state, groupId, sample, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntVector groups, IntBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SampleIntAggregator.combine(state, groupId, values.getInt(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + int valueValue = valueBlock.getInt(valueOffset); + SampleIntAggregator.combine(state, groupId, valueValue); } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntVector groups, IntVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SampleIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int valueValue = valueVector.getInt(valuesPosition); + SampleIntAggregator.combine(state, groupId, valueValue); } } @@ -253,7 +273,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SampleIntAggregator.combineIntermediate(state, groupId, sample, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + SampleIntAggregator.combineIntermediate(state, groupId, sample, valuesPosition); } } 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 590d29dee9864..dad6db965daf4 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 @@ -89,18 +89,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(LongVector valueVector) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - long valueValue = valueVector.getLong(i); + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + long valueValue = valueVector.getLong(valuesPosition); SampleLongAggregator.combine(state, valueValue); } } private void addRawVector(LongVector valueVector, BooleanVector mask) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - long valueValue = valueVector.getLong(i); + long valueValue = valueVector.getLong(valuesPosition); SampleLongAggregator.combine(state, valueValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleLongGroupingAggregatorFunction.java index 64d29eeaf60aa..327118fca0b18 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SampleLongGroupingAggregatorFunction.java @@ -62,26 +62,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongBlock valueBlock = page.getBlock(channels.get(0)); + LongVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override @@ -92,17 +92,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override @@ -111,34 +111,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SampleLongAggregator.combine(state, groupId, values.getLong(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + long valueValue = valueBlock.getLong(valueOffset); + SampleLongAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long valueValue = valueVector.getLong(valuesPosition); + SampleLongAggregator.combine(state, groupId, valueValue); } } } @@ -161,39 +168,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleLongAggregator.combineIntermediate(state, groupId, sample, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + SampleLongAggregator.combineIntermediate(state, groupId, sample, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SampleLongAggregator.combine(state, groupId, values.getLong(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + long valueValue = valueBlock.getLong(valueOffset); + SampleLongAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long valueValue = valueVector.getLong(valuesPosition); + SampleLongAggregator.combine(state, groupId, valueValue); } } } @@ -216,29 +231,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SampleLongAggregator.combineIntermediate(state, groupId, sample, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + SampleLongAggregator.combineIntermediate(state, groupId, sample, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SampleLongAggregator.combine(state, groupId, values.getLong(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + long valueValue = valueBlock.getLong(valueOffset); + SampleLongAggregator.combine(state, groupId, valueValue); } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntVector groups, LongVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SampleLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long valueValue = valueVector.getLong(valuesPosition); + SampleLongAggregator.combine(state, groupId, valueValue); } } @@ -254,7 +274,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SampleLongAggregator.combineIntermediate(state, groupId, sample, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + SampleLongAggregator.combineIntermediate(state, groupId, sample, valuesPosition); } } 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 a1bccaa9f1d3b..4fde6226074f4 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 @@ -88,18 +88,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(DoubleVector valueVector) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - double valueValue = valueVector.getDouble(i); + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + double valueValue = valueVector.getDouble(valuesPosition); StdDevDoubleAggregator.combine(state, valueValue); } } private void addRawVector(DoubleVector valueVector, BooleanVector mask) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - double valueValue = valueVector.getDouble(i); + double valueValue = valueVector.getDouble(valuesPosition); StdDevDoubleAggregator.combine(state, valueValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevDoubleGroupingAggregatorFunction.java index 83af53eebf60e..fe2e49da0a805 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevDoubleGroupingAggregatorFunction.java @@ -61,26 +61,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - DoubleBlock valuesBlock = page.getBlock(channels.get(0)); - DoubleVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + DoubleBlock valueBlock = page.getBlock(channels.get(0)); + DoubleVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override @@ -91,17 +91,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override @@ -110,34 +110,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + double valueValue = valueBlock.getDouble(valueOffset); + StdDevDoubleAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double valueValue = valueVector.getDouble(valuesPosition); + StdDevDoubleAggregator.combine(state, groupId, valueValue); } } } @@ -170,39 +177,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevDoubleAggregator.combineIntermediate(state, groupId, mean.getDouble(groupPosition + positionOffset), m2.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + StdDevDoubleAggregator.combineIntermediate(state, groupId, mean.getDouble(valuesPosition), m2.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + double valueValue = valueBlock.getDouble(valueOffset); + StdDevDoubleAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double valueValue = valueVector.getDouble(valuesPosition); + StdDevDoubleAggregator.combine(state, groupId, valueValue); } } } @@ -235,29 +250,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevDoubleAggregator.combineIntermediate(state, groupId, mean.getDouble(groupPosition + positionOffset), m2.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + StdDevDoubleAggregator.combineIntermediate(state, groupId, mean.getDouble(valuesPosition), m2.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + double valueValue = valueBlock.getDouble(valueOffset); + StdDevDoubleAggregator.combine(state, groupId, valueValue); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - StdDevDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double valueValue = valueVector.getDouble(valuesPosition); + StdDevDoubleAggregator.combine(state, groupId, valueValue); } } @@ -283,7 +303,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert mean.getPositionCount() == m2.getPositionCount() && mean.getPositionCount() == count.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - StdDevDoubleAggregator.combineIntermediate(state, groupId, mean.getDouble(groupPosition + positionOffset), m2.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + StdDevDoubleAggregator.combineIntermediate(state, groupId, mean.getDouble(valuesPosition), m2.getDouble(valuesPosition), count.getLong(valuesPosition)); } } 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 4ece85c8dcec1..863adcbeb68dd 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 @@ -90,18 +90,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(FloatVector valueVector) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - float valueValue = valueVector.getFloat(i); + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + float valueValue = valueVector.getFloat(valuesPosition); StdDevFloatAggregator.combine(state, valueValue); } } private void addRawVector(FloatVector valueVector, BooleanVector mask) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - float valueValue = valueVector.getFloat(i); + float valueValue = valueVector.getFloat(valuesPosition); StdDevFloatAggregator.combine(state, valueValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevFloatGroupingAggregatorFunction.java index 2d86c3355c4fc..b72d98a947227 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevFloatGroupingAggregatorFunction.java @@ -63,26 +63,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - FloatBlock valuesBlock = page.getBlock(channels.get(0)); - FloatVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + FloatBlock valueBlock = page.getBlock(channels.get(0)); + FloatVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override @@ -93,17 +93,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override @@ -112,34 +112,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevFloatAggregator.combine(state, groupId, values.getFloat(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + float valueValue = valueBlock.getFloat(valueOffset); + StdDevFloatAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float valueValue = valueVector.getFloat(valuesPosition); + StdDevFloatAggregator.combine(state, groupId, valueValue); } } } @@ -172,39 +179,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevFloatAggregator.combineIntermediate(state, groupId, mean.getDouble(groupPosition + positionOffset), m2.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + StdDevFloatAggregator.combineIntermediate(state, groupId, mean.getDouble(valuesPosition), m2.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevFloatAggregator.combine(state, groupId, values.getFloat(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + float valueValue = valueBlock.getFloat(valueOffset); + StdDevFloatAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float valueValue = valueVector.getFloat(valuesPosition); + StdDevFloatAggregator.combine(state, groupId, valueValue); } } } @@ -237,29 +252,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevFloatAggregator.combineIntermediate(state, groupId, mean.getDouble(groupPosition + positionOffset), m2.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + StdDevFloatAggregator.combineIntermediate(state, groupId, mean.getDouble(valuesPosition), m2.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntVector groups, FloatBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevFloatAggregator.combine(state, groupId, values.getFloat(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + float valueValue = valueBlock.getFloat(valueOffset); + StdDevFloatAggregator.combine(state, groupId, valueValue); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntVector groups, FloatVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - StdDevFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float valueValue = valueVector.getFloat(valuesPosition); + StdDevFloatAggregator.combine(state, groupId, valueValue); } } @@ -285,7 +305,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert mean.getPositionCount() == m2.getPositionCount() && mean.getPositionCount() == count.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - StdDevFloatAggregator.combineIntermediate(state, groupId, mean.getDouble(groupPosition + positionOffset), m2.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + StdDevFloatAggregator.combineIntermediate(state, groupId, mean.getDouble(valuesPosition), m2.getDouble(valuesPosition), count.getLong(valuesPosition)); } } 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 2c927a35cb1a6..752d0e7136590 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 @@ -90,18 +90,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(IntVector valueVector) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - int valueValue = valueVector.getInt(i); + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + int valueValue = valueVector.getInt(valuesPosition); StdDevIntAggregator.combine(state, valueValue); } } private void addRawVector(IntVector valueVector, BooleanVector mask) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - int valueValue = valueVector.getInt(i); + int valueValue = valueVector.getInt(valuesPosition); StdDevIntAggregator.combine(state, valueValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevIntGroupingAggregatorFunction.java index 5f09d9ab82ad8..f3a6acbcbb014 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevIntGroupingAggregatorFunction.java @@ -62,26 +62,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - IntBlock valuesBlock = page.getBlock(channels.get(0)); - IntVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + IntBlock valueBlock = page.getBlock(channels.get(0)); + IntVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override @@ -92,17 +92,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override @@ -111,34 +111,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevIntAggregator.combine(state, groupId, values.getInt(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + int valueValue = valueBlock.getInt(valueOffset); + StdDevIntAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int valueValue = valueVector.getInt(valuesPosition); + StdDevIntAggregator.combine(state, groupId, valueValue); } } } @@ -171,39 +178,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevIntAggregator.combineIntermediate(state, groupId, mean.getDouble(groupPosition + positionOffset), m2.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + StdDevIntAggregator.combineIntermediate(state, groupId, mean.getDouble(valuesPosition), m2.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevIntAggregator.combine(state, groupId, values.getInt(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + int valueValue = valueBlock.getInt(valueOffset); + StdDevIntAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int valueValue = valueVector.getInt(valuesPosition); + StdDevIntAggregator.combine(state, groupId, valueValue); } } } @@ -236,29 +251,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevIntAggregator.combineIntermediate(state, groupId, mean.getDouble(groupPosition + positionOffset), m2.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + StdDevIntAggregator.combineIntermediate(state, groupId, mean.getDouble(valuesPosition), m2.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntVector groups, IntBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevIntAggregator.combine(state, groupId, values.getInt(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + int valueValue = valueBlock.getInt(valueOffset); + StdDevIntAggregator.combine(state, groupId, valueValue); } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntVector groups, IntVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - StdDevIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int valueValue = valueVector.getInt(valuesPosition); + StdDevIntAggregator.combine(state, groupId, valueValue); } } @@ -284,7 +304,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert mean.getPositionCount() == m2.getPositionCount() && mean.getPositionCount() == count.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - StdDevIntAggregator.combineIntermediate(state, groupId, mean.getDouble(groupPosition + positionOffset), m2.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + StdDevIntAggregator.combineIntermediate(state, groupId, mean.getDouble(valuesPosition), m2.getDouble(valuesPosition), count.getLong(valuesPosition)); } } 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 db256f56f7d2e..6706aa3635336 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 @@ -88,18 +88,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(LongVector valueVector) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - long valueValue = valueVector.getLong(i); + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + long valueValue = valueVector.getLong(valuesPosition); StdDevLongAggregator.combine(state, valueValue); } } private void addRawVector(LongVector valueVector, BooleanVector mask) { - for (int i = 0; i < valueVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < valueVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - long valueValue = valueVector.getLong(i); + long valueValue = valueVector.getLong(valuesPosition); StdDevLongAggregator.combine(state, valueValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevLongGroupingAggregatorFunction.java index bf9a79addd086..79dc47b387484 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevLongGroupingAggregatorFunction.java @@ -61,26 +61,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongBlock valueBlock = page.getBlock(channels.get(0)); + LongVector valueVector = valueBlock.asVector(); + if (valueVector == null) { + if (valueBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, valueBlock); } @Override @@ -91,17 +91,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, valueVector); } @Override @@ -110,34 +110,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevLongAggregator.combine(state, groupId, values.getLong(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + long valueValue = valueBlock.getLong(valueOffset); + StdDevLongAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long valueValue = valueVector.getLong(valuesPosition); + StdDevLongAggregator.combine(state, groupId, valueValue); } } } @@ -170,39 +177,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevLongAggregator.combineIntermediate(state, groupId, mean.getDouble(groupPosition + positionOffset), m2.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + StdDevLongAggregator.combineIntermediate(state, groupId, mean.getDouble(valuesPosition), m2.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevLongAggregator.combine(state, groupId, values.getLong(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + long valueValue = valueBlock.getLong(valueOffset); + StdDevLongAggregator.combine(state, groupId, valueValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long valueValue = valueVector.getLong(valuesPosition); + StdDevLongAggregator.combine(state, groupId, valueValue); } } } @@ -235,29 +250,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - StdDevLongAggregator.combineIntermediate(state, groupId, mean.getDouble(groupPosition + positionOffset), m2.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + StdDevLongAggregator.combineIntermediate(state, groupId, mean.getDouble(valuesPosition), m2.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock valueBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valueBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevLongAggregator.combine(state, groupId, values.getLong(v)); + int valueStart = valueBlock.getFirstValueIndex(valuesPosition); + int valueEnd = valueStart + valueBlock.getValueCount(valuesPosition); + for (int valueOffset = valueStart; valueOffset < valueEnd; valueOffset++) { + long valueValue = valueBlock.getLong(valueOffset); + StdDevLongAggregator.combine(state, groupId, valueValue); } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntVector groups, LongVector valueVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - StdDevLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long valueValue = valueVector.getLong(valuesPosition); + StdDevLongAggregator.combine(state, groupId, valueValue); } } @@ -283,7 +303,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert mean.getPositionCount() == m2.getPositionCount() && mean.getPositionCount() == count.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - StdDevLongAggregator.combineIntermediate(state, groupId, mean.getDouble(groupPosition + positionOffset), m2.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + StdDevLongAggregator.combineIntermediate(state, groupId, mean.getDouble(valuesPosition), m2.getDouble(valuesPosition), count.getLong(valuesPosition)); } } 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 432b58f190410..61c3652c1bdf0 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 @@ -88,19 +88,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(DoubleVector vVector) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - double vValue = vVector.getDouble(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + double vValue = vVector.getDouble(valuesPosition); SumDoubleAggregator.combine(state, vValue); } } private void addRawVector(DoubleVector vVector, BooleanVector mask) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - double vValue = vVector.getDouble(i); + double vValue = vVector.getDouble(valuesPosition); SumDoubleAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumDoubleGroupingAggregatorFunction.java index c4b888032dbb1..d252140fe8fbd 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumDoubleGroupingAggregatorFunction.java @@ -61,26 +61,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - DoubleBlock valuesBlock = page.getBlock(channels.get(0)); - DoubleVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + DoubleBlock vBlock = page.getBlock(channels.get(0)); + DoubleVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -91,17 +91,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -110,34 +110,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SumDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + SumDoubleAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SumDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + SumDoubleAggregator.combine(state, groupId, vValue); } } } @@ -170,39 +177,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SumDoubleAggregator.combineIntermediate(state, groupId, value.getDouble(groupPosition + positionOffset), delta.getDouble(groupPosition + positionOffset), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SumDoubleAggregator.combineIntermediate(state, groupId, value.getDouble(valuesPosition), delta.getDouble(valuesPosition), seen.getBoolean(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SumDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + SumDoubleAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SumDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + SumDoubleAggregator.combine(state, groupId, vValue); } } } @@ -235,29 +250,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SumDoubleAggregator.combineIntermediate(state, groupId, value.getDouble(groupPosition + positionOffset), delta.getDouble(groupPosition + positionOffset), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SumDoubleAggregator.combineIntermediate(state, groupId, value.getDouble(valuesPosition), delta.getDouble(valuesPosition), seen.getBoolean(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SumDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + SumDoubleAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SumDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + SumDoubleAggregator.combine(state, groupId, vValue); } } @@ -283,7 +303,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert value.getPositionCount() == delta.getPositionCount() && value.getPositionCount() == seen.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SumDoubleAggregator.combineIntermediate(state, groupId, value.getDouble(groupPosition + positionOffset), delta.getDouble(groupPosition + positionOffset), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SumDoubleAggregator.combineIntermediate(state, groupId, value.getDouble(valuesPosition), delta.getDouble(valuesPosition), seen.getBoolean(valuesPosition)); } } 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 ebd61094c2d91..45daa8a702fa1 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 @@ -90,19 +90,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(FloatVector vVector) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - float vValue = vVector.getFloat(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + float vValue = vVector.getFloat(valuesPosition); SumFloatAggregator.combine(state, vValue); } } private void addRawVector(FloatVector vVector, BooleanVector mask) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - float vValue = vVector.getFloat(i); + float vValue = vVector.getFloat(valuesPosition); SumFloatAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumFloatGroupingAggregatorFunction.java index 5debadd250fb6..3403533f5c6ae 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumFloatGroupingAggregatorFunction.java @@ -63,26 +63,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - FloatBlock valuesBlock = page.getBlock(channels.get(0)); - FloatVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + FloatBlock vBlock = page.getBlock(channels.get(0)); + FloatVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -93,17 +93,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -112,34 +112,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SumFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + SumFloatAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SumFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + SumFloatAggregator.combine(state, groupId, vValue); } } } @@ -172,39 +179,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SumFloatAggregator.combineIntermediate(state, groupId, value.getDouble(groupPosition + positionOffset), delta.getDouble(groupPosition + positionOffset), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SumFloatAggregator.combineIntermediate(state, groupId, value.getDouble(valuesPosition), delta.getDouble(valuesPosition), seen.getBoolean(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SumFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + SumFloatAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SumFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + SumFloatAggregator.combine(state, groupId, vValue); } } } @@ -237,29 +252,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SumFloatAggregator.combineIntermediate(state, groupId, value.getDouble(groupPosition + positionOffset), delta.getDouble(groupPosition + positionOffset), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SumFloatAggregator.combineIntermediate(state, groupId, value.getDouble(valuesPosition), delta.getDouble(valuesPosition), seen.getBoolean(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntVector groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SumFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + SumFloatAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntVector groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SumFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + SumFloatAggregator.combine(state, groupId, vValue); } } @@ -285,7 +305,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert value.getPositionCount() == delta.getPositionCount() && value.getPositionCount() == seen.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SumFloatAggregator.combineIntermediate(state, groupId, value.getDouble(groupPosition + positionOffset), delta.getDouble(groupPosition + positionOffset), seen.getBoolean(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SumFloatAggregator.combineIntermediate(state, groupId, value.getDouble(valuesPosition), delta.getDouble(valuesPosition), seen.getBoolean(valuesPosition)); } } 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 e99d4afd606d1..b6ee294470e7f 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 @@ -89,19 +89,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(IntVector vVector) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - int vValue = vVector.getInt(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + int vValue = vVector.getInt(valuesPosition); state.longValue(SumIntAggregator.combine(state.longValue(), vValue)); } } private void addRawVector(IntVector vVector, BooleanVector mask) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - int vValue = vVector.getInt(i); + int vValue = vVector.getInt(valuesPosition); state.longValue(SumIntAggregator.combine(state.longValue(), vValue)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumIntGroupingAggregatorFunction.java index d4faee6d9428d..2b74ba2220233 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumIntGroupingAggregatorFunction.java @@ -61,26 +61,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - IntBlock valuesBlock = page.getBlock(channels.get(0)); - IntVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + IntBlock vBlock = page.getBlock(channels.get(0)); + IntVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -91,17 +91,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -110,34 +110,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + int vValue = vVector.getInt(valuesPosition); + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -165,41 +172,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), sum.getLong(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), sum.getLong(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + int vValue = vVector.getInt(valuesPosition); + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -227,31 +242,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), sum.getLong(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), sum.getLong(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntVector groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntVector groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + int vValue = vVector.getInt(valuesPosition); + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), vValue)); } } @@ -272,8 +292,9 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert sum.getPositionCount() == seen.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), sum.getLong(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), sum.getLong(valuesPosition))); } } } 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 c588348680615..d9d2cef9c00a7 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 @@ -87,19 +87,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(LongVector vVector) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - long vValue = vVector.getLong(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + long vValue = vVector.getLong(valuesPosition); state.longValue(SumLongAggregator.combine(state.longValue(), vValue)); } } private void addRawVector(LongVector vVector, BooleanVector mask) { state.seen(true); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - long vValue = vVector.getLong(i); + long vValue = vVector.getLong(valuesPosition); state.longValue(SumLongAggregator.combine(state.longValue(), vValue)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumLongGroupingAggregatorFunction.java index 80d2209ee4fe0..33570326aa300 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumLongGroupingAggregatorFunction.java @@ -60,26 +60,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongBlock vBlock = page.getBlock(channels.get(0)); + LongVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -90,17 +90,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -109,34 +109,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + long vValue = vVector.getLong(valuesPosition); + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -164,41 +171,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), sum.getLong(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), sum.getLong(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + long vValue = vVector.getLong(valuesPosition); + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } } @@ -226,31 +241,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), sum.getLong(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), sum.getLong(valuesPosition))); } } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntVector groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + long vValue = vVector.getLong(valuesPosition); + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), vValue)); } } @@ -271,8 +291,9 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert sum.getPositionCount() == seen.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - if (seen.getBoolean(groupPosition + positionOffset)) { - state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), sum.getLong(groupPosition + positionOffset))); + int valuesPosition = groupPosition + positionOffset; + if (seen.getBoolean(valuesPosition)) { + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), sum.getLong(valuesPosition))); } } } 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 fa69a07bc0ec0..2af3c9420e0ee 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 @@ -89,18 +89,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(BooleanVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - boolean vValue = vVector.getBoolean(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + boolean vValue = vVector.getBoolean(valuesPosition); TopBooleanAggregator.combine(state, vValue); } } private void addRawVector(BooleanVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - boolean vValue = vVector.getBoolean(i); + boolean vValue = vVector.getBoolean(valuesPosition); TopBooleanAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBooleanGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBooleanGroupingAggregatorFunction.java index f7cc8f2ba062b..94aa1d20f2df5 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBooleanGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBooleanGroupingAggregatorFunction.java @@ -64,26 +64,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BooleanBlock valuesBlock = page.getBlock(channels.get(0)); - BooleanVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BooleanBlock vBlock = page.getBlock(channels.get(0)); + BooleanVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -94,17 +94,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -113,34 +113,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + boolean vValue = vBlock.getBoolean(vOffset); + TopBooleanAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + boolean vValue = vVector.getBoolean(valuesPosition); + TopBooleanAggregator.combine(state, groupId, vValue); } } } @@ -162,39 +169,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopBooleanAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopBooleanAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + boolean vValue = vBlock.getBoolean(vOffset); + TopBooleanAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + boolean vValue = vVector.getBoolean(valuesPosition); + TopBooleanAggregator.combine(state, groupId, vValue); } } } @@ -216,29 +231,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopBooleanAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopBooleanAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntVector groups, BooleanBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + boolean vValue = vBlock.getBoolean(vOffset); + TopBooleanAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntVector groups, BooleanVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - TopBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + boolean vValue = vVector.getBoolean(valuesPosition); + TopBooleanAggregator.combine(state, groupId, vValue); } } @@ -253,7 +273,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BooleanBlock top = (BooleanBlock) topUncast; for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - TopBooleanAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopBooleanAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } 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 41a3492d22349..3572b9145707d 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 @@ -92,19 +92,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BytesRefVector vVector) { BytesRef vScratch = new BytesRef(); - for (int i = 0; i < vVector.getPositionCount(); i++) { - BytesRef vValue = vVector.getBytesRef(i, vScratch); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); TopBytesRefAggregator.combine(state, vValue); } } private void addRawVector(BytesRefVector vVector, BooleanVector mask) { BytesRef vScratch = new BytesRef(); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - BytesRef vValue = vVector.getBytesRef(i, vScratch); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); TopBytesRefAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBytesRefGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBytesRefGroupingAggregatorFunction.java index 1c49c8890c26c..a4b83a742c97a 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBytesRefGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBytesRefGroupingAggregatorFunction.java @@ -65,26 +65,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BytesRefBlock valuesBlock = page.getBlock(channels.get(0)); - BytesRefVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BytesRefBlock vBlock = page.getBlock(channels.get(0)); + BytesRefVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -95,17 +95,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -114,36 +114,43 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock vBlock) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch); + TopBytesRefAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector vVector) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); + TopBytesRefAggregator.combine(state, groupId, vValue); } } } @@ -166,41 +173,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopBytesRefAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopBytesRefAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock vBlock) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch); + TopBytesRefAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector vVector) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); + TopBytesRefAggregator.combine(state, groupId, vValue); } } } @@ -223,31 +238,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopBytesRefAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopBytesRefAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock vBlock) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch); + TopBytesRefAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector vVector) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); + TopBytesRefAggregator.combine(state, groupId, vValue); } } @@ -263,7 +283,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - TopBytesRefAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopBytesRefAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } 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 679cb5a52de87..5250bd564b4e4 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 @@ -90,18 +90,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(DoubleVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - double vValue = vVector.getDouble(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + double vValue = vVector.getDouble(valuesPosition); TopDoubleAggregator.combine(state, vValue); } } private void addRawVector(DoubleVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - double vValue = vVector.getDouble(i); + double vValue = vVector.getDouble(valuesPosition); TopDoubleAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopDoubleGroupingAggregatorFunction.java index 3bd8ec8fa9801..f9892c35fe878 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopDoubleGroupingAggregatorFunction.java @@ -64,26 +64,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - DoubleBlock valuesBlock = page.getBlock(channels.get(0)); - DoubleVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + DoubleBlock vBlock = page.getBlock(channels.get(0)); + DoubleVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -94,17 +94,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -113,34 +113,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + TopDoubleAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + TopDoubleAggregator.combine(state, groupId, vValue); } } } @@ -162,39 +169,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopDoubleAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopDoubleAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + TopDoubleAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + TopDoubleAggregator.combine(state, groupId, vValue); } } } @@ -216,29 +231,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopDoubleAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopDoubleAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + TopDoubleAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - TopDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + TopDoubleAggregator.combine(state, groupId, vValue); } } @@ -253,7 +273,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page DoubleBlock top = (DoubleBlock) topUncast; for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - TopDoubleAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopDoubleAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } 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 dfb328ec3edc7..e682334c3eaa0 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 @@ -90,18 +90,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(FloatVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - float vValue = vVector.getFloat(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + float vValue = vVector.getFloat(valuesPosition); TopFloatAggregator.combine(state, vValue); } } private void addRawVector(FloatVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - float vValue = vVector.getFloat(i); + float vValue = vVector.getFloat(valuesPosition); TopFloatAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopFloatGroupingAggregatorFunction.java index 4e7eba0027810..313377cb313ff 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopFloatGroupingAggregatorFunction.java @@ -64,26 +64,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - FloatBlock valuesBlock = page.getBlock(channels.get(0)); - FloatVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + FloatBlock vBlock = page.getBlock(channels.get(0)); + FloatVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -94,17 +94,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -113,34 +113,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + TopFloatAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + TopFloatAggregator.combine(state, groupId, vValue); } } } @@ -162,39 +169,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopFloatAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopFloatAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + TopFloatAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + TopFloatAggregator.combine(state, groupId, vValue); } } } @@ -216,29 +231,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopFloatAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopFloatAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntVector groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + TopFloatAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntVector groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - TopFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + TopFloatAggregator.combine(state, groupId, vValue); } } @@ -253,7 +273,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page FloatBlock top = (FloatBlock) topUncast; for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - TopFloatAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopFloatAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } 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 1c5b1fcc91509..2956af5b9c130 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 @@ -90,18 +90,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(IntVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - int vValue = vVector.getInt(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + int vValue = vVector.getInt(valuesPosition); TopIntAggregator.combine(state, vValue); } } private void addRawVector(IntVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - int vValue = vVector.getInt(i); + int vValue = vVector.getInt(valuesPosition); TopIntAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIntGroupingAggregatorFunction.java index 0ea18a3118c6d..363ff8da73368 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIntGroupingAggregatorFunction.java @@ -63,26 +63,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - IntBlock valuesBlock = page.getBlock(channels.get(0)); - IntVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + IntBlock vBlock = page.getBlock(channels.get(0)); + IntVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -93,17 +93,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -112,34 +112,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopIntAggregator.combine(state, groupId, values.getInt(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + TopIntAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int vValue = vVector.getInt(valuesPosition); + TopIntAggregator.combine(state, groupId, vValue); } } } @@ -161,39 +168,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopIntAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopIntAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopIntAggregator.combine(state, groupId, values.getInt(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + TopIntAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int vValue = vVector.getInt(valuesPosition); + TopIntAggregator.combine(state, groupId, vValue); } } } @@ -215,29 +230,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopIntAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopIntAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntVector groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopIntAggregator.combine(state, groupId, values.getInt(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + TopIntAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntVector groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - TopIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int vValue = vVector.getInt(valuesPosition); + TopIntAggregator.combine(state, groupId, vValue); } } @@ -252,7 +272,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page IntBlock top = (IntBlock) topUncast; for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - TopIntAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopIntAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } 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 a0a4988d0ec14..07b5980dc54d0 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 @@ -92,19 +92,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BytesRefVector vVector) { BytesRef vScratch = new BytesRef(); - for (int i = 0; i < vVector.getPositionCount(); i++) { - BytesRef vValue = vVector.getBytesRef(i, vScratch); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); TopIpAggregator.combine(state, vValue); } } private void addRawVector(BytesRefVector vVector, BooleanVector mask) { BytesRef vScratch = new BytesRef(); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - BytesRef vValue = vVector.getBytesRef(i, vScratch); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); TopIpAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIpGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIpGroupingAggregatorFunction.java index 0026fa15cbff1..2527c25b4daec 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIpGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIpGroupingAggregatorFunction.java @@ -65,26 +65,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BytesRefBlock valuesBlock = page.getBlock(channels.get(0)); - BytesRefVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BytesRefBlock vBlock = page.getBlock(channels.get(0)); + BytesRefVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -95,17 +95,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -114,36 +114,43 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock vBlock) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch); + TopIpAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector vVector) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); + TopIpAggregator.combine(state, groupId, vValue); } } } @@ -166,41 +173,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopIpAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopIpAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock vBlock) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch); + TopIpAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector vVector) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); + TopIpAggregator.combine(state, groupId, vValue); } } } @@ -223,31 +238,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopIpAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopIpAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock vBlock) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch); + TopIpAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector vVector) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - TopIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); + TopIpAggregator.combine(state, groupId, vValue); } } @@ -263,7 +283,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - TopIpAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopIpAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } 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 85908cb98ad8a..3657dc8a4db2f 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 @@ -90,18 +90,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(LongVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - long vValue = vVector.getLong(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + long vValue = vVector.getLong(valuesPosition); TopLongAggregator.combine(state, vValue); } } private void addRawVector(LongVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - long vValue = vVector.getLong(i); + long vValue = vVector.getLong(valuesPosition); TopLongAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopLongGroupingAggregatorFunction.java index 494d0bb51cb10..0d637b46fd833 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopLongGroupingAggregatorFunction.java @@ -64,26 +64,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongBlock vBlock = page.getBlock(channels.get(0)); + LongVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -94,17 +94,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -113,34 +113,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopLongAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + TopLongAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + TopLongAggregator.combine(state, groupId, vValue); } } } @@ -162,39 +169,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopLongAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopLongAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopLongAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + TopLongAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + TopLongAggregator.combine(state, groupId, vValue); } } } @@ -216,29 +231,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - TopLongAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopLongAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopLongAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + TopLongAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntVector groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - TopLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + TopLongAggregator.combine(state, groupId, vValue); } } @@ -253,7 +273,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page LongBlock top = (LongBlock) topUncast; for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - TopLongAggregator.combineIntermediate(state, groupId, top, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + TopLongAggregator.combineIntermediate(state, groupId, top, valuesPosition); } } 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 b958bd78eedd3..c1fa658f8d1d1 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 @@ -83,18 +83,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(BooleanVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - boolean vValue = vVector.getBoolean(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + boolean vValue = vVector.getBoolean(valuesPosition); ValuesBooleanAggregator.combine(state, vValue); } } private void addRawVector(BooleanVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - boolean vValue = vVector.getBoolean(i); + boolean vValue = vVector.getBoolean(valuesPosition); ValuesBooleanAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBooleanGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBooleanGroupingAggregatorFunction.java index e8cd576001709..1852a678576e5 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBooleanGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBooleanGroupingAggregatorFunction.java @@ -57,26 +57,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BooleanBlock valuesBlock = page.getBlock(channels.get(0)); - BooleanVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BooleanBlock vBlock = page.getBlock(channels.get(0)); + BooleanVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -87,17 +87,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -106,34 +106,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + boolean vValue = vBlock.getBoolean(vOffset); + ValuesBooleanAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + boolean vValue = vVector.getBoolean(valuesPosition); + ValuesBooleanAggregator.combine(state, groupId, vValue); } } } @@ -155,39 +162,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesBooleanAggregator.combineIntermediate(state, groupId, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + ValuesBooleanAggregator.combineIntermediate(state, groupId, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + boolean vValue = vBlock.getBoolean(vOffset); + ValuesBooleanAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + boolean vValue = vVector.getBoolean(valuesPosition); + ValuesBooleanAggregator.combine(state, groupId, vValue); } } } @@ -209,29 +224,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesBooleanAggregator.combineIntermediate(state, groupId, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + ValuesBooleanAggregator.combineIntermediate(state, groupId, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntVector groups, BooleanBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + boolean vValue = vBlock.getBoolean(vOffset); + ValuesBooleanAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntVector groups, BooleanVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + boolean vValue = vVector.getBoolean(valuesPosition); + ValuesBooleanAggregator.combine(state, groupId, vValue); } } @@ -246,7 +266,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page BooleanBlock values = (BooleanBlock) valuesUncast; for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - ValuesBooleanAggregator.combineIntermediate(state, groupId, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + ValuesBooleanAggregator.combineIntermediate(state, groupId, values, valuesPosition); } } 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 8a82cc317cfd1..080c7cf0a4912 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 @@ -86,19 +86,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BytesRefVector vVector) { BytesRef vScratch = new BytesRef(); - for (int i = 0; i < vVector.getPositionCount(); i++) { - BytesRef vValue = vVector.getBytesRef(i, vScratch); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); ValuesBytesRefAggregator.combine(state, vValue); } } private void addRawVector(BytesRefVector vVector, BooleanVector mask) { BytesRef vScratch = new BytesRef(); - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - BytesRef vValue = vVector.getBytesRef(i, vScratch); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); ValuesBytesRefAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBytesRefGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBytesRefGroupingAggregatorFunction.java index 3f104fb548f8b..60d8e5d53ddcd 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBytesRefGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBytesRefGroupingAggregatorFunction.java @@ -58,87 +58,94 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BytesRefBlock valuesBlock = page.getBlock(channels.get(0)); - BytesRefVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BytesRefBlock vBlock = page.getBlock(channels.get(0)); + BytesRefVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } var addInput = new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void close() { } }; - return ValuesBytesRefAggregator.wrapAddInput(addInput, state, valuesBlock); + return ValuesBytesRefAggregator.wrapAddInput(addInput, state, vBlock); } var addInput = new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void close() { } }; - return ValuesBytesRefAggregator.wrapAddInput(addInput, state, valuesVector); + return ValuesBytesRefAggregator.wrapAddInput(addInput, state, vVector); } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock vBlock) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch); + ValuesBytesRefAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector vVector) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); + ValuesBytesRefAggregator.combine(state, groupId, vValue); } } } @@ -155,36 +162,43 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page ValuesBytesRefAggregator.combineIntermediate(state, positionOffset, groups, values); } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock vBlock) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch); + ValuesBytesRefAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector vVector) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); + ValuesBytesRefAggregator.combine(state, groupId, vValue); } } } @@ -201,26 +215,30 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa ValuesBytesRefAggregator.combineIntermediate(state, positionOffset, groups, values); } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock vBlock) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + BytesRef vValue = vBlock.getBytesRef(vOffset, vScratch); + ValuesBytesRefAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector vVector) { + BytesRef vScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef vValue = vVector.getBytesRef(valuesPosition, vScratch); + ValuesBytesRefAggregator.combine(state, groupId, 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 cda945d592d92..34d802c58ea1b 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 @@ -84,18 +84,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(DoubleVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - double vValue = vVector.getDouble(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + double vValue = vVector.getDouble(valuesPosition); ValuesDoubleAggregator.combine(state, vValue); } } private void addRawVector(DoubleVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - double vValue = vVector.getDouble(i); + double vValue = vVector.getDouble(valuesPosition); ValuesDoubleAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesDoubleGroupingAggregatorFunction.java index b10a918f3fd4c..27e6fc53f2ba5 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesDoubleGroupingAggregatorFunction.java @@ -57,26 +57,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - DoubleBlock valuesBlock = page.getBlock(channels.get(0)); - DoubleVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + DoubleBlock vBlock = page.getBlock(channels.get(0)); + DoubleVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -87,17 +87,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -106,34 +106,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + ValuesDoubleAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + ValuesDoubleAggregator.combine(state, groupId, vValue); } } } @@ -155,39 +162,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesDoubleAggregator.combineIntermediate(state, groupId, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + ValuesDoubleAggregator.combineIntermediate(state, groupId, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + ValuesDoubleAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + ValuesDoubleAggregator.combine(state, groupId, vValue); } } } @@ -209,29 +224,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesDoubleAggregator.combineIntermediate(state, groupId, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + ValuesDoubleAggregator.combineIntermediate(state, groupId, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + double vValue = vBlock.getDouble(vOffset); + ValuesDoubleAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntVector groups, DoubleVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - ValuesDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + double vValue = vVector.getDouble(valuesPosition); + ValuesDoubleAggregator.combine(state, groupId, vValue); } } @@ -246,7 +266,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page DoubleBlock values = (DoubleBlock) valuesUncast; for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - ValuesDoubleAggregator.combineIntermediate(state, groupId, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + ValuesDoubleAggregator.combineIntermediate(state, groupId, values, valuesPosition); } } 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 3dcb011aea7fe..2e2c238bb8fa3 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 @@ -84,18 +84,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(FloatVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - float vValue = vVector.getFloat(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + float vValue = vVector.getFloat(valuesPosition); ValuesFloatAggregator.combine(state, vValue); } } private void addRawVector(FloatVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - float vValue = vVector.getFloat(i); + float vValue = vVector.getFloat(valuesPosition); ValuesFloatAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesFloatGroupingAggregatorFunction.java index 556bba8be88f8..f9b8418735b07 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesFloatGroupingAggregatorFunction.java @@ -57,26 +57,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - FloatBlock valuesBlock = page.getBlock(channels.get(0)); - FloatVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + FloatBlock vBlock = page.getBlock(channels.get(0)); + FloatVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -87,17 +87,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -106,34 +106,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + ValuesFloatAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + ValuesFloatAggregator.combine(state, groupId, vValue); } } } @@ -155,39 +162,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesFloatAggregator.combineIntermediate(state, groupId, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + ValuesFloatAggregator.combineIntermediate(state, groupId, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + ValuesFloatAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + ValuesFloatAggregator.combine(state, groupId, vValue); } } } @@ -209,29 +224,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesFloatAggregator.combineIntermediate(state, groupId, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + ValuesFloatAggregator.combineIntermediate(state, groupId, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntVector groups, FloatBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesFloatAggregator.combine(state, groupId, values.getFloat(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + float vValue = vBlock.getFloat(vOffset); + ValuesFloatAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntVector groups, FloatVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - ValuesFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + float vValue = vVector.getFloat(valuesPosition); + ValuesFloatAggregator.combine(state, groupId, vValue); } } @@ -246,7 +266,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page FloatBlock values = (FloatBlock) valuesUncast; for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - ValuesFloatAggregator.combineIntermediate(state, groupId, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + ValuesFloatAggregator.combineIntermediate(state, groupId, values, valuesPosition); } } 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 21094f2c4f039..40b2d0c3facbe 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 @@ -84,18 +84,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(IntVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - int vValue = vVector.getInt(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + int vValue = vVector.getInt(valuesPosition); ValuesIntAggregator.combine(state, vValue); } } private void addRawVector(IntVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - int vValue = vVector.getInt(i); + int vValue = vVector.getInt(valuesPosition); ValuesIntAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesIntGroupingAggregatorFunction.java index dcb05cfe37635..beb87dd6e4ff5 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesIntGroupingAggregatorFunction.java @@ -56,26 +56,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - IntBlock valuesBlock = page.getBlock(channels.get(0)); - IntVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + IntBlock vBlock = page.getBlock(channels.get(0)); + IntVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -86,17 +86,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -105,34 +105,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesIntAggregator.combine(state, groupId, values.getInt(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + ValuesIntAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int vValue = vVector.getInt(valuesPosition); + ValuesIntAggregator.combine(state, groupId, vValue); } } } @@ -154,39 +161,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesIntAggregator.combineIntermediate(state, groupId, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + ValuesIntAggregator.combineIntermediate(state, groupId, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesIntAggregator.combine(state, groupId, values.getInt(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + ValuesIntAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int vValue = vVector.getInt(valuesPosition); + ValuesIntAggregator.combine(state, groupId, vValue); } } } @@ -208,29 +223,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesIntAggregator.combineIntermediate(state, groupId, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + ValuesIntAggregator.combineIntermediate(state, groupId, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntVector groups, IntBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesIntAggregator.combine(state, groupId, values.getInt(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + int vValue = vBlock.getInt(vOffset); + ValuesIntAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntVector groups, IntVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - ValuesIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + int vValue = vVector.getInt(valuesPosition); + ValuesIntAggregator.combine(state, groupId, vValue); } } @@ -245,7 +265,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page IntBlock values = (IntBlock) valuesUncast; for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - ValuesIntAggregator.combineIntermediate(state, groupId, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + ValuesIntAggregator.combineIntermediate(state, groupId, values, valuesPosition); } } 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 d3c7f3f34be6f..b46e35fc0a9ba 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 @@ -84,18 +84,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(LongVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - long vValue = vVector.getLong(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + long vValue = vVector.getLong(valuesPosition); ValuesLongAggregator.combine(state, vValue); } } private void addRawVector(LongVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - long vValue = vVector.getLong(i); + long vValue = vVector.getLong(valuesPosition); ValuesLongAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesLongGroupingAggregatorFunction.java index 18f706b974101..1e6b1d56110b3 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesLongGroupingAggregatorFunction.java @@ -57,26 +57,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongBlock vBlock = page.getBlock(channels.get(0)); + LongVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -87,17 +87,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -106,34 +106,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesLongAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + ValuesLongAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + ValuesLongAggregator.combine(state, groupId, vValue); } } } @@ -155,39 +162,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesLongAggregator.combineIntermediate(state, groupId, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + ValuesLongAggregator.combineIntermediate(state, groupId, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesLongAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + ValuesLongAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + ValuesLongAggregator.combine(state, groupId, vValue); } } } @@ -209,29 +224,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - ValuesLongAggregator.combineIntermediate(state, groupId, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + ValuesLongAggregator.combineIntermediate(state, groupId, values, valuesPosition); } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesLongAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + ValuesLongAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntVector groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - ValuesLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + ValuesLongAggregator.combine(state, groupId, vValue); } } @@ -246,7 +266,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page LongBlock values = (LongBlock) valuesUncast; for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - ValuesLongAggregator.combineIntermediate(state, groupId, values, groupPosition + positionOffset); + int valuesPosition = groupPosition + positionOffset; + ValuesLongAggregator.combineIntermediate(state, groupId, values, valuesPosition); } } 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 0988ab23faaa0..81c045041165e 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 @@ -92,18 +92,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(LongVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - long vValue = vVector.getLong(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + long vValue = vVector.getLong(valuesPosition); SpatialCentroidCartesianPointDocValuesAggregator.combine(state, vValue); } } private void addRawVector(LongVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - long vValue = vVector.getLong(i); + long vValue = vVector.getLong(valuesPosition); SpatialCentroidCartesianPointDocValuesAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointDocValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointDocValuesGroupingAggregatorFunction.java index 75dc0bbe3ea03..3e7bebbf58d81 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointDocValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointDocValuesGroupingAggregatorFunction.java @@ -67,26 +67,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongBlock encodedBlock = page.getBlock(channels.get(0)); + LongVector encodedVector = encodedBlock.asVector(); + if (encodedVector == null) { + if (encodedBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, encodedBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, encodedBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, encodedBlock); } @Override @@ -97,17 +97,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, encodedVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, encodedVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, encodedVector); } @Override @@ -116,34 +116,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock encodedBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (encodedBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int encodedStart = encodedBlock.getFirstValueIndex(valuesPosition); + int encodedEnd = encodedStart + encodedBlock.getValueCount(valuesPosition); + for (int encodedOffset = encodedStart; encodedOffset < encodedEnd; encodedOffset++) { + long encodedValue = encodedBlock.getLong(encodedOffset); + SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, encodedValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector encodedVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long encodedValue = encodedVector.getLong(valuesPosition); + SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, encodedValue); } } } @@ -186,39 +193,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidCartesianPointDocValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(groupPosition + positionOffset), xDel.getDouble(groupPosition + positionOffset), yVal.getDouble(groupPosition + positionOffset), yDel.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialCentroidCartesianPointDocValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(valuesPosition), xDel.getDouble(valuesPosition), yVal.getDouble(valuesPosition), yDel.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock encodedBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (encodedBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int encodedStart = encodedBlock.getFirstValueIndex(valuesPosition); + int encodedEnd = encodedStart + encodedBlock.getValueCount(valuesPosition); + for (int encodedOffset = encodedStart; encodedOffset < encodedEnd; encodedOffset++) { + long encodedValue = encodedBlock.getLong(encodedOffset); + SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, encodedValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector encodedVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long encodedValue = encodedVector.getLong(valuesPosition); + SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, encodedValue); } } } @@ -261,29 +276,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidCartesianPointDocValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(groupPosition + positionOffset), xDel.getDouble(groupPosition + positionOffset), yVal.getDouble(groupPosition + positionOffset), yDel.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialCentroidCartesianPointDocValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(valuesPosition), xDel.getDouble(valuesPosition), yVal.getDouble(valuesPosition), yDel.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock encodedBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (encodedBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int encodedStart = encodedBlock.getFirstValueIndex(valuesPosition); + int encodedEnd = encodedStart + encodedBlock.getValueCount(valuesPosition); + for (int encodedOffset = encodedStart; encodedOffset < encodedEnd; encodedOffset++) { + long encodedValue = encodedBlock.getLong(encodedOffset); + SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, encodedValue); } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntVector groups, LongVector encodedVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long encodedValue = encodedVector.getLong(valuesPosition); + SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, encodedValue); } } @@ -319,7 +339,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert xVal.getPositionCount() == xDel.getPositionCount() && xVal.getPositionCount() == yVal.getPositionCount() && xVal.getPositionCount() == yDel.getPositionCount() && xVal.getPositionCount() == count.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SpatialCentroidCartesianPointDocValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(groupPosition + positionOffset), xDel.getDouble(groupPosition + positionOffset), yVal.getDouble(groupPosition + positionOffset), yDel.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialCentroidCartesianPointDocValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(valuesPosition), xDel.getDouble(valuesPosition), yVal.getDouble(valuesPosition), yDel.getDouble(valuesPosition), count.getLong(valuesPosition)); } } 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 cf2d54b487e7e..887f16d0f2b75 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 @@ -96,19 +96,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BytesRefVector wkbVector) { BytesRef wkbScratch = new BytesRef(); - for (int i = 0; i < wkbVector.getPositionCount(); i++) { - BytesRef wkbValue = wkbVector.getBytesRef(i, wkbScratch); + for (int valuesPosition = 0; valuesPosition < wkbVector.getPositionCount(); valuesPosition++) { + BytesRef wkbValue = wkbVector.getBytesRef(valuesPosition, wkbScratch); SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, wkbValue); } } private void addRawVector(BytesRefVector wkbVector, BooleanVector mask) { BytesRef wkbScratch = new BytesRef(); - for (int i = 0; i < wkbVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < wkbVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - BytesRef wkbValue = wkbVector.getBytesRef(i, wkbScratch); + BytesRef wkbValue = wkbVector.getBytesRef(valuesPosition, wkbScratch); SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, wkbValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointSourceValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointSourceValuesGroupingAggregatorFunction.java index 48b970dbe574c..b2e4db514acba 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointSourceValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointSourceValuesGroupingAggregatorFunction.java @@ -70,26 +70,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BytesRefBlock valuesBlock = page.getBlock(channels.get(0)); - BytesRefVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BytesRefBlock wkbBlock = page.getBlock(channels.get(0)); + BytesRefVector wkbVector = wkbBlock.asVector(); + if (wkbVector == null) { + if (wkbBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, wkbBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, wkbBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, wkbBlock); } @Override @@ -100,17 +100,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, wkbVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, wkbVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, wkbVector); } @Override @@ -119,36 +119,43 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock wkbBlock) { + BytesRef wkbScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (wkbBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int wkbStart = wkbBlock.getFirstValueIndex(valuesPosition); + int wkbEnd = wkbStart + wkbBlock.getValueCount(valuesPosition); + for (int wkbOffset = wkbStart; wkbOffset < wkbEnd; wkbOffset++) { + BytesRef wkbValue = wkbBlock.getBytesRef(wkbOffset, wkbScratch); + SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, wkbValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector wkbVector) { + BytesRef wkbScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef wkbValue = wkbVector.getBytesRef(valuesPosition, wkbScratch); + SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, wkbValue); } } } @@ -191,41 +198,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidCartesianPointSourceValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(groupPosition + positionOffset), xDel.getDouble(groupPosition + positionOffset), yVal.getDouble(groupPosition + positionOffset), yDel.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialCentroidCartesianPointSourceValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(valuesPosition), xDel.getDouble(valuesPosition), yVal.getDouble(valuesPosition), yDel.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock wkbBlock) { + BytesRef wkbScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (wkbBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int wkbStart = wkbBlock.getFirstValueIndex(valuesPosition); + int wkbEnd = wkbStart + wkbBlock.getValueCount(valuesPosition); + for (int wkbOffset = wkbStart; wkbOffset < wkbEnd; wkbOffset++) { + BytesRef wkbValue = wkbBlock.getBytesRef(wkbOffset, wkbScratch); + SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, wkbValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector wkbVector) { + BytesRef wkbScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef wkbValue = wkbVector.getBytesRef(valuesPosition, wkbScratch); + SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, wkbValue); } } } @@ -268,31 +283,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidCartesianPointSourceValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(groupPosition + positionOffset), xDel.getDouble(groupPosition + positionOffset), yVal.getDouble(groupPosition + positionOffset), yDel.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialCentroidCartesianPointSourceValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(valuesPosition), xDel.getDouble(valuesPosition), yVal.getDouble(valuesPosition), yDel.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock wkbBlock) { + BytesRef wkbScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (wkbBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int wkbStart = wkbBlock.getFirstValueIndex(valuesPosition); + int wkbEnd = wkbStart + wkbBlock.getValueCount(valuesPosition); + for (int wkbOffset = wkbStart; wkbOffset < wkbEnd; wkbOffset++) { + BytesRef wkbValue = wkbBlock.getBytesRef(wkbOffset, wkbScratch); + SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, wkbValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector wkbVector) { + BytesRef wkbScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef wkbValue = wkbVector.getBytesRef(valuesPosition, wkbScratch); + SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, wkbValue); } } @@ -328,7 +348,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert xVal.getPositionCount() == xDel.getPositionCount() && xVal.getPositionCount() == yVal.getPositionCount() && xVal.getPositionCount() == yDel.getPositionCount() && xVal.getPositionCount() == count.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SpatialCentroidCartesianPointSourceValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(groupPosition + positionOffset), xDel.getDouble(groupPosition + positionOffset), yVal.getDouble(groupPosition + positionOffset), yDel.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialCentroidCartesianPointSourceValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(valuesPosition), xDel.getDouble(valuesPosition), yVal.getDouble(valuesPosition), yDel.getDouble(valuesPosition), count.getLong(valuesPosition)); } } 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 d39f286f5386a..cd8817717ff52 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 @@ -92,18 +92,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(LongVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - long vValue = vVector.getLong(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + long vValue = vVector.getLong(valuesPosition); SpatialCentroidGeoPointDocValuesAggregator.combine(state, vValue); } } private void addRawVector(LongVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - long vValue = vVector.getLong(i); + long vValue = vVector.getLong(valuesPosition); SpatialCentroidGeoPointDocValuesAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointDocValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointDocValuesGroupingAggregatorFunction.java index 5c120e539dcae..2c0835fe0a740 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointDocValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointDocValuesGroupingAggregatorFunction.java @@ -67,26 +67,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongBlock encodedBlock = page.getBlock(channels.get(0)); + LongVector encodedVector = encodedBlock.asVector(); + if (encodedVector == null) { + if (encodedBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, encodedBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, encodedBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, encodedBlock); } @Override @@ -97,17 +97,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, encodedVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, encodedVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, encodedVector); } @Override @@ -116,34 +116,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock encodedBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (encodedBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int encodedStart = encodedBlock.getFirstValueIndex(valuesPosition); + int encodedEnd = encodedStart + encodedBlock.getValueCount(valuesPosition); + for (int encodedOffset = encodedStart; encodedOffset < encodedEnd; encodedOffset++) { + long encodedValue = encodedBlock.getLong(encodedOffset); + SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, encodedValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector encodedVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long encodedValue = encodedVector.getLong(valuesPosition); + SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, encodedValue); } } } @@ -186,39 +193,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidGeoPointDocValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(groupPosition + positionOffset), xDel.getDouble(groupPosition + positionOffset), yVal.getDouble(groupPosition + positionOffset), yDel.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialCentroidGeoPointDocValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(valuesPosition), xDel.getDouble(valuesPosition), yVal.getDouble(valuesPosition), yDel.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock encodedBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (encodedBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int encodedStart = encodedBlock.getFirstValueIndex(valuesPosition); + int encodedEnd = encodedStart + encodedBlock.getValueCount(valuesPosition); + for (int encodedOffset = encodedStart; encodedOffset < encodedEnd; encodedOffset++) { + long encodedValue = encodedBlock.getLong(encodedOffset); + SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, encodedValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector encodedVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long encodedValue = encodedVector.getLong(valuesPosition); + SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, encodedValue); } } } @@ -261,29 +276,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidGeoPointDocValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(groupPosition + positionOffset), xDel.getDouble(groupPosition + positionOffset), yVal.getDouble(groupPosition + positionOffset), yDel.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialCentroidGeoPointDocValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(valuesPosition), xDel.getDouble(valuesPosition), yVal.getDouble(valuesPosition), yDel.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock encodedBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (encodedBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int encodedStart = encodedBlock.getFirstValueIndex(valuesPosition); + int encodedEnd = encodedStart + encodedBlock.getValueCount(valuesPosition); + for (int encodedOffset = encodedStart; encodedOffset < encodedEnd; encodedOffset++) { + long encodedValue = encodedBlock.getLong(encodedOffset); + SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, encodedValue); } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntVector groups, LongVector encodedVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long encodedValue = encodedVector.getLong(valuesPosition); + SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, encodedValue); } } @@ -319,7 +339,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert xVal.getPositionCount() == xDel.getPositionCount() && xVal.getPositionCount() == yVal.getPositionCount() && xVal.getPositionCount() == yDel.getPositionCount() && xVal.getPositionCount() == count.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SpatialCentroidGeoPointDocValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(groupPosition + positionOffset), xDel.getDouble(groupPosition + positionOffset), yVal.getDouble(groupPosition + positionOffset), yDel.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialCentroidGeoPointDocValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(valuesPosition), xDel.getDouble(valuesPosition), yVal.getDouble(valuesPosition), yDel.getDouble(valuesPosition), count.getLong(valuesPosition)); } } 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 2550e9e690959..f65f15c73f4a1 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 @@ -96,19 +96,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BytesRefVector wkbVector) { BytesRef wkbScratch = new BytesRef(); - for (int i = 0; i < wkbVector.getPositionCount(); i++) { - BytesRef wkbValue = wkbVector.getBytesRef(i, wkbScratch); + for (int valuesPosition = 0; valuesPosition < wkbVector.getPositionCount(); valuesPosition++) { + BytesRef wkbValue = wkbVector.getBytesRef(valuesPosition, wkbScratch); SpatialCentroidGeoPointSourceValuesAggregator.combine(state, wkbValue); } } private void addRawVector(BytesRefVector wkbVector, BooleanVector mask) { BytesRef wkbScratch = new BytesRef(); - for (int i = 0; i < wkbVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < wkbVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - BytesRef wkbValue = wkbVector.getBytesRef(i, wkbScratch); + BytesRef wkbValue = wkbVector.getBytesRef(valuesPosition, wkbScratch); SpatialCentroidGeoPointSourceValuesAggregator.combine(state, wkbValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointSourceValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointSourceValuesGroupingAggregatorFunction.java index b50f9c36b8f3b..5cc8c1501038a 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointSourceValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointSourceValuesGroupingAggregatorFunction.java @@ -70,26 +70,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BytesRefBlock valuesBlock = page.getBlock(channels.get(0)); - BytesRefVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BytesRefBlock wkbBlock = page.getBlock(channels.get(0)); + BytesRefVector wkbVector = wkbBlock.asVector(); + if (wkbVector == null) { + if (wkbBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, wkbBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, wkbBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, wkbBlock); } @Override @@ -100,17 +100,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, wkbVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, wkbVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, wkbVector); } @Override @@ -119,36 +119,43 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock wkbBlock) { + BytesRef wkbScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (wkbBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int wkbStart = wkbBlock.getFirstValueIndex(valuesPosition); + int wkbEnd = wkbStart + wkbBlock.getValueCount(valuesPosition); + for (int wkbOffset = wkbStart; wkbOffset < wkbEnd; wkbOffset++) { + BytesRef wkbValue = wkbBlock.getBytesRef(wkbOffset, wkbScratch); + SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, wkbValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector wkbVector) { + BytesRef wkbScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef wkbValue = wkbVector.getBytesRef(valuesPosition, wkbScratch); + SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, wkbValue); } } } @@ -191,41 +198,49 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidGeoPointSourceValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(groupPosition + positionOffset), xDel.getDouble(groupPosition + positionOffset), yVal.getDouble(groupPosition + positionOffset), yDel.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialCentroidGeoPointSourceValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(valuesPosition), xDel.getDouble(valuesPosition), yVal.getDouble(valuesPosition), yDel.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock wkbBlock) { + BytesRef wkbScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (wkbBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int wkbStart = wkbBlock.getFirstValueIndex(valuesPosition); + int wkbEnd = wkbStart + wkbBlock.getValueCount(valuesPosition); + for (int wkbOffset = wkbStart; wkbOffset < wkbEnd; wkbOffset++) { + BytesRef wkbValue = wkbBlock.getBytesRef(wkbOffset, wkbScratch); + SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, wkbValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector wkbVector) { + BytesRef wkbScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef wkbValue = wkbVector.getBytesRef(valuesPosition, wkbScratch); + SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, wkbValue); } } } @@ -268,31 +283,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialCentroidGeoPointSourceValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(groupPosition + positionOffset), xDel.getDouble(groupPosition + positionOffset), yVal.getDouble(groupPosition + positionOffset), yDel.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialCentroidGeoPointSourceValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(valuesPosition), xDel.getDouble(valuesPosition), yVal.getDouble(valuesPosition), yDel.getDouble(valuesPosition), count.getLong(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock wkbBlock) { + BytesRef wkbScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (wkbBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int wkbStart = wkbBlock.getFirstValueIndex(valuesPosition); + int wkbEnd = wkbStart + wkbBlock.getValueCount(valuesPosition); + for (int wkbOffset = wkbStart; wkbOffset < wkbEnd; wkbOffset++) { + BytesRef wkbValue = wkbBlock.getBytesRef(wkbOffset, wkbScratch); + SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, wkbValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector wkbVector) { + BytesRef wkbScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef wkbValue = wkbVector.getBytesRef(valuesPosition, wkbScratch); + SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, wkbValue); } } @@ -328,7 +348,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert xVal.getPositionCount() == xDel.getPositionCount() && xVal.getPositionCount() == yVal.getPositionCount() && xVal.getPositionCount() == yDel.getPositionCount() && xVal.getPositionCount() == count.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SpatialCentroidGeoPointSourceValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(groupPosition + positionOffset), xDel.getDouble(groupPosition + positionOffset), yVal.getDouble(groupPosition + positionOffset), yDel.getDouble(groupPosition + positionOffset), count.getLong(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialCentroidGeoPointSourceValuesAggregator.combineIntermediate(state, groupId, xVal.getDouble(valuesPosition), xDel.getDouble(valuesPosition), yVal.getDouble(valuesPosition), yDel.getDouble(valuesPosition), count.getLong(valuesPosition)); } } 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 8eba05ba85d06..f7fb8bd52c913 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 @@ -91,18 +91,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(LongVector vVector) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - long vValue = vVector.getLong(i); + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + long vValue = vVector.getLong(valuesPosition); SpatialExtentCartesianPointDocValuesAggregator.combine(state, vValue); } } private void addRawVector(LongVector vVector, BooleanVector mask) { - for (int i = 0; i < vVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < vVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - long vValue = vVector.getLong(i); + long vValue = vVector.getLong(valuesPosition); SpatialExtentCartesianPointDocValuesAggregator.combine(state, vValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointDocValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointDocValuesGroupingAggregatorFunction.java index c00051755cdf2..a1ec8a11079d7 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointDocValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointDocValuesGroupingAggregatorFunction.java @@ -65,26 +65,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongBlock vBlock = page.getBlock(channels.get(0)); + LongVector vVector = vBlock.asVector(); + if (vVector == null) { + if (vBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, vBlock); } @Override @@ -95,17 +95,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, vVector); } @Override @@ -114,34 +114,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, vValue); } } } @@ -179,39 +186,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentCartesianPointDocValuesAggregator.combineIntermediate(state, groupId, minX.getInt(groupPosition + positionOffset), maxX.getInt(groupPosition + positionOffset), maxY.getInt(groupPosition + positionOffset), minY.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentCartesianPointDocValuesAggregator.combineIntermediate(state, groupId, minX.getInt(valuesPosition), maxX.getInt(valuesPosition), maxY.getInt(valuesPosition), minY.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, vValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, vValue); } } } @@ -249,29 +264,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentCartesianPointDocValuesAggregator.combineIntermediate(state, groupId, minX.getInt(groupPosition + positionOffset), maxX.getInt(groupPosition + positionOffset), maxY.getInt(groupPosition + positionOffset), minY.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentCartesianPointDocValuesAggregator.combineIntermediate(state, groupId, minX.getInt(valuesPosition), maxX.getInt(valuesPosition), maxY.getInt(valuesPosition), minY.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock vBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (vBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int vStart = vBlock.getFirstValueIndex(valuesPosition); + int vEnd = vStart + vBlock.getValueCount(valuesPosition); + for (int vOffset = vStart; vOffset < vEnd; vOffset++) { + long vValue = vBlock.getLong(vOffset); + SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, vValue); } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntVector groups, LongVector vVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long vValue = vVector.getLong(valuesPosition); + SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, vValue); } } @@ -302,7 +322,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert minX.getPositionCount() == maxX.getPositionCount() && minX.getPositionCount() == maxY.getPositionCount() && minX.getPositionCount() == minY.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SpatialExtentCartesianPointDocValuesAggregator.combineIntermediate(state, groupId, minX.getInt(groupPosition + positionOffset), maxX.getInt(groupPosition + positionOffset), maxY.getInt(groupPosition + positionOffset), minY.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentCartesianPointDocValuesAggregator.combineIntermediate(state, groupId, minX.getInt(valuesPosition), maxX.getInt(valuesPosition), maxY.getInt(valuesPosition), minY.getInt(valuesPosition)); } } 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 f3355a9a4bace..d10ef283d7902 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 @@ -93,19 +93,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BytesRefVector bytesVector) { BytesRef bytesScratch = new BytesRef(); - for (int i = 0; i < bytesVector.getPositionCount(); i++) { - BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch); + for (int valuesPosition = 0; valuesPosition < bytesVector.getPositionCount(); valuesPosition++) { + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); SpatialExtentCartesianPointSourceValuesAggregator.combine(state, bytesValue); } } private void addRawVector(BytesRefVector bytesVector, BooleanVector mask) { BytesRef bytesScratch = new BytesRef(); - for (int i = 0; i < bytesVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < bytesVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); SpatialExtentCartesianPointSourceValuesAggregator.combine(state, bytesValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointSourceValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointSourceValuesGroupingAggregatorFunction.java index f52b8ec855117..c68996d317deb 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointSourceValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointSourceValuesGroupingAggregatorFunction.java @@ -66,26 +66,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BytesRefBlock valuesBlock = page.getBlock(channels.get(0)); - BytesRefVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BytesRefBlock bytesBlock = page.getBlock(channels.get(0)); + BytesRefVector bytesVector = bytesBlock.asVector(); + if (bytesVector == null) { + if (bytesBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, bytesBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, bytesBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, bytesBlock); } @Override @@ -96,17 +96,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, bytesVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, bytesVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, bytesVector); } @Override @@ -115,36 +115,43 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock bytesBlock) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (bytesBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int bytesStart = bytesBlock.getFirstValueIndex(valuesPosition); + int bytesEnd = bytesStart + bytesBlock.getValueCount(valuesPosition); + for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) { + BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch); + SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, bytesValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector bytesVector) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); + SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, bytesValue); } } } @@ -182,41 +189,50 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentCartesianPointSourceValuesAggregator.combineIntermediate(state, groupId, minX.getInt(groupPosition + positionOffset), maxX.getInt(groupPosition + positionOffset), maxY.getInt(groupPosition + positionOffset), minY.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentCartesianPointSourceValuesAggregator.combineIntermediate(state, groupId, minX.getInt(valuesPosition), maxX.getInt(valuesPosition), maxY.getInt(valuesPosition), minY.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock bytesBlock) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (bytesBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int bytesStart = bytesBlock.getFirstValueIndex(valuesPosition); + int bytesEnd = bytesStart + bytesBlock.getValueCount(valuesPosition); + for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) { + BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch); + SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, bytesValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, + BytesRefVector bytesVector) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); + SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, bytesValue); } } } @@ -254,31 +270,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentCartesianPointSourceValuesAggregator.combineIntermediate(state, groupId, minX.getInt(groupPosition + positionOffset), maxX.getInt(groupPosition + positionOffset), maxY.getInt(groupPosition + positionOffset), minY.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentCartesianPointSourceValuesAggregator.combineIntermediate(state, groupId, minX.getInt(valuesPosition), maxX.getInt(valuesPosition), maxY.getInt(valuesPosition), minY.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock bytesBlock) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (bytesBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int bytesStart = bytesBlock.getFirstValueIndex(valuesPosition); + int bytesEnd = bytesStart + bytesBlock.getValueCount(valuesPosition); + for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) { + BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch); + SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, bytesValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector bytesVector) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); + SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, bytesValue); } } @@ -309,7 +330,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert minX.getPositionCount() == maxX.getPositionCount() && minX.getPositionCount() == maxY.getPositionCount() && minX.getPositionCount() == minY.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SpatialExtentCartesianPointSourceValuesAggregator.combineIntermediate(state, groupId, minX.getInt(groupPosition + positionOffset), maxX.getInt(groupPosition + positionOffset), maxY.getInt(groupPosition + positionOffset), minY.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentCartesianPointSourceValuesAggregator.combineIntermediate(state, groupId, minX.getInt(valuesPosition), maxX.getInt(valuesPosition), maxY.getInt(valuesPosition), minY.getInt(valuesPosition)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeDocValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeDocValuesGroupingAggregatorFunction.java index 6bca1ac2b3437..8607ff009fc1d 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeDocValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeDocValuesGroupingAggregatorFunction.java @@ -112,27 +112,31 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock valuesBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valuesBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); + int valuesStart = valuesBlock.getFirstValueIndex(valuesPosition); + int valuesEnd = valuesStart + valuesBlock.getValueCount(valuesPosition); int[] valuesArray = new int[valuesEnd - valuesStart]; for (int v = valuesStart; v < valuesEnd; v++) { - valuesArray[v-valuesStart] = values.getInt(v); + valuesArray[v-valuesStart] = valuesBlock.getInt(v); } SpatialExtentCartesianShapeDocValuesAggregator.combine(state, groupId, valuesArray); } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector valuesVector) { // This type does not support vectors because all values are multi-valued } @@ -169,32 +173,37 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentCartesianShapeDocValuesAggregator.combineIntermediate(state, groupId, minX.getInt(groupPosition + positionOffset), maxX.getInt(groupPosition + positionOffset), maxY.getInt(groupPosition + positionOffset), minY.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentCartesianShapeDocValuesAggregator.combineIntermediate(state, groupId, minX.getInt(valuesPosition), maxX.getInt(valuesPosition), maxY.getInt(valuesPosition), minY.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock valuesBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valuesBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); + int valuesStart = valuesBlock.getFirstValueIndex(valuesPosition); + int valuesEnd = valuesStart + valuesBlock.getValueCount(valuesPosition); int[] valuesArray = new int[valuesEnd - valuesStart]; for (int v = valuesStart; v < valuesEnd; v++) { - valuesArray[v-valuesStart] = values.getInt(v); + valuesArray[v-valuesStart] = valuesBlock.getInt(v); } SpatialExtentCartesianShapeDocValuesAggregator.combine(state, groupId, valuesArray); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector valuesVector) { // This type does not support vectors because all values are multi-valued } @@ -231,28 +240,30 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentCartesianShapeDocValuesAggregator.combineIntermediate(state, groupId, minX.getInt(groupPosition + positionOffset), maxX.getInt(groupPosition + positionOffset), maxY.getInt(groupPosition + positionOffset), minY.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentCartesianShapeDocValuesAggregator.combineIntermediate(state, groupId, minX.getInt(valuesPosition), maxX.getInt(valuesPosition), maxY.getInt(valuesPosition), minY.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntVector groups, IntBlock valuesBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valuesBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); + int valuesStart = valuesBlock.getFirstValueIndex(valuesPosition); + int valuesEnd = valuesStart + valuesBlock.getValueCount(valuesPosition); int[] valuesArray = new int[valuesEnd - valuesStart]; for (int v = valuesStart; v < valuesEnd; v++) { - valuesArray[v-valuesStart] = values.getInt(v); + valuesArray[v-valuesStart] = valuesBlock.getInt(v); } SpatialExtentCartesianShapeDocValuesAggregator.combine(state, groupId, valuesArray); } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntVector groups, IntVector valuesVector) { // This type does not support vectors because all values are multi-valued } @@ -283,7 +294,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert minX.getPositionCount() == maxX.getPositionCount() && minX.getPositionCount() == maxY.getPositionCount() && minX.getPositionCount() == minY.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SpatialExtentCartesianShapeDocValuesAggregator.combineIntermediate(state, groupId, minX.getInt(groupPosition + positionOffset), maxX.getInt(groupPosition + positionOffset), maxY.getInt(groupPosition + positionOffset), minY.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentCartesianShapeDocValuesAggregator.combineIntermediate(state, groupId, minX.getInt(valuesPosition), maxX.getInt(valuesPosition), maxY.getInt(valuesPosition), minY.getInt(valuesPosition)); } } 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 620317539c77c..659793042bd12 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 @@ -93,19 +93,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BytesRefVector bytesVector) { BytesRef bytesScratch = new BytesRef(); - for (int i = 0; i < bytesVector.getPositionCount(); i++) { - BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch); + for (int valuesPosition = 0; valuesPosition < bytesVector.getPositionCount(); valuesPosition++) { + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, bytesValue); } } private void addRawVector(BytesRefVector bytesVector, BooleanVector mask) { BytesRef bytesScratch = new BytesRef(); - for (int i = 0; i < bytesVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < bytesVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, bytesValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeSourceValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeSourceValuesGroupingAggregatorFunction.java index 7d633c3e90850..ae017576d641d 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeSourceValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeSourceValuesGroupingAggregatorFunction.java @@ -66,26 +66,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BytesRefBlock valuesBlock = page.getBlock(channels.get(0)); - BytesRefVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BytesRefBlock bytesBlock = page.getBlock(channels.get(0)); + BytesRefVector bytesVector = bytesBlock.asVector(); + if (bytesVector == null) { + if (bytesBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, bytesBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, bytesBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, bytesBlock); } @Override @@ -96,17 +96,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, bytesVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, bytesVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, bytesVector); } @Override @@ -115,36 +115,43 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock bytesBlock) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (bytesBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int bytesStart = bytesBlock.getFirstValueIndex(valuesPosition); + int bytesEnd = bytesStart + bytesBlock.getValueCount(valuesPosition); + for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) { + BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch); + SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, bytesValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector bytesVector) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); + SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, bytesValue); } } } @@ -182,41 +189,50 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentCartesianShapeSourceValuesAggregator.combineIntermediate(state, groupId, minX.getInt(groupPosition + positionOffset), maxX.getInt(groupPosition + positionOffset), maxY.getInt(groupPosition + positionOffset), minY.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentCartesianShapeSourceValuesAggregator.combineIntermediate(state, groupId, minX.getInt(valuesPosition), maxX.getInt(valuesPosition), maxY.getInt(valuesPosition), minY.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock bytesBlock) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (bytesBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int bytesStart = bytesBlock.getFirstValueIndex(valuesPosition); + int bytesEnd = bytesStart + bytesBlock.getValueCount(valuesPosition); + for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) { + BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch); + SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, bytesValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, + BytesRefVector bytesVector) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); + SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, bytesValue); } } } @@ -254,31 +270,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentCartesianShapeSourceValuesAggregator.combineIntermediate(state, groupId, minX.getInt(groupPosition + positionOffset), maxX.getInt(groupPosition + positionOffset), maxY.getInt(groupPosition + positionOffset), minY.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentCartesianShapeSourceValuesAggregator.combineIntermediate(state, groupId, minX.getInt(valuesPosition), maxX.getInt(valuesPosition), maxY.getInt(valuesPosition), minY.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock bytesBlock) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (bytesBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int bytesStart = bytesBlock.getFirstValueIndex(valuesPosition); + int bytesEnd = bytesStart + bytesBlock.getValueCount(valuesPosition); + for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) { + BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch); + SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, bytesValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector bytesVector) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); + SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, bytesValue); } } @@ -309,7 +330,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert minX.getPositionCount() == maxX.getPositionCount() && minX.getPositionCount() == maxY.getPositionCount() && minX.getPositionCount() == minY.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SpatialExtentCartesianShapeSourceValuesAggregator.combineIntermediate(state, groupId, minX.getInt(groupPosition + positionOffset), maxX.getInt(groupPosition + positionOffset), maxY.getInt(groupPosition + positionOffset), minY.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentCartesianShapeSourceValuesAggregator.combineIntermediate(state, groupId, minX.getInt(valuesPosition), maxX.getInt(valuesPosition), maxY.getInt(valuesPosition), minY.getInt(valuesPosition)); } } 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 4ab150c3325f0..e0bfd3f670bcf 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 @@ -93,18 +93,18 @@ private void addRawInputNotMasked(Page page) { } private void addRawVector(LongVector encodedVector) { - for (int i = 0; i < encodedVector.getPositionCount(); i++) { - long encodedValue = encodedVector.getLong(i); + for (int valuesPosition = 0; valuesPosition < encodedVector.getPositionCount(); valuesPosition++) { + long encodedValue = encodedVector.getLong(valuesPosition); SpatialExtentGeoPointDocValuesAggregator.combine(state, encodedValue); } } private void addRawVector(LongVector encodedVector, BooleanVector mask) { - for (int i = 0; i < encodedVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < encodedVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - long encodedValue = encodedVector.getLong(i); + long encodedValue = encodedVector.getLong(valuesPosition); SpatialExtentGeoPointDocValuesAggregator.combine(state, encodedValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointDocValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointDocValuesGroupingAggregatorFunction.java index d8421eac6d9c2..aa386bf3f2bdb 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointDocValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointDocValuesGroupingAggregatorFunction.java @@ -67,26 +67,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - LongBlock valuesBlock = page.getBlock(channels.get(0)); - LongVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + LongBlock encodedBlock = page.getBlock(channels.get(0)); + LongVector encodedVector = encodedBlock.asVector(); + if (encodedVector == null) { + if (encodedBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, encodedBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, encodedBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, encodedBlock); } @Override @@ -97,17 +97,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, encodedVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, encodedVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, encodedVector); } @Override @@ -116,34 +116,41 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock encodedBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (encodedBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int encodedStart = encodedBlock.getFirstValueIndex(valuesPosition); + int encodedEnd = encodedStart + encodedBlock.getValueCount(valuesPosition); + for (int encodedOffset = encodedStart; encodedOffset < encodedEnd; encodedOffset++) { + long encodedValue = encodedBlock.getLong(encodedOffset); + SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, encodedValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector encodedVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long encodedValue = encodedVector.getLong(valuesPosition); + SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, encodedValue); } } } @@ -191,39 +198,47 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentGeoPointDocValuesAggregator.combineIntermediate(state, groupId, top.getInt(groupPosition + positionOffset), bottom.getInt(groupPosition + positionOffset), negLeft.getInt(groupPosition + positionOffset), negRight.getInt(groupPosition + positionOffset), posLeft.getInt(groupPosition + positionOffset), posRight.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentGeoPointDocValuesAggregator.combineIntermediate(state, groupId, top.getInt(valuesPosition), bottom.getInt(valuesPosition), negLeft.getInt(valuesPosition), negRight.getInt(valuesPosition), posLeft.getInt(valuesPosition), posRight.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock encodedBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (encodedBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int encodedStart = encodedBlock.getFirstValueIndex(valuesPosition); + int encodedEnd = encodedStart + encodedBlock.getValueCount(valuesPosition); + for (int encodedOffset = encodedStart; encodedOffset < encodedEnd; encodedOffset++) { + long encodedValue = encodedBlock.getLong(encodedOffset); + SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, encodedValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector encodedVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long encodedValue = encodedVector.getLong(valuesPosition); + SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, encodedValue); } } } @@ -271,29 +286,34 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentGeoPointDocValuesAggregator.combineIntermediate(state, groupId, top.getInt(groupPosition + positionOffset), bottom.getInt(groupPosition + positionOffset), negLeft.getInt(groupPosition + positionOffset), negRight.getInt(groupPosition + positionOffset), posLeft.getInt(groupPosition + positionOffset), posRight.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentGeoPointDocValuesAggregator.combineIntermediate(state, groupId, top.getInt(valuesPosition), bottom.getInt(valuesPosition), negLeft.getInt(valuesPosition), negRight.getInt(valuesPosition), posLeft.getInt(valuesPosition), posRight.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntVector groups, LongBlock encodedBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (encodedBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int encodedStart = encodedBlock.getFirstValueIndex(valuesPosition); + int encodedEnd = encodedStart + encodedBlock.getValueCount(valuesPosition); + for (int encodedOffset = encodedStart; encodedOffset < encodedEnd; encodedOffset++) { + long encodedValue = encodedBlock.getLong(encodedOffset); + SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, encodedValue); } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntVector groups, LongVector encodedVector) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + long encodedValue = encodedVector.getLong(valuesPosition); + SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, encodedValue); } } @@ -334,7 +354,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert top.getPositionCount() == bottom.getPositionCount() && top.getPositionCount() == negLeft.getPositionCount() && top.getPositionCount() == negRight.getPositionCount() && top.getPositionCount() == posLeft.getPositionCount() && top.getPositionCount() == posRight.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SpatialExtentGeoPointDocValuesAggregator.combineIntermediate(state, groupId, top.getInt(groupPosition + positionOffset), bottom.getInt(groupPosition + positionOffset), negLeft.getInt(groupPosition + positionOffset), negRight.getInt(groupPosition + positionOffset), posLeft.getInt(groupPosition + positionOffset), posRight.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentGeoPointDocValuesAggregator.combineIntermediate(state, groupId, top.getInt(valuesPosition), bottom.getInt(valuesPosition), negLeft.getInt(valuesPosition), negRight.getInt(valuesPosition), posLeft.getInt(valuesPosition), posRight.getInt(valuesPosition)); } } 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 40e9374291903..25dddefe5d429 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 @@ -95,19 +95,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BytesRefVector bytesVector) { BytesRef bytesScratch = new BytesRef(); - for (int i = 0; i < bytesVector.getPositionCount(); i++) { - BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch); + for (int valuesPosition = 0; valuesPosition < bytesVector.getPositionCount(); valuesPosition++) { + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); SpatialExtentGeoPointSourceValuesAggregator.combine(state, bytesValue); } } private void addRawVector(BytesRefVector bytesVector, BooleanVector mask) { BytesRef bytesScratch = new BytesRef(); - for (int i = 0; i < bytesVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < bytesVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); SpatialExtentGeoPointSourceValuesAggregator.combine(state, bytesValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointSourceValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointSourceValuesGroupingAggregatorFunction.java index d65282b81fda9..057aae8e5af88 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointSourceValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointSourceValuesGroupingAggregatorFunction.java @@ -68,26 +68,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BytesRefBlock valuesBlock = page.getBlock(channels.get(0)); - BytesRefVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BytesRefBlock bytesBlock = page.getBlock(channels.get(0)); + BytesRefVector bytesVector = bytesBlock.asVector(); + if (bytesVector == null) { + if (bytesBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, bytesBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, bytesBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, bytesBlock); } @Override @@ -98,17 +98,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, bytesVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, bytesVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, bytesVector); } @Override @@ -117,36 +117,43 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock bytesBlock) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (bytesBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int bytesStart = bytesBlock.getFirstValueIndex(valuesPosition); + int bytesEnd = bytesStart + bytesBlock.getValueCount(valuesPosition); + for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) { + BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch); + SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, bytesValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector bytesVector) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); + SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, bytesValue); } } } @@ -194,41 +201,50 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentGeoPointSourceValuesAggregator.combineIntermediate(state, groupId, top.getInt(groupPosition + positionOffset), bottom.getInt(groupPosition + positionOffset), negLeft.getInt(groupPosition + positionOffset), negRight.getInt(groupPosition + positionOffset), posLeft.getInt(groupPosition + positionOffset), posRight.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentGeoPointSourceValuesAggregator.combineIntermediate(state, groupId, top.getInt(valuesPosition), bottom.getInt(valuesPosition), negLeft.getInt(valuesPosition), negRight.getInt(valuesPosition), posLeft.getInt(valuesPosition), posRight.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock bytesBlock) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (bytesBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int bytesStart = bytesBlock.getFirstValueIndex(valuesPosition); + int bytesEnd = bytesStart + bytesBlock.getValueCount(valuesPosition); + for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) { + BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch); + SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, bytesValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, + BytesRefVector bytesVector) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); + SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, bytesValue); } } } @@ -276,31 +292,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentGeoPointSourceValuesAggregator.combineIntermediate(state, groupId, top.getInt(groupPosition + positionOffset), bottom.getInt(groupPosition + positionOffset), negLeft.getInt(groupPosition + positionOffset), negRight.getInt(groupPosition + positionOffset), posLeft.getInt(groupPosition + positionOffset), posRight.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentGeoPointSourceValuesAggregator.combineIntermediate(state, groupId, top.getInt(valuesPosition), bottom.getInt(valuesPosition), negLeft.getInt(valuesPosition), negRight.getInt(valuesPosition), posLeft.getInt(valuesPosition), posRight.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock bytesBlock) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (bytesBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int bytesStart = bytesBlock.getFirstValueIndex(valuesPosition); + int bytesEnd = bytesStart + bytesBlock.getValueCount(valuesPosition); + for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) { + BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch); + SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, bytesValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector bytesVector) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); + SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, bytesValue); } } @@ -341,7 +362,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert top.getPositionCount() == bottom.getPositionCount() && top.getPositionCount() == negLeft.getPositionCount() && top.getPositionCount() == negRight.getPositionCount() && top.getPositionCount() == posLeft.getPositionCount() && top.getPositionCount() == posRight.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SpatialExtentGeoPointSourceValuesAggregator.combineIntermediate(state, groupId, top.getInt(groupPosition + positionOffset), bottom.getInt(groupPosition + positionOffset), negLeft.getInt(groupPosition + positionOffset), negRight.getInt(groupPosition + positionOffset), posLeft.getInt(groupPosition + positionOffset), posRight.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentGeoPointSourceValuesAggregator.combineIntermediate(state, groupId, top.getInt(valuesPosition), bottom.getInt(valuesPosition), negLeft.getInt(valuesPosition), negRight.getInt(valuesPosition), posLeft.getInt(valuesPosition), posRight.getInt(valuesPosition)); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeDocValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeDocValuesGroupingAggregatorFunction.java index a532b40479ecf..c118e9315b6ff 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeDocValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeDocValuesGroupingAggregatorFunction.java @@ -114,27 +114,31 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock valuesBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valuesBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); + int valuesStart = valuesBlock.getFirstValueIndex(valuesPosition); + int valuesEnd = valuesStart + valuesBlock.getValueCount(valuesPosition); int[] valuesArray = new int[valuesEnd - valuesStart]; for (int v = valuesStart; v < valuesEnd; v++) { - valuesArray[v-valuesStart] = values.getInt(v); + valuesArray[v-valuesStart] = valuesBlock.getInt(v); } SpatialExtentGeoShapeDocValuesAggregator.combine(state, groupId, valuesArray); } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector valuesVector) { // This type does not support vectors because all values are multi-valued } @@ -181,32 +185,37 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentGeoShapeDocValuesAggregator.combineIntermediate(state, groupId, top.getInt(groupPosition + positionOffset), bottom.getInt(groupPosition + positionOffset), negLeft.getInt(groupPosition + positionOffset), negRight.getInt(groupPosition + positionOffset), posLeft.getInt(groupPosition + positionOffset), posRight.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentGeoShapeDocValuesAggregator.combineIntermediate(state, groupId, top.getInt(valuesPosition), bottom.getInt(valuesPosition), negLeft.getInt(valuesPosition), negRight.getInt(valuesPosition), posLeft.getInt(valuesPosition), posRight.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock valuesBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (valuesBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); + int valuesStart = valuesBlock.getFirstValueIndex(valuesPosition); + int valuesEnd = valuesStart + valuesBlock.getValueCount(valuesPosition); int[] valuesArray = new int[valuesEnd - valuesStart]; for (int v = valuesStart; v < valuesEnd; v++) { - valuesArray[v-valuesStart] = values.getInt(v); + valuesArray[v-valuesStart] = valuesBlock.getInt(v); } SpatialExtentGeoShapeDocValuesAggregator.combine(state, groupId, valuesArray); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector valuesVector) { // This type does not support vectors because all values are multi-valued } @@ -253,28 +262,30 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentGeoShapeDocValuesAggregator.combineIntermediate(state, groupId, top.getInt(groupPosition + positionOffset), bottom.getInt(groupPosition + positionOffset), negLeft.getInt(groupPosition + positionOffset), negRight.getInt(groupPosition + positionOffset), posLeft.getInt(groupPosition + positionOffset), posRight.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentGeoShapeDocValuesAggregator.combineIntermediate(state, groupId, top.getInt(valuesPosition), bottom.getInt(valuesPosition), negLeft.getInt(valuesPosition), negRight.getInt(valuesPosition), posLeft.getInt(valuesPosition), posRight.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntVector groups, IntBlock valuesBlock) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (valuesBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); + int valuesStart = valuesBlock.getFirstValueIndex(valuesPosition); + int valuesEnd = valuesStart + valuesBlock.getValueCount(valuesPosition); int[] valuesArray = new int[valuesEnd - valuesStart]; for (int v = valuesStart; v < valuesEnd; v++) { - valuesArray[v-valuesStart] = values.getInt(v); + valuesArray[v-valuesStart] = valuesBlock.getInt(v); } SpatialExtentGeoShapeDocValuesAggregator.combine(state, groupId, valuesArray); } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntVector groups, IntVector valuesVector) { // This type does not support vectors because all values are multi-valued } @@ -315,7 +326,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert top.getPositionCount() == bottom.getPositionCount() && top.getPositionCount() == negLeft.getPositionCount() && top.getPositionCount() == negRight.getPositionCount() && top.getPositionCount() == posLeft.getPositionCount() && top.getPositionCount() == posRight.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SpatialExtentGeoShapeDocValuesAggregator.combineIntermediate(state, groupId, top.getInt(groupPosition + positionOffset), bottom.getInt(groupPosition + positionOffset), negLeft.getInt(groupPosition + positionOffset), negRight.getInt(groupPosition + positionOffset), posLeft.getInt(groupPosition + positionOffset), posRight.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentGeoShapeDocValuesAggregator.combineIntermediate(state, groupId, top.getInt(valuesPosition), bottom.getInt(valuesPosition), negLeft.getInt(valuesPosition), negRight.getInt(valuesPosition), posLeft.getInt(valuesPosition), posRight.getInt(valuesPosition)); } } 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 1be574713e12e..22e0eb4f9c195 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 @@ -95,19 +95,19 @@ private void addRawInputNotMasked(Page page) { private void addRawVector(BytesRefVector bytesVector) { BytesRef bytesScratch = new BytesRef(); - for (int i = 0; i < bytesVector.getPositionCount(); i++) { - BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch); + for (int valuesPosition = 0; valuesPosition < bytesVector.getPositionCount(); valuesPosition++) { + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); SpatialExtentGeoShapeSourceValuesAggregator.combine(state, bytesValue); } } private void addRawVector(BytesRefVector bytesVector, BooleanVector mask) { BytesRef bytesScratch = new BytesRef(); - for (int i = 0; i < bytesVector.getPositionCount(); i++) { - if (mask.getBoolean(i) == false) { + for (int valuesPosition = 0; valuesPosition < bytesVector.getPositionCount(); valuesPosition++) { + if (mask.getBoolean(valuesPosition) == false) { continue; } - BytesRef bytesValue = bytesVector.getBytesRef(i, bytesScratch); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); SpatialExtentGeoShapeSourceValuesAggregator.combine(state, bytesValue); } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeSourceValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeSourceValuesGroupingAggregatorFunction.java index 57fca5af50059..37024a3df6cd4 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeSourceValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeSourceValuesGroupingAggregatorFunction.java @@ -68,26 +68,26 @@ public int intermediateBlockCount() { @Override public GroupingAggregatorFunction.AddInput prepareProcessRawInputPage(SeenGroupIds seenGroupIds, Page page) { - BytesRefBlock valuesBlock = page.getBlock(channels.get(0)); - BytesRefVector valuesVector = valuesBlock.asVector(); - if (valuesVector == null) { - if (valuesBlock.mayHaveNulls()) { + BytesRefBlock bytesBlock = page.getBlock(channels.get(0)); + BytesRefVector bytesVector = bytesBlock.asVector(); + if (bytesVector == null) { + if (bytesBlock.mayHaveNulls()) { state.enableGroupIdTracking(seenGroupIds); } return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, bytesBlock); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, bytesBlock); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesBlock); + addRawInput(positionOffset, groupIds, bytesBlock); } @Override @@ -98,17 +98,17 @@ public void close() { return new GroupingAggregatorFunction.AddInput() { @Override public void add(int positionOffset, IntArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, bytesVector); } @Override public void add(int positionOffset, IntBigArrayBlock groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, bytesVector); } @Override public void add(int positionOffset, IntVector groupIds) { - addRawInput(positionOffset, groupIds, valuesVector); + addRawInput(positionOffset, groupIds, bytesVector); } @Override @@ -117,36 +117,43 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock bytesBlock) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (bytesBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int bytesStart = bytesBlock.getFirstValueIndex(valuesPosition); + int bytesEnd = bytesStart + bytesBlock.getValueCount(valuesPosition); + for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) { + BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch); + SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, bytesValue); } } } } - private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector bytesVector) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); + SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, bytesValue); } } } @@ -194,41 +201,50 @@ public void addIntermediateInput(int positionOffset, IntArrayBlock groups, Page int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentGeoShapeSourceValuesAggregator.combineIntermediate(state, groupId, top.getInt(groupPosition + positionOffset), bottom.getInt(groupPosition + positionOffset), negLeft.getInt(groupPosition + positionOffset), negRight.getInt(groupPosition + positionOffset), posLeft.getInt(groupPosition + positionOffset), posRight.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentGeoShapeSourceValuesAggregator.combineIntermediate(state, groupId, top.getInt(valuesPosition), bottom.getInt(valuesPosition), negLeft.getInt(valuesPosition), negRight.getInt(valuesPosition), posLeft.getInt(valuesPosition), posRight.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock bytesBlock) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (groups.isNull(groupPosition) || values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { + continue; + } + int valuesPosition = groupPosition + positionOffset; + if (bytesBlock.isNull(valuesPosition)) { continue; } int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int bytesStart = bytesBlock.getFirstValueIndex(valuesPosition); + int bytesEnd = bytesStart + bytesBlock.getValueCount(valuesPosition); + for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) { + BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch); + SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, bytesValue); } } } } - private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntBigArrayBlock groups, + BytesRefVector bytesVector) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; } + int valuesPosition = groupPosition + positionOffset; int groupStart = groups.getFirstValueIndex(groupPosition); int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); + SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, bytesValue); } } } @@ -276,31 +292,36 @@ public void addIntermediateInput(int positionOffset, IntBigArrayBlock groups, Pa int groupEnd = groupStart + groups.getValueCount(groupPosition); for (int g = groupStart; g < groupEnd; g++) { int groupId = groups.getInt(g); - SpatialExtentGeoShapeSourceValuesAggregator.combineIntermediate(state, groupId, top.getInt(groupPosition + positionOffset), bottom.getInt(groupPosition + positionOffset), negLeft.getInt(groupPosition + positionOffset), negRight.getInt(groupPosition + positionOffset), posLeft.getInt(groupPosition + positionOffset), posRight.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentGeoShapeSourceValuesAggregator.combineIntermediate(state, groupId, top.getInt(valuesPosition), bottom.getInt(valuesPosition), negLeft.getInt(valuesPosition), negRight.getInt(valuesPosition), posLeft.getInt(valuesPosition), posRight.getInt(valuesPosition)); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock bytesBlock) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - if (values.isNull(groupPosition + positionOffset)) { + int valuesPosition = groupPosition + positionOffset; + if (bytesBlock.isNull(valuesPosition)) { continue; } int groupId = groups.getInt(groupPosition); - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int bytesStart = bytesBlock.getFirstValueIndex(valuesPosition); + int bytesEnd = bytesStart + bytesBlock.getValueCount(valuesPosition); + for (int bytesOffset = bytesStart; bytesOffset < bytesEnd; bytesOffset++) { + BytesRef bytesValue = bytesBlock.getBytesRef(bytesOffset, bytesScratch); + SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, bytesValue); } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { - BytesRef scratch = new BytesRef(); + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector bytesVector) { + BytesRef bytesScratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int valuesPosition = groupPosition + positionOffset; int groupId = groups.getInt(groupPosition); - SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + BytesRef bytesValue = bytesVector.getBytesRef(valuesPosition, bytesScratch); + SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, bytesValue); } } @@ -341,7 +362,8 @@ public void addIntermediateInput(int positionOffset, IntVector groups, Page page assert top.getPositionCount() == bottom.getPositionCount() && top.getPositionCount() == negLeft.getPositionCount() && top.getPositionCount() == negRight.getPositionCount() && top.getPositionCount() == posLeft.getPositionCount() && top.getPositionCount() == posRight.getPositionCount(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { int groupId = groups.getInt(groupPosition); - SpatialExtentGeoShapeSourceValuesAggregator.combineIntermediate(state, groupId, top.getInt(groupPosition + positionOffset), bottom.getInt(groupPosition + positionOffset), negLeft.getInt(groupPosition + positionOffset), negRight.getInt(groupPosition + positionOffset), posLeft.getInt(groupPosition + positionOffset), posRight.getInt(groupPosition + positionOffset)); + int valuesPosition = groupPosition + positionOffset; + SpatialExtentGeoShapeSourceValuesAggregator.combineIntermediate(state, groupId, top.getInt(valuesPosition), bottom.getInt(valuesPosition), negLeft.getInt(valuesPosition), negRight.getInt(valuesPosition), posLeft.getInt(valuesPosition), posRight.getInt(valuesPosition)); } } diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/X-RateAggregator.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/X-RateAggregator.java.st index 2f1b6f444f450..3059ec96f2f7b 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/X-RateAggregator.java.st +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/X-RateAggregator.java.st @@ -45,7 +45,7 @@ public class Rate$Type$Aggregator { return new $Type$RateGroupingState(driverContext.bigArrays(), driverContext.breaker()); } - public static void combine($Type$RateGroupingState current, int groupId, long timestamp, $type$ value) { + public static void combine($Type$RateGroupingState current, int groupId, $type$ value, long timestamp) { current.append(groupId, timestamp, value); } diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/X-ValueOverTimeAggregator.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/X-ValueOverTimeAggregator.java.st index d52ae67471dae..1935ae5948325 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/X-ValueOverTimeAggregator.java.st +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/X-ValueOverTimeAggregator.java.st @@ -11,9 +11,11 @@ package org.elasticsearch.compute.aggregation; import org.elasticsearch.common.util.BigArrays; import org.elasticsearch.common.util.$Type$Array; import org.elasticsearch.common.util.LongArray; +import org.elasticsearch.compute.ann.Aggregator; import org.elasticsearch.compute.ann.GroupingAggregator; import org.elasticsearch.compute.ann.IntermediateState; import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.$Type$Block; import org.elasticsearch.compute.data.IntVector; import org.elasticsearch.compute.data.LongBlock; @@ -26,17 +28,16 @@ import org.elasticsearch.core.Releasables; * This class is generated. Edit `X-ValueOverTimeAggregator.java.st` instead. */ @GroupingAggregator( - value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "$TYPE$_BLOCK") } + { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "$TYPE$_BLOCK") } ) public class $Occurrence$OverTime$Type$Aggregator { - public static GroupingState initGrouping(DriverContext driverContext) { return new GroupingState(driverContext.bigArrays()); } // TODO: Since data in data_streams is sorted by `_tsid` and timestamp in descending order, // we can read the first encountered value for each group of `_tsid` and time bucket. - public static void combine(GroupingState current, int groupId, long timestamp, $type$ value) { + public static void combine(GroupingState current, int groupId, $type$ value, long timestamp) { current.collectValue(groupId, timestamp, value); } @@ -47,6 +48,7 @@ public class $Occurrence$OverTime$Type$Aggregator { $Type$Block values, int otherPosition ) { + // TODO seen should probably be part of the intermediate representation int valueCount = values.getValueCount(otherPosition); if (valueCount > 0) { long timestamp = timestamps.getLong(timestamps.getFirstValueIndex(otherPosition));