diff --git a/docs/changelog/119458.yaml b/docs/changelog/119458.yaml new file mode 100644 index 0000000000000..bf2ba0a14e21a --- /dev/null +++ b/docs/changelog/119458.yaml @@ -0,0 +1,5 @@ +pr: 119458 +summary: ES|QL change point +area: Machine Learning +type: feature +issues: [] diff --git a/x-pack/plugin/esql/compute/ann/src/main/java/org/elasticsearch/compute/ann/Aggregator.java b/x-pack/plugin/esql/compute/ann/src/main/java/org/elasticsearch/compute/ann/Aggregator.java index 444dbcc1b9e58..586f839d54b64 100644 --- a/x-pack/plugin/esql/compute/ann/src/main/java/org/elasticsearch/compute/ann/Aggregator.java +++ b/x-pack/plugin/esql/compute/ann/src/main/java/org/elasticsearch/compute/ann/Aggregator.java @@ -63,4 +63,8 @@ */ Class[] warnExceptions() default {}; + /** + * If {@code true} then the @timestamp LongVector will be appended to the input blocks of the aggregation function. + */ + boolean includeTimestamps() default false; } diff --git a/x-pack/plugin/esql/compute/build.gradle b/x-pack/plugin/esql/compute/build.gradle index 8e866cec3f421..b91264f0a3a07 100644 --- a/x-pack/plugin/esql/compute/build.gradle +++ b/x-pack/plugin/esql/compute/build.gradle @@ -669,6 +669,28 @@ tasks.named('stringTemplates').configure { it.outputFile = "org/elasticsearch/compute/aggregation/TopIpAggregator.java" } + File changePointAggregatorInputFile = new File("${projectDir}/src/main/java/org/elasticsearch/compute/aggregation/X-ChangePointAggregator.java.st") + template { + it.properties = intProperties + it.inputFile = changePointAggregatorInputFile + it.outputFile = "org/elasticsearch/compute/aggregation/ChangePointIntAggregator.java" + } + template { + it.properties = longProperties + it.inputFile = changePointAggregatorInputFile + it.outputFile = "org/elasticsearch/compute/aggregation/ChangePointLongAggregator.java" + } + template { + it.properties = floatProperties + it.inputFile = changePointAggregatorInputFile + it.outputFile = "org/elasticsearch/compute/aggregation/ChangePointFloatAggregator.java" + } + template { + it.properties = doubleProperties + it.inputFile = changePointAggregatorInputFile + it.outputFile = "org/elasticsearch/compute/aggregation/ChangePointDoubleAggregator.java" + } + File multivalueDedupeInputFile = file("src/main/java/org/elasticsearch/compute/operator/mvdedupe/X-MultivalueDedupe.java.st") template { it.properties = intProperties 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 4aee9ea517d8f..4a19308a8680a 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 @@ -87,12 +87,14 @@ public class AggregatorImplementer { private final boolean valuesIsBytesRef; private final List intermediateState; private final List createParameters; + private final boolean includeTimestampVector; public AggregatorImplementer( Elements elements, TypeElement declarationType, IntermediateState[] interStateAnno, - List warnExceptions + List warnExceptions, + boolean includeTimestampVector ) { this.declarationType = declarationType; this.warnExceptions = warnExceptions; @@ -128,6 +130,7 @@ public AggregatorImplementer( ); this.valuesIsBytesRef = BYTES_REF.equals(TypeName.get(combine.getParameters().get(combine.getParameters().size() - 1).asType())); intermediateState = Arrays.stream(interStateAnno).map(IntermediateStateDesc::newIntermediateStateDesc).toList(); + this.includeTimestampVector = includeTimestampVector; } ClassName implementation() { @@ -359,27 +362,34 @@ private MethodSpec addRawInput() { builder.addStatement("return"); } builder.endControlFlow(); + builder.addStatement("$T block = page.getBlock(channels.get(0))", valueBlockType(init, combine)); + builder.addStatement("$T vector = block.asVector()", valueVectorType(init, combine)); + if (includeTimestampVector) { + builder.addStatement("$T timestampsBlock = page.getBlock(channels.get(1))", LONG_BLOCK); + builder.addStatement("$T timestampsVector = timestampsBlock.asVector()", LONG_VECTOR); + builder.beginControlFlow("if (timestampsVector == null) "); + builder.addStatement("throw new IllegalStateException($S)", "expected @timestamp vector; but got a block"); + builder.endControlFlow(); + } + builder.beginControlFlow("if (mask.allTrue())"); + String extra = includeTimestampVector ? ", timestampsVector" : ""; { builder.addComment("No masking"); - builder.addStatement("$T block = page.getBlock(channels.get(0))", valueBlockType(init, combine)); - builder.addStatement("$T vector = block.asVector()", valueVectorType(init, combine)); builder.beginControlFlow("if (vector != null)"); - builder.addStatement("addRawVector(vector)"); + builder.addStatement("addRawVector(vector$L)", extra); builder.nextControlFlow("else"); - builder.addStatement("addRawBlock(block)"); + builder.addStatement("addRawBlock(block$L)", extra); builder.endControlFlow(); builder.addStatement("return"); } - builder.endControlFlow(); - + builder.nextControlFlow("else"); builder.addComment("Some positions masked away, others kept"); - builder.addStatement("$T block = page.getBlock(channels.get(0))", valueBlockType(init, combine)); - builder.addStatement("$T vector = block.asVector()", valueVectorType(init, combine)); builder.beginControlFlow("if (vector != null)"); - builder.addStatement("addRawVector(vector, mask)"); + builder.addStatement("addRawVector(vector$L, mask)", extra); builder.nextControlFlow("else"); - builder.addStatement("addRawBlock(block, mask)"); + builder.addStatement("addRawBlock(block$L, mask)", extra); + builder.endControlFlow(); builder.endControlFlow(); return builder.build(); } @@ -387,6 +397,9 @@ private MethodSpec addRawInput() { private MethodSpec addRawVector(boolean masked) { MethodSpec.Builder builder = MethodSpec.methodBuilder("addRawVector"); builder.addModifiers(Modifier.PRIVATE).addParameter(valueVectorType(init, combine), "vector"); + if (includeTimestampVector) { + builder.addParameter(LONG_VECTOR, "timestamps"); + } if (masked) { builder.addParameter(BOOLEAN_VECTOR, "mask"); } @@ -416,6 +429,9 @@ private MethodSpec addRawVector(boolean masked) { private MethodSpec addRawBlock(boolean masked) { MethodSpec.Builder builder = MethodSpec.methodBuilder("addRawBlock"); builder.addModifiers(Modifier.PRIVATE).addParameter(valueBlockType(init, combine), "block"); + if (includeTimestampVector) { + builder.addParameter(LONG_VECTOR, "timestamps"); + } if (masked) { builder.addParameter(BOOLEAN_VECTOR, "mask"); } @@ -455,6 +471,8 @@ private void combineRawInput(MethodSpec.Builder builder, String blockVariable) { } if (valuesIsBytesRef) { combineRawInputForBytesRef(builder, blockVariable); + } else if (includeTimestampVector) { + combineRawInputWithTimestamp(builder, blockVariable); } else if (returnType.isPrimitive()) { combineRawInputForPrimitive(returnType, builder, blockVariable); } else if (returnType == TypeName.VOID) { @@ -492,6 +510,12 @@ private void combineRawInputForVoid(MethodSpec.Builder builder, String blockVari ); } + private void combineRawInputWithTimestamp(MethodSpec.Builder builder, String blockVariable) { + TypeName valueType = TypeName.get(combine.getParameters().get(combine.getParameters().size() - 1).asType()); + String blockType = valueType.toString().substring(0, 1).toUpperCase(Locale.ROOT) + valueType.toString().substring(1); + builder.addStatement("$T.combine(state, timestamps.getLong(i), $L.get$L(i))", declarationType, blockVariable, blockType); + } + private void combineRawInputForBytesRef(MethodSpec.Builder builder, String blockVariable) { // scratch is a BytesRef var that must have been defined before the iteration starts builder.addStatement("$T.combine(state, $L.getBytesRef(i, scratch))", declarationType, blockVariable); diff --git a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/AggregatorProcessor.java b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/AggregatorProcessor.java index 863db86eb934a..5ff5806a3009f 100644 --- a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/AggregatorProcessor.java +++ b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/AggregatorProcessor.java @@ -87,7 +87,14 @@ public boolean process(Set set, RoundEnvironment roundEnv ); if (aggClass.getAnnotation(Aggregator.class) != null) { IntermediateState[] intermediateState = aggClass.getAnnotation(Aggregator.class).value(); - implementer = new AggregatorImplementer(env.getElementUtils(), aggClass, intermediateState, warnExceptionsTypes); + boolean includeTimestamps = aggClass.getAnnotation(Aggregator.class).includeTimestamps(); + implementer = new AggregatorImplementer( + env.getElementUtils(), + aggClass, + intermediateState, + warnExceptionsTypes, + includeTimestamps + ); write(aggClass, "aggregator", implementer.sourceFile(), env); } GroupingAggregatorImplementer groupingAggregatorImplementer = null; diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/ChangePointDoubleAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/ChangePointDoubleAggregator.java new file mode 100644 index 0000000000000..8f43238182b65 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/ChangePointDoubleAggregator.java @@ -0,0 +1,77 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +package org.elasticsearch.compute.aggregation; + +import org.elasticsearch.compute.aggregation.ChangePointStates.GroupingState; +import org.elasticsearch.compute.aggregation.ChangePointStates.SingleState; +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.DoubleBlock; +import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * Change point detection for series of double values. + * This class is generated. Edit @{code X-ChangePointAggregator.java.st} instead + * of this file. + */ +@Aggregator( + includeTimestamps = true, + value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "DOUBLE_BLOCK") } +) +@GroupingAggregator( + includeTimestamps = true, + value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "DOUBLE_BLOCK") } +) +class ChangePointDoubleAggregator { + + public static SingleState initSingle(DriverContext driverContext) { + return new SingleState(driverContext.bigArrays()); + } + + public static void combine(SingleState state, long timestamp, double value) { + state.add(timestamp, value); + } + + public static void combineIntermediate(SingleState state, LongBlock timestamps, DoubleBlock values) { + state.add(timestamps, values); + } + + public static Block evaluateFinal(SingleState state, DriverContext driverContext) { + return state.toBlock(driverContext.blockFactory()); + } + + public static GroupingState initGrouping(DriverContext driverContext) { + return new GroupingState(driverContext.bigArrays()); + } + + public static void combine(GroupingState current, int groupId, long timestamp, double value) { + current.add(groupId, timestamp, value); + } + + public static void combineIntermediate( + GroupingState current, + int groupId, + LongBlock timestamps, + DoubleBlock values, + int otherPosition + ) { + current.combine(groupId, timestamps, values, otherPosition); + } + + public static void combineStates(GroupingState current, int currentGroupId, GroupingState otherState, int otherGroupId) { + current.combineState(currentGroupId, otherState, otherGroupId); + } + + public static Block evaluateFinal(GroupingState state, IntVector selected, DriverContext driverContext) { + return state.evaluateFinal(selected, driverContext.blockFactory()); + } +} diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/ChangePointFloatAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/ChangePointFloatAggregator.java new file mode 100644 index 0000000000000..e7a320a6bae6d --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/ChangePointFloatAggregator.java @@ -0,0 +1,77 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +package org.elasticsearch.compute.aggregation; + +import org.elasticsearch.compute.aggregation.ChangePointStates.GroupingState; +import org.elasticsearch.compute.aggregation.ChangePointStates.SingleState; +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.DoubleBlock; +import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * Change point detection for series of float values. + * This class is generated. Edit @{code X-ChangePointAggregator.java.st} instead + * of this file. + */ +@Aggregator( + includeTimestamps = true, + value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "DOUBLE_BLOCK") } +) +@GroupingAggregator( + includeTimestamps = true, + value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "DOUBLE_BLOCK") } +) +class ChangePointFloatAggregator { + + public static SingleState initSingle(DriverContext driverContext) { + return new SingleState(driverContext.bigArrays()); + } + + public static void combine(SingleState state, long timestamp, float value) { + state.add(timestamp, value); + } + + public static void combineIntermediate(SingleState state, LongBlock timestamps, DoubleBlock values) { + state.add(timestamps, values); + } + + public static Block evaluateFinal(SingleState state, DriverContext driverContext) { + return state.toBlock(driverContext.blockFactory()); + } + + public static GroupingState initGrouping(DriverContext driverContext) { + return new GroupingState(driverContext.bigArrays()); + } + + public static void combine(GroupingState current, int groupId, long timestamp, float value) { + current.add(groupId, timestamp, value); + } + + public static void combineIntermediate( + GroupingState current, + int groupId, + LongBlock timestamps, + DoubleBlock values, + int otherPosition + ) { + current.combine(groupId, timestamps, values, otherPosition); + } + + public static void combineStates(GroupingState current, int currentGroupId, GroupingState otherState, int otherGroupId) { + current.combineState(currentGroupId, otherState, otherGroupId); + } + + public static Block evaluateFinal(GroupingState state, IntVector selected, DriverContext driverContext) { + return state.evaluateFinal(selected, driverContext.blockFactory()); + } +} diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/ChangePointIntAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/ChangePointIntAggregator.java new file mode 100644 index 0000000000000..e0e72c631d712 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/ChangePointIntAggregator.java @@ -0,0 +1,77 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +package org.elasticsearch.compute.aggregation; + +import org.elasticsearch.compute.aggregation.ChangePointStates.GroupingState; +import org.elasticsearch.compute.aggregation.ChangePointStates.SingleState; +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.DoubleBlock; +import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * Change point detection for series of int values. + * This class is generated. Edit @{code X-ChangePointAggregator.java.st} instead + * of this file. + */ +@Aggregator( + includeTimestamps = true, + value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "DOUBLE_BLOCK") } +) +@GroupingAggregator( + includeTimestamps = true, + value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "DOUBLE_BLOCK") } +) +class ChangePointIntAggregator { + + public static SingleState initSingle(DriverContext driverContext) { + return new SingleState(driverContext.bigArrays()); + } + + public static void combine(SingleState state, long timestamp, int value) { + state.add(timestamp, value); + } + + public static void combineIntermediate(SingleState state, LongBlock timestamps, DoubleBlock values) { + state.add(timestamps, values); + } + + public static Block evaluateFinal(SingleState state, DriverContext driverContext) { + return state.toBlock(driverContext.blockFactory()); + } + + public static GroupingState initGrouping(DriverContext driverContext) { + return new GroupingState(driverContext.bigArrays()); + } + + public static void combine(GroupingState current, int groupId, long timestamp, int value) { + current.add(groupId, timestamp, value); + } + + public static void combineIntermediate( + GroupingState current, + int groupId, + LongBlock timestamps, + DoubleBlock values, + int otherPosition + ) { + current.combine(groupId, timestamps, values, otherPosition); + } + + public static void combineStates(GroupingState current, int currentGroupId, GroupingState otherState, int otherGroupId) { + current.combineState(currentGroupId, otherState, otherGroupId); + } + + public static Block evaluateFinal(GroupingState state, IntVector selected, DriverContext driverContext) { + return state.evaluateFinal(selected, driverContext.blockFactory()); + } +} diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/ChangePointLongAggregator.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/ChangePointLongAggregator.java new file mode 100644 index 0000000000000..03605355c9ddc --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/ChangePointLongAggregator.java @@ -0,0 +1,77 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +package org.elasticsearch.compute.aggregation; + +import org.elasticsearch.compute.aggregation.ChangePointStates.GroupingState; +import org.elasticsearch.compute.aggregation.ChangePointStates.SingleState; +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.DoubleBlock; +import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * Change point detection for series of long values. + * This class is generated. Edit @{code X-ChangePointAggregator.java.st} instead + * of this file. + */ +@Aggregator( + includeTimestamps = true, + value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "DOUBLE_BLOCK") } +) +@GroupingAggregator( + includeTimestamps = true, + value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "DOUBLE_BLOCK") } +) +class ChangePointLongAggregator { + + public static SingleState initSingle(DriverContext driverContext) { + return new SingleState(driverContext.bigArrays()); + } + + public static void combine(SingleState state, long timestamp, long value) { + state.add(timestamp, value); + } + + public static void combineIntermediate(SingleState state, LongBlock timestamps, DoubleBlock values) { + state.add(timestamps, values); + } + + public static Block evaluateFinal(SingleState state, DriverContext driverContext) { + return state.toBlock(driverContext.blockFactory()); + } + + public static GroupingState initGrouping(DriverContext driverContext) { + return new GroupingState(driverContext.bigArrays()); + } + + public static void combine(GroupingState current, int groupId, long timestamp, long value) { + current.add(groupId, timestamp, value); + } + + public static void combineIntermediate( + GroupingState current, + int groupId, + LongBlock timestamps, + DoubleBlock values, + int otherPosition + ) { + current.combine(groupId, timestamps, values, otherPosition); + } + + public static void combineStates(GroupingState current, int currentGroupId, GroupingState otherState, int otherGroupId) { + current.combineState(currentGroupId, otherState, otherGroupId); + } + + public static Block evaluateFinal(GroupingState state, IntVector selected, DriverContext driverContext) { + return state.evaluateFinal(selected, driverContext.blockFactory()); + } +} diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointDoubleAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointDoubleAggregatorFunction.java new file mode 100644 index 0000000000000..fe4605fd267a3 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointDoubleAggregatorFunction.java @@ -0,0 +1,175 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License +// 2.0; you may not use this file except in compliance with the Elastic License +// 2.0. +package org.elasticsearch.compute.aggregation; + +import java.lang.Integer; +import java.lang.Override; +import java.lang.String; +import java.lang.StringBuilder; +import java.util.List; +import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BooleanVector; +import org.elasticsearch.compute.data.DoubleBlock; +import org.elasticsearch.compute.data.DoubleVector; +import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.data.LongVector; +import org.elasticsearch.compute.data.Page; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * {@link AggregatorFunction} implementation for {@link ChangePointDoubleAggregator}. + * This class is generated. Do not edit it. + */ +public final class ChangePointDoubleAggregatorFunction implements AggregatorFunction { + private static final List INTERMEDIATE_STATE_DESC = List.of( + new IntermediateStateDesc("timestamps", ElementType.LONG), + new IntermediateStateDesc("values", ElementType.DOUBLE) ); + + private final DriverContext driverContext; + + private final ChangePointStates.SingleState state; + + private final List channels; + + public ChangePointDoubleAggregatorFunction(DriverContext driverContext, List channels, + ChangePointStates.SingleState state) { + this.driverContext = driverContext; + this.channels = channels; + this.state = state; + } + + public static ChangePointDoubleAggregatorFunction create(DriverContext driverContext, + List channels) { + return new ChangePointDoubleAggregatorFunction(driverContext, channels, ChangePointDoubleAggregator.initSingle(driverContext)); + } + + public static List intermediateStateDesc() { + return INTERMEDIATE_STATE_DESC; + } + + @Override + public int intermediateBlockCount() { + return INTERMEDIATE_STATE_DESC.size(); + } + + @Override + public void addRawInput(Page page, BooleanVector mask) { + if (mask.allFalse()) { + // Entire page masked away + return; + } + DoubleBlock block = page.getBlock(channels.get(0)); + DoubleVector vector = block.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"); + } + if (mask.allTrue()) { + // No masking + if (vector != null) { + addRawVector(vector, timestampsVector); + } else { + addRawBlock(block, timestampsVector); + } + return; + } else { + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, timestampsVector, mask); + } else { + addRawBlock(block, timestampsVector, mask); + } + } + } + + private void addRawVector(DoubleVector vector, LongVector timestamps) { + for (int i = 0; i < vector.getPositionCount(); i++) { + ChangePointDoubleAggregator.combine(state, timestamps.getLong(i), vector.getDouble(i)); + } + } + + private void addRawVector(DoubleVector vector, LongVector timestamps, BooleanVector mask) { + for (int i = 0; i < vector.getPositionCount(); i++) { + if (mask.getBoolean(i) == false) { + continue; + } + ChangePointDoubleAggregator.combine(state, timestamps.getLong(i), vector.getDouble(i)); + } + } + + private void addRawBlock(DoubleBlock block, LongVector timestamps) { + for (int p = 0; p < block.getPositionCount(); p++) { + if (block.isNull(p)) { + continue; + } + int start = block.getFirstValueIndex(p); + int end = start + block.getValueCount(p); + for (int i = start; i < end; i++) { + ChangePointDoubleAggregator.combine(state, timestamps.getLong(i), block.getDouble(i)); + } + } + } + + private void addRawBlock(DoubleBlock block, LongVector timestamps, BooleanVector mask) { + for (int p = 0; p < block.getPositionCount(); p++) { + if (mask.getBoolean(p) == false) { + continue; + } + if (block.isNull(p)) { + continue; + } + int start = block.getFirstValueIndex(p); + int end = start + block.getValueCount(p); + for (int i = start; i < end; i++) { + ChangePointDoubleAggregator.combine(state, timestamps.getLong(i), block.getDouble(i)); + } + } + } + + @Override + public void addIntermediateInput(Page page) { + assert channels.size() == intermediateBlockCount(); + assert page.getBlockCount() >= channels.get(0) + intermediateStateDesc().size(); + Block timestampsUncast = page.getBlock(channels.get(0)); + if (timestampsUncast.areAllValuesNull()) { + return; + } + LongBlock timestamps = (LongBlock) timestampsUncast; + assert timestamps.getPositionCount() == 1; + Block valuesUncast = page.getBlock(channels.get(1)); + if (valuesUncast.areAllValuesNull()) { + return; + } + DoubleBlock values = (DoubleBlock) valuesUncast; + assert values.getPositionCount() == 1; + ChangePointDoubleAggregator.combineIntermediate(state, timestamps, values); + } + + @Override + public void evaluateIntermediate(Block[] blocks, int offset, DriverContext driverContext) { + state.toIntermediate(blocks, offset, driverContext); + } + + @Override + public void evaluateFinal(Block[] blocks, int offset, DriverContext driverContext) { + blocks[offset] = ChangePointDoubleAggregator.evaluateFinal(state, driverContext); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(getClass().getSimpleName()).append("["); + sb.append("channels=").append(channels); + sb.append("]"); + return sb.toString(); + } + + @Override + public void close() { + state.close(); + } +} diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointDoubleAggregatorFunctionSupplier.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointDoubleAggregatorFunctionSupplier.java new file mode 100644 index 0000000000000..4237d31b22ff3 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointDoubleAggregatorFunctionSupplier.java @@ -0,0 +1,39 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License +// 2.0; you may not use this file except in compliance with the Elastic License +// 2.0. +package org.elasticsearch.compute.aggregation; + +import java.lang.Integer; +import java.lang.Override; +import java.lang.String; +import java.util.List; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * {@link AggregatorFunctionSupplier} implementation for {@link ChangePointDoubleAggregator}. + * This class is generated. Do not edit it. + */ +public final class ChangePointDoubleAggregatorFunctionSupplier implements AggregatorFunctionSupplier { + private final List channels; + + public ChangePointDoubleAggregatorFunctionSupplier(List channels) { + this.channels = channels; + } + + @Override + public ChangePointDoubleAggregatorFunction aggregator(DriverContext driverContext) { + return ChangePointDoubleAggregatorFunction.create(driverContext, channels); + } + + @Override + public ChangePointDoubleGroupingAggregatorFunction groupingAggregator( + DriverContext driverContext) { + return ChangePointDoubleGroupingAggregatorFunction.create(channels, driverContext); + } + + @Override + public String describe() { + return "change_point of doubles"; + } +} diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointDoubleGroupingAggregatorFunction.java new file mode 100644 index 0000000000000..3c9508809c1ac --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointDoubleGroupingAggregatorFunction.java @@ -0,0 +1,228 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License +// 2.0; you may not use this file except in compliance with the Elastic License +// 2.0. +package org.elasticsearch.compute.aggregation; + +import java.lang.Integer; +import java.lang.Override; +import java.lang.String; +import java.lang.StringBuilder; +import java.util.List; +import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.DoubleBlock; +import org.elasticsearch.compute.data.DoubleVector; +import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntBlock; +import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.data.LongVector; +import org.elasticsearch.compute.data.Page; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * {@link GroupingAggregatorFunction} implementation for {@link ChangePointDoubleAggregator}. + * This class is generated. Do not edit it. + */ +public final class ChangePointDoubleGroupingAggregatorFunction implements GroupingAggregatorFunction { + private static final List INTERMEDIATE_STATE_DESC = List.of( + new IntermediateStateDesc("timestamps", ElementType.LONG), + new IntermediateStateDesc("values", ElementType.DOUBLE) ); + + private final ChangePointStates.GroupingState state; + + private final List channels; + + private final DriverContext driverContext; + + public ChangePointDoubleGroupingAggregatorFunction(List channels, + ChangePointStates.GroupingState state, DriverContext driverContext) { + this.channels = channels; + this.state = state; + this.driverContext = driverContext; + } + + public static ChangePointDoubleGroupingAggregatorFunction create(List channels, + DriverContext driverContext) { + return new ChangePointDoubleGroupingAggregatorFunction(channels, ChangePointDoubleAggregator.initGrouping(driverContext), driverContext); + } + + public static List intermediateStateDesc() { + return INTERMEDIATE_STATE_DESC; + } + + @Override + public int intermediateBlockCount() { + return INTERMEDIATE_STATE_DESC.size(); + } + + @Override + public GroupingAggregatorFunction.AddInput prepareProcessPage(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"); + } + if (valuesVector == null) { + if (valuesBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void close() { + } + }; + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void close() { + } + }; + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + if (values.isNull(groupPosition + positionOffset)) { + continue; + } + int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); + int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); + for (int v = valuesStart; v < valuesEnd; v++) { + ChangePointDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleVector values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + var valuePosition = groupPosition + positionOffset; + ChangePointDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + } + } + + private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + if (groups.isNull(groupPosition)) { + continue; + } + int groupStart = groups.getFirstValueIndex(groupPosition); + int groupEnd = groupStart + groups.getValueCount(groupPosition); + for (int g = groupStart; g < groupEnd; g++) { + int groupId = groups.getInt(g); + if (values.isNull(groupPosition + positionOffset)) { + continue; + } + int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); + int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); + for (int v = valuesStart; v < valuesEnd; v++) { + ChangePointDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + if (groups.isNull(groupPosition)) { + continue; + } + 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; + ChangePointDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + } + } + } + + @Override + public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { + state.enableGroupIdTracking(seenGroupIds); + } + + @Override + public void addIntermediateInput(int positionOffset, IntVector groups, Page page) { + state.enableGroupIdTracking(new SeenGroupIds.Empty()); + assert channels.size() == intermediateBlockCount(); + Block timestampsUncast = page.getBlock(channels.get(0)); + if (timestampsUncast.areAllValuesNull()) { + return; + } + LongBlock timestamps = (LongBlock) timestampsUncast; + Block valuesUncast = page.getBlock(channels.get(1)); + if (valuesUncast.areAllValuesNull()) { + return; + } + DoubleBlock values = (DoubleBlock) valuesUncast; + assert timestamps.getPositionCount() == values.getPositionCount(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + ChangePointDoubleAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + } + } + + @Override + public void addIntermediateRowInput(int groupId, GroupingAggregatorFunction input, int position) { + if (input.getClass() != getClass()) { + throw new IllegalArgumentException("expected " + getClass() + "; got " + input.getClass()); + } + ChangePointStates.GroupingState inState = ((ChangePointDoubleGroupingAggregatorFunction) input).state; + state.enableGroupIdTracking(new SeenGroupIds.Empty()); + ChangePointDoubleAggregator.combineStates(state, groupId, inState, position); + } + + @Override + public void evaluateIntermediate(Block[] blocks, int offset, IntVector selected) { + state.toIntermediate(blocks, offset, selected, driverContext); + } + + @Override + public void evaluateFinal(Block[] blocks, int offset, IntVector selected, + DriverContext driverContext) { + blocks[offset] = ChangePointDoubleAggregator.evaluateFinal(state, selected, driverContext); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(getClass().getSimpleName()).append("["); + sb.append("channels=").append(channels); + sb.append("]"); + return sb.toString(); + } + + @Override + public void close() { + state.close(); + } +} diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointFloatAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointFloatAggregatorFunction.java new file mode 100644 index 0000000000000..5fd3c81900049 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointFloatAggregatorFunction.java @@ -0,0 +1,176 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License +// 2.0; you may not use this file except in compliance with the Elastic License +// 2.0. +package org.elasticsearch.compute.aggregation; + +import java.lang.Integer; +import java.lang.Override; +import java.lang.String; +import java.lang.StringBuilder; +import java.util.List; +import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BooleanVector; +import org.elasticsearch.compute.data.DoubleBlock; +import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.FloatBlock; +import org.elasticsearch.compute.data.FloatVector; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.data.LongVector; +import org.elasticsearch.compute.data.Page; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * {@link AggregatorFunction} implementation for {@link ChangePointFloatAggregator}. + * This class is generated. Do not edit it. + */ +public final class ChangePointFloatAggregatorFunction implements AggregatorFunction { + private static final List INTERMEDIATE_STATE_DESC = List.of( + new IntermediateStateDesc("timestamps", ElementType.LONG), + new IntermediateStateDesc("values", ElementType.DOUBLE) ); + + private final DriverContext driverContext; + + private final ChangePointStates.SingleState state; + + private final List channels; + + public ChangePointFloatAggregatorFunction(DriverContext driverContext, List channels, + ChangePointStates.SingleState state) { + this.driverContext = driverContext; + this.channels = channels; + this.state = state; + } + + public static ChangePointFloatAggregatorFunction create(DriverContext driverContext, + List channels) { + return new ChangePointFloatAggregatorFunction(driverContext, channels, ChangePointFloatAggregator.initSingle(driverContext)); + } + + public static List intermediateStateDesc() { + return INTERMEDIATE_STATE_DESC; + } + + @Override + public int intermediateBlockCount() { + return INTERMEDIATE_STATE_DESC.size(); + } + + @Override + public void addRawInput(Page page, BooleanVector mask) { + if (mask.allFalse()) { + // Entire page masked away + return; + } + FloatBlock block = page.getBlock(channels.get(0)); + FloatVector vector = block.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"); + } + if (mask.allTrue()) { + // No masking + if (vector != null) { + addRawVector(vector, timestampsVector); + } else { + addRawBlock(block, timestampsVector); + } + return; + } else { + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, timestampsVector, mask); + } else { + addRawBlock(block, timestampsVector, mask); + } + } + } + + private void addRawVector(FloatVector vector, LongVector timestamps) { + for (int i = 0; i < vector.getPositionCount(); i++) { + ChangePointFloatAggregator.combine(state, timestamps.getLong(i), vector.getFloat(i)); + } + } + + private void addRawVector(FloatVector vector, LongVector timestamps, BooleanVector mask) { + for (int i = 0; i < vector.getPositionCount(); i++) { + if (mask.getBoolean(i) == false) { + continue; + } + ChangePointFloatAggregator.combine(state, timestamps.getLong(i), vector.getFloat(i)); + } + } + + private void addRawBlock(FloatBlock block, LongVector timestamps) { + for (int p = 0; p < block.getPositionCount(); p++) { + if (block.isNull(p)) { + continue; + } + int start = block.getFirstValueIndex(p); + int end = start + block.getValueCount(p); + for (int i = start; i < end; i++) { + ChangePointFloatAggregator.combine(state, timestamps.getLong(i), block.getFloat(i)); + } + } + } + + private void addRawBlock(FloatBlock block, LongVector timestamps, BooleanVector mask) { + for (int p = 0; p < block.getPositionCount(); p++) { + if (mask.getBoolean(p) == false) { + continue; + } + if (block.isNull(p)) { + continue; + } + int start = block.getFirstValueIndex(p); + int end = start + block.getValueCount(p); + for (int i = start; i < end; i++) { + ChangePointFloatAggregator.combine(state, timestamps.getLong(i), block.getFloat(i)); + } + } + } + + @Override + public void addIntermediateInput(Page page) { + assert channels.size() == intermediateBlockCount(); + assert page.getBlockCount() >= channels.get(0) + intermediateStateDesc().size(); + Block timestampsUncast = page.getBlock(channels.get(0)); + if (timestampsUncast.areAllValuesNull()) { + return; + } + LongBlock timestamps = (LongBlock) timestampsUncast; + assert timestamps.getPositionCount() == 1; + Block valuesUncast = page.getBlock(channels.get(1)); + if (valuesUncast.areAllValuesNull()) { + return; + } + DoubleBlock values = (DoubleBlock) valuesUncast; + assert values.getPositionCount() == 1; + ChangePointFloatAggregator.combineIntermediate(state, timestamps, values); + } + + @Override + public void evaluateIntermediate(Block[] blocks, int offset, DriverContext driverContext) { + state.toIntermediate(blocks, offset, driverContext); + } + + @Override + public void evaluateFinal(Block[] blocks, int offset, DriverContext driverContext) { + blocks[offset] = ChangePointFloatAggregator.evaluateFinal(state, driverContext); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(getClass().getSimpleName()).append("["); + sb.append("channels=").append(channels); + sb.append("]"); + return sb.toString(); + } + + @Override + public void close() { + state.close(); + } +} diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointFloatAggregatorFunctionSupplier.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointFloatAggregatorFunctionSupplier.java new file mode 100644 index 0000000000000..5d6985fc099f9 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointFloatAggregatorFunctionSupplier.java @@ -0,0 +1,39 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License +// 2.0; you may not use this file except in compliance with the Elastic License +// 2.0. +package org.elasticsearch.compute.aggregation; + +import java.lang.Integer; +import java.lang.Override; +import java.lang.String; +import java.util.List; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * {@link AggregatorFunctionSupplier} implementation for {@link ChangePointFloatAggregator}. + * This class is generated. Do not edit it. + */ +public final class ChangePointFloatAggregatorFunctionSupplier implements AggregatorFunctionSupplier { + private final List channels; + + public ChangePointFloatAggregatorFunctionSupplier(List channels) { + this.channels = channels; + } + + @Override + public ChangePointFloatAggregatorFunction aggregator(DriverContext driverContext) { + return ChangePointFloatAggregatorFunction.create(driverContext, channels); + } + + @Override + public ChangePointFloatGroupingAggregatorFunction groupingAggregator( + DriverContext driverContext) { + return ChangePointFloatGroupingAggregatorFunction.create(channels, driverContext); + } + + @Override + public String describe() { + return "change_point of floats"; + } +} diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointFloatGroupingAggregatorFunction.java new file mode 100644 index 0000000000000..52e5c32e1a0d7 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointFloatGroupingAggregatorFunction.java @@ -0,0 +1,229 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License +// 2.0; you may not use this file except in compliance with the Elastic License +// 2.0. +package org.elasticsearch.compute.aggregation; + +import java.lang.Integer; +import java.lang.Override; +import java.lang.String; +import java.lang.StringBuilder; +import java.util.List; +import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.DoubleBlock; +import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.FloatBlock; +import org.elasticsearch.compute.data.FloatVector; +import org.elasticsearch.compute.data.IntBlock; +import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.data.LongVector; +import org.elasticsearch.compute.data.Page; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * {@link GroupingAggregatorFunction} implementation for {@link ChangePointFloatAggregator}. + * This class is generated. Do not edit it. + */ +public final class ChangePointFloatGroupingAggregatorFunction implements GroupingAggregatorFunction { + private static final List INTERMEDIATE_STATE_DESC = List.of( + new IntermediateStateDesc("timestamps", ElementType.LONG), + new IntermediateStateDesc("values", ElementType.DOUBLE) ); + + private final ChangePointStates.GroupingState state; + + private final List channels; + + private final DriverContext driverContext; + + public ChangePointFloatGroupingAggregatorFunction(List channels, + ChangePointStates.GroupingState state, DriverContext driverContext) { + this.channels = channels; + this.state = state; + this.driverContext = driverContext; + } + + public static ChangePointFloatGroupingAggregatorFunction create(List channels, + DriverContext driverContext) { + return new ChangePointFloatGroupingAggregatorFunction(channels, ChangePointFloatAggregator.initGrouping(driverContext), driverContext); + } + + public static List intermediateStateDesc() { + return INTERMEDIATE_STATE_DESC; + } + + @Override + public int intermediateBlockCount() { + return INTERMEDIATE_STATE_DESC.size(); + } + + @Override + public GroupingAggregatorFunction.AddInput prepareProcessPage(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"); + } + if (valuesVector == null) { + if (valuesBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void close() { + } + }; + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void close() { + } + }; + } + + private void addRawInput(int positionOffset, IntVector groups, FloatBlock values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + if (values.isNull(groupPosition + positionOffset)) { + continue; + } + int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); + int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); + for (int v = valuesStart; v < valuesEnd; v++) { + ChangePointFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatVector values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + var valuePosition = groupPosition + positionOffset; + ChangePointFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + } + } + + private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + if (groups.isNull(groupPosition)) { + continue; + } + int groupStart = groups.getFirstValueIndex(groupPosition); + int groupEnd = groupStart + groups.getValueCount(groupPosition); + for (int g = groupStart; g < groupEnd; g++) { + int groupId = groups.getInt(g); + if (values.isNull(groupPosition + positionOffset)) { + continue; + } + int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); + int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); + for (int v = valuesStart; v < valuesEnd; v++) { + ChangePointFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBlock groups, FloatVector values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + if (groups.isNull(groupPosition)) { + continue; + } + 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; + ChangePointFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + } + } + } + + @Override + public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { + state.enableGroupIdTracking(seenGroupIds); + } + + @Override + public void addIntermediateInput(int positionOffset, IntVector groups, Page page) { + state.enableGroupIdTracking(new SeenGroupIds.Empty()); + assert channels.size() == intermediateBlockCount(); + Block timestampsUncast = page.getBlock(channels.get(0)); + if (timestampsUncast.areAllValuesNull()) { + return; + } + LongBlock timestamps = (LongBlock) timestampsUncast; + Block valuesUncast = page.getBlock(channels.get(1)); + if (valuesUncast.areAllValuesNull()) { + return; + } + DoubleBlock values = (DoubleBlock) valuesUncast; + assert timestamps.getPositionCount() == values.getPositionCount(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + ChangePointFloatAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + } + } + + @Override + public void addIntermediateRowInput(int groupId, GroupingAggregatorFunction input, int position) { + if (input.getClass() != getClass()) { + throw new IllegalArgumentException("expected " + getClass() + "; got " + input.getClass()); + } + ChangePointStates.GroupingState inState = ((ChangePointFloatGroupingAggregatorFunction) input).state; + state.enableGroupIdTracking(new SeenGroupIds.Empty()); + ChangePointFloatAggregator.combineStates(state, groupId, inState, position); + } + + @Override + public void evaluateIntermediate(Block[] blocks, int offset, IntVector selected) { + state.toIntermediate(blocks, offset, selected, driverContext); + } + + @Override + public void evaluateFinal(Block[] blocks, int offset, IntVector selected, + DriverContext driverContext) { + blocks[offset] = ChangePointFloatAggregator.evaluateFinal(state, selected, driverContext); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(getClass().getSimpleName()).append("["); + sb.append("channels=").append(channels); + sb.append("]"); + return sb.toString(); + } + + @Override + public void close() { + state.close(); + } +} diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointIntAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointIntAggregatorFunction.java new file mode 100644 index 0000000000000..029acb6111818 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointIntAggregatorFunction.java @@ -0,0 +1,176 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License +// 2.0; you may not use this file except in compliance with the Elastic License +// 2.0. +package org.elasticsearch.compute.aggregation; + +import java.lang.Integer; +import java.lang.Override; +import java.lang.String; +import java.lang.StringBuilder; +import java.util.List; +import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BooleanVector; +import org.elasticsearch.compute.data.DoubleBlock; +import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntBlock; +import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.data.LongVector; +import org.elasticsearch.compute.data.Page; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * {@link AggregatorFunction} implementation for {@link ChangePointIntAggregator}. + * This class is generated. Do not edit it. + */ +public final class ChangePointIntAggregatorFunction implements AggregatorFunction { + private static final List INTERMEDIATE_STATE_DESC = List.of( + new IntermediateStateDesc("timestamps", ElementType.LONG), + new IntermediateStateDesc("values", ElementType.DOUBLE) ); + + private final DriverContext driverContext; + + private final ChangePointStates.SingleState state; + + private final List channels; + + public ChangePointIntAggregatorFunction(DriverContext driverContext, List channels, + ChangePointStates.SingleState state) { + this.driverContext = driverContext; + this.channels = channels; + this.state = state; + } + + public static ChangePointIntAggregatorFunction create(DriverContext driverContext, + List channels) { + return new ChangePointIntAggregatorFunction(driverContext, channels, ChangePointIntAggregator.initSingle(driverContext)); + } + + public static List intermediateStateDesc() { + return INTERMEDIATE_STATE_DESC; + } + + @Override + public int intermediateBlockCount() { + return INTERMEDIATE_STATE_DESC.size(); + } + + @Override + public void addRawInput(Page page, BooleanVector mask) { + if (mask.allFalse()) { + // Entire page masked away + return; + } + IntBlock block = page.getBlock(channels.get(0)); + IntVector vector = block.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"); + } + if (mask.allTrue()) { + // No masking + if (vector != null) { + addRawVector(vector, timestampsVector); + } else { + addRawBlock(block, timestampsVector); + } + return; + } else { + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, timestampsVector, mask); + } else { + addRawBlock(block, timestampsVector, mask); + } + } + } + + private void addRawVector(IntVector vector, LongVector timestamps) { + for (int i = 0; i < vector.getPositionCount(); i++) { + ChangePointIntAggregator.combine(state, timestamps.getLong(i), vector.getInt(i)); + } + } + + private void addRawVector(IntVector vector, LongVector timestamps, BooleanVector mask) { + for (int i = 0; i < vector.getPositionCount(); i++) { + if (mask.getBoolean(i) == false) { + continue; + } + ChangePointIntAggregator.combine(state, timestamps.getLong(i), vector.getInt(i)); + } + } + + private void addRawBlock(IntBlock block, LongVector timestamps) { + for (int p = 0; p < block.getPositionCount(); p++) { + if (block.isNull(p)) { + continue; + } + int start = block.getFirstValueIndex(p); + int end = start + block.getValueCount(p); + for (int i = start; i < end; i++) { + ChangePointIntAggregator.combine(state, timestamps.getLong(i), block.getInt(i)); + } + } + } + + private void addRawBlock(IntBlock block, LongVector timestamps, BooleanVector mask) { + for (int p = 0; p < block.getPositionCount(); p++) { + if (mask.getBoolean(p) == false) { + continue; + } + if (block.isNull(p)) { + continue; + } + int start = block.getFirstValueIndex(p); + int end = start + block.getValueCount(p); + for (int i = start; i < end; i++) { + ChangePointIntAggregator.combine(state, timestamps.getLong(i), block.getInt(i)); + } + } + } + + @Override + public void addIntermediateInput(Page page) { + assert channels.size() == intermediateBlockCount(); + assert page.getBlockCount() >= channels.get(0) + intermediateStateDesc().size(); + Block timestampsUncast = page.getBlock(channels.get(0)); + if (timestampsUncast.areAllValuesNull()) { + return; + } + LongBlock timestamps = (LongBlock) timestampsUncast; + assert timestamps.getPositionCount() == 1; + Block valuesUncast = page.getBlock(channels.get(1)); + if (valuesUncast.areAllValuesNull()) { + return; + } + DoubleBlock values = (DoubleBlock) valuesUncast; + assert values.getPositionCount() == 1; + ChangePointIntAggregator.combineIntermediate(state, timestamps, values); + } + + @Override + public void evaluateIntermediate(Block[] blocks, int offset, DriverContext driverContext) { + state.toIntermediate(blocks, offset, driverContext); + } + + @Override + public void evaluateFinal(Block[] blocks, int offset, DriverContext driverContext) { + blocks[offset] = ChangePointIntAggregator.evaluateFinal(state, driverContext); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(getClass().getSimpleName()).append("["); + sb.append("channels=").append(channels); + sb.append("]"); + return sb.toString(); + } + + @Override + public void close() { + state.close(); + } +} diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointIntAggregatorFunctionSupplier.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointIntAggregatorFunctionSupplier.java new file mode 100644 index 0000000000000..ba340113cd133 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointIntAggregatorFunctionSupplier.java @@ -0,0 +1,38 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License +// 2.0; you may not use this file except in compliance with the Elastic License +// 2.0. +package org.elasticsearch.compute.aggregation; + +import java.lang.Integer; +import java.lang.Override; +import java.lang.String; +import java.util.List; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * {@link AggregatorFunctionSupplier} implementation for {@link ChangePointIntAggregator}. + * This class is generated. Do not edit it. + */ +public final class ChangePointIntAggregatorFunctionSupplier implements AggregatorFunctionSupplier { + private final List channels; + + public ChangePointIntAggregatorFunctionSupplier(List channels) { + this.channels = channels; + } + + @Override + public ChangePointIntAggregatorFunction aggregator(DriverContext driverContext) { + return ChangePointIntAggregatorFunction.create(driverContext, channels); + } + + @Override + public ChangePointIntGroupingAggregatorFunction groupingAggregator(DriverContext driverContext) { + return ChangePointIntGroupingAggregatorFunction.create(channels, driverContext); + } + + @Override + public String describe() { + return "change_point of ints"; + } +} diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointIntGroupingAggregatorFunction.java new file mode 100644 index 0000000000000..7713cb12e3400 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointIntGroupingAggregatorFunction.java @@ -0,0 +1,227 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License +// 2.0; you may not use this file except in compliance with the Elastic License +// 2.0. +package org.elasticsearch.compute.aggregation; + +import java.lang.Integer; +import java.lang.Override; +import java.lang.String; +import java.lang.StringBuilder; +import java.util.List; +import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.DoubleBlock; +import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntBlock; +import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.data.LongVector; +import org.elasticsearch.compute.data.Page; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * {@link GroupingAggregatorFunction} implementation for {@link ChangePointIntAggregator}. + * This class is generated. Do not edit it. + */ +public final class ChangePointIntGroupingAggregatorFunction implements GroupingAggregatorFunction { + private static final List INTERMEDIATE_STATE_DESC = List.of( + new IntermediateStateDesc("timestamps", ElementType.LONG), + new IntermediateStateDesc("values", ElementType.DOUBLE) ); + + private final ChangePointStates.GroupingState state; + + private final List channels; + + private final DriverContext driverContext; + + public ChangePointIntGroupingAggregatorFunction(List channels, + ChangePointStates.GroupingState state, DriverContext driverContext) { + this.channels = channels; + this.state = state; + this.driverContext = driverContext; + } + + public static ChangePointIntGroupingAggregatorFunction create(List channels, + DriverContext driverContext) { + return new ChangePointIntGroupingAggregatorFunction(channels, ChangePointIntAggregator.initGrouping(driverContext), driverContext); + } + + public static List intermediateStateDesc() { + return INTERMEDIATE_STATE_DESC; + } + + @Override + public int intermediateBlockCount() { + return INTERMEDIATE_STATE_DESC.size(); + } + + @Override + public GroupingAggregatorFunction.AddInput prepareProcessPage(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"); + } + if (valuesVector == null) { + if (valuesBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void close() { + } + }; + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void close() { + } + }; + } + + private void addRawInput(int positionOffset, IntVector groups, IntBlock values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + if (values.isNull(groupPosition + positionOffset)) { + continue; + } + int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); + int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); + for (int v = valuesStart; v < valuesEnd; v++) { + ChangePointIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntVector values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + var valuePosition = groupPosition + positionOffset; + ChangePointIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + } + } + + private void addRawInput(int positionOffset, IntBlock groups, IntBlock values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + if (groups.isNull(groupPosition)) { + continue; + } + int groupStart = groups.getFirstValueIndex(groupPosition); + int groupEnd = groupStart + groups.getValueCount(groupPosition); + for (int g = groupStart; g < groupEnd; g++) { + int groupId = groups.getInt(g); + if (values.isNull(groupPosition + positionOffset)) { + continue; + } + int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); + int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); + for (int v = valuesStart; v < valuesEnd; v++) { + ChangePointIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBlock groups, IntVector values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + if (groups.isNull(groupPosition)) { + continue; + } + 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; + ChangePointIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + } + } + } + + @Override + public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { + state.enableGroupIdTracking(seenGroupIds); + } + + @Override + public void addIntermediateInput(int positionOffset, IntVector groups, Page page) { + state.enableGroupIdTracking(new SeenGroupIds.Empty()); + assert channels.size() == intermediateBlockCount(); + Block timestampsUncast = page.getBlock(channels.get(0)); + if (timestampsUncast.areAllValuesNull()) { + return; + } + LongBlock timestamps = (LongBlock) timestampsUncast; + Block valuesUncast = page.getBlock(channels.get(1)); + if (valuesUncast.areAllValuesNull()) { + return; + } + DoubleBlock values = (DoubleBlock) valuesUncast; + assert timestamps.getPositionCount() == values.getPositionCount(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + ChangePointIntAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + } + } + + @Override + public void addIntermediateRowInput(int groupId, GroupingAggregatorFunction input, int position) { + if (input.getClass() != getClass()) { + throw new IllegalArgumentException("expected " + getClass() + "; got " + input.getClass()); + } + ChangePointStates.GroupingState inState = ((ChangePointIntGroupingAggregatorFunction) input).state; + state.enableGroupIdTracking(new SeenGroupIds.Empty()); + ChangePointIntAggregator.combineStates(state, groupId, inState, position); + } + + @Override + public void evaluateIntermediate(Block[] blocks, int offset, IntVector selected) { + state.toIntermediate(blocks, offset, selected, driverContext); + } + + @Override + public void evaluateFinal(Block[] blocks, int offset, IntVector selected, + DriverContext driverContext) { + blocks[offset] = ChangePointIntAggregator.evaluateFinal(state, selected, driverContext); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(getClass().getSimpleName()).append("["); + sb.append("channels=").append(channels); + sb.append("]"); + return sb.toString(); + } + + @Override + public void close() { + state.close(); + } +} diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointLongAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointLongAggregatorFunction.java new file mode 100644 index 0000000000000..d32693eebc19b --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointLongAggregatorFunction.java @@ -0,0 +1,174 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License +// 2.0; you may not use this file except in compliance with the Elastic License +// 2.0. +package org.elasticsearch.compute.aggregation; + +import java.lang.Integer; +import java.lang.Override; +import java.lang.String; +import java.lang.StringBuilder; +import java.util.List; +import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BooleanVector; +import org.elasticsearch.compute.data.DoubleBlock; +import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.data.LongVector; +import org.elasticsearch.compute.data.Page; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * {@link AggregatorFunction} implementation for {@link ChangePointLongAggregator}. + * This class is generated. Do not edit it. + */ +public final class ChangePointLongAggregatorFunction implements AggregatorFunction { + private static final List INTERMEDIATE_STATE_DESC = List.of( + new IntermediateStateDesc("timestamps", ElementType.LONG), + new IntermediateStateDesc("values", ElementType.DOUBLE) ); + + private final DriverContext driverContext; + + private final ChangePointStates.SingleState state; + + private final List channels; + + public ChangePointLongAggregatorFunction(DriverContext driverContext, List channels, + ChangePointStates.SingleState state) { + this.driverContext = driverContext; + this.channels = channels; + this.state = state; + } + + public static ChangePointLongAggregatorFunction create(DriverContext driverContext, + List channels) { + return new ChangePointLongAggregatorFunction(driverContext, channels, ChangePointLongAggregator.initSingle(driverContext)); + } + + public static List intermediateStateDesc() { + return INTERMEDIATE_STATE_DESC; + } + + @Override + public int intermediateBlockCount() { + return INTERMEDIATE_STATE_DESC.size(); + } + + @Override + public void addRawInput(Page page, BooleanVector mask) { + if (mask.allFalse()) { + // Entire page masked away + return; + } + LongBlock block = page.getBlock(channels.get(0)); + LongVector vector = block.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"); + } + if (mask.allTrue()) { + // No masking + if (vector != null) { + addRawVector(vector, timestampsVector); + } else { + addRawBlock(block, timestampsVector); + } + return; + } else { + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, timestampsVector, mask); + } else { + addRawBlock(block, timestampsVector, mask); + } + } + } + + private void addRawVector(LongVector vector, LongVector timestamps) { + for (int i = 0; i < vector.getPositionCount(); i++) { + ChangePointLongAggregator.combine(state, timestamps.getLong(i), vector.getLong(i)); + } + } + + private void addRawVector(LongVector vector, LongVector timestamps, BooleanVector mask) { + for (int i = 0; i < vector.getPositionCount(); i++) { + if (mask.getBoolean(i) == false) { + continue; + } + ChangePointLongAggregator.combine(state, timestamps.getLong(i), vector.getLong(i)); + } + } + + private void addRawBlock(LongBlock block, LongVector timestamps) { + for (int p = 0; p < block.getPositionCount(); p++) { + if (block.isNull(p)) { + continue; + } + int start = block.getFirstValueIndex(p); + int end = start + block.getValueCount(p); + for (int i = start; i < end; i++) { + ChangePointLongAggregator.combine(state, timestamps.getLong(i), block.getLong(i)); + } + } + } + + private void addRawBlock(LongBlock block, LongVector timestamps, BooleanVector mask) { + for (int p = 0; p < block.getPositionCount(); p++) { + if (mask.getBoolean(p) == false) { + continue; + } + if (block.isNull(p)) { + continue; + } + int start = block.getFirstValueIndex(p); + int end = start + block.getValueCount(p); + for (int i = start; i < end; i++) { + ChangePointLongAggregator.combine(state, timestamps.getLong(i), block.getLong(i)); + } + } + } + + @Override + public void addIntermediateInput(Page page) { + assert channels.size() == intermediateBlockCount(); + assert page.getBlockCount() >= channels.get(0) + intermediateStateDesc().size(); + Block timestampsUncast = page.getBlock(channels.get(0)); + if (timestampsUncast.areAllValuesNull()) { + return; + } + LongBlock timestamps = (LongBlock) timestampsUncast; + assert timestamps.getPositionCount() == 1; + Block valuesUncast = page.getBlock(channels.get(1)); + if (valuesUncast.areAllValuesNull()) { + return; + } + DoubleBlock values = (DoubleBlock) valuesUncast; + assert values.getPositionCount() == 1; + ChangePointLongAggregator.combineIntermediate(state, timestamps, values); + } + + @Override + public void evaluateIntermediate(Block[] blocks, int offset, DriverContext driverContext) { + state.toIntermediate(blocks, offset, driverContext); + } + + @Override + public void evaluateFinal(Block[] blocks, int offset, DriverContext driverContext) { + blocks[offset] = ChangePointLongAggregator.evaluateFinal(state, driverContext); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(getClass().getSimpleName()).append("["); + sb.append("channels=").append(channels); + sb.append("]"); + return sb.toString(); + } + + @Override + public void close() { + state.close(); + } +} diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointLongAggregatorFunctionSupplier.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointLongAggregatorFunctionSupplier.java new file mode 100644 index 0000000000000..c26dd4bda550e --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointLongAggregatorFunctionSupplier.java @@ -0,0 +1,38 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License +// 2.0; you may not use this file except in compliance with the Elastic License +// 2.0. +package org.elasticsearch.compute.aggregation; + +import java.lang.Integer; +import java.lang.Override; +import java.lang.String; +import java.util.List; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * {@link AggregatorFunctionSupplier} implementation for {@link ChangePointLongAggregator}. + * This class is generated. Do not edit it. + */ +public final class ChangePointLongAggregatorFunctionSupplier implements AggregatorFunctionSupplier { + private final List channels; + + public ChangePointLongAggregatorFunctionSupplier(List channels) { + this.channels = channels; + } + + @Override + public ChangePointLongAggregatorFunction aggregator(DriverContext driverContext) { + return ChangePointLongAggregatorFunction.create(driverContext, channels); + } + + @Override + public ChangePointLongGroupingAggregatorFunction groupingAggregator(DriverContext driverContext) { + return ChangePointLongGroupingAggregatorFunction.create(channels, driverContext); + } + + @Override + public String describe() { + return "change_point of longs"; + } +} diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointLongGroupingAggregatorFunction.java new file mode 100644 index 0000000000000..b3bb2509716c5 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ChangePointLongGroupingAggregatorFunction.java @@ -0,0 +1,227 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License +// 2.0; you may not use this file except in compliance with the Elastic License +// 2.0. +package org.elasticsearch.compute.aggregation; + +import java.lang.Integer; +import java.lang.Override; +import java.lang.String; +import java.lang.StringBuilder; +import java.util.List; +import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.DoubleBlock; +import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntBlock; +import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.data.LongVector; +import org.elasticsearch.compute.data.Page; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * {@link GroupingAggregatorFunction} implementation for {@link ChangePointLongAggregator}. + * This class is generated. Do not edit it. + */ +public final class ChangePointLongGroupingAggregatorFunction implements GroupingAggregatorFunction { + private static final List INTERMEDIATE_STATE_DESC = List.of( + new IntermediateStateDesc("timestamps", ElementType.LONG), + new IntermediateStateDesc("values", ElementType.DOUBLE) ); + + private final ChangePointStates.GroupingState state; + + private final List channels; + + private final DriverContext driverContext; + + public ChangePointLongGroupingAggregatorFunction(List channels, + ChangePointStates.GroupingState state, DriverContext driverContext) { + this.channels = channels; + this.state = state; + this.driverContext = driverContext; + } + + public static ChangePointLongGroupingAggregatorFunction create(List channels, + DriverContext driverContext) { + return new ChangePointLongGroupingAggregatorFunction(channels, ChangePointLongAggregator.initGrouping(driverContext), driverContext); + } + + public static List intermediateStateDesc() { + return INTERMEDIATE_STATE_DESC; + } + + @Override + public int intermediateBlockCount() { + return INTERMEDIATE_STATE_DESC.size(); + } + + @Override + public GroupingAggregatorFunction.AddInput prepareProcessPage(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"); + } + if (valuesVector == null) { + if (valuesBlock.mayHaveNulls()) { + state.enableGroupIdTracking(seenGroupIds); + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void close() { + } + }; + } + return new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void close() { + } + }; + } + + private void addRawInput(int positionOffset, IntVector groups, LongBlock values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + if (values.isNull(groupPosition + positionOffset)) { + continue; + } + int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); + int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); + for (int v = valuesStart; v < valuesEnd; v++) { + ChangePointLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongVector values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + var valuePosition = groupPosition + positionOffset; + ChangePointLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + } + } + + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + if (groups.isNull(groupPosition)) { + continue; + } + int groupStart = groups.getFirstValueIndex(groupPosition); + int groupEnd = groupStart + groups.getValueCount(groupPosition); + for (int g = groupStart; g < groupEnd; g++) { + int groupId = groups.getInt(g); + if (values.isNull(groupPosition + positionOffset)) { + continue; + } + int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); + int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); + for (int v = valuesStart; v < valuesEnd; v++) { + ChangePointLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBlock groups, LongVector values, + LongVector timestamps) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + if (groups.isNull(groupPosition)) { + continue; + } + 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; + ChangePointLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + } + } + } + + @Override + public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { + state.enableGroupIdTracking(seenGroupIds); + } + + @Override + public void addIntermediateInput(int positionOffset, IntVector groups, Page page) { + state.enableGroupIdTracking(new SeenGroupIds.Empty()); + assert channels.size() == intermediateBlockCount(); + Block timestampsUncast = page.getBlock(channels.get(0)); + if (timestampsUncast.areAllValuesNull()) { + return; + } + LongBlock timestamps = (LongBlock) timestampsUncast; + Block valuesUncast = page.getBlock(channels.get(1)); + if (valuesUncast.areAllValuesNull()) { + return; + } + DoubleBlock values = (DoubleBlock) valuesUncast; + assert timestamps.getPositionCount() == values.getPositionCount(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + ChangePointLongAggregator.combineIntermediate(state, groupId, timestamps, values, groupPosition + positionOffset); + } + } + + @Override + public void addIntermediateRowInput(int groupId, GroupingAggregatorFunction input, int position) { + if (input.getClass() != getClass()) { + throw new IllegalArgumentException("expected " + getClass() + "; got " + input.getClass()); + } + ChangePointStates.GroupingState inState = ((ChangePointLongGroupingAggregatorFunction) input).state; + state.enableGroupIdTracking(new SeenGroupIds.Empty()); + ChangePointLongAggregator.combineStates(state, groupId, inState, position); + } + + @Override + public void evaluateIntermediate(Block[] blocks, int offset, IntVector selected) { + state.toIntermediate(blocks, offset, selected, driverContext); + } + + @Override + public void evaluateFinal(Block[] blocks, int offset, IntVector selected, + DriverContext driverContext) { + blocks[offset] = ChangePointLongAggregator.evaluateFinal(state, selected, driverContext); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(getClass().getSimpleName()).append("["); + sb.append("channels=").append(channels); + sb.append("]"); + return sb.toString(); + } + + @Override + public void close() { + state.close(); + } +} 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 ca5cd1bda44d0..50f54e39e5615 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 @@ -58,24 +58,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BooleanBlock block = page.getBlock(channels.get(0)); + BooleanVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BooleanBlock block = page.getBlock(channels.get(0)); - BooleanVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BooleanBlock block = page.getBlock(channels.get(0)); - BooleanVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 38dadda1eba0c..940d67c7a2bfa 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 @@ -62,24 +62,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BytesRefBlock block = page.getBlock(channels.get(0)); + BytesRefVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 1d985fbd1dff6..6f50acb73e149 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 @@ -64,24 +64,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + DoubleBlock block = page.getBlock(channels.get(0)); + DoubleVector vector = block.asVector(); if (mask.allTrue()) { // No masking - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 36d2aaf3e3d4f..bf19587d43181 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 @@ -64,24 +64,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + FloatBlock block = page.getBlock(channels.get(0)); + FloatVector vector = block.asVector(); if (mask.allTrue()) { // No masking - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 05bebca924f7e..4c170ab980567 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 @@ -64,24 +64,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + IntBlock block = page.getBlock(channels.get(0)); + IntVector vector = block.asVector(); if (mask.allTrue()) { // No masking - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 9e62525fa2bb0..13235ed115dba 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 @@ -64,24 +64,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + LongBlock block = page.getBlock(channels.get(0)); + LongVector vector = block.asVector(); if (mask.allTrue()) { // No masking - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 01763200f2d2c..a5af42797526a 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 @@ -58,24 +58,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BooleanBlock block = page.getBlock(channels.get(0)); + BooleanVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BooleanBlock block = page.getBlock(channels.get(0)); - BooleanVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BooleanBlock block = page.getBlock(channels.get(0)); - BooleanVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 73b927cd9c521..8872904c9c7c9 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 @@ -61,24 +61,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BytesRefBlock block = page.getBlock(channels.get(0)); + BytesRefVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 04d24d49cbff8..369bb8e63d173 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 @@ -60,24 +60,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + DoubleBlock block = page.getBlock(channels.get(0)); + DoubleVector vector = block.asVector(); if (mask.allTrue()) { // No masking - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 ce22983bff72b..a1adf12c6f444 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 @@ -60,24 +60,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + FloatBlock block = page.getBlock(channels.get(0)); + FloatVector vector = block.asVector(); if (mask.allTrue()) { // No masking - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 6a91b574da769..7c7cca128f000 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 @@ -60,24 +60,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + IntBlock block = page.getBlock(channels.get(0)); + IntVector vector = block.asVector(); if (mask.allTrue()) { // No masking - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 7f6d47ce1c876..9c58f81c7de9e 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 @@ -61,24 +61,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BytesRefBlock block = page.getBlock(channels.get(0)); + BytesRefVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 97d12d1ef6852..ca50445945618 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 @@ -60,24 +60,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + LongBlock block = page.getBlock(channels.get(0)); + LongVector vector = block.asVector(); if (mask.allTrue()) { // No masking - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 611314318eba7..17724280e093e 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 @@ -61,24 +61,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + DoubleBlock block = page.getBlock(channels.get(0)); + DoubleVector vector = block.asVector(); if (mask.allTrue()) { // No masking - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 e20badf2ce38a..5369f127d841e 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 @@ -61,24 +61,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + FloatBlock block = page.getBlock(channels.get(0)); + FloatVector vector = block.asVector(); if (mask.allTrue()) { // No masking - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 df0d24d442283..b073f371b0bec 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 @@ -61,24 +61,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + IntBlock block = page.getBlock(channels.get(0)); + IntVector vector = block.asVector(); if (mask.allTrue()) { // No masking - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 e0ace94a1da49..fc6f0743e38bd 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 @@ -61,24 +61,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + LongBlock block = page.getBlock(channels.get(0)); + LongVector vector = block.asVector(); if (mask.allTrue()) { // No masking - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 4d91d3794aecb..117ec0ef51455 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 @@ -58,24 +58,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BooleanBlock block = page.getBlock(channels.get(0)); + BooleanVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BooleanBlock block = page.getBlock(channels.get(0)); - BooleanVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BooleanBlock block = page.getBlock(channels.get(0)); - BooleanVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 01ee21f82ab53..5745b3dca18d2 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 @@ -61,24 +61,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BytesRefBlock block = page.getBlock(channels.get(0)); + BytesRefVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 a436cdcdbef6d..a893cf7681172 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 @@ -60,24 +60,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + DoubleBlock block = page.getBlock(channels.get(0)); + DoubleVector vector = block.asVector(); if (mask.allTrue()) { // No masking - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 ec6757e59d074..0cf0ec5afd291 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 @@ -60,24 +60,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + FloatBlock block = page.getBlock(channels.get(0)); + FloatVector vector = block.asVector(); if (mask.allTrue()) { // No masking - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 f76dcec81d871..34d15f2cf6c93 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 @@ -60,24 +60,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + IntBlock block = page.getBlock(channels.get(0)); + IntVector vector = block.asVector(); if (mask.allTrue()) { // No masking - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 795299d9332fc..7870a2d603de7 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 @@ -61,24 +61,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BytesRefBlock block = page.getBlock(channels.get(0)); + BytesRefVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 4fc968bab2eff..e8f3a8aeaeeec 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 @@ -60,24 +60,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + LongBlock block = page.getBlock(channels.get(0)); + LongVector vector = block.asVector(); if (mask.allTrue()) { // No masking - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 9ece01135e0a9..d286d40d8e163 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 @@ -64,24 +64,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + DoubleBlock block = page.getBlock(channels.get(0)); + DoubleVector vector = block.asVector(); if (mask.allTrue()) { // No masking - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 434989adf47b2..f76683c0bf0a3 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 @@ -64,24 +64,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + FloatBlock block = page.getBlock(channels.get(0)); + FloatVector vector = block.asVector(); if (mask.allTrue()) { // No masking - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 eb4ae96f5dea5..473b8f34f96b1 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 @@ -64,24 +64,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + IntBlock block = page.getBlock(channels.get(0)); + IntVector vector = block.asVector(); if (mask.allTrue()) { // No masking - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 837f7efb32441..730794d8b756d 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 @@ -64,24 +64,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + LongBlock block = page.getBlock(channels.get(0)); + LongVector vector = block.asVector(); if (mask.allTrue()) { // No masking - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 dd6cc89401a99..5556d58ed2fe6 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 @@ -62,24 +62,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + DoubleBlock block = page.getBlock(channels.get(0)); + DoubleVector vector = block.asVector(); if (mask.allTrue()) { // No masking - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 bf8c4854f6b93..7deb6cb213756 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 @@ -64,24 +64,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + FloatBlock block = page.getBlock(channels.get(0)); + FloatVector vector = block.asVector(); if (mask.allTrue()) { // No masking - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 4a5585a7dd454..79eef21bc75c7 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 @@ -64,24 +64,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + IntBlock block = page.getBlock(channels.get(0)); + IntVector vector = block.asVector(); if (mask.allTrue()) { // No masking - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 b5ed31116a90c..45c4a8462ecbc 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 @@ -62,24 +62,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + LongBlock block = page.getBlock(channels.get(0)); + LongVector vector = block.asVector(); if (mask.allTrue()) { // No masking - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 4d24579203df1..45668176b75f3 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 @@ -61,24 +61,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + DoubleBlock block = page.getBlock(channels.get(0)); + DoubleVector vector = block.asVector(); if (mask.allTrue()) { // No masking - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 50f41b5edc05f..72f539bc4f434 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 @@ -63,24 +63,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + FloatBlock block = page.getBlock(channels.get(0)); + FloatVector vector = block.asVector(); if (mask.allTrue()) { // No masking - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 95bd95ac474ad..b2c6ac4bfef78 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 @@ -62,24 +62,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + IntBlock block = page.getBlock(channels.get(0)); + IntVector vector = block.asVector(); if (mask.allTrue()) { // No masking - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 fac21d99bf713..be64c23561a73 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 @@ -60,24 +60,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + LongBlock block = page.getBlock(channels.get(0)); + LongVector vector = block.asVector(); if (mask.allTrue()) { // No masking - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 b8d06787f7f68..a93c120f21e83 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 @@ -63,24 +63,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BooleanBlock block = page.getBlock(channels.get(0)); + BooleanVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BooleanBlock block = page.getBlock(channels.get(0)); - BooleanVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BooleanBlock block = page.getBlock(channels.get(0)); - BooleanVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 9ef460be5796b..ced638ee3de07 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 @@ -65,24 +65,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BytesRefBlock block = page.getBlock(channels.get(0)); + BytesRefVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 210bc76483a81..105bb0d8929a9 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 @@ -64,24 +64,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + DoubleBlock block = page.getBlock(channels.get(0)); + DoubleVector vector = block.asVector(); if (mask.allTrue()) { // No masking - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 f7fdb406acadb..519d64c052874 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 @@ -64,24 +64,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + FloatBlock block = page.getBlock(channels.get(0)); + FloatVector vector = block.asVector(); if (mask.allTrue()) { // No masking - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 1ea40134f7260..74a52bd306c93 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 @@ -64,24 +64,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + IntBlock block = page.getBlock(channels.get(0)); + IntVector vector = block.asVector(); if (mask.allTrue()) { // No masking - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 8c216c90504c1..5fb06eb01dfb5 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 @@ -65,24 +65,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BytesRefBlock block = page.getBlock(channels.get(0)); + BytesRefVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 85df0f7edc843..e49e287336a08 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 @@ -64,24 +64,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + LongBlock block = page.getBlock(channels.get(0)); + LongVector vector = block.asVector(); if (mask.allTrue()) { // No masking - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 abf73c07d4ab6..698db601c8fc1 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 @@ -57,24 +57,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BooleanBlock block = page.getBlock(channels.get(0)); + BooleanVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BooleanBlock block = page.getBlock(channels.get(0)); - BooleanVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BooleanBlock block = page.getBlock(channels.get(0)); - BooleanVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 ecc6424ba8501..13157868d0978 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 @@ -59,24 +59,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BytesRefBlock block = page.getBlock(channels.get(0)); + BytesRefVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 2fa8ed31ec427..cffda158c2540 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 @@ -58,24 +58,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + DoubleBlock block = page.getBlock(channels.get(0)); + DoubleVector vector = block.asVector(); if (mask.allTrue()) { // No masking - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - DoubleBlock block = page.getBlock(channels.get(0)); - DoubleVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 8b61c6d07eed6..041aebf86b4be 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 @@ -58,24 +58,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + FloatBlock block = page.getBlock(channels.get(0)); + FloatVector vector = block.asVector(); if (mask.allTrue()) { // No masking - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - FloatBlock block = page.getBlock(channels.get(0)); - FloatVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 7f12bbc18b202..060eb9248f4ea 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 @@ -58,24 +58,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + IntBlock block = page.getBlock(channels.get(0)); + IntVector vector = block.asVector(); if (mask.allTrue()) { // No masking - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - IntBlock block = page.getBlock(channels.get(0)); - IntVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 7e8c256d90f93..cf29fa8bfe635 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 @@ -58,24 +58,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + LongBlock block = page.getBlock(channels.get(0)); + LongVector vector = block.asVector(); if (mask.allTrue()) { // No masking - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 a205c728db5fc..36a6919d70849 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 @@ -66,24 +66,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + LongBlock block = page.getBlock(channels.get(0)); + LongVector vector = block.asVector(); if (mask.allTrue()) { // No masking - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 e20a3fb1cfa35..2c3bb6000c12c 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 @@ -69,24 +69,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BytesRefBlock block = page.getBlock(channels.get(0)); + BytesRefVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 b2c237a904796..6092483f02c85 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 @@ -66,24 +66,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + LongBlock block = page.getBlock(channels.get(0)); + LongVector vector = block.asVector(); if (mask.allTrue()) { // No masking - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 db61420fb8cbe..be11329b37111 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 @@ -69,24 +69,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BytesRefBlock block = page.getBlock(channels.get(0)); + BytesRefVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 21306036fbf50..58a9c76d31c84 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 @@ -65,24 +65,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + LongBlock block = page.getBlock(channels.get(0)); + LongVector vector = block.asVector(); if (mask.allTrue()) { // No masking - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 6610168e1df21..73d2bd4b00767 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 @@ -66,24 +66,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BytesRefBlock block = page.getBlock(channels.get(0)); + BytesRefVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeAggregatorFunction.java index 19aa4f7ca78a2..ca393bce6e5c2 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeAggregatorFunction.java @@ -66,24 +66,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BytesRefBlock block = page.getBlock(channels.get(0)); + BytesRefVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 c883e82d45989..4e33e6b8d5d31 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 @@ -67,24 +67,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + LongBlock block = page.getBlock(channels.get(0)); + LongVector vector = block.asVector(); if (mask.allTrue()) { // No masking - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - LongBlock block = page.getBlock(channels.get(0)); - LongVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } 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 cf65fbdde594c..6472e0ef05c56 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 @@ -68,24 +68,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BytesRefBlock block = page.getBlock(channels.get(0)); + BytesRefVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeAggregatorFunction.java index abee9a1cee284..45155dcb76e1e 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeAggregatorFunction.java @@ -68,24 +68,23 @@ public void addRawInput(Page page, BooleanVector mask) { // Entire page masked away return; } + BytesRefBlock block = page.getBlock(channels.get(0)); + BytesRefVector vector = block.asVector(); if (mask.allTrue()) { // No masking - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); if (vector != null) { addRawVector(vector); } else { addRawBlock(block); } return; - } - // Some positions masked away, others kept - BytesRefBlock block = page.getBlock(channels.get(0)); - BytesRefVector vector = block.asVector(); - if (vector != null) { - addRawVector(vector, mask); } else { - addRawBlock(block, mask); + // Some positions masked away, others kept + if (vector != null) { + addRawVector(vector, mask); + } else { + addRawBlock(block, mask); + } } } diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/ChangePointStates.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/ChangePointStates.java new file mode 100644 index 0000000000000..b4c64e2ea7878 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/ChangePointStates.java @@ -0,0 +1,278 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +package org.elasticsearch.compute.aggregation; + +import org.apache.lucene.util.BytesRef; +import org.elasticsearch.common.Strings; +import org.elasticsearch.common.util.BigArrays; +import org.elasticsearch.common.util.DoubleArray; +import org.elasticsearch.common.util.LongArray; +import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BlockFactory; +import org.elasticsearch.compute.data.BytesRefBlock; +import org.elasticsearch.compute.data.DoubleBlock; +import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.operator.DriverContext; +import org.elasticsearch.core.Releasable; +import org.elasticsearch.core.Releasables; +import org.elasticsearch.xcontent.ToXContent; +import org.elasticsearch.xcontent.XContentBuilder; +import org.elasticsearch.xcontent.XContentFactory; +import org.elasticsearch.xpack.core.ml.utils.NamedXContentObjectHelper; +import org.elasticsearch.xpack.ml.aggs.MlAggsHelper; +import org.elasticsearch.xpack.ml.aggs.changepoint.ChangePointDetector; +import org.elasticsearch.xpack.ml.aggs.changepoint.ChangeType; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class ChangePointStates { + + record TimeAndValue(long timestamp, double value) implements Comparable { + @Override + public int compareTo(TimeAndValue other) { + return Long.compare(timestamp, other.timestamp); + } + } + + static class SingleState implements Releasable { + private final BigArrays bigArrays; + private int count; + private LongArray timestamps; + private DoubleArray values; + + SingleState(BigArrays bigArrays) { + this.bigArrays = bigArrays; + count = 0; + timestamps = bigArrays.newLongArray(0); + values = bigArrays.newDoubleArray(0); + } + + void add(long timestamp, double value) { + count++; + timestamps = bigArrays.grow(timestamps, count); + timestamps.set(count - 1, timestamp); + values = bigArrays.grow(values, count); + values.set(count - 1, value); + } + + void add(LongBlock timestamps, DoubleBlock values) { + add(timestamps, values, 0); + } + + void add(LongBlock timestamps, DoubleBlock values, int otherPosition) { + final int valueCount = timestamps.getValueCount(otherPosition); + final int firstIndex = timestamps.getFirstValueIndex(otherPosition); + for (int i = 0; i < valueCount; i++) { + add(timestamps.getLong(firstIndex + i), values.getDouble(firstIndex + i)); + } + } + + void toIntermediate(Block[] blocks, int offset, DriverContext driverContext) { + blocks[offset] = buildTimestampsBlock(driverContext.blockFactory()); + blocks[offset + 1] = buildValuesBlock(driverContext.blockFactory()); + } + + // TODO: this needs to output multiple columns or a composite object, not a JSON blob. + Block toBlock(BlockFactory blockFactory) { + return blockFactory.newConstantBytesRefBlockWith(getChangePoint(), 1); + } + + private Block buildTimestampsBlock(BlockFactory blockFactory) { + if (timestamps.size() == 0) { + return blockFactory.newConstantNullBlock(1); + } + if (values.size() == 1) { + return blockFactory.newConstantLongBlockWith(timestamps.get(0), 1); + } + try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder((int) timestamps.size())) { + builder.beginPositionEntry(); + for (int id = 0; id < count; id++) { + builder.appendLong(timestamps.get(id)); + } + builder.endPositionEntry(); + return builder.build(); + } + } + + private Block buildValuesBlock(BlockFactory blockFactory) { + if (values.size() == 0) { + return blockFactory.newConstantNullBlock(1); + } + if (values.size() == 1) { + return blockFactory.newConstantDoubleBlockWith(values.get(0), 1); + } + try (DoubleBlock.Builder builder = blockFactory.newDoubleBlockBuilder((int) values.size())) { + builder.beginPositionEntry(); + for (int id = 0; id < count; id++) { + builder.appendDouble(values.get(id)); + } + builder.endPositionEntry(); + return builder.build(); + } + } + + // TODO: this needs to output multiple columns or a composite object, not a JSON blob. + private BytesRef getChangePoint() { + // TODO: probably reuse ES|QL sort/orderBy to get results in order + // TODO: this copying/sorting doesn't account for memory + List list = new ArrayList<>(count); + for (int i = 0; i < count; i++) { + list.add(new TimeAndValue(timestamps.get(i), values.get(i))); + } + Collections.sort(list); + double[] values = new double[count]; + for (int i = 0; i < count; i++) { + values[i] = list.get(i).value; + } + MlAggsHelper.DoubleBucketValues bucketValues = new MlAggsHelper.DoubleBucketValues(null, values); + ChangeType changeType = ChangePointDetector.getChangeType(bucketValues); + try (XContentBuilder xContentBuilder = XContentFactory.jsonBuilder()) { + xContentBuilder.startObject(); + NamedXContentObjectHelper.writeNamedObject(xContentBuilder, ToXContent.EMPTY_PARAMS, "type", changeType); + xContentBuilder.endObject(); + String xContent = Strings.toString(xContentBuilder); + return new BytesRef(xContent); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + @Override + public void close() { + Releasables.close(timestamps, values); + } + } + + static class GroupingState implements Releasable { + private final BigArrays bigArrays; + private final Map states; + + GroupingState(BigArrays bigArrays) { + this.bigArrays = bigArrays; + states = new HashMap<>(); + } + + void add(int groupId, long timestamp, double value) { + SingleState state = states.computeIfAbsent(groupId, key -> new SingleState(bigArrays)); + state.add(timestamp, value); + } + + void combine(int groupId, LongBlock timestamps, DoubleBlock values, int otherPosition) { + if (timestamps.getValueCount(otherPosition) == 0) { + return; + } + SingleState state = states.computeIfAbsent(groupId, key -> new SingleState(bigArrays)); + state.add(timestamps, values, otherPosition); + } + + void combineState(int groupId, GroupingState otherState, int otherGroupId) { + SingleState other = otherState.states.get(otherGroupId); + if (other == null) { + return; + } + var state = states.computeIfAbsent(groupId, key -> new SingleState(bigArrays)); + for (int i = 0; i < other.timestamps.size(); i++) { + state.add(state.timestamps.get(i), state.values.get(i)); + } + } + + void toIntermediate(Block[] blocks, int offset, IntVector selected, DriverContext driverContext) { + blocks[offset] = buildTimestampsBlock(driverContext.blockFactory(), selected); + blocks[offset + 1] = buildValuesBlock(driverContext.blockFactory(), selected); + } + + // TODO: this needs to output multiple columns or a composite object, not a JSON blob. + Block evaluateFinal(IntVector selected, BlockFactory blockFactory) { + try (BytesRefBlock.Builder builder = blockFactory.newBytesRefBlockBuilder(selected.getPositionCount())) { + for (int s = 0; s < selected.getPositionCount(); s++) { + builder.appendBytesRef(states.get(selected.getInt(s)).getChangePoint()); + } + return builder.build(); + } + } + + private Block buildTimestampsBlock(BlockFactory blockFactory, IntVector selected) { + if (states.isEmpty()) { + return blockFactory.newConstantNullBlock(selected.getPositionCount()); + } + try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder(selected.getPositionCount())) { + for (int s = 0; s < selected.getPositionCount(); s++) { + int selectedGroup = selected.getInt(s); + SingleState state = states.get(selectedGroup); + int count = 0; + long first = 0; + for (int i = 0; i < state.count; i++) { + long timestamp = state.timestamps.get(i); + switch (count) { + case 0 -> first = timestamp; + case 1 -> { + builder.beginPositionEntry(); + builder.appendLong(first); + builder.appendLong(timestamp); + } + default -> builder.appendLong(timestamp); + } + count++; + } + switch (count) { + case 0 -> builder.appendNull(); + case 1 -> builder.appendLong(first); + default -> builder.endPositionEntry(); + } + } + return builder.build(); + } + } + + private Block buildValuesBlock(BlockFactory blockFactory, IntVector selected) { + if (states.isEmpty()) { + return blockFactory.newConstantNullBlock(selected.getPositionCount()); + } + try (DoubleBlock.Builder builder = blockFactory.newDoubleBlockBuilder(selected.getPositionCount())) { + for (int s = 0; s < selected.getPositionCount(); s++) { + int selectedGroup = selected.getInt(s); + SingleState state = states.get(selectedGroup); + int count = 0; + double first = 0; + for (int i = 0; i < state.count; i++) { + double value = state.values.get(i); + switch (count) { + case 0 -> first = value; + case 1 -> { + builder.beginPositionEntry(); + builder.appendDouble(first); + builder.appendDouble(value); + } + default -> builder.appendDouble(value); + } + count++; + } + switch (count) { + case 0 -> builder.appendNull(); + case 1 -> builder.appendDouble(first); + default -> builder.endPositionEntry(); + } + } + return builder.build(); + } + } + + void enableGroupIdTracking(SeenGroupIds seenGroupIds) {} + + @Override + public void close() { + Releasables.close(states.values()); + } + } +} diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/X-ChangePointAggregator.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/X-ChangePointAggregator.java.st new file mode 100644 index 0000000000000..97ce04844a58a --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/X-ChangePointAggregator.java.st @@ -0,0 +1,77 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +package org.elasticsearch.compute.aggregation; + +import org.elasticsearch.compute.aggregation.ChangePointStates.GroupingState; +import org.elasticsearch.compute.aggregation.ChangePointStates.SingleState; +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.DoubleBlock; +import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.operator.DriverContext; + +/** + * Change point detection for series of $type$ values. + * This class is generated. Edit @{code X-ChangePointAggregator.java.st} instead + * of this file. + */ +@Aggregator( + includeTimestamps = true, + value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "DOUBLE_BLOCK") } +) +@GroupingAggregator( + includeTimestamps = true, + value = { @IntermediateState(name = "timestamps", type = "LONG_BLOCK"), @IntermediateState(name = "values", type = "DOUBLE_BLOCK") } +) +class ChangePoint$Type$Aggregator { + + public static SingleState initSingle(DriverContext driverContext) { + return new SingleState(driverContext.bigArrays()); + } + + public static void combine(SingleState state, long timestamp, $type$ value) { + state.add(timestamp, value); + } + + public static void combineIntermediate(SingleState state, LongBlock timestamps, DoubleBlock values) { + state.add(timestamps, values); + } + + public static Block evaluateFinal(SingleState state, DriverContext driverContext) { + return state.toBlock(driverContext.blockFactory()); + } + + public static GroupingState initGrouping(DriverContext driverContext) { + return new GroupingState(driverContext.bigArrays()); + } + + public static void combine(GroupingState current, int groupId, long timestamp, $type$ value) { + current.add(groupId, timestamp, value); + } + + public static void combineIntermediate( + GroupingState current, + int groupId, + LongBlock timestamps, + DoubleBlock values, + int otherPosition + ) { + current.combine(groupId, timestamps, values, otherPosition); + } + + public static void combineStates(GroupingState current, int currentGroupId, GroupingState otherState, int otherGroupId) { + current.combineState(currentGroupId, otherState, otherGroupId); + } + + public static Block evaluateFinal(GroupingState state, IntVector selected, DriverContext driverContext) { + return state.evaluateFinal(selected, driverContext.blockFactory()); + } +} diff --git a/x-pack/plugin/esql/qa/testFixtures/src/main/resources/change_point.csv-spec b/x-pack/plugin/esql/qa/testFixtures/src/main/resources/change_point.csv-spec new file mode 100644 index 0000000000000..15572ede49254 --- /dev/null +++ b/x-pack/plugin/esql/qa/testFixtures/src/main/resources/change_point.csv-spec @@ -0,0 +1,98 @@ +change point stationary with timestamp argument +required_capability: change_point + +FROM k8s + | STATS count=COUNT() BY timestamp=BUCKET(@timestamp, 1 minute) + | STATS cp=CHANGE_POINT(count, timestamp) +; + +cp:keyword +"{""type"":{""stationary"":{}}}" +; + + +change point stationary without timestamp argument +required_capability: change_point + +FROM k8s + | STATS count=COUNT() BY @timestamp=BUCKET(@timestamp, 1 minute) + | STATS cp=CHANGE_POINT(count) +; + +cp:keyword +"{""type"":{""stationary"":{}}}" +; + + +change point spike (long) +required_capability: change_point + +FROM k8s + | STATS count=COUNT() BY timestamp=BUCKET(@timestamp, 1 minute) + | EVAL count = count + CASE(timestamp=="2024-05-10T00:09:00.000Z", 1000, 0) + | STATS cp=CHANGE_POINT(count, timestamp) +; + +cp:keyword +"{""type"":{""spike"":{""p_value"":0.0,""change_point"":9}}}" +; + + +change point spike (int) +required_capability: change_point + +FROM k8s + | STATS count=COUNT() BY timestamp=BUCKET(@timestamp, 1 minute) + | EVAL count = TO_INTEGER(count + CASE(timestamp=="2024-05-10T00:09:00.000Z", 1000, 0)) + | STATS cp=CHANGE_POINT(count, timestamp) +; + +cp:keyword +"{""type"":{""spike"":{""p_value"":0.0,""change_point"":9}}}" +; + + +change point spike (double) +required_capability: change_point + +FROM k8s + | STATS count=COUNT() BY timestamp=BUCKET(@timestamp, 1 minute) + | EVAL count = TO_DOUBLE(count + CASE(timestamp=="2024-05-10T00:09:00.000Z", 1000, 0)) + | STATS cp=CHANGE_POINT(count, timestamp) +; + +cp:keyword +"{""type"":{""spike"":{""p_value"":0.0,""change_point"":9}}}" +; + + +change point grouping with timestamp argument +required_capability: change_point + +FROM k8s + | STATS count=COUNT() BY timestamp=BUCKET(@timestamp, 1 minute), cluster + | STATS cp=CHANGE_POINT(count, timestamp) BY cluster + | SORT cluster +; + +cp:keyword | cluster:keyword +"{""type"":{""indeterminable"":{""reason"":""not enough buckets to calculate change_point. Requires at least [22]; found [21]""}}}" | prod +"{""type"":{""stationary"":{}}}" | qa +"{""type"":{""indeterminable"":{""reason"":""not enough buckets to calculate change_point. Requires at least [22]; found [18]""}}}" | staging +; + + +change point grouping without timestamp argument +required_capability: change_point + +FROM k8s + | STATS count=COUNT() BY @timestamp=BUCKET(@timestamp, 1 minute), cluster + | STATS cp=CHANGE_POINT(count) BY cluster + | SORT cluster +; + +cp:keyword | cluster:keyword +"{""type"":{""indeterminable"":{""reason"":""not enough buckets to calculate change_point. Requires at least [22]; found [21]""}}}" | prod +"{""type"":{""stationary"":{}}}" | qa +"{""type"":{""indeterminable"":{""reason"":""not enough buckets to calculate change_point. Requires at least [22]; found [18]""}}}" | staging +; diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/EsqlCapabilities.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/EsqlCapabilities.java index 5c259caa9c940..2535f9cec2840 100644 --- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/EsqlCapabilities.java +++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/EsqlCapabilities.java @@ -600,7 +600,12 @@ public enum Cap { /** * Full text functions can be used in disjunctions */ - FULL_TEXT_FUNCTIONS_DISJUNCTIONS; + FULL_TEXT_FUNCTIONS_DISJUNCTIONS, + + /** + * Support change point detection function "CHANGE_POINT" + */ + CHANGE_POINT; private final boolean enabled; diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/EsqlFunctionRegistry.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/EsqlFunctionRegistry.java index 908c9c5f197a8..e663ae98b32e7 100644 --- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/EsqlFunctionRegistry.java +++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/EsqlFunctionRegistry.java @@ -18,6 +18,7 @@ import org.elasticsearch.xpack.esql.core.type.DataType; import org.elasticsearch.xpack.esql.core.util.Check; import org.elasticsearch.xpack.esql.expression.function.aggregate.Avg; +import org.elasticsearch.xpack.esql.expression.function.aggregate.ChangePoint; import org.elasticsearch.xpack.esql.expression.function.aggregate.Count; import org.elasticsearch.xpack.esql.expression.function.aggregate.CountDistinct; import org.elasticsearch.xpack.esql.expression.function.aggregate.Max; @@ -427,6 +428,7 @@ private static FunctionDefinition[][] snapshotFunctions() { new FunctionDefinition[] { // The delay() function is for debug/snapshot environments only and should never be enabled in a non-snapshot build. // This is an experimental function and can be removed without notice. + def(ChangePoint.class, bi(ChangePoint::new), "change_point"), def(Delay.class, Delay::new, "delay"), def(Kql.class, uni(Kql::new), "kql"), def(Rate.class, Rate::withUnresolvedTimestamp, "rate"), diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/aggregate/AggregateWritables.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/aggregate/AggregateWritables.java index db1d2a9e6f254..d94298eb55ec7 100644 --- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/aggregate/AggregateWritables.java +++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/aggregate/AggregateWritables.java @@ -16,6 +16,7 @@ public class AggregateWritables { public static List getNamedWriteables() { return List.of( Avg.ENTRY, + ChangePoint.ENTRY, Count.ENTRY, CountDistinct.ENTRY, Max.ENTRY, diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/aggregate/ChangePoint.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/aggregate/ChangePoint.java new file mode 100644 index 0000000000000..3e3bcc28ca0f4 --- /dev/null +++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/aggregate/ChangePoint.java @@ -0,0 +1,121 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +package org.elasticsearch.xpack.esql.expression.function.aggregate; + +import org.elasticsearch.common.io.stream.NamedWriteableRegistry; +import org.elasticsearch.common.io.stream.StreamInput; +import org.elasticsearch.compute.aggregation.AggregatorFunctionSupplier; +import org.elasticsearch.compute.aggregation.ChangePointDoubleAggregatorFunctionSupplier; +import org.elasticsearch.compute.aggregation.ChangePointIntAggregatorFunctionSupplier; +import org.elasticsearch.compute.aggregation.ChangePointLongAggregatorFunctionSupplier; +import org.elasticsearch.xpack.esql.EsqlIllegalArgumentException; +import org.elasticsearch.xpack.esql.core.expression.Expression; +import org.elasticsearch.xpack.esql.core.expression.Literal; +import org.elasticsearch.xpack.esql.core.expression.UnresolvedAttribute; +import org.elasticsearch.xpack.esql.core.tree.NodeInfo; +import org.elasticsearch.xpack.esql.core.tree.Source; +import org.elasticsearch.xpack.esql.core.type.DataType; +import org.elasticsearch.xpack.esql.expression.function.FunctionInfo; +import org.elasticsearch.xpack.esql.expression.function.OptionalArgument; +import org.elasticsearch.xpack.esql.expression.function.Param; +import org.elasticsearch.xpack.esql.io.stream.PlanStreamInput; +import org.elasticsearch.xpack.esql.planner.ToAggregator; + +import java.io.IOException; +import java.util.List; + +import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.ParamOrdinal.FIRST; +import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.ParamOrdinal.SECOND; +import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.isType; + +public class ChangePoint extends AggregateFunction implements OptionalArgument, ToAggregator { + public static final NamedWriteableRegistry.Entry ENTRY = new NamedWriteableRegistry.Entry( + Expression.class, + "ChangePoint", + ChangePoint::new + ); + + @FunctionInfo(returnType = { "string" }, description = "Detects spikes, dips, and change points in a metric", isAggregation = true) + public ChangePoint( + Source source, + @Param(name = "field", type = { "double", "integer", "long" }, description = "field") Expression field, + @Param(optional = true, name = "timestamp", type = { "date_nanos", "datetime", "double", "integer", "long" }) Expression timestamp + ) { + this(source, field, Literal.TRUE, timestamp != null ? timestamp : new UnresolvedAttribute(source, "@timestamp")); + } + + public ChangePoint(Source source, Expression field, Expression filter, Expression timestamp) { + super(source, field, filter, List.of(timestamp)); + } + + private ChangePoint(StreamInput in) throws IOException { + super( + Source.readFrom((PlanStreamInput) in), + in.readNamedWriteable(Expression.class), + in.readNamedWriteable(Expression.class), + in.readNamedWriteableCollectionAsList(Expression.class) + ); + } + + @Override + public String getWriteableName() { + return ENTRY.name; + } + + Expression timestamp() { + return parameters().get(0); + } + + @Override + protected NodeInfo info() { + return NodeInfo.create(this, ChangePoint::new, field(), filter(), timestamp()); + } + + @Override + public ChangePoint replaceChildren(List newChildren) { + if (newChildren.size() == 2) { + return new ChangePoint(source(), newChildren.get(0), newChildren.get(1)); + } else { + return new ChangePoint(source(), newChildren.get(0), newChildren.get(1), newChildren.get(2)); + } + } + + // TODO: this needs to output multiple columns or a composite object + @Override + public DataType dataType() { + return DataType.KEYWORD; + } + + @Override + protected TypeResolution resolveType() { + return isType(field(), dt -> dt.isNumeric(), sourceText(), FIRST, "numeric").and( + isType(timestamp(), dt -> dt.isDate() || dt.isNumeric(), sourceText(), SECOND, "date_nanos or datetime or numeric") + ); + } + + @Override + public AggregateFunction withFilter(Expression filter) { + return new ChangePoint(source(), field(), filter, timestamp()); + } + + @Override + public AggregatorFunctionSupplier supplier(List inputChannels) { + final DataType type = field().dataType(); + return switch (type) { + case LONG -> new ChangePointLongAggregatorFunctionSupplier(inputChannels); + case INTEGER -> new ChangePointIntAggregatorFunctionSupplier(inputChannels); + case DOUBLE -> new ChangePointDoubleAggregatorFunctionSupplier(inputChannels); + default -> throw EsqlIllegalArgumentException.illegalDataType(type); + }; + } + + @Override + public String toString() { + return "change_point{field=" + field() + ",timestamp=" + timestamp() + "}"; + } +} diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/planner/AggregateMapper.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/planner/AggregateMapper.java index 1918e3036e2b0..698b159abb466 100644 --- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/planner/AggregateMapper.java +++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/planner/AggregateMapper.java @@ -24,6 +24,7 @@ import org.elasticsearch.xpack.esql.core.tree.Source; import org.elasticsearch.xpack.esql.core.type.DataType; import org.elasticsearch.xpack.esql.expression.function.aggregate.AggregateFunction; +import org.elasticsearch.xpack.esql.expression.function.aggregate.ChangePoint; import org.elasticsearch.xpack.esql.expression.function.aggregate.Count; import org.elasticsearch.xpack.esql.expression.function.aggregate.CountDistinct; import org.elasticsearch.xpack.esql.expression.function.aggregate.FromPartial; @@ -71,6 +72,7 @@ final class AggregateMapper { /** List of all mappable ESQL agg functions (excludes surrogates like AVG = SUM/COUNT). */ private static final List> AGG_FUNCTIONS = List.of( + ChangePoint.class, Count.class, CountDistinct.class, Max.class, @@ -195,6 +197,8 @@ private static Stream, Tuple>> typeAndNames(Class types = List.of(""); // no type } else if (CountDistinct.class.isAssignableFrom(clazz)) { types = Stream.concat(NUMERIC.stream(), Stream.of("Boolean", "BytesRef")).toList(); + } else if (ChangePoint.class.isAssignableFrom(clazz)) { + types = List.of("Int", "Long", "Double"); } else { assert false : "unknown aggregate type " + clazz; throw new IllegalArgumentException("unknown aggregate type " + clazz); diff --git a/x-pack/plugin/ml/src/main/java/module-info.java b/x-pack/plugin/ml/src/main/java/module-info.java index 4984fa8912e28..8752cdc149484 100644 --- a/x-pack/plugin/ml/src/main/java/module-info.java +++ b/x-pack/plugin/ml/src/main/java/module-info.java @@ -37,7 +37,9 @@ exports org.elasticsearch.xpack.ml; exports org.elasticsearch.xpack.ml.action; + exports org.elasticsearch.xpack.ml.aggs; exports org.elasticsearch.xpack.ml.aggs.categorization; + exports org.elasticsearch.xpack.ml.aggs.changepoint; exports org.elasticsearch.xpack.ml.autoscaling; exports org.elasticsearch.xpack.ml.job.categorization; exports org.elasticsearch.xpack.ml.notifications; diff --git a/x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/esql/60_usage.yml b/x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/esql/60_usage.yml index b6d75048591e5..d2ba4708c4662 100644 --- a/x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/esql/60_usage.yml +++ b/x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/esql/60_usage.yml @@ -92,7 +92,7 @@ setup: - gt: {esql.functions.to_long: $functions_to_long} - match: {esql.functions.coalesce: $functions_coalesce} # Testing for the entire function set isn't feasbile, so we just check that we return the correct count as an approximation. - - length: {esql.functions: 130} # check the "sister" test below for a likely update to the same esql.functions length check + - length: {esql.functions: 131} # check the "sister" test below for a likely update to the same esql.functions length check --- "Basic ESQL usage output (telemetry) non-snapshot version":