From 3322f34faefcea4610c162ca084b29bb3588b23b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Wed, 16 Apr 2025 14:29:20 +0200 Subject: [PATCH 01/39] Add initial blockhash with TreeSet and basic operator test --- .../blockhash/BytesRefBlockHash.java | 9 + .../blockhash/DoubleBlockHash.java | 9 + .../aggregation/blockhash/IntBlockHash.java | 9 + .../aggregation/blockhash/LongBlockHash.java | 9 + .../blockhash/LongTopNBlockHash.java | 303 ++++++++ .../aggregation/blockhash/TopNBlockHash.java | 52 ++ .../aggregation/blockhash/X-BlockHash.java.st | 9 + .../compute/data/sort/LongSortedSet.java | 40 ++ .../mvdedupe/TopNMultivalueDedupeLong.java | 655 ++++++++++++++++++ .../HashAggregationOperatorTests.java | 66 ++ 10 files changed, 1161 insertions(+) create mode 100644 x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java create mode 100644 x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHash.java create mode 100644 x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongSortedSet.java create mode 100644 x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/BytesRefBlockHash.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/BytesRefBlockHash.java index 9297e76d5c0be..834585f5475a7 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/BytesRefBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/BytesRefBlockHash.java @@ -74,6 +74,9 @@ public void add(Page page, GroupingAggregatorFunction.AddInput addInput) { } } + /** + * Adds the vector values to the hash, and returns a new vector with the group IDs for those positions. + */ IntVector add(BytesRefVector vector) { var ordinals = vector.asOrdinals(); if (ordinals != null) { @@ -90,6 +93,12 @@ IntVector add(BytesRefVector vector) { } } + /** + * Adds the block values to the hash, and returns a new vector with the group IDs for those positions. + *

+ * For nulls, a 0 group ID is used. For multivalues, a multivalue is used with all the group IDs. + *

+ */ IntBlock add(BytesRefBlock block) { var ordinals = block.asOrdinals(); if (ordinals != null) { diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/DoubleBlockHash.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/DoubleBlockHash.java index ede268271d9dd..48fa60242b459 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/DoubleBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/DoubleBlockHash.java @@ -73,6 +73,9 @@ public void add(Page page, GroupingAggregatorFunction.AddInput addInput) { } } + /** + * Adds the vector values to the hash, and returns a new vector with the group IDs for those positions. + */ IntVector add(DoubleVector vector) { int positions = vector.getPositionCount(); try (var builder = blockFactory.newIntVectorFixedBuilder(positions)) { @@ -84,6 +87,12 @@ IntVector add(DoubleVector vector) { } } + /** + * Adds the block values to the hash, and returns a new vector with the group IDs for those positions. + *

+ * For nulls, a 0 group ID is used. For multivalues, a multivalue is used with all the group IDs. + *

+ */ IntBlock add(DoubleBlock block) { MultivalueDedupe.HashResult result = new MultivalueDedupeDouble(block).hashAdd(blockFactory, hash); seenNull |= result.sawNull(); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/IntBlockHash.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/IntBlockHash.java index 3a3267af3c983..40c49e31ea349 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/IntBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/IntBlockHash.java @@ -71,6 +71,9 @@ public void add(Page page, GroupingAggregatorFunction.AddInput addInput) { } } + /** + * Adds the vector values to the hash, and returns a new vector with the group IDs for those positions. + */ IntVector add(IntVector vector) { int positions = vector.getPositionCount(); try (var builder = blockFactory.newIntVectorFixedBuilder(positions)) { @@ -82,6 +85,12 @@ IntVector add(IntVector vector) { } } + /** + * Adds the block values to the hash, and returns a new vector with the group IDs for those positions. + *

+ * For nulls, a 0 group ID is used. For multivalues, a multivalue is used with all the group IDs. + *

+ */ IntBlock add(IntBlock block) { MultivalueDedupe.HashResult result = new MultivalueDedupeInt(block).hashAdd(blockFactory, hash); seenNull |= result.sawNull(); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/LongBlockHash.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/LongBlockHash.java index c5152ae3cd22d..a260b52eb2642 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/LongBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/blockhash/LongBlockHash.java @@ -73,6 +73,9 @@ public void add(Page page, GroupingAggregatorFunction.AddInput addInput) { } } + /** + * Adds the vector values to the hash, and returns a new vector with the group IDs for those positions. + */ IntVector add(LongVector vector) { int positions = vector.getPositionCount(); try (var builder = blockFactory.newIntVectorFixedBuilder(positions)) { @@ -84,6 +87,12 @@ IntVector add(LongVector vector) { } } + /** + * Adds the block values to the hash, and returns a new vector with the group IDs for those positions. + *

+ * For nulls, a 0 group ID is used. For multivalues, a multivalue is used with all the group IDs. + *

+ */ IntBlock add(LongBlock block) { MultivalueDedupe.HashResult result = new MultivalueDedupeLong(block).hashAdd(blockFactory, hash); seenNull |= result.sawNull(); diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java new file mode 100644 index 0000000000000..29ee4b5ab0519 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -0,0 +1,303 @@ +/* + * 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.blockhash; + +import org.elasticsearch.common.unit.ByteSizeValue; +import org.elasticsearch.common.util.BigArrays; +import org.elasticsearch.common.util.BitArray; +import org.elasticsearch.common.util.LongHash; +import org.elasticsearch.compute.aggregation.GroupingAggregatorFunction; +import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BlockFactory; +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.mvdedupe.MultivalueDedupe; +import org.elasticsearch.compute.operator.mvdedupe.MultivalueDedupeLong; +import org.elasticsearch.compute.operator.mvdedupe.TopNMultivalueDedupeLong; +import org.elasticsearch.core.ReleasableIterator; + +import java.util.BitSet; +import java.util.Comparator; +import java.util.TreeSet; + +/** + * Maps a {@link LongBlock} column to group ids, keeping only the top N values. + */ +// TODO: package-private instead of public? +public final class LongTopNBlockHash extends TopNBlockHash { + private final int channel; + private final boolean asc; + private final boolean nullsFirst; + private final int limit; + private final LongHash hash; + private final TreeSet topValues; + + /** + * Have we seen any {@code null} values? + *

+ * We reserve the 0 ordinal for the {@code null} key so methods like + * {@link #nonEmpty} need to skip 0 if we haven't seen any null values. + *

+ */ + private boolean hasNull; + + // TODO: package-private instead of public? + public LongTopNBlockHash(int channel, boolean asc, boolean nullsFirst, int limit, BlockFactory blockFactory) { + super(blockFactory); + this.channel = channel; + this.asc = asc; + this.nullsFirst = nullsFirst; + this.limit = limit; + this.hash = new LongHash(1, blockFactory.bigArrays()); + this.topValues = new TreeSet<>(asc ? Comparator.naturalOrder() : Comparator.reverseOrder()); + + assert limit > 0 : "LongTopNBlockHash requires a limit greater than 0"; + } + + @Override + public void add(Page page, GroupingAggregatorFunction.AddInput addInput) { + // TODO track raw counts and which implementation we pick for the profiler - #114008 + var block = page.getBlock(channel); + + if (block.areAllValuesNull() && acceptNull()) { + hasNull = true; + try (IntVector groupIds = blockFactory.newConstantIntVector(0, block.getPositionCount())) { + addInput.add(0, groupIds); + } + return; + } + LongBlock castBlock = (LongBlock) block; + LongVector vector = castBlock.asVector(); + if (vector == null) { + try (IntBlock groupIds = add(castBlock)) { + addInput.add(0, groupIds); + } + return; + } + try (IntVector groupIds = add(vector)) { + addInput.add(0, groupIds); + } + } + + /** + * Tries to add null to the top values, and returns true if it was successful. + */ + private boolean acceptNull() { + if (hasNull) { + return true; + } + + if (nullsFirst) { + hasNull = true; + if (topValues.size() == limit) { + topValues.remove(topValues.last()); + } + return true; + } + + if (topValues.size() < limit) { + hasNull = true; + return true; + } + + return false; + } + + /** + * Tries to add the value to the top values, and returns true if it was successful. + */ + private boolean acceptValue(long value) { + if (isAcceptable(value) == false && isTopComplete()) { + return false; + } + + topValues.add(value); + + if (topValues.size() > limit - (hasNull ? 1 : 0)) { + if (hasNull && nullsFirst == false) { + hasNull = false; + } else { + topValues.remove(topValues.last()); + } + } + + return true; + } + + /** + * Returns true if the value is in, or can be added to the top; false otherwise. + */ + private boolean isAcceptable(long value) { + return isTopComplete() == false || isInTop(value); + } + + /** + * Returns true if the value is in the top; false otherwise. + */ + private boolean isInTop(long value) { + return asc ? value <= topValues.last() : value >= topValues.last(); + } + + /** + * Returns true if there are {@code limit} values in the blockhash; false otherwise. + */ + private boolean isTopComplete() { + return topValues.size() >= limit - (hasNull ? 1 : 0); + } + + /** + * Adds the vector values to the hash, and returns a new vector with the group IDs for those positions. + */ + IntVector add(LongVector vector) { + int positions = vector.getPositionCount(); + + // Add all values to the top set, so we don't end up sending invalid values later + for (int i = 0; i < positions; i++) { + long v = vector.getLong(i); + acceptValue(v); + } + + // Create a vector with the groups + try (var builder = blockFactory.newIntVectorFixedBuilder(positions)) { + for (int i = 0; i < positions; i++) { + long v = vector.getLong(i); + if (isAcceptable(v)) { + builder.appendInt(Math.toIntExact(hashOrdToGroupNullReserved(hash.add(v)))); + } + } + return builder.build(); + } + } + + /** + * Adds the block values to the hash, and returns a new vector with the group IDs for those positions. + *

+ * For nulls, a 0 group ID is used. For multivalues, a multivalue is used with all the group IDs. + *

+ */ + IntBlock add(LongBlock block) { + // Add all the values to the top set, so we don't end up sending invalid values later + for (int p = 0; p < block.getPositionCount(); p++) { + int count = block.getValueCount(p); + if (count == 0) { + acceptNull(); + continue; + } + int first = block.getFirstValueIndex(p); + + for (int i = 0; i < count; i++) { + long value = block.getLong(first + i); + acceptValue(value); + } + } + + // TODO: Make the custom dedupe *less custom* + MultivalueDedupe.HashResult result = new TopNMultivalueDedupeLong(block, hasNull, this::isAcceptable).hashAdd(blockFactory, hash); + + return result.ords(); + } + + @Override + public ReleasableIterator lookup(Page page, ByteSizeValue targetBlockSize) { + var block = page.getBlock(channel); + if (block.areAllValuesNull()) { + return ReleasableIterator.single(blockFactory.newConstantIntVector(0, block.getPositionCount()).asBlock()); + } + + LongBlock castBlock = (LongBlock) block; + LongVector vector = castBlock.asVector(); + // TODO honor targetBlockSize and chunk the pages if requested. + if (vector == null) { + return ReleasableIterator.single(lookup(castBlock)); + } + return ReleasableIterator.single(lookup(vector)); + } + + private IntBlock lookup(LongVector vector) { + int positions = vector.getPositionCount(); + try (var builder = blockFactory.newIntBlockBuilder(positions)) { + for (int i = 0; i < positions; i++) { + long v = vector.getLong(i); + long found = hash.find(v); + if (found < 0) { + builder.appendNull(); + } else { + builder.appendInt(Math.toIntExact(hashOrdToGroupNullReserved(found))); + } + } + return builder.build(); + } + } + + private IntBlock lookup(LongBlock block) { + return new MultivalueDedupeLong(block).hashLookup(blockFactory, hash); + } + + @Override + public LongBlock[] getKeys() { + if (hasNull) { + final long[] keys = new long[topValues.size() + 1]; + int keysIndex = 1; + for (int i = 1; i < hash.size() + 1; i++) { + long value = hash.get(i - 1); + if (isInTop(value)) { + keys[keysIndex++] = value; + } + } + BitSet nulls = new BitSet(1); + nulls.set(0); + return new LongBlock[] { + blockFactory.newLongArrayBlock(keys, keys.length, null, nulls, Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING) }; + } + final long[] keys = new long[topValues.size()]; + int keysIndex = 0; + for (int i = 0; i < hash.size(); i++) { + long value = hash.get(i); + if (isInTop(value)) { + keys[keysIndex++] = value; + } + } + return new LongBlock[] { blockFactory.newLongArrayVector(keys, keys.length).asBlock() }; + } + + @Override + public IntVector nonEmpty() { + int nullOffset = hasNull ? 1 : 0; + final int[] ids = new int[topValues.size() + nullOffset]; + int idsIndex = nullOffset; + for (int i = 1; i < hash.size() + 1; i++) { + long value = hash.get(i - 1); + if (isInTop(value)) { + ids[idsIndex++] = i; + } + } + return blockFactory.newIntArrayVector(ids, ids.length); + } + + @Override + public BitArray seenGroupIds(BigArrays bigArrays) { + return new Range(hasNull ? 0 : 1, Math.toIntExact(hash.size() + 1)).seenGroupIds(bigArrays); + } + + @Override + public void close() { + hash.close(); + } + + @Override + public String toString() { + StringBuilder b = new StringBuilder(); + b.append("LongBlockHash{channel=").append(channel); + b.append(", entries=").append(hash.size()); + b.append(", seenNull=").append(hasNull); + return b.append('}').toString(); + } +} diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHash.java new file mode 100644 index 0000000000000..83742be8cbf26 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHash.java @@ -0,0 +1,52 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +package org.elasticsearch.compute.aggregation.blockhash; + +import org.elasticsearch.common.unit.ByteSizeValue; +import org.elasticsearch.common.util.BigArrays; +import org.elasticsearch.common.util.BitArray; +import org.elasticsearch.compute.aggregation.GroupingAggregatorFunction; +import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BlockFactory; +import org.elasticsearch.compute.data.IntBlock; +import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.Page; +import org.elasticsearch.core.ReleasableIterator; + +// TODO: Do we need this class? +/** + * {@link BlockHash} specialization for hashes that store only the top N elements. + */ +public abstract class TopNBlockHash extends BlockHash { + + TopNBlockHash(BlockFactory blockFactory) { + super(blockFactory); + } + + // TODO: Insert only if the value is within the top N + @Override + public abstract void add(Page page, GroupingAggregatorFunction.AddInput addInput); + + // TODO: Something to do with this? + @Override + public abstract ReleasableIterator lookup(Page page, ByteSizeValue targetBlockSize); + + // TODO: What happens with inserted but then ignored groups? (e.g. Top 2 DESC; 5, 4, 6 -> [6, 5], 4 discarded) + @Override + public abstract Block[] getKeys(); + + // TODO: What to do with nonEmpty? + @Override + public abstract IntVector nonEmpty(); + + // TODO: What to do with seenGroupIds? + @Override + public abstract BitArray seenGroupIds(BigArrays bigArrays); + + // TODO: Implement build() methods like in BlockHash +} diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/X-BlockHash.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/X-BlockHash.java.st index d87ff9ba66442..8d7d3fd048d0f 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/X-BlockHash.java.st +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/X-BlockHash.java.st @@ -104,6 +104,9 @@ final class $Type$BlockHash extends BlockHash { } } + /** + * Adds the vector values to the hash, and returns a new vector with the group IDs for those positions. + */ IntVector add($Type$Vector vector) { $if(BytesRef)$ var ordinals = vector.asOrdinals(); @@ -128,6 +131,12 @@ $endif$ } } + /** + * Adds the block values to the hash, and returns a new vector with the group IDs for those positions. + *

+ * For nulls, a 0 group ID is used. For multivalues, a multivalue is used with all the group IDs. + *

+ */ IntBlock add($Type$Block block) { $if(BytesRef)$ var ordinals = block.asOrdinals(); diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongSortedSet.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongSortedSet.java new file mode 100644 index 0000000000000..acd15a5e2e0f9 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongSortedSet.java @@ -0,0 +1,40 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +package org.elasticsearch.compute.data.sort; + +import org.elasticsearch.common.util.BigArrays; +import org.elasticsearch.common.util.LongArray; +import org.elasticsearch.core.Releasable; +import org.elasticsearch.search.sort.SortOrder; + +public class LongSortedSet implements Releasable { + private final SortOrder order; + private final boolean nullsFirst; + + private final LongArray values; + private boolean hasNull; + private int valuesSize; + + public LongSortedSet(BigArrays bigArrays, SortOrder order, boolean nullsFirst, int limit) { + this.order = order; + this.nullsFirst = nullsFirst; + + this.values = bigArrays.newLongArray(limit, false); + this.hasNull = false; + this.valuesSize = 0; + } + + public boolean add(long value) { + throw new RuntimeException("Not implemented yet"); + } + + @Override + public void close() { + values.close(); + } +} diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java new file mode 100644 index 0000000000000..f77153940cf8a --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java @@ -0,0 +1,655 @@ +/* + * 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.operator.mvdedupe; + +import org.apache.lucene.util.ArrayUtil; +import org.elasticsearch.common.util.LongHash; +import org.elasticsearch.compute.aggregation.GroupingAggregatorFunction; +import org.elasticsearch.compute.aggregation.blockhash.BlockHash; +import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BlockFactory; +import org.elasticsearch.compute.data.IntBlock; +import org.elasticsearch.compute.data.LongBlock; + +import java.util.Arrays; +import java.util.function.Predicate; + +/** + * Removes duplicate values from multivalued positions, and keeps only the top N. + */ +public class TopNMultivalueDedupeLong { + /** + * The number of entries before we switch from and {@code n^2} strategy + * with low overhead to an {@code n*log(n)} strategy with higher overhead. + * The choice of number has been experimentally derived. + */ + static final int ALWAYS_COPY_MISSING = 300; + + /** + * The {@link Block} being deduplicated. + */ + final LongBlock block; + /** + * Whether the hash expects nulls or not. + */ + final boolean hasNull; + /** + * A predicate to test if a value is part of the top N or not. + */ + final Predicate isAcceptable; + /** + * Oversized array of values that contains deduplicated values after + * running {@link #copyMissing} and sorted values after calling + * {@link #copyAndSort} + */ + long[] work = new long[ArrayUtil.oversize(2, Long.BYTES)]; + /** + * After calling {@link #copyMissing} or {@link #copyAndSort} this is + * the number of values in {@link #work} for the current position. + */ + int w; + + public TopNMultivalueDedupeLong(LongBlock block, boolean hasNull, Predicate isAcceptable) { + this.block = block; + this.hasNull = hasNull; + this.isAcceptable = isAcceptable; + } + + /** + * Remove duplicate values from each position and write the results to a + * {@link Block} using an adaptive algorithm based on the size of the input list. + */ + public LongBlock dedupeToBlockAdaptive(BlockFactory blockFactory) { + if (block.mvDeduplicated()) { + block.incRef(); + return block; + } + try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder(block.getPositionCount())) { + for (int p = 0; p < block.getPositionCount(); p++) { + int count = block.getValueCount(p); + int first = block.getFirstValueIndex(p); + switch (count) { + case 0 -> builder.appendNull(); + case 1 -> builder.appendLong(block.getLong(first)); + default -> { + /* + * It's better to copyMissing when there are few unique values + * and better to copy and sort when there are many unique values. + * The more duplicate values there are the more comparatively worse + * copyAndSort is. But we don't know how many unique values there + * because our job is to find them. So we use the count of values + * as a proxy that is fast to test. It's not always going to be + * optimal but it has the nice property of being quite quick on + * short lists and not n^2 levels of terrible on long ones. + * + * It'd also be possible to make a truly hybrid mechanism that + * switches from copyMissing to copyUnique once it collects enough + * unique values. The trouble is that the switch is expensive and + * makes kind of a "hole" in the performance of that mechanism where + * you may as well have just gone with either of the two other + * strategies. So we just don't try it for now. + */ + if (count < ALWAYS_COPY_MISSING) { + copyMissing(first, count); + writeUniquedWork(builder); + } else { + copyAndSort(first, count); + deduplicatedSortedWork(builder); + } + } + } + } + return builder.build(); + } + } + + /** + * Remove duplicate values from each position and write the results to a + * {@link Block} using an algorithm with very low overhead but {@code n^2} + * case complexity for larger. Prefer {@link #dedupeToBlockAdaptive} + * which picks based on the number of elements at each position. + */ + public LongBlock dedupeToBlockUsingCopyAndSort(BlockFactory blockFactory) { + if (block.mvDeduplicated()) { + block.incRef(); + return block; + } + try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder(block.getPositionCount())) { + for (int p = 0; p < block.getPositionCount(); p++) { + int count = block.getValueCount(p); + int first = block.getFirstValueIndex(p); + switch (count) { + case 0 -> builder.appendNull(); + case 1 -> builder.appendLong(block.getLong(first)); + default -> { + copyAndSort(first, count); + deduplicatedSortedWork(builder); + } + } + } + return builder.build(); + } + } + + /** + * Remove duplicate values from each position and write the results to a + * {@link Block} using an algorithm that sorts all values. It has a higher + * overhead for small numbers of values at each position than + * {@link #dedupeToBlockUsingCopyMissing} for large numbers of values the + * performance is dominated by the {@code n*log n} sort. Prefer + * {@link #dedupeToBlockAdaptive} unless you need the results sorted. + */ + public LongBlock dedupeToBlockUsingCopyMissing(BlockFactory blockFactory) { + if (block.mvDeduplicated()) { + block.incRef(); + return block; + } + try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder(block.getPositionCount())) { + for (int p = 0; p < block.getPositionCount(); p++) { + int count = block.getValueCount(p); + int first = block.getFirstValueIndex(p); + switch (count) { + case 0 -> builder.appendNull(); + case 1 -> builder.appendLong(block.getLong(first)); + default -> { + copyMissing(first, count); + writeUniquedWork(builder); + } + } + } + return builder.build(); + } + } + + /** + * Sort values from each position and write the results to a {@link Block}. + */ + public LongBlock sortToBlock(BlockFactory blockFactory, boolean ascending) { + try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder(block.getPositionCount())) { + for (int p = 0; p < block.getPositionCount(); p++) { + int count = block.getValueCount(p); + int first = block.getFirstValueIndex(p); + switch (count) { + case 0 -> builder.appendNull(); + case 1 -> builder.appendLong(block.getLong(first)); + default -> { + copyAndSort(first, count); + writeSortedWork(builder, ascending); + } + } + } + return builder.build(); + } + } + + /** + * Dedupe values, add them to the hash, and build an {@link IntBlock} of + * their hashes. This block is suitable for passing as the grouping block + * to a {@link GroupingAggregatorFunction}. + */ + public MultivalueDedupe.HashResult hashAdd(BlockFactory blockFactory, LongHash hash) { + try (IntBlock.Builder builder = blockFactory.newIntBlockBuilder(block.getPositionCount())) { + boolean sawNull = false; + for (int p = 0; p < block.getPositionCount(); p++) { + int count = block.getValueCount(p); + int first = block.getFirstValueIndex(p); + switch (count) { + case 0 -> { + if (hasNull) { + sawNull = true; + builder.appendInt(0); + } + } + case 1 -> { + long v = block.getLong(first); + hashAdd(builder, hash, v); + } + default -> { + if (count < ALWAYS_COPY_MISSING) { + copyMissing(first, count); + hashAddUniquedWork(hash, builder); + } else { + copyAndSort(first, count); + hashAddSortedWork(hash, builder); + } + } + } + } + return new MultivalueDedupe.HashResult(builder.build(), sawNull); + } + } + + /** + * Dedupe values and build an {@link IntBlock} of their hashes. This block is + * suitable for passing as the grouping block to a {@link GroupingAggregatorFunction}. + */ + public IntBlock hashLookup(BlockFactory blockFactory, LongHash hash) { + try (IntBlock.Builder builder = blockFactory.newIntBlockBuilder(block.getPositionCount())) { + for (int p = 0; p < block.getPositionCount(); p++) { + int count = block.getValueCount(p); + int first = block.getFirstValueIndex(p); + switch (count) { + case 0 -> builder.appendInt(0); + case 1 -> { + long v = block.getLong(first); + hashLookupSingle(builder, hash, v); + } + default -> { + if (count < ALWAYS_COPY_MISSING) { + copyMissing(first, count); + hashLookupUniquedWork(hash, builder); + } else { + copyAndSort(first, count); + hashLookupSortedWork(hash, builder); + } + } + } + } + return builder.build(); + } + } + + /** + * Build a {@link BatchEncoder} which deduplicates values at each position + * and then encodes the results into a {@link byte[]} which can be used for + * things like hashing many fields together. + */ + public BatchEncoder batchEncoder(int batchSize) { + block.incRef(); + return new BatchEncoder.Longs(batchSize) { + @Override + protected void readNextBatch() { + int position = firstPosition(); + if (w > 0) { + // The last block didn't fit so we have to *make* it fit + ensureCapacity(w); + startPosition(); + encodeUniquedWork(this); + endPosition(); + position++; + } + for (; position < block.getPositionCount(); position++) { + int count = block.getValueCount(position); + int first = block.getFirstValueIndex(position); + switch (count) { + case 0 -> encodeNull(); + case 1 -> { + long v = block.getLong(first); + if (hasCapacity(1)) { + startPosition(); + encode(v); + endPosition(); + } else { + work[0] = v; + w = 1; + return; + } + } + default -> { + if (count < ALWAYS_COPY_MISSING) { + copyMissing(first, count); + } else { + copyAndSort(first, count); + convertSortedWorkToUnique(); + } + if (hasCapacity(w)) { + startPosition(); + encodeUniquedWork(this); + endPosition(); + } else { + return; + } + } + } + } + } + + @Override + public void close() { + block.decRef(); + } + }; + } + + /** + * Copy all value from the position into {@link #work} and then + * sorts it {@code n * log(n)}. + */ + void copyAndSort(int first, int count) { + grow(count); + int end = first + count; + + w = 0; + for (int i = first; i < end; i++) { + work[w++] = block.getLong(i); + } + + Arrays.sort(work, 0, w); + } + + /** + * Fill {@link #work} with the unique values in the position by scanning + * all fields already copied {@code n^2}. + */ + void copyMissing(int first, int count) { + grow(count); + int end = first + count; + + work[0] = block.getLong(first); + w = 1; + i: for (int i = first + 1; i < end; i++) { + long v = block.getLong(i); + for (int j = 0; j < w; j++) { + if (v == work[j]) { + continue i; + } + } + work[w++] = v; + } + } + + /** + * Writes an already deduplicated {@link #work} to a {@link LongBlock.Builder}. + */ + private void writeUniquedWork(LongBlock.Builder builder) { + if (w == 1) { + builder.appendLong(work[0]); + return; + } + builder.beginPositionEntry(); + for (int i = 0; i < w; i++) { + builder.appendLong(work[i]); + } + builder.endPositionEntry(); + } + + /** + * Writes a sorted {@link #work} to a {@link LongBlock.Builder}, skipping duplicates. + */ + private void deduplicatedSortedWork(LongBlock.Builder builder) { + builder.beginPositionEntry(); + long prev = work[0]; + builder.appendLong(prev); + for (int i = 1; i < w; i++) { + if (prev != work[i]) { + prev = work[i]; + builder.appendLong(prev); + } + } + builder.endPositionEntry(); + } + + /** + * Writes a {@link #work} to a {@link LongBlock.Builder}. + */ + private void writeSortedWork(LongBlock.Builder builder, boolean ascending) { + builder.beginPositionEntry(); + for (int i = 0; i < w; i++) { + if (ascending) { + builder.appendLong(work[i]); + } else { + builder.appendLong(work[w - i - 1]); + } + } + builder.endPositionEntry(); + } + + /** + * Writes an already deduplicated {@link #work} to a hash. + */ + private void hashAddUniquedWork(LongHash hash, IntBlock.Builder builder) { + if (w == 1) { + hashAdd(builder, hash, work[0]); + return; + } + + int totalAcceptableValues = 0; + for (int i = 0; i < w; i++) { + if (isAcceptable.test(work[i])) { + totalAcceptableValues++; + } + } + + if (totalAcceptableValues == 0) { + return; + } + + if (totalAcceptableValues > 1) { + builder.beginPositionEntry(); + } + for (int i = 0; i < w; i++) { + hashAdd(builder, hash, work[i]); + } + if (totalAcceptableValues > 1) { + builder.endPositionEntry(); + } + } + + /** + * Writes a sorted {@link #work} to a hash, skipping duplicates. + */ + private void hashAddSortedWork(LongHash hash, IntBlock.Builder builder) { + if (w == 1) { + hashAdd(builder, hash, work[0]); + return; + } + + int totalAcceptableValues = 0; + for (int i = 0; i < w; i++) { + if (isAcceptable.test(work[i])) { + totalAcceptableValues++; + } + } + + if (totalAcceptableValues == 0) { + return; + } + + if (totalAcceptableValues > 1) { + builder.beginPositionEntry(); + } + long prev = work[0]; + hashAdd(builder, hash, prev); + for (int i = 1; i < w; i++) { + if (false == valuesEqual(prev, work[i])) { + prev = work[i]; + hashAdd(builder, hash, prev); + } + } + if (totalAcceptableValues > 1) { + builder.endPositionEntry(); + } + } + + /** + * Looks up an already deduplicated {@link #work} to a hash. + */ + private void hashLookupUniquedWork(LongHash hash, IntBlock.Builder builder) { + if (w == 1) { + hashLookupSingle(builder, hash, work[0]); + return; + } + + int i = 1; + long firstLookup = hashLookup(hash, work[0]); + while (firstLookup < 0) { + if (i >= w) { + // Didn't find any values + builder.appendNull(); + return; + } + firstLookup = hashLookup(hash, work[i]); + i++; + } + + /* + * Step 2 - find the next unique value in the hash + */ + boolean foundSecond = false; + while (i < w) { + long nextLookup = hashLookup(hash, work[i]); + if (nextLookup >= 0) { + builder.beginPositionEntry(); + appendFound(builder, firstLookup); + appendFound(builder, nextLookup); + i++; + foundSecond = true; + break; + } + i++; + } + + /* + * Step 3a - we didn't find a second value, just emit the first one + */ + if (false == foundSecond) { + appendFound(builder, firstLookup); + return; + } + + /* + * Step 3b - we found a second value, search for more + */ + while (i < w) { + long nextLookup = hashLookup(hash, work[i]); + if (nextLookup >= 0) { + appendFound(builder, nextLookup); + } + i++; + } + builder.endPositionEntry(); + } + + /** + * Looks up a sorted {@link #work} to a hash, skipping duplicates. + */ + private void hashLookupSortedWork(LongHash hash, IntBlock.Builder builder) { + if (w == 1) { + hashLookupSingle(builder, hash, work[0]); + return; + } + + /* + * Step 1 - find the first unique value in the hash + * i will contain the next value to probe + * prev will contain the first value in the array contained in the hash + * firstLookup will contain the first value in the hash + */ + int i = 1; + long prev = work[0]; + long firstLookup = hashLookup(hash, prev); + while (firstLookup < 0) { + if (i >= w) { + // Didn't find any values + builder.appendNull(); + return; + } + prev = work[i]; + firstLookup = hashLookup(hash, prev); + i++; + } + + /* + * Step 2 - find the next unique value in the hash + */ + boolean foundSecond = false; + while (i < w) { + if (false == valuesEqual(prev, work[i])) { + long nextLookup = hashLookup(hash, work[i]); + if (nextLookup >= 0) { + prev = work[i]; + builder.beginPositionEntry(); + appendFound(builder, firstLookup); + appendFound(builder, nextLookup); + i++; + foundSecond = true; + break; + } + } + i++; + } + + /* + * Step 3a - we didn't find a second value, just emit the first one + */ + if (false == foundSecond) { + appendFound(builder, firstLookup); + return; + } + + /* + * Step 3b - we found a second value, search for more + */ + while (i < w) { + if (false == valuesEqual(prev, work[i])) { + long nextLookup = hashLookup(hash, work[i]); + if (nextLookup >= 0) { + prev = work[i]; + appendFound(builder, nextLookup); + } + } + i++; + } + builder.endPositionEntry(); + } + + /** + * Writes a deduplicated {@link #work} to a {@link BatchEncoder.Longs}. + */ + private void encodeUniquedWork(BatchEncoder.Longs encoder) { + for (int i = 0; i < w; i++) { + encoder.encode(work[i]); + } + } + + /** + * Converts {@link #work} from sorted array to a deduplicated array. + */ + private void convertSortedWorkToUnique() { + long prev = work[0]; + int end = w; + w = 1; + for (int i = 1; i < end; i++) { + if (false == valuesEqual(prev, work[i])) { + prev = work[i]; + work[w++] = prev; + } + } + } + + private void grow(int size) { + work = ArrayUtil.grow(work, size); + } + + private void hashAdd(IntBlock.Builder builder, LongHash hash, long v) { + if (isAcceptable.test(v)) { + appendFound(builder, hash.add(v)); + } + } + + private long hashLookup(LongHash hash, long v) { + return hash.find(v); + } + + private void hashLookupSingle(IntBlock.Builder builder, LongHash hash, long v) { + long found = hashLookup(hash, v); + if (found >= 0) { + appendFound(builder, found); + } else { + builder.appendNull(); + } + } + + private void appendFound(IntBlock.Builder builder, long found) { + builder.appendInt(Math.toIntExact(BlockHash.hashOrdToGroupNullReserved(found))); + } + + private static boolean valuesEqual(long lhs, long rhs) { + return lhs == rhs; + } +} diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java index 30579f864abcb..d499fbf333312 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java @@ -15,11 +15,14 @@ import org.elasticsearch.compute.aggregation.SumLongAggregatorFunctionSupplier; import org.elasticsearch.compute.aggregation.SumLongGroupingAggregatorFunctionTests; import org.elasticsearch.compute.aggregation.blockhash.BlockHash; +import org.elasticsearch.compute.aggregation.blockhash.LongTopNBlockHash; import org.elasticsearch.compute.data.Block; import org.elasticsearch.compute.data.BlockFactory; +import org.elasticsearch.compute.data.BlockUtils; import org.elasticsearch.compute.data.ElementType; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.Page; +import org.elasticsearch.compute.test.BlockTestUtils; import org.elasticsearch.core.Tuple; import org.hamcrest.Matcher; @@ -96,4 +99,67 @@ protected void assertSimpleOutput(List input, List results) { max.assertSimpleGroup(input, maxs, i, group); } } + + public void testTopN() { + var mode = AggregatorMode.SINGLE; + var aggregatorChannels = List.of(1); + try ( + var operator = new HashAggregationOperator( + List.of( + new SumLongAggregatorFunctionSupplier().groupingAggregatorFactory(mode, aggregatorChannels), + new MaxLongAggregatorFunctionSupplier().groupingAggregatorFactory(mode, aggregatorChannels) + ), + () -> new LongTopNBlockHash(0, false, true, 3, blockFactory()), + driverContext() + ) + ) { + + var page = new Page( + BlockUtils.fromList(blockFactory(), List.of(List.of(10L, 2L), List.of(20L, 4L), List.of(30L, 8L), List.of(30L, 16L))) + ); + operator.addInput(page); + page.releaseBlocks(); + + page = new Page( + BlockUtils.fromList( + blockFactory(), + List.of( + List.of(50L, 64L), + List.of(40L, 32L), + List.of(List.of(10L, 50L), 128L), + List.of(0L, 256L) + + ) + ) + ); + operator.addInput(page); + page.releaseBlocks(); + + operator.finish(); + + var outputPage = operator.getOutput(); + + var groups = (LongBlock) outputPage.getBlock(0); + var sumBlock = (LongBlock) outputPage.getBlock(1); + var maxBlock = (LongBlock) outputPage.getBlock(2); + + assertThat(groups.getPositionCount(), equalTo(3)); + assertThat(sumBlock.getPositionCount(), equalTo(3)); + assertThat(maxBlock.getPositionCount(), equalTo(3)); + + assertThat(groups.getTotalValueCount(), equalTo(3)); + assertThat(sumBlock.getTotalValueCount(), equalTo(3)); + assertThat(maxBlock.getTotalValueCount(), equalTo(3)); + + assertThat(BlockTestUtils.valuesAtPositions(groups, 0, 3), equalTo(List.of(List.of(30L), List.of(50L), List.of(40L)))); + assertThat(BlockTestUtils.valuesAtPositions(sumBlock, 0, 3), equalTo(List.of(List.of(24L), List.of(192L), List.of(32L)))); + assertThat(BlockTestUtils.valuesAtPositions(maxBlock, 0, 3), equalTo(List.of(List.of(16L), List.of(128L), List.of(32L)))); + + outputPage.releaseBlocks(); + } + } + + public void testTopNWithNulls() { + // TODO: To be implemented + } } From fcdfbd42ab03020613e47bd1f93cbc9a669b2f03 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Wed, 16 Apr 2025 16:16:50 +0200 Subject: [PATCH 02/39] Fix dedupe for nulls and multivalues --- .../mvdedupe/TopNMultivalueDedupeLong.java | 75 +++++++++---------- .../HashAggregationOperatorTests.java | 73 ++++++++++++++++-- 2 files changed, 101 insertions(+), 47 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java index f77153940cf8a..8fe3a59557240 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java @@ -203,6 +203,8 @@ public MultivalueDedupe.HashResult hashAdd(BlockFactory blockFactory, LongHash h if (hasNull) { sawNull = true; builder.appendInt(0); + } else { + builder.appendNull(); } } case 1 -> { @@ -326,7 +328,10 @@ void copyAndSort(int first, int count) { w = 0; for (int i = first; i < end; i++) { - work[w++] = block.getLong(i); + long value = block.getLong(i); + if (isAcceptable.test(value)) { + work[w++] = value; + } } Arrays.sort(work, 0, w); @@ -344,12 +349,14 @@ void copyMissing(int first, int count) { w = 1; i: for (int i = first + 1; i < end; i++) { long v = block.getLong(i); - for (int j = 0; j < w; j++) { - if (v == work[j]) { - continue i; + if (isAcceptable.test(v)) { + for (int j = 0; j < w; j++) { + if (v == work[j]) { + continue i; + } } + work[w++] = v; } - work[w++] = v; } } @@ -403,67 +410,47 @@ private void writeSortedWork(LongBlock.Builder builder, boolean ascending) { * Writes an already deduplicated {@link #work} to a hash. */ private void hashAddUniquedWork(LongHash hash, IntBlock.Builder builder) { - if (w == 1) { - hashAdd(builder, hash, work[0]); + if (w == 0) { + builder.appendNull(); return; } - int totalAcceptableValues = 0; - for (int i = 0; i < w; i++) { - if (isAcceptable.test(work[i])) { - totalAcceptableValues++; - } - } - - if (totalAcceptableValues == 0) { + if (w == 1) { + hashAddNoCheck(builder, hash, work[0]); return; } - if (totalAcceptableValues > 1) { - builder.beginPositionEntry(); - } + builder.beginPositionEntry(); for (int i = 0; i < w; i++) { - hashAdd(builder, hash, work[i]); - } - if (totalAcceptableValues > 1) { - builder.endPositionEntry(); + hashAddNoCheck(builder, hash, work[i]); } + builder.endPositionEntry(); } /** * Writes a sorted {@link #work} to a hash, skipping duplicates. */ private void hashAddSortedWork(LongHash hash, IntBlock.Builder builder) { - if (w == 1) { - hashAdd(builder, hash, work[0]); + if (w == 0) { + builder.appendNull(); return; } - int totalAcceptableValues = 0; - for (int i = 0; i < w; i++) { - if (isAcceptable.test(work[i])) { - totalAcceptableValues++; - } - } - - if (totalAcceptableValues == 0) { + if (w == 1) { + hashAddNoCheck(builder, hash, work[0]); return; } - if (totalAcceptableValues > 1) { - builder.beginPositionEntry(); - } + builder.beginPositionEntry(); long prev = work[0]; - hashAdd(builder, hash, prev); + hashAddNoCheck(builder, hash, prev); for (int i = 1; i < w; i++) { if (false == valuesEqual(prev, work[i])) { prev = work[i]; - hashAdd(builder, hash, prev); + hashAddNoCheck(builder, hash, prev); } } - if (totalAcceptableValues > 1) { - builder.endPositionEntry(); - } + builder.endPositionEntry(); } /** @@ -628,10 +615,16 @@ private void grow(int size) { private void hashAdd(IntBlock.Builder builder, LongHash hash, long v) { if (isAcceptable.test(v)) { - appendFound(builder, hash.add(v)); + hashAddNoCheck(builder, hash, v); + } else { + builder.appendNull(); } } + private void hashAddNoCheck(IntBlock.Builder builder, LongHash hash, long v) { + appendFound(builder, hash.add(v)); + } + private long hashLookup(LongHash hash, long v) { return hash.find(v); } diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java index d499fbf333312..d7fc6bd9bedb5 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java @@ -26,6 +26,7 @@ import org.elasticsearch.core.Tuple; import org.hamcrest.Matcher; +import java.util.Arrays; import java.util.List; import java.util.stream.LongStream; @@ -100,7 +101,7 @@ protected void assertSimpleOutput(List input, List results) { } } - public void testTopN() { + public void testTopNNullsLast() { var mode = AggregatorMode.SINGLE; var aggregatorChannels = List.of(1); try ( @@ -109,11 +110,75 @@ public void testTopN() { new SumLongAggregatorFunctionSupplier().groupingAggregatorFactory(mode, aggregatorChannels), new MaxLongAggregatorFunctionSupplier().groupingAggregatorFactory(mode, aggregatorChannels) ), - () -> new LongTopNBlockHash(0, false, true, 3, blockFactory()), + () -> new LongTopNBlockHash(0, false, false, 3, blockFactory()), driverContext() ) ) { + var page = new Page( + BlockUtils.fromList( + blockFactory(), + List.of( + List.of(10L, 2L), + Arrays.asList(null, 1L), + List.of(20L, 4L), + List.of(30L, 8L), + List.of(30L, 16L) + ) + ) + ); + operator.addInput(page); + + page = new Page( + BlockUtils.fromList( + blockFactory(), + List.of( + List.of(50L, 64L), + List.of(40L, 32L), + List.of(List.of(10L, 50L), 128L), + List.of(0L, 256L), + Arrays.asList(null, 512L) + ) + ) + ); + operator.addInput(page); + + operator.finish(); + var outputPage = operator.getOutput(); + + var groups = (LongBlock) outputPage.getBlock(0); + var sumBlock = (LongBlock) outputPage.getBlock(1); + var maxBlock = (LongBlock) outputPage.getBlock(2); + + assertThat(groups.getPositionCount(), equalTo(3)); + assertThat(sumBlock.getPositionCount(), equalTo(3)); + assertThat(maxBlock.getPositionCount(), equalTo(3)); + + assertThat(groups.getTotalValueCount(), equalTo(3)); + assertThat(sumBlock.getTotalValueCount(), equalTo(3)); + assertThat(maxBlock.getTotalValueCount(), equalTo(3)); + + assertThat(BlockTestUtils.valuesAtPositions(groups, 0, 3), equalTo(List.of(List.of(30L), List.of(50L), List.of(40L)))); + assertThat(BlockTestUtils.valuesAtPositions(sumBlock, 0, 3), equalTo(List.of(List.of(24L), List.of(192L), List.of(32L)))); + assertThat(BlockTestUtils.valuesAtPositions(maxBlock, 0, 3), equalTo(List.of(List.of(16L), List.of(128L), List.of(32L)))); + + outputPage.releaseBlocks(); + } + } + + public void testTopNNullsFirst() { + var mode = AggregatorMode.SINGLE; + var aggregatorChannels = List.of(1); + try ( + var operator = new HashAggregationOperator( + List.of( + new SumLongAggregatorFunctionSupplier().groupingAggregatorFactory(mode, aggregatorChannels), + new MaxLongAggregatorFunctionSupplier().groupingAggregatorFactory(mode, aggregatorChannels) + ), + () -> new LongTopNBlockHash(0, false, true, 3, blockFactory()), + driverContext() + ) + ) { var page = new Page( BlockUtils.fromList(blockFactory(), List.of(List.of(10L, 2L), List.of(20L, 4L), List.of(30L, 8L), List.of(30L, 16L))) ); @@ -158,8 +223,4 @@ public void testTopN() { outputPage.releaseBlocks(); } } - - public void testTopNWithNulls() { - // TODO: To be implemented - } } From 7282e98574dd737f66f800cb369538ee63e5de87 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Wed, 16 Apr 2025 17:46:28 +0200 Subject: [PATCH 03/39] Added tests for null order and sort order --- .../HashAggregationOperatorTests.java | 84 ++++++++++++------- 1 file changed, 56 insertions(+), 28 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java index d7fc6bd9bedb5..2d04e4d3f7c2b 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java @@ -27,6 +27,7 @@ import org.hamcrest.Matcher; import java.util.Arrays; +import java.util.Comparator; import java.util.List; import java.util.stream.LongStream; @@ -102,15 +103,22 @@ protected void assertSimpleOutput(List input, List results) { } public void testTopNNullsLast() { + boolean ascOrder = randomBoolean(); + var groups = new Long[] { 0L, 10L, 20L, 30L, 40L, 50L }; + if (ascOrder) { + Arrays.sort(groups, Comparator.reverseOrder()); + } var mode = AggregatorMode.SINGLE; + var groupChannel = 0; var aggregatorChannels = List.of(1); + try ( var operator = new HashAggregationOperator( List.of( new SumLongAggregatorFunctionSupplier().groupingAggregatorFactory(mode, aggregatorChannels), new MaxLongAggregatorFunctionSupplier().groupingAggregatorFactory(mode, aggregatorChannels) ), - () -> new LongTopNBlockHash(0, false, false, 3, blockFactory()), + () -> new LongTopNBlockHash(groupChannel, ascOrder, false, 3, blockFactory()), driverContext() ) ) { @@ -118,11 +126,11 @@ public void testTopNNullsLast() { BlockUtils.fromList( blockFactory(), List.of( - List.of(10L, 2L), + List.of(groups[1], 2L), Arrays.asList(null, 1L), - List.of(20L, 4L), - List.of(30L, 8L), - List.of(30L, 16L) + List.of(groups[2], 4L), + List.of(groups[3], 8L), + List.of(groups[3], 16L) ) ) ); @@ -132,10 +140,10 @@ public void testTopNNullsLast() { BlockUtils.fromList( blockFactory(), List.of( - List.of(50L, 64L), - List.of(40L, 32L), - List.of(List.of(10L, 50L), 128L), - List.of(0L, 256L), + List.of(groups[5], 64L), + List.of(groups[4], 32L), + List.of(List.of(groups[1], groups[5]), 128L), + List.of(groups[0], 256L), Arrays.asList(null, 512L) ) ) @@ -146,19 +154,22 @@ public void testTopNNullsLast() { var outputPage = operator.getOutput(); - var groups = (LongBlock) outputPage.getBlock(0); + var groupsBlock = (LongBlock) outputPage.getBlock(0); var sumBlock = (LongBlock) outputPage.getBlock(1); var maxBlock = (LongBlock) outputPage.getBlock(2); - assertThat(groups.getPositionCount(), equalTo(3)); + assertThat(groupsBlock.getPositionCount(), equalTo(3)); assertThat(sumBlock.getPositionCount(), equalTo(3)); assertThat(maxBlock.getPositionCount(), equalTo(3)); - assertThat(groups.getTotalValueCount(), equalTo(3)); + assertThat(groupsBlock.getTotalValueCount(), equalTo(3)); assertThat(sumBlock.getTotalValueCount(), equalTo(3)); assertThat(maxBlock.getTotalValueCount(), equalTo(3)); - assertThat(BlockTestUtils.valuesAtPositions(groups, 0, 3), equalTo(List.of(List.of(30L), List.of(50L), List.of(40L)))); + assertThat( + BlockTestUtils.valuesAtPositions(groupsBlock, 0, 3), + equalTo(List.of(List.of(groups[3]), List.of(groups[5]), List.of(groups[4]))) + ); assertThat(BlockTestUtils.valuesAtPositions(sumBlock, 0, 3), equalTo(List.of(List.of(24L), List.of(192L), List.of(32L)))); assertThat(BlockTestUtils.valuesAtPositions(maxBlock, 0, 3), equalTo(List.of(List.of(16L), List.of(128L), List.of(32L)))); @@ -167,58 +178,75 @@ public void testTopNNullsLast() { } public void testTopNNullsFirst() { + boolean ascOrder = randomBoolean(); + var groups = new Long[] { 0L, 10L, 20L, 30L, 40L, 50L }; + if (ascOrder) { + Arrays.sort(groups, Comparator.reverseOrder()); + } var mode = AggregatorMode.SINGLE; + var groupChannel = 0; var aggregatorChannels = List.of(1); + try ( var operator = new HashAggregationOperator( List.of( new SumLongAggregatorFunctionSupplier().groupingAggregatorFactory(mode, aggregatorChannels), new MaxLongAggregatorFunctionSupplier().groupingAggregatorFactory(mode, aggregatorChannels) ), - () -> new LongTopNBlockHash(0, false, true, 3, blockFactory()), + () -> new LongTopNBlockHash(groupChannel, ascOrder, true, 3, blockFactory()), driverContext() ) ) { var page = new Page( - BlockUtils.fromList(blockFactory(), List.of(List.of(10L, 2L), List.of(20L, 4L), List.of(30L, 8L), List.of(30L, 16L))) + BlockUtils.fromList( + blockFactory(), + List.of( + List.of(groups[1], 2L), + Arrays.asList(null, 1L), + List.of(groups[2], 4L), + List.of(groups[3], 8L), + List.of(groups[3], 16L) + ) + ) ); operator.addInput(page); - page.releaseBlocks(); page = new Page( BlockUtils.fromList( blockFactory(), List.of( - List.of(50L, 64L), - List.of(40L, 32L), - List.of(List.of(10L, 50L), 128L), - List.of(0L, 256L) - + List.of(groups[5], 64L), + List.of(groups[4], 32L), + List.of(List.of(groups[1], groups[5]), 128L), + List.of(groups[0], 256L), + Arrays.asList(null, 512L) ) ) ); operator.addInput(page); - page.releaseBlocks(); operator.finish(); var outputPage = operator.getOutput(); - var groups = (LongBlock) outputPage.getBlock(0); + var groupsBlock = (LongBlock) outputPage.getBlock(0); var sumBlock = (LongBlock) outputPage.getBlock(1); var maxBlock = (LongBlock) outputPage.getBlock(2); - assertThat(groups.getPositionCount(), equalTo(3)); + assertThat(groupsBlock.getPositionCount(), equalTo(3)); assertThat(sumBlock.getPositionCount(), equalTo(3)); assertThat(maxBlock.getPositionCount(), equalTo(3)); - assertThat(groups.getTotalValueCount(), equalTo(3)); + assertThat(groupsBlock.getTotalValueCount(), equalTo(2)); assertThat(sumBlock.getTotalValueCount(), equalTo(3)); assertThat(maxBlock.getTotalValueCount(), equalTo(3)); - assertThat(BlockTestUtils.valuesAtPositions(groups, 0, 3), equalTo(List.of(List.of(30L), List.of(50L), List.of(40L)))); - assertThat(BlockTestUtils.valuesAtPositions(sumBlock, 0, 3), equalTo(List.of(List.of(24L), List.of(192L), List.of(32L)))); - assertThat(BlockTestUtils.valuesAtPositions(maxBlock, 0, 3), equalTo(List.of(List.of(16L), List.of(128L), List.of(32L)))); + assertThat( + BlockTestUtils.valuesAtPositions(groupsBlock, 0, 3), + equalTo(Arrays.asList(null, List.of(groups[5]), List.of(groups[4]))) + ); + assertThat(BlockTestUtils.valuesAtPositions(sumBlock, 0, 3), equalTo(List.of(List.of(513L), List.of(192L), List.of(32L)))); + assertThat(BlockTestUtils.valuesAtPositions(maxBlock, 0, 3), equalTo(List.of(List.of(512L), List.of(128L), List.of(32L)))); outputPage.releaseBlocks(); } From 4950f5fe79f7f25132bdc7dec0ac71b3ebfa4ef7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Mon, 21 Apr 2025 14:48:24 +0200 Subject: [PATCH 04/39] Move generic BlockHash code to base TestCase --- .../blockhash/BlockHashTestCase.java | 163 +++++ .../aggregation/blockhash/BlockHashTests.java | 632 +++++++----------- 2 files changed, 413 insertions(+), 382 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java index 5cd9120e05305..d732e7fe62471 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java @@ -7,15 +7,35 @@ package org.elasticsearch.compute.aggregation.blockhash; +import org.apache.lucene.util.BytesRef; import org.elasticsearch.common.breaker.CircuitBreaker; import org.elasticsearch.common.unit.ByteSizeValue; import org.elasticsearch.common.util.BigArrays; import org.elasticsearch.common.util.MockBigArrays; import org.elasticsearch.common.util.PageCacheRecycler; +import org.elasticsearch.compute.aggregation.GroupingAggregatorFunction; +import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.BooleanBlock; +import org.elasticsearch.compute.data.BytesRefBlock; +import org.elasticsearch.compute.data.DoubleBlock; +import org.elasticsearch.compute.data.IntBlock; +import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.test.MockBlockFactory; +import org.elasticsearch.compute.test.TestBlockFactory; +import org.elasticsearch.core.ReleasableIterator; +import org.elasticsearch.core.Releasables; import org.elasticsearch.indices.breaker.CircuitBreakerService; import org.elasticsearch.test.ESTestCase; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; +import java.util.function.Consumer; + +import static org.hamcrest.Matchers.arrayWithSize; +import static org.hamcrest.Matchers.equalTo; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @@ -31,4 +51,147 @@ private static CircuitBreakerService mockBreakerService(CircuitBreaker breaker) when(breakerService.getBreaker(CircuitBreaker.REQUEST)).thenReturn(breaker); return breakerService; } + + protected record OrdsAndKeys(String description, int positionOffset, IntBlock ords, Block[] keys, IntVector nonEmpty) {} + + protected static void hash(boolean collectKeys, BlockHash blockHash, Consumer callback, Block... values) { + blockHash.add(new Page(values), new GroupingAggregatorFunction.AddInput() { + @Override + public void add(int positionOffset, IntBlock groupIds) { + OrdsAndKeys result = new OrdsAndKeys( + blockHash.toString(), + positionOffset, + groupIds, + collectKeys ? blockHash.getKeys() : null, + blockHash.nonEmpty() + ); + + try { + Set allowedOrds = new HashSet<>(); + for (int p = 0; p < result.nonEmpty.getPositionCount(); p++) { + allowedOrds.add(result.nonEmpty.getInt(p)); + } + for (int p = 0; p < result.ords.getPositionCount(); p++) { + if (result.ords.isNull(p)) { + continue; + } + int start = result.ords.getFirstValueIndex(p); + int end = start + result.ords.getValueCount(p); + for (int i = start; i < end; i++) { + int ord = result.ords.getInt(i); + if (false == allowedOrds.contains(ord)) { + fail("ord is not allowed " + ord); + } + } + } + callback.accept(result); + } finally { + Releasables.close(result.keys == null ? null : Releasables.wrap(result.keys), result.nonEmpty); + } + } + + @Override + public void add(int positionOffset, IntVector groupIds) { + add(positionOffset, groupIds.asBlock()); + } + + @Override + public void close() { + fail("hashes should not close AddInput"); + } + }); + if (blockHash instanceof LongLongBlockHash == false + && blockHash instanceof BytesRefLongBlockHash == false + && blockHash instanceof BytesRef2BlockHash == false + && blockHash instanceof BytesRef3BlockHash == false) { + Block[] keys = blockHash.getKeys(); + try (ReleasableIterator lookup = blockHash.lookup(new Page(keys), ByteSizeValue.ofKb(between(1, 100)))) { + while (lookup.hasNext()) { + try (IntBlock ords = lookup.next()) { + for (int p = 0; p < ords.getPositionCount(); p++) { + assertFalse(ords.isNull(p)); + } + } + } + } finally { + Releasables.closeExpectNoException(keys); + } + } + } + + protected void assertOrds(IntBlock ordsBlock, Integer... expectedOrds) { + assertOrds(ordsBlock, Arrays.stream(expectedOrds).map(l -> l == null ? null : new int[] { l }).toArray(int[][]::new)); + } + + protected void assertOrds(IntBlock ordsBlock, int[]... expectedOrds) { + assertEquals(expectedOrds.length, ordsBlock.getPositionCount()); + for (int p = 0; p < expectedOrds.length; p++) { + int start = ordsBlock.getFirstValueIndex(p); + int count = ordsBlock.getValueCount(p); + if (expectedOrds[p] == null) { + if (false == ordsBlock.isNull(p)) { + StringBuilder error = new StringBuilder(); + error.append(p); + error.append(": expected null but was ["); + for (int i = 0; i < count; i++) { + if (i != 0) { + error.append(", "); + } + error.append(ordsBlock.getInt(start + i)); + } + fail(error.append("]").toString()); + } + continue; + } + assertFalse(p + ": expected not null", ordsBlock.isNull(p)); + int[] actual = new int[count]; + for (int i = 0; i < count; i++) { + actual[i] = ordsBlock.getInt(start + i); + } + assertThat("position " + p, actual, equalTo(expectedOrds[p])); + } + } + + protected void assertKeys(Block[] actualKeys, Object... expectedKeys) { + Object[][] flipped = new Object[expectedKeys.length][]; + for (int r = 0; r < flipped.length; r++) { + flipped[r] = new Object[] { expectedKeys[r] }; + } + assertKeys(actualKeys, flipped); + } + + protected void assertKeys(Block[] actualKeys, Object[][] expectedKeys) { + for (int r = 0; r < expectedKeys.length; r++) { + assertThat(actualKeys, arrayWithSize(expectedKeys[r].length)); + } + for (int c = 0; c < actualKeys.length; c++) { + assertThat("block " + c, actualKeys[c].getPositionCount(), equalTo(expectedKeys.length)); + } + for (int r = 0; r < expectedKeys.length; r++) { + for (int c = 0; c < actualKeys.length; c++) { + if (expectedKeys[r][c] == null) { + assertThat("expected null", actualKeys[c].isNull(r), equalTo(true)); + return; + } + assertThat(actualKeys[c].isNull(r), equalTo(false)); + if (expectedKeys[r][c] instanceof Integer v) { + assertThat(((IntBlock) actualKeys[c]).getInt(r), equalTo(v)); + } else if (expectedKeys[r][c] instanceof Long v) { + assertThat(((LongBlock) actualKeys[c]).getLong(r), equalTo(v)); + } else if (expectedKeys[r][c] instanceof Double v) { + assertThat(((DoubleBlock) actualKeys[c]).getDouble(r), equalTo(v)); + } else if (expectedKeys[r][c] instanceof String v) { + assertThat(((BytesRefBlock) actualKeys[c]).getBytesRef(r, new BytesRef()), equalTo(new BytesRef(v))); + } else if (expectedKeys[r][c] instanceof Boolean v) { + assertThat(((BooleanBlock) actualKeys[c]).getBoolean(r), equalTo(v)); + } else { + throw new IllegalArgumentException("unsupported type " + expectedKeys[r][c].getClass()); + } + } + } + } + + protected IntVector intRange(int startInclusive, int endExclusive) { + return IntVector.range(startInclusive, endExclusive, TestBlockFactory.getNonBreakingInstance()); + } } diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java index 431b82db322f5..63893c8d22bca 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java @@ -32,15 +32,11 @@ import org.junit.After; import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashSet; import java.util.List; -import java.util.Set; import java.util.function.Consumer; import java.util.stream.IntStream; import java.util.stream.LongStream; -import static org.hamcrest.Matchers.arrayWithSize; import static org.hamcrest.Matchers.either; import static org.hamcrest.Matchers.endsWith; import static org.hamcrest.Matchers.equalTo; @@ -74,15 +70,15 @@ public void testIntHash() { int[] values = new int[] { 1, 2, 3, 1, 2, 3, 1, 2, 3 }; hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:INT], entries=3, size=")); - assertOrds(ordsAndKeys.ords, 0, 1, 2, 0, 1, 2, 0, 1, 2); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 3))); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:INT], entries=3, size=")); + assertOrds(ordsAndKeys.ords(), 0, 1, 2, 0, 1, 2, 0, 1, 2); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 3))); } else { - assertThat(ordsAndKeys.description, equalTo("IntBlockHash{channel=0, entries=3, seenNull=false}")); - assertOrds(ordsAndKeys.ords, 1, 2, 3, 1, 2, 3, 1, 2, 3); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(1, 4))); + assertThat(ordsAndKeys.description(), equalTo("IntBlockHash{channel=0, entries=3, seenNull=false}")); + assertOrds(ordsAndKeys.ords(), 1, 2, 3, 1, 2, 3, 1, 2, 3); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(1, 4))); } - assertKeys(ordsAndKeys.keys, 1, 2, 3); + assertKeys(ordsAndKeys.keys(), 1, 2, 3); }, blockFactory.newIntArrayVector(values, values.length).asBlock()); } @@ -95,15 +91,15 @@ public void testIntHashWithNulls() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:INT], entries=3, size=")); - assertOrds(ordsAndKeys.ords, 0, 1, 2, 1); - assertKeys(ordsAndKeys.keys, 0, null, 2); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:INT], entries=3, size=")); + assertOrds(ordsAndKeys.ords(), 0, 1, 2, 1); + assertKeys(ordsAndKeys.keys(), 0, null, 2); } else { - assertThat(ordsAndKeys.description, equalTo("IntBlockHash{channel=0, entries=2, seenNull=true}")); - assertOrds(ordsAndKeys.ords, 1, 0, 2, 0); - assertKeys(ordsAndKeys.keys, null, 0, 2); + assertThat(ordsAndKeys.description(), equalTo("IntBlockHash{channel=0, entries=2, seenNull=true}")); + assertOrds(ordsAndKeys.ords(), 1, 0, 2, 0); + assertKeys(ordsAndKeys.keys(), null, 0, 2); } - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 3))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 3))); }, builder); } } @@ -132,9 +128,9 @@ public void testIntHashWithMultiValuedFields() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:INT], entries=4, size=")); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:INT], entries=4, size=")); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 0 }, new int[] { 0, 1 }, new int[] { 2, 0 }, @@ -142,11 +138,11 @@ public void testIntHashWithMultiValuedFields() { new int[] { 3 }, new int[] { 2, 1, 0 } ); - assertKeys(ordsAndKeys.keys, 1, 2, 3, null); + assertKeys(ordsAndKeys.keys(), 1, 2, 3, null); } else { - assertThat(ordsAndKeys.description, equalTo("IntBlockHash{channel=0, entries=3, seenNull=true}")); + assertThat(ordsAndKeys.description(), equalTo("IntBlockHash{channel=0, entries=3, seenNull=true}")); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 1 }, new int[] { 1, 2 }, new int[] { 3, 1 }, @@ -154,9 +150,9 @@ public void testIntHashWithMultiValuedFields() { new int[] { 0 }, new int[] { 3, 2, 1 } ); - assertKeys(ordsAndKeys.keys, null, 1, 2, 3); + assertKeys(ordsAndKeys.keys(), null, 1, 2, 3); } - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 4))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); }, builder); } } @@ -166,15 +162,15 @@ public void testLongHash() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:LONG], entries=4, size=")); - assertOrds(ordsAndKeys.ords, 0, 1, 2, 0, 2, 1, 3, 2); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 4))); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:LONG], entries=4, size=")); + assertOrds(ordsAndKeys.ords(), 0, 1, 2, 0, 2, 1, 3, 2); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); } else { - assertThat(ordsAndKeys.description, equalTo("LongBlockHash{channel=0, entries=4, seenNull=false}")); - assertOrds(ordsAndKeys.ords, 1, 2, 3, 1, 3, 2, 4, 3); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(1, 5))); + assertThat(ordsAndKeys.description(), equalTo("LongBlockHash{channel=0, entries=4, seenNull=false}")); + assertOrds(ordsAndKeys.ords(), 1, 2, 3, 1, 3, 2, 4, 3); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(1, 5))); } - assertKeys(ordsAndKeys.keys, 2L, 1L, 4L, 3L); + assertKeys(ordsAndKeys.keys(), 2L, 1L, 4L, 3L); }, blockFactory.newLongArrayVector(values, values.length).asBlock()); } @@ -187,15 +183,15 @@ public void testLongHashWithNulls() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:LONG], entries=3, size=")); - assertOrds(ordsAndKeys.ords, 0, 1, 2, 1); - assertKeys(ordsAndKeys.keys, 0L, null, 2L); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:LONG], entries=3, size=")); + assertOrds(ordsAndKeys.ords(), 0, 1, 2, 1); + assertKeys(ordsAndKeys.keys(), 0L, null, 2L); } else { - assertThat(ordsAndKeys.description, equalTo("LongBlockHash{channel=0, entries=2, seenNull=true}")); - assertOrds(ordsAndKeys.ords, 1, 0, 2, 0); - assertKeys(ordsAndKeys.keys, null, 0L, 2L); + assertThat(ordsAndKeys.description(), equalTo("LongBlockHash{channel=0, entries=2, seenNull=true}")); + assertOrds(ordsAndKeys.ords(), 1, 0, 2, 0); + assertKeys(ordsAndKeys.keys(), null, 0L, 2L); } - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 3))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 3))); }, builder); } } @@ -224,9 +220,9 @@ public void testLongHashWithMultiValuedFields() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:LONG], entries=4, size=")); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:LONG], entries=4, size=")); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 0 }, new int[] { 0, 1, 2 }, new int[] { 0 }, @@ -234,11 +230,11 @@ public void testLongHashWithMultiValuedFields() { new int[] { 3 }, new int[] { 2, 1, 0 } ); - assertKeys(ordsAndKeys.keys, 1L, 2L, 3L, null); + assertKeys(ordsAndKeys.keys(), 1L, 2L, 3L, null); } else { - assertThat(ordsAndKeys.description, equalTo("LongBlockHash{channel=0, entries=3, seenNull=true}")); + assertThat(ordsAndKeys.description(), equalTo("LongBlockHash{channel=0, entries=3, seenNull=true}")); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 1 }, new int[] { 1, 2, 3 }, new int[] { 1 }, @@ -246,9 +242,9 @@ public void testLongHashWithMultiValuedFields() { new int[] { 0 }, new int[] { 3, 2, 1 } ); - assertKeys(ordsAndKeys.keys, null, 1L, 2L, 3L); + assertKeys(ordsAndKeys.keys(), null, 1L, 2L, 3L); } - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 4))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); }, builder); } } @@ -257,15 +253,15 @@ public void testDoubleHash() { double[] values = new double[] { 2.0, 1.0, 4.0, 2.0, 4.0, 1.0, 3.0, 4.0 }; hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:DOUBLE], entries=4, size=")); - assertOrds(ordsAndKeys.ords, 0, 1, 2, 0, 2, 1, 3, 2); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 4))); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:DOUBLE], entries=4, size=")); + assertOrds(ordsAndKeys.ords(), 0, 1, 2, 0, 2, 1, 3, 2); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); } else { - assertThat(ordsAndKeys.description, equalTo("DoubleBlockHash{channel=0, entries=4, seenNull=false}")); - assertOrds(ordsAndKeys.ords, 1, 2, 3, 1, 3, 2, 4, 3); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(1, 5))); + assertThat(ordsAndKeys.description(), equalTo("DoubleBlockHash{channel=0, entries=4, seenNull=false}")); + assertOrds(ordsAndKeys.ords(), 1, 2, 3, 1, 3, 2, 4, 3); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(1, 5))); } - assertKeys(ordsAndKeys.keys, 2.0, 1.0, 4.0, 3.0); + assertKeys(ordsAndKeys.keys(), 2.0, 1.0, 4.0, 3.0); }, blockFactory.newDoubleArrayVector(values, values.length).asBlock()); } @@ -278,15 +274,15 @@ public void testDoubleHashWithNulls() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:DOUBLE], entries=3, size=")); - assertOrds(ordsAndKeys.ords, 0, 1, 2, 1); - assertKeys(ordsAndKeys.keys, 0.0, null, 2.0); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:DOUBLE], entries=3, size=")); + assertOrds(ordsAndKeys.ords(), 0, 1, 2, 1); + assertKeys(ordsAndKeys.keys(), 0.0, null, 2.0); } else { - assertThat(ordsAndKeys.description, equalTo("DoubleBlockHash{channel=0, entries=2, seenNull=true}")); - assertOrds(ordsAndKeys.ords, 1, 0, 2, 0); - assertKeys(ordsAndKeys.keys, null, 0.0, 2.0); + assertThat(ordsAndKeys.description(), equalTo("DoubleBlockHash{channel=0, entries=2, seenNull=true}")); + assertOrds(ordsAndKeys.ords(), 1, 0, 2, 0); + assertKeys(ordsAndKeys.keys(), null, 0.0, 2.0); } - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 3))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 3))); }, builder); } } @@ -314,9 +310,9 @@ public void testDoubleHashWithMultiValuedFields() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:DOUBLE], entries=4, size=")); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:DOUBLE], entries=4, size=")); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 0 }, new int[] { 1, 2 }, new int[] { 2, 1 }, @@ -324,11 +320,11 @@ public void testDoubleHashWithMultiValuedFields() { new int[] { 3 }, new int[] { 0, 1 } ); - assertKeys(ordsAndKeys.keys, 1.0, 2.0, 3.0, null); + assertKeys(ordsAndKeys.keys(), 1.0, 2.0, 3.0, null); } else { - assertThat(ordsAndKeys.description, equalTo("DoubleBlockHash{channel=0, entries=3, seenNull=true}")); + assertThat(ordsAndKeys.description(), equalTo("DoubleBlockHash{channel=0, entries=3, seenNull=true}")); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 1 }, new int[] { 2, 3 }, new int[] { 3, 2 }, @@ -336,9 +332,9 @@ public void testDoubleHashWithMultiValuedFields() { new int[] { 0 }, new int[] { 1, 2 } ); - assertKeys(ordsAndKeys.keys, null, 1.0, 2.0, 3.0); + assertKeys(ordsAndKeys.keys(), null, 1.0, 2.0, 3.0); } - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 4))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); }, builder); } } @@ -356,17 +352,17 @@ public void testBasicBytesRefHash() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:BYTES_REF], entries=4, size=")); - assertThat(ordsAndKeys.description, endsWith("b}")); - assertOrds(ordsAndKeys.ords, 0, 1, 2, 0, 2, 1, 3, 2); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 4))); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:BYTES_REF], entries=4, size=")); + assertThat(ordsAndKeys.description(), endsWith("b}")); + assertOrds(ordsAndKeys.ords(), 0, 1, 2, 0, 2, 1, 3, 2); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); } else { - assertThat(ordsAndKeys.description, startsWith("BytesRefBlockHash{channel=0, entries=4, size=")); - assertThat(ordsAndKeys.description, endsWith("b, seenNull=false}")); - assertOrds(ordsAndKeys.ords, 1, 2, 3, 1, 3, 2, 4, 3); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(1, 5))); + assertThat(ordsAndKeys.description(), startsWith("BytesRefBlockHash{channel=0, entries=4, size=")); + assertThat(ordsAndKeys.description(), endsWith("b, seenNull=false}")); + assertOrds(ordsAndKeys.ords(), 1, 2, 3, 1, 3, 2, 4, 3); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(1, 5))); } - assertKeys(ordsAndKeys.keys, "item-2", "item-1", "item-4", "item-3"); + assertKeys(ordsAndKeys.keys(), "item-2", "item-1", "item-4", "item-3"); }, builder); } } @@ -380,17 +376,17 @@ public void testBytesRefHashWithNulls() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:BYTES_REF], entries=3, size=")); - assertThat(ordsAndKeys.description, endsWith("b}")); - assertOrds(ordsAndKeys.ords, 0, 1, 2, 1); - assertKeys(ordsAndKeys.keys, "cat", null, "dog"); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:BYTES_REF], entries=3, size=")); + assertThat(ordsAndKeys.description(), endsWith("b}")); + assertOrds(ordsAndKeys.ords(), 0, 1, 2, 1); + assertKeys(ordsAndKeys.keys(), "cat", null, "dog"); } else { - assertThat(ordsAndKeys.description, startsWith("BytesRefBlockHash{channel=0, entries=2, size=")); - assertThat(ordsAndKeys.description, endsWith("b, seenNull=true}")); - assertOrds(ordsAndKeys.ords, 1, 0, 2, 0); - assertKeys(ordsAndKeys.keys, null, "cat", "dog"); + assertThat(ordsAndKeys.description(), startsWith("BytesRefBlockHash{channel=0, entries=2, size=")); + assertThat(ordsAndKeys.description(), endsWith("b, seenNull=true}")); + assertOrds(ordsAndKeys.ords(), 1, 0, 2, 0); + assertKeys(ordsAndKeys.keys(), null, "cat", "dog"); } - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 3))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 3))); }, builder); } } @@ -419,10 +415,10 @@ public void testBytesRefHashWithMultiValuedFields() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:BYTES_REF], entries=4, size=")); - assertThat(ordsAndKeys.description, endsWith("b}")); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:BYTES_REF], entries=4, size=")); + assertThat(ordsAndKeys.description(), endsWith("b}")); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 0 }, new int[] { 0, 1 }, new int[] { 1, 2 }, @@ -430,12 +426,12 @@ public void testBytesRefHashWithMultiValuedFields() { new int[] { 3 }, new int[] { 2, 1 } ); - assertKeys(ordsAndKeys.keys, "foo", "bar", "bort", null); + assertKeys(ordsAndKeys.keys(), "foo", "bar", "bort", null); } else { - assertThat(ordsAndKeys.description, startsWith("BytesRefBlockHash{channel=0, entries=3, size=")); - assertThat(ordsAndKeys.description, endsWith("b, seenNull=true}")); + assertThat(ordsAndKeys.description(), startsWith("BytesRefBlockHash{channel=0, entries=3, size=")); + assertThat(ordsAndKeys.description(), endsWith("b, seenNull=true}")); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 1 }, new int[] { 1, 2 }, new int[] { 2, 3 }, @@ -443,9 +439,9 @@ public void testBytesRefHashWithMultiValuedFields() { new int[] { 0 }, new int[] { 3, 2 } ); - assertKeys(ordsAndKeys.keys, null, "foo", "bar", "bort"); + assertKeys(ordsAndKeys.keys(), null, "foo", "bar", "bort"); } - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 4))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); }, builder); } } @@ -470,17 +466,17 @@ public void testBasicOrdinals() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:BYTES_REF], entries=4, size=")); - assertThat(ordsAndKeys.description, endsWith("b}")); - assertOrds(ordsAndKeys.ords, 0, 1, 2, 0, 2, 1, 3, 2); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 4))); - assertKeys(ordsAndKeys.keys, "item-2", "item-1", "item-4", "item-3"); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:BYTES_REF], entries=4, size=")); + assertThat(ordsAndKeys.description(), endsWith("b}")); + assertOrds(ordsAndKeys.ords(), 0, 1, 2, 0, 2, 1, 3, 2); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); + assertKeys(ordsAndKeys.keys(), "item-2", "item-1", "item-4", "item-3"); } else { - assertThat(ordsAndKeys.description, startsWith("BytesRefBlockHash{channel=0, entries=4, size=")); - assertThat(ordsAndKeys.description, endsWith("b, seenNull=false}")); - assertOrds(ordsAndKeys.ords, 2, 1, 4, 2, 4, 1, 3, 4); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(1, 5))); - assertKeys(ordsAndKeys.keys, "item-1", "item-2", "item-3", "item-4"); + assertThat(ordsAndKeys.description(), startsWith("BytesRefBlockHash{channel=0, entries=4, size=")); + assertThat(ordsAndKeys.description(), endsWith("b, seenNull=false}")); + assertOrds(ordsAndKeys.ords(), 2, 1, 4, 2, 4, 1, 3, 4); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(1, 5))); + assertKeys(ordsAndKeys.keys(), "item-1", "item-2", "item-3", "item-4"); } }, new OrdinalBytesRefVector(ords.build(), bytes.build()).asBlock()); } @@ -500,17 +496,17 @@ public void testOrdinalsWithNulls() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:BYTES_REF], entries=3, size=")); - assertThat(ordsAndKeys.description, endsWith("b}")); - assertOrds(ordsAndKeys.ords, 0, 1, 2, 1); - assertKeys(ordsAndKeys.keys, "cat", null, "dog"); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:BYTES_REF], entries=3, size=")); + assertThat(ordsAndKeys.description(), endsWith("b}")); + assertOrds(ordsAndKeys.ords(), 0, 1, 2, 1); + assertKeys(ordsAndKeys.keys(), "cat", null, "dog"); } else { - assertThat(ordsAndKeys.description, startsWith("BytesRefBlockHash{channel=0, entries=2, size=")); - assertThat(ordsAndKeys.description, endsWith("b, seenNull=true}")); - assertOrds(ordsAndKeys.ords, 1, 0, 2, 0); - assertKeys(ordsAndKeys.keys, null, "cat", "dog"); + assertThat(ordsAndKeys.description(), startsWith("BytesRefBlockHash{channel=0, entries=2, size=")); + assertThat(ordsAndKeys.description(), endsWith("b, seenNull=true}")); + assertOrds(ordsAndKeys.ords(), 1, 0, 2, 0); + assertKeys(ordsAndKeys.keys(), null, "cat", "dog"); } - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 3))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 3))); }, new OrdinalBytesRefBlock(ords.build(), bytes.build())); } } @@ -546,10 +542,10 @@ public void testOrdinalsWithMultiValuedFields() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:BYTES_REF], entries=4, size=")); - assertThat(ordsAndKeys.description, endsWith("b}")); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:BYTES_REF], entries=4, size=")); + assertThat(ordsAndKeys.description(), endsWith("b}")); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 0 }, new int[] { 0, 1 }, new int[] { 1, 2 }, @@ -557,12 +553,12 @@ public void testOrdinalsWithMultiValuedFields() { new int[] { 3 }, new int[] { 2, 1 } ); - assertKeys(ordsAndKeys.keys, "foo", "bar", "bort", null); + assertKeys(ordsAndKeys.keys(), "foo", "bar", "bort", null); } else { - assertThat(ordsAndKeys.description, startsWith("BytesRefBlockHash{channel=0, entries=3, size=")); - assertThat(ordsAndKeys.description, endsWith("b, seenNull=true}")); + assertThat(ordsAndKeys.description(), startsWith("BytesRefBlockHash{channel=0, entries=3, size=")); + assertThat(ordsAndKeys.description(), endsWith("b, seenNull=true}")); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 1 }, new int[] { 1, 2 }, new int[] { 2, 3 }, @@ -570,9 +566,9 @@ public void testOrdinalsWithMultiValuedFields() { new int[] { 0 }, new int[] { 3, 2 } ); - assertKeys(ordsAndKeys.keys, null, "foo", "bar", "bort"); + assertKeys(ordsAndKeys.keys(), null, "foo", "bar", "bort"); } - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 4))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); }, new OrdinalBytesRefBlock(ords.build(), bytes.build())); } } @@ -581,15 +577,18 @@ public void testBooleanHashFalseFirst() { boolean[] values = new boolean[] { false, true, true, true, true }; hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:BOOLEAN], entries=2, size=")); - assertOrds(ordsAndKeys.ords, 0, 1, 1, 1, 1); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 2))); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:BOOLEAN], entries=2, size=")); + assertOrds(ordsAndKeys.ords(), 0, 1, 1, 1, 1); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 2))); } else { - assertThat(ordsAndKeys.description, equalTo("BooleanBlockHash{channel=0, seenFalse=true, seenTrue=true, seenNull=false}")); - assertOrds(ordsAndKeys.ords, 1, 2, 2, 2, 2); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(1, 3))); + assertThat( + ordsAndKeys.description(), + equalTo("BooleanBlockHash{channel=0, seenFalse=true, seenTrue=true, seenNull=false}") + ); + assertOrds(ordsAndKeys.ords(), 1, 2, 2, 2, 2); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(1, 3))); } - assertKeys(ordsAndKeys.keys, false, true); + assertKeys(ordsAndKeys.keys(), false, true); }, blockFactory.newBooleanArrayVector(values, values.length).asBlock()); } @@ -597,15 +596,18 @@ public void testBooleanHashTrueFirst() { boolean[] values = new boolean[] { true, false, false, true, true }; hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:BOOLEAN], entries=2, size=")); - assertOrds(ordsAndKeys.ords, 0, 1, 1, 0, 0); - assertKeys(ordsAndKeys.keys, true, false); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 2))); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:BOOLEAN], entries=2, size=")); + assertOrds(ordsAndKeys.ords(), 0, 1, 1, 0, 0); + assertKeys(ordsAndKeys.keys(), true, false); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 2))); } else { - assertThat(ordsAndKeys.description, equalTo("BooleanBlockHash{channel=0, seenFalse=true, seenTrue=true, seenNull=false}")); - assertOrds(ordsAndKeys.ords, 2, 1, 1, 2, 2); - assertKeys(ordsAndKeys.keys, false, true); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(1, 3))); + assertThat( + ordsAndKeys.description(), + equalTo("BooleanBlockHash{channel=0, seenFalse=true, seenTrue=true, seenNull=false}") + ); + assertOrds(ordsAndKeys.ords(), 2, 1, 1, 2, 2); + assertKeys(ordsAndKeys.keys(), false, true); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(1, 3))); } }, blockFactory.newBooleanArrayVector(values, values.length).asBlock()); } @@ -614,15 +616,18 @@ public void testBooleanHashTrueOnly() { boolean[] values = new boolean[] { true, true, true, true }; hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:BOOLEAN], entries=1, size=")); - assertOrds(ordsAndKeys.ords, 0, 0, 0, 0); - assertKeys(ordsAndKeys.keys, true); - assertThat(ordsAndKeys.nonEmpty, equalTo(TestBlockFactory.getNonBreakingInstance().newConstantIntVector(0, 1))); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:BOOLEAN], entries=1, size=")); + assertOrds(ordsAndKeys.ords(), 0, 0, 0, 0); + assertKeys(ordsAndKeys.keys(), true); + assertThat(ordsAndKeys.nonEmpty(), equalTo(TestBlockFactory.getNonBreakingInstance().newConstantIntVector(0, 1))); } else { - assertThat(ordsAndKeys.description, equalTo("BooleanBlockHash{channel=0, seenFalse=false, seenTrue=true, seenNull=false}")); - assertOrds(ordsAndKeys.ords, 2, 2, 2, 2); - assertKeys(ordsAndKeys.keys, true); - assertThat(ordsAndKeys.nonEmpty, equalTo(TestBlockFactory.getNonBreakingInstance().newConstantIntVector(2, 1))); + assertThat( + ordsAndKeys.description(), + equalTo("BooleanBlockHash{channel=0, seenFalse=false, seenTrue=true, seenNull=false}") + ); + assertOrds(ordsAndKeys.ords(), 2, 2, 2, 2); + assertKeys(ordsAndKeys.keys(), true); + assertThat(ordsAndKeys.nonEmpty(), equalTo(TestBlockFactory.getNonBreakingInstance().newConstantIntVector(2, 1))); } }, blockFactory.newBooleanArrayVector(values, values.length).asBlock()); } @@ -631,15 +636,18 @@ public void testBooleanHashFalseOnly() { boolean[] values = new boolean[] { false, false, false, false }; hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:BOOLEAN], entries=1, size=")); - assertOrds(ordsAndKeys.ords, 0, 0, 0, 0); - assertThat(ordsAndKeys.nonEmpty, equalTo(TestBlockFactory.getNonBreakingInstance().newConstantIntVector(0, 1))); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:BOOLEAN], entries=1, size=")); + assertOrds(ordsAndKeys.ords(), 0, 0, 0, 0); + assertThat(ordsAndKeys.nonEmpty(), equalTo(TestBlockFactory.getNonBreakingInstance().newConstantIntVector(0, 1))); } else { - assertThat(ordsAndKeys.description, equalTo("BooleanBlockHash{channel=0, seenFalse=true, seenTrue=false, seenNull=false}")); - assertOrds(ordsAndKeys.ords, 1, 1, 1, 1); - assertThat(ordsAndKeys.nonEmpty, equalTo(TestBlockFactory.getNonBreakingInstance().newConstantIntVector(1, 1))); + assertThat( + ordsAndKeys.description(), + equalTo("BooleanBlockHash{channel=0, seenFalse=true, seenTrue=false, seenNull=false}") + ); + assertOrds(ordsAndKeys.ords(), 1, 1, 1, 1); + assertThat(ordsAndKeys.nonEmpty(), equalTo(TestBlockFactory.getNonBreakingInstance().newConstantIntVector(1, 1))); } - assertKeys(ordsAndKeys.keys, false); + assertKeys(ordsAndKeys.keys(), false); }, blockFactory.newBooleanArrayVector(values, values.length).asBlock()); } @@ -652,18 +660,18 @@ public void testBooleanHashWithNulls() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:BOOLEAN], entries=3, size=")); - assertOrds(ordsAndKeys.ords, 0, 1, 2, 1); - assertKeys(ordsAndKeys.keys, false, null, true); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:BOOLEAN], entries=3, size=")); + assertOrds(ordsAndKeys.ords(), 0, 1, 2, 1); + assertKeys(ordsAndKeys.keys(), false, null, true); } else { assertThat( - ordsAndKeys.description, + ordsAndKeys.description(), equalTo("BooleanBlockHash{channel=0, seenFalse=true, seenTrue=true, seenNull=true}") ); - assertOrds(ordsAndKeys.ords, 1, 0, 2, 0); - assertKeys(ordsAndKeys.keys, null, false, true); + assertOrds(ordsAndKeys.ords(), 1, 0, 2, 0); + assertKeys(ordsAndKeys.keys(), null, false, true); } - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 3))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 3))); }, builder); } } @@ -691,9 +699,9 @@ public void testBooleanHashWithMultiValuedFields() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:BOOLEAN], entries=3, size=")); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:BOOLEAN], entries=3, size=")); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 0 }, new int[] { 0, 1 }, new int[] { 0, 1 }, // Order is not preserved @@ -701,14 +709,14 @@ public void testBooleanHashWithMultiValuedFields() { new int[] { 2 }, new int[] { 0, 1 } ); - assertKeys(ordsAndKeys.keys, false, true, null); + assertKeys(ordsAndKeys.keys(), false, true, null); } else { assertThat( - ordsAndKeys.description, + ordsAndKeys.description(), equalTo("BooleanBlockHash{channel=0, seenFalse=true, seenTrue=true, seenNull=true}") ); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 1 }, new int[] { 1, 2 }, new int[] { 1, 2 }, // Order is not preserved @@ -716,9 +724,9 @@ public void testBooleanHashWithMultiValuedFields() { new int[] { 0 }, new int[] { 1, 2 } ); - assertKeys(ordsAndKeys.keys, null, false, true); + assertKeys(ordsAndKeys.keys(), null, false, true); } - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 3))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 3))); }, builder); } } @@ -727,13 +735,13 @@ public void testNullHash() { Object[] values = new Object[] { null, null, null, null }; hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:NULL], entries=1, size=")); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:NULL], entries=1, size=")); } else { - assertThat(ordsAndKeys.description, equalTo("NullBlockHash{channel=0, seenNull=true}")); + assertThat(ordsAndKeys.description(), equalTo("NullBlockHash{channel=0, seenNull=true}")); } - assertOrds(ordsAndKeys.ords, 0, 0, 0, 0); - assertThat(ordsAndKeys.nonEmpty, equalTo(TestBlockFactory.getNonBreakingInstance().newConstantIntVector(0, 1))); - assertKeys(ordsAndKeys.keys, new Object[][] { new Object[] { null } }); + assertOrds(ordsAndKeys.ords(), 0, 0, 0, 0); + assertThat(ordsAndKeys.nonEmpty(), equalTo(TestBlockFactory.getNonBreakingInstance().newConstantIntVector(0, 1))); + assertKeys(ordsAndKeys.keys(), new Object[][] { new Object[] { null } }); }, blockFactory.newConstantNullBlock(values.length)); } @@ -748,14 +756,14 @@ public void testLongLongHash() { new Object[] { 0L, 1L } }; assertThat( - ordsAndKeys.description, + ordsAndKeys.description(), forcePackedHash ? startsWith("PackedValuesBlockHash{groups=[0:LONG, 1:LONG], entries=4, size=") : equalTo("LongLongBlockHash{channels=[0,1], entries=4}") ); - assertOrds(ordsAndKeys.ords, 0, 1, 0, 2, 3, 2); - assertKeys(ordsAndKeys.keys, expectedKeys); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 4))); + assertOrds(ordsAndKeys.ords(), 0, 1, 0, 2, 3, 2); + assertKeys(ordsAndKeys.keys(), expectedKeys); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); }, blockFactory.newLongArrayVector(values1, values1.length).asBlock(), blockFactory.newLongArrayVector(values2, values2.length).asBlock() @@ -801,9 +809,9 @@ public void testLongLongHashWithMultiValuedFields() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:LONG, 1:LONG], entries=10, size=")); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:LONG, 1:LONG], entries=10, size=")); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 0, 1, 2, 3 }, new int[] { 0, 2 }, new int[] { 0, 1 }, @@ -815,7 +823,7 @@ public void testLongLongHashWithMultiValuedFields() { new int[] { 6, 0, 7, 2, 8, 9 } ); assertKeys( - ordsAndKeys.keys, + ordsAndKeys.keys(), new Object[][] { new Object[] { 1L, 10L }, new Object[] { 1L, 20L }, @@ -828,11 +836,11 @@ public void testLongLongHashWithMultiValuedFields() { new Object[] { 3L, 30L }, new Object[] { 3L, 10L }, } ); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 10))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 10))); } else { - assertThat(ordsAndKeys.description, equalTo("LongLongBlockHash{channels=[0,1], entries=8}")); + assertThat(ordsAndKeys.description(), equalTo("LongLongBlockHash{channels=[0,1], entries=8}")); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 0, 1, 2, 3 }, new int[] { 0, 2 }, new int[] { 0, 1 }, @@ -844,7 +852,7 @@ public void testLongLongHashWithMultiValuedFields() { new int[] { 4, 0, 5, 2, 6, 7 } ); assertKeys( - ordsAndKeys.keys, + ordsAndKeys.keys(), new Object[][] { new Object[] { 1L, 10L }, new Object[] { 1L, 20L }, @@ -855,7 +863,7 @@ public void testLongLongHashWithMultiValuedFields() { new Object[] { 3L, 30L }, new Object[] { 3L, 10L }, } ); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 8))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 8))); } }, b1, b2); } @@ -876,19 +884,19 @@ public void testLongLongHashHugeCombinatorialExplosion() { int start = expectedEntries[0]; expectedEntries[0] = Math.min(expectedEntries[0] + pageSize, v1.length * v2.length); assertThat( - ordsAndKeys.description, + ordsAndKeys.description(), forcePackedHash ? startsWith("PackedValuesBlockHash{groups=[0:LONG, 1:LONG], entries=" + expectedEntries[0] + ", size=") : equalTo("LongLongBlockHash{channels=[0,1], entries=" + expectedEntries[0] + "}") ); - assertOrds(ordsAndKeys.ords, IntStream.range(start, expectedEntries[0]).toArray()); + assertOrds(ordsAndKeys.ords(), IntStream.range(start, expectedEntries[0]).toArray()); assertKeys( - ordsAndKeys.keys, + ordsAndKeys.keys(), IntStream.range(0, expectedEntries[0]) .mapToObj(i -> new Object[] { v1[i / v2.length], v2[i % v2.length] }) .toArray(l -> new Object[l][]) ); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, expectedEntries[0]))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, expectedEntries[0]))); }, pageSize, b1, b2); assertThat("misconfigured test", expectedEntries[0], greaterThan(0)); @@ -900,10 +908,10 @@ public void testIntLongHash() { long[] values2 = new long[] { 0, 0, 0, 1, 1, 1 }; Object[][] expectedKeys = { new Object[] { 0, 0L }, new Object[] { 1, 0L }, new Object[] { 1, 1L }, new Object[] { 0, 1L } }; hash(ordsAndKeys -> { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:INT, 1:LONG], entries=4, size=")); - assertThat(ordsAndKeys.description, endsWith("b}")); - assertOrds(ordsAndKeys.ords, 0, 1, 0, 2, 3, 2); - assertKeys(ordsAndKeys.keys, expectedKeys); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:INT, 1:LONG], entries=4, size=")); + assertThat(ordsAndKeys.description(), endsWith("b}")); + assertOrds(ordsAndKeys.ords(), 0, 1, 0, 2, 3, 2); + assertKeys(ordsAndKeys.keys(), expectedKeys); }, blockFactory.newIntArrayVector(values1, values1.length).asBlock(), blockFactory.newLongArrayVector(values2, values2.length).asBlock() @@ -915,10 +923,10 @@ public void testLongDoubleHash() { double[] values2 = new double[] { 0, 0, 0, 1, 1, 1 }; Object[][] expectedKeys = { new Object[] { 0L, 0d }, new Object[] { 1L, 0d }, new Object[] { 1L, 1d }, new Object[] { 0L, 1d } }; hash((OrdsAndKeys ordsAndKeys) -> { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:LONG, 1:DOUBLE], entries=4, size=")); - assertThat(ordsAndKeys.description, endsWith("b}")); - assertOrds(ordsAndKeys.ords, 0, 1, 0, 2, 3, 2); - assertKeys(ordsAndKeys.keys, expectedKeys); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:LONG, 1:DOUBLE], entries=4, size=")); + assertThat(ordsAndKeys.description(), endsWith("b}")); + assertOrds(ordsAndKeys.ords(), 0, 1, 0, 2, 3, 2); + assertKeys(ordsAndKeys.keys(), expectedKeys); }, blockFactory.newLongArrayVector(values1, values1.length).asBlock(), blockFactory.newDoubleArrayVector(values2, values2.length).asBlock() @@ -934,10 +942,10 @@ public void testIntBooleanHash() { new Object[] { 1, true }, new Object[] { 0, true } }; hash((OrdsAndKeys ordsAndKeys) -> { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:INT, 1:BOOLEAN], entries=4, size=")); - assertThat(ordsAndKeys.description, endsWith("b}")); - assertOrds(ordsAndKeys.ords, 0, 1, 0, 2, 3, 2); - assertKeys(ordsAndKeys.keys, expectedKeys); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:INT, 1:BOOLEAN], entries=4, size=")); + assertThat(ordsAndKeys.description(), endsWith("b}")); + assertOrds(ordsAndKeys.ords(), 0, 1, 0, 2, 3, 2); + assertKeys(ordsAndKeys.keys(), expectedKeys); }, blockFactory.newIntArrayVector(values1, values1.length).asBlock(), blockFactory.newBooleanArrayVector(values2, values2.length).asBlock() @@ -959,10 +967,10 @@ public void testLongLongHashWithNull() { hash((OrdsAndKeys ordsAndKeys) -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:LONG, 1:LONG], entries=5, size=")); - assertOrds(ordsAndKeys.ords, 0, 1, 2, 3, 4); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:LONG, 1:LONG], entries=5, size=")); + assertOrds(ordsAndKeys.ords(), 0, 1, 2, 3, 4); assertKeys( - ordsAndKeys.keys, + ordsAndKeys.keys(), new Object[][] { new Object[] { 1L, 0L }, new Object[] { null, null }, @@ -970,12 +978,12 @@ public void testLongLongHashWithNull() { new Object[] { 0L, null }, new Object[] { null, 0L }, } ); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 5))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 5))); } else { - assertThat(ordsAndKeys.description, equalTo("LongLongBlockHash{channels=[0,1], entries=2}")); - assertOrds(ordsAndKeys.ords, 0, null, 1, null, null); - assertKeys(ordsAndKeys.keys, new Object[][] { new Object[] { 1L, 0L }, new Object[] { 0L, 1L } }); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 2))); + assertThat(ordsAndKeys.description(), equalTo("LongLongBlockHash{channels=[0,1], entries=2}")); + assertOrds(ordsAndKeys.ords(), 0, null, 1, null, null); + assertKeys(ordsAndKeys.keys(), new Object[][] { new Object[] { 1L, 0L }, new Object[] { 0L, 1L } }); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 2))); } }, b1, b2); } @@ -1000,17 +1008,17 @@ public void testLongBytesRefHash() { hash((OrdsAndKeys ordsAndKeys) -> { assertThat( - ordsAndKeys.description, + ordsAndKeys.description(), startsWith( forcePackedHash ? "PackedValuesBlockHash{groups=[0:LONG, 1:BYTES_REF], entries=4, size=" : "BytesRefLongBlockHash{keys=[BytesRefKey[channel=1], LongKey[channel=0]], entries=4, size=" ) ); - assertThat(ordsAndKeys.description, endsWith("b}")); - assertOrds(ordsAndKeys.ords, 0, 1, 0, 2, 3, 2); - assertKeys(ordsAndKeys.keys, expectedKeys); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 4))); + assertThat(ordsAndKeys.description(), endsWith("b}")); + assertOrds(ordsAndKeys.ords(), 0, 1, 0, 2, 3, 2); + assertKeys(ordsAndKeys.keys(), expectedKeys); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); }, b1, b2); } } @@ -1028,11 +1036,14 @@ public void testLongBytesRefHashWithNull() { hash((OrdsAndKeys ordsAndKeys) -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:LONG, 1:BYTES_REF], entries=5, size=")); - assertThat(ordsAndKeys.description, endsWith("b}")); - assertOrds(ordsAndKeys.ords, 0, 1, 2, 3, 4); + assertThat( + ordsAndKeys.description(), + startsWith("PackedValuesBlockHash{groups=[0:LONG, 1:BYTES_REF], entries=5, size=") + ); + assertThat(ordsAndKeys.description(), endsWith("b}")); + assertOrds(ordsAndKeys.ords(), 0, 1, 2, 3, 4); assertKeys( - ordsAndKeys.keys, + ordsAndKeys.keys(), new Object[][] { new Object[] { 1L, "cat" }, new Object[] { null, null }, @@ -1040,19 +1051,19 @@ public void testLongBytesRefHashWithNull() { new Object[] { 1L, null }, new Object[] { null, "nn" } } ); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 5))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 5))); } else { assertThat( - ordsAndKeys.description, + ordsAndKeys.description(), startsWith("BytesRefLongBlockHash{keys=[BytesRefKey[channel=1], LongKey[channel=0]], entries=3, size=") ); - assertThat(ordsAndKeys.description, endsWith("b}")); - assertOrds(ordsAndKeys.ords, 0, null, 1, 2, null); + assertThat(ordsAndKeys.description(), endsWith("b}")); + assertOrds(ordsAndKeys.ords(), 0, null, 1, 2, null); assertKeys( - ordsAndKeys.keys, + ordsAndKeys.keys(), new Object[][] { new Object[] { 1L, "cat" }, new Object[] { 0L, "dog" }, new Object[] { 0L, null } } ); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 3))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 3))); } }, b1, b2); } @@ -1101,11 +1112,11 @@ public void testLongBytesRefHashWithMultiValuedFields() { hash((OrdsAndKeys ordsAndKeys) -> { if (forcePackedHash) { assertThat( - ordsAndKeys.description, + ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:LONG, 1:BYTES_REF], entries=10, size=") ); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 0, 1, 2, 3 }, new int[] { 0, 2 }, new int[] { 0, 1 }, @@ -1117,7 +1128,7 @@ public void testLongBytesRefHashWithMultiValuedFields() { new int[] { 6, 0, 7, 2, 8, 9 } ); assertKeys( - ordsAndKeys.keys, + ordsAndKeys.keys(), new Object[][] { new Object[] { 1L, "a" }, new Object[] { 1L, "b" }, @@ -1130,14 +1141,14 @@ public void testLongBytesRefHashWithMultiValuedFields() { new Object[] { 3L, "c" }, new Object[] { 3L, "a" }, } ); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 10))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 10))); } else { assertThat( - ordsAndKeys.description, + ordsAndKeys.description(), equalTo("BytesRefLongBlockHash{keys=[BytesRefKey[channel=1], LongKey[channel=0]], entries=9, size=483b}") ); assertOrds( - ordsAndKeys.ords, + ordsAndKeys.ords(), new int[] { 0, 1, 2, 3 }, new int[] { 0, 1 }, new int[] { 0, 2 }, @@ -1149,7 +1160,7 @@ public void testLongBytesRefHashWithMultiValuedFields() { new int[] { 5, 6, 7, 0, 1, 8 } ); assertKeys( - ordsAndKeys.keys, + ordsAndKeys.keys(), new Object[][] { new Object[] { 1L, "a" }, new Object[] { 2L, "a" }, @@ -1161,7 +1172,7 @@ public void testLongBytesRefHashWithMultiValuedFields() { new Object[] { 3L, "c" }, new Object[] { 3L, "a" }, } ); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 9))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 9))); } }, b1, b2); } @@ -1182,7 +1193,7 @@ public void testBytesRefLongHashHugeCombinatorialExplosion() { int start = expectedEntries[0]; expectedEntries[0] = Math.min(expectedEntries[0] + pageSize, v1.length * v2.length); assertThat( - ordsAndKeys.description, + ordsAndKeys.description(), forcePackedHash ? startsWith("PackedValuesBlockHash{groups=[0:LONG, 1:BYTES_REF], entries=" + expectedEntries[0] + ", size=") : startsWith( @@ -1191,9 +1202,9 @@ public void testBytesRefLongHashHugeCombinatorialExplosion() { + ", size=" ) ); - assertOrds(ordsAndKeys.ords, IntStream.range(start, expectedEntries[0]).toArray()); + assertOrds(ordsAndKeys.ords(), IntStream.range(start, expectedEntries[0]).toArray()); assertKeys( - ordsAndKeys.keys, + ordsAndKeys.keys(), IntStream.range(0, expectedEntries[0]) .mapToObj( i -> forcePackedHash @@ -1202,7 +1213,7 @@ public void testBytesRefLongHashHugeCombinatorialExplosion() { ) .toArray(l -> new Object[l][]) ); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, expectedEntries[0]))); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, expectedEntries[0]))); }, pageSize, b1, b2); assertThat("misconfigured test", expectedEntries[0], greaterThan(0)); @@ -1218,10 +1229,10 @@ public void testLongNull() { new Object[] { 2L, null }, new Object[] { 3L, null } }; - assertThat(ordsAndKeys.description, startsWith("PackedValuesBlockHash{groups=[0:LONG, 1:NULL], entries=4, size=")); - assertOrds(ordsAndKeys.ords, 0, 1, 0, 2, 3, 1); - assertKeys(ordsAndKeys.keys, expectedKeys); - assertThat(ordsAndKeys.nonEmpty, equalTo(intRange(0, 4))); + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:LONG, 1:NULL], entries=4, size=")); + assertOrds(ordsAndKeys.ords(), 0, 1, 0, 2, 3, 1); + assertKeys(ordsAndKeys.keys(), expectedKeys); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); }, blockFactory.newLongArrayVector(values, values.length).asBlock(), blockFactory.newConstantNullBlock(values.length)); } @@ -1326,8 +1337,6 @@ public void close() { } } - record OrdsAndKeys(String description, int positionOffset, IntBlock ords, Block[] keys, IntVector nonEmpty) {} - /** * Hash some values into a single block of group ids. If the hash produces * more than one block of group ids this will fail. @@ -1355,7 +1364,7 @@ private void hash(Consumer callback, Block... values) { try (ReleasableIterator lookup = hash.lookup(new Page(values), ByteSizeValue.ofKb(between(1, 100)))) { assertThat(lookup.hasNext(), equalTo(true)); try (IntBlock ords = lookup.next()) { - assertThat(ords, equalTo(ordsAndKeys.ords)); + assertThat(ords, equalTo(ordsAndKeys.ords())); } } } @@ -1383,145 +1392,4 @@ private BlockHash buildBlockHash(int emitBatchSize, Block... values) { ? new PackedValuesBlockHash(specs, blockFactory, emitBatchSize) : BlockHash.build(specs, blockFactory, emitBatchSize, true); } - - static void hash(boolean collectKeys, BlockHash blockHash, Consumer callback, Block... values) { - blockHash.add(new Page(values), new GroupingAggregatorFunction.AddInput() { - @Override - public void add(int positionOffset, IntBlock groupIds) { - OrdsAndKeys result = new OrdsAndKeys( - blockHash.toString(), - positionOffset, - groupIds, - collectKeys ? blockHash.getKeys() : null, - blockHash.nonEmpty() - ); - - try { - Set allowedOrds = new HashSet<>(); - for (int p = 0; p < result.nonEmpty.getPositionCount(); p++) { - allowedOrds.add(result.nonEmpty.getInt(p)); - } - for (int p = 0; p < result.ords.getPositionCount(); p++) { - if (result.ords.isNull(p)) { - continue; - } - int start = result.ords.getFirstValueIndex(p); - int end = start + result.ords.getValueCount(p); - for (int i = start; i < end; i++) { - int ord = result.ords.getInt(i); - if (false == allowedOrds.contains(ord)) { - fail("ord is not allowed " + ord); - } - } - } - callback.accept(result); - } finally { - Releasables.close(result.keys == null ? null : Releasables.wrap(result.keys), result.nonEmpty); - } - } - - @Override - public void add(int positionOffset, IntVector groupIds) { - add(positionOffset, groupIds.asBlock()); - } - - @Override - public void close() { - fail("hashes should not close AddInput"); - } - }); - if (blockHash instanceof LongLongBlockHash == false - && blockHash instanceof BytesRefLongBlockHash == false - && blockHash instanceof BytesRef2BlockHash == false - && blockHash instanceof BytesRef3BlockHash == false) { - Block[] keys = blockHash.getKeys(); - try (ReleasableIterator lookup = blockHash.lookup(new Page(keys), ByteSizeValue.ofKb(between(1, 100)))) { - while (lookup.hasNext()) { - try (IntBlock ords = lookup.next()) { - for (int p = 0; p < ords.getPositionCount(); p++) { - assertFalse(ords.isNull(p)); - } - } - } - } finally { - Releasables.closeExpectNoException(keys); - } - } - } - - private void assertOrds(IntBlock ordsBlock, Integer... expectedOrds) { - assertOrds(ordsBlock, Arrays.stream(expectedOrds).map(l -> l == null ? null : new int[] { l }).toArray(int[][]::new)); - } - - private void assertOrds(IntBlock ordsBlock, int[]... expectedOrds) { - assertEquals(expectedOrds.length, ordsBlock.getPositionCount()); - for (int p = 0; p < expectedOrds.length; p++) { - int start = ordsBlock.getFirstValueIndex(p); - int count = ordsBlock.getValueCount(p); - if (expectedOrds[p] == null) { - if (false == ordsBlock.isNull(p)) { - StringBuilder error = new StringBuilder(); - error.append(p); - error.append(": expected null but was ["); - for (int i = 0; i < count; i++) { - if (i != 0) { - error.append(", "); - } - error.append(ordsBlock.getInt(start + i)); - } - fail(error.append("]").toString()); - } - continue; - } - assertFalse(p + ": expected not null", ordsBlock.isNull(p)); - int[] actual = new int[count]; - for (int i = 0; i < count; i++) { - actual[i] = ordsBlock.getInt(start + i); - } - assertThat("position " + p, actual, equalTo(expectedOrds[p])); - } - } - - private void assertKeys(Block[] actualKeys, Object... expectedKeys) { - Object[][] flipped = new Object[expectedKeys.length][]; - for (int r = 0; r < flipped.length; r++) { - flipped[r] = new Object[] { expectedKeys[r] }; - } - assertKeys(actualKeys, flipped); - } - - private void assertKeys(Block[] actualKeys, Object[][] expectedKeys) { - for (int r = 0; r < expectedKeys.length; r++) { - assertThat(actualKeys, arrayWithSize(expectedKeys[r].length)); - } - for (int c = 0; c < actualKeys.length; c++) { - assertThat("block " + c, actualKeys[c].getPositionCount(), equalTo(expectedKeys.length)); - } - for (int r = 0; r < expectedKeys.length; r++) { - for (int c = 0; c < actualKeys.length; c++) { - if (expectedKeys[r][c] == null) { - assertThat("expected null", actualKeys[c].isNull(r), equalTo(true)); - return; - } - assertThat(actualKeys[c].isNull(r), equalTo(false)); - if (expectedKeys[r][c] instanceof Integer v) { - assertThat(((IntBlock) actualKeys[c]).getInt(r), equalTo(v)); - } else if (expectedKeys[r][c] instanceof Long v) { - assertThat(((LongBlock) actualKeys[c]).getLong(r), equalTo(v)); - } else if (expectedKeys[r][c] instanceof Double v) { - assertThat(((DoubleBlock) actualKeys[c]).getDouble(r), equalTo(v)); - } else if (expectedKeys[r][c] instanceof String v) { - assertThat(((BytesRefBlock) actualKeys[c]).getBytesRef(r, new BytesRef()), equalTo(new BytesRef(v))); - } else if (expectedKeys[r][c] instanceof Boolean v) { - assertThat(((BooleanBlock) actualKeys[c]).getBoolean(r), equalTo(v)); - } else { - throw new IllegalArgumentException("unsupported type " + expectedKeys[r][c].getClass()); - } - } - } - } - - IntVector intRange(int startInclusive, int endExclusive) { - return IntVector.range(startInclusive, endExclusive, TestBlockFactory.getNonBreakingInstance()); - } } From a425c5dadbe8f1d685301f4282ea9c0fdcd2324d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Mon, 21 Apr 2025 18:39:13 +0200 Subject: [PATCH 05/39] Initial TopNBlockHash test structure, WIP --- .../blockhash/LongTopNBlockHash.java | 8 +- .../blockhash/BlockHashTestCase.java | 8 + .../aggregation/blockhash/BlockHashTests.java | 6 - .../blockhash/TopNBlockHashTests.java | 218 ++++++++++++++++++ 4 files changed, 232 insertions(+), 8 deletions(-) create mode 100644 x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 29ee4b5ab0519..960bce57b9631 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -273,6 +273,7 @@ public IntVector nonEmpty() { int nullOffset = hasNull ? 1 : 0; final int[] ids = new int[topValues.size() + nullOffset]; int idsIndex = nullOffset; + // TODO: Can we instead iterate the top and take the ids from the hash? To avoid checking unused values for (int i = 1; i < hash.size() + 1; i++) { long value = hash.get(i - 1); if (isInTop(value)) { @@ -295,9 +296,12 @@ public void close() { @Override public String toString() { StringBuilder b = new StringBuilder(); - b.append("LongBlockHash{channel=").append(channel); + b.append("LongTopNBlockHash{channel=").append(channel); + b.append(", asc=").append(asc); + b.append(", nullsFirst=").append(nullsFirst); + b.append(", limit=").append(limit); b.append(", entries=").append(hash.size()); - b.append(", seenNull=").append(hasNull); + b.append(", hasNull=").append(hasNull); return b.append('}').toString(); } } diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java index d732e7fe62471..9790186423109 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java @@ -28,6 +28,7 @@ import org.elasticsearch.core.Releasables; import org.elasticsearch.indices.breaker.CircuitBreakerService; import org.elasticsearch.test.ESTestCase; +import org.junit.After; import java.util.Arrays; import java.util.HashSet; @@ -36,6 +37,7 @@ import static org.hamcrest.Matchers.arrayWithSize; import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.is; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @@ -45,6 +47,12 @@ public abstract class BlockHashTestCase extends ESTestCase { final BigArrays bigArrays = new MockBigArrays(PageCacheRecycler.NON_RECYCLING_INSTANCE, mockBreakerService(breaker)); final MockBlockFactory blockFactory = new MockBlockFactory(breaker, bigArrays); + @After + public void checkBreaker() { + blockFactory.ensureAllBlocksAreReleased(); + assertThat(breaker.getUsed(), is(0L)); + } + // A breaker service that always returns the given breaker for getBreaker(CircuitBreaker.REQUEST) private static CircuitBreakerService mockBreakerService(CircuitBreaker breaker) { CircuitBreakerService breakerService = mock(CircuitBreakerService.class); diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java index 63893c8d22bca..2acc240ef44bb 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java @@ -54,12 +54,6 @@ public static List params() { return params; } - @After - public void checkBreaker() { - blockFactory.ensureAllBlocksAreReleased(); - assertThat(breaker.getUsed(), is(0L)); - } - private final boolean forcePackedHash; public BlockHashTests(@Name("forcePackedHash") boolean forcePackedHash) { diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java new file mode 100644 index 0000000000000..a46132d92ea50 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java @@ -0,0 +1,218 @@ +/* + * 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.blockhash; + +import com.carrotsearch.randomizedtesting.annotations.Name; +import com.carrotsearch.randomizedtesting.annotations.ParametersFactory; + +import org.elasticsearch.common.unit.ByteSizeValue; +import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.IntBlock; +import org.elasticsearch.compute.data.LongBlock; +import org.elasticsearch.compute.data.Page; +import org.elasticsearch.core.ReleasableIterator; +import org.elasticsearch.core.Releasables; +import org.junit.After; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; + +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.startsWith; + +public class TopNBlockHashTests extends BlockHashTestCase { + + @ParametersFactory + public static List params() { + List params = new ArrayList<>(); + + // TODO: Uncomment "true" when implemented + for (boolean forcePackedHash : new boolean[]{/*true,*/false}) { + for (boolean asc : new boolean[]{true, false}) { + for (boolean nullsFirst : new boolean[]{true, false}) { + for (int limit : new int[]{2, 10000}) { + params.add(new Object[] { forcePackedHash, asc, nullsFirst, limit }); + } + } + } + } + + return params; + } + + private final boolean forcePackedHash; + private final boolean asc; + private final boolean nullsFirst; + private final int limit; + + public TopNBlockHashTests( + @Name("forcePackedHash") boolean forcePackedHash, + @Name("asc") boolean asc, + @Name("nullsFirst") boolean nullsFirst, + @Name("limit") int limit + ) { + this.forcePackedHash = forcePackedHash; + this.asc = asc; + this.nullsFirst = nullsFirst; + this.limit = limit; + } + + public void testLongHash() { + long[] values = new long[] { 2, 1, 4, 2, 4, 1, 3, 4 }; + + hash(ordsAndKeys -> { + if (forcePackedHash) { + // TODO: Not tested + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:LONG], entries=4, size=")); + assertOrds(ordsAndKeys.ords(), 0, 1, 2, 0, 2, 1, 3, 2); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); + } else { + assertThat(ordsAndKeys.description(), equalTo("LongTopNBlockHash{channel=0, entries=4, seenNull=false}")); + assertOrds(ordsAndKeys.ords(), 1, 2, 3, 1, 3, 2, 4, 3); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(1, 5))); + } + assertKeys(ordsAndKeys.keys(), 2L, 1L, 4L, 3L); + }, blockFactory.newLongArrayVector(values, values.length).asBlock()); + } + + /*public void testLongHashWithNulls() { + try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder(4)) { + builder.appendLong(0); + builder.appendNull(); + builder.appendLong(2); + builder.appendNull(); + + hash(ordsAndKeys -> { + if (forcePackedHash) { + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:LONG], entries=3, size=")); + assertOrds(ordsAndKeys.ords(), 0, 1, 2, 1); + assertKeys(ordsAndKeys.keys(), 0L, null, 2L); + } else { + assertThat(ordsAndKeys.description(), equalTo("LongBlockHash{channel=0, entries=2, seenNull=true}")); + assertOrds(ordsAndKeys.ords(), 1, 0, 2, 0); + assertKeys(ordsAndKeys.keys(), null, 0L, 2L); + } + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 3))); + }, builder); + } + } + + public void testLongHashWithMultiValuedFields() { + try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder(8)) { + builder.appendLong(1); + builder.beginPositionEntry(); + builder.appendLong(1); + builder.appendLong(2); + builder.appendLong(3); + builder.endPositionEntry(); + builder.beginPositionEntry(); + builder.appendLong(1); + builder.appendLong(1); + builder.endPositionEntry(); + builder.beginPositionEntry(); + builder.appendLong(3); + builder.endPositionEntry(); + builder.appendNull(); + builder.beginPositionEntry(); + builder.appendLong(3); + builder.appendLong(2); + builder.appendLong(1); + builder.endPositionEntry(); + + hash(ordsAndKeys -> { + if (forcePackedHash) { + assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:LONG], entries=4, size=")); + assertOrds( + ordsAndKeys.ords(), + new int[] { 0 }, + new int[] { 0, 1, 2 }, + new int[] { 0 }, + new int[] { 2 }, + new int[] { 3 }, + new int[] { 2, 1, 0 } + ); + assertKeys(ordsAndKeys.keys(), 1L, 2L, 3L, null); + } else { + assertThat(ordsAndKeys.description(), equalTo("LongBlockHash{channel=0, entries=3, seenNull=true}")); + assertOrds( + ordsAndKeys.ords(), + new int[] { 1 }, + new int[] { 1, 2, 3 }, + new int[] { 1 }, + new int[] { 3 }, + new int[] { 0 }, + new int[] { 3, 2, 1 } + ); + assertKeys(ordsAndKeys.keys(), null, 1L, 2L, 3L); + } + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); + }, builder); + } + }*/ + + /** + * Hash some values into a single block of group ids. If the hash produces + * more than one block of group ids this will fail. + */ + private void hash(Consumer callback, Block.Builder... values) { + hash(callback, Block.Builder.buildAll(values)); + } + + /** + * Hash some values into a single block of group ids. If the hash produces + * more than one block of group ids this will fail. + */ + private void hash(Consumer callback, Block... values) { + boolean[] called = new boolean[] { false }; + try (BlockHash hash = buildBlockHash(16 * 1024, values)) { + hash(true, hash, ordsAndKeys -> { + if (called[0]) { + throw new IllegalStateException("hash produced more than one block"); + } + called[0] = true; + callback.accept(ordsAndKeys); + if (hash instanceof LongLongBlockHash == false + && hash instanceof BytesRefLongBlockHash == false + && hash instanceof BytesRef3BlockHash == false) { + try (ReleasableIterator lookup = hash.lookup(new Page(values), ByteSizeValue.ofKb(between(1, 100)))) { + assertThat(lookup.hasNext(), equalTo(true)); + try (IntBlock ords = lookup.next()) { + assertThat(ords, equalTo(ordsAndKeys.ords())); + } + } + } + }, values); + } finally { + Releasables.close(values); + } + } + + private void hash(Consumer callback, int emitBatchSize, Block.Builder... values) { + Block[] blocks = Block.Builder.buildAll(values); + try (BlockHash hash = buildBlockHash(emitBatchSize, blocks)) { + hash(true, hash, callback, blocks); + } finally { + Releasables.closeExpectNoException(blocks); + } + } + + private BlockHash buildBlockHash(int emitBatchSize, Block... values) { + List specs = new ArrayList<>(values.length); + for (int c = 0; c < values.length; c++) { + specs.add(new BlockHash.GroupSpec(c, values[c].elementType())); + } + assert forcePackedHash == false : "Packed TopN hash not implemented yet"; + /*return forcePackedHash + ? new PackedValuesBlockHash(specs, blockFactory, emitBatchSize) + : BlockHash.build(specs, blockFactory, emitBatchSize, true);*/ + + return new LongTopNBlockHash(specs.get(0).channel(), asc, nullsFirst, limit, blockFactory); + } +} From 665ace3b628a4e481ed6063f18df10fcee0a52a4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Tue, 22 Apr 2025 12:24:20 +0200 Subject: [PATCH 06/39] Added TopNBlockHash test without nulls, and fixed bug in ords --- .../blockhash/LongTopNBlockHash.java | 8 ++-- .../blockhash/BlockHashTestCase.java | 4 ++ .../blockhash/TopNBlockHashTests.java | 39 ++++++++++++++----- 3 files changed, 39 insertions(+), 12 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 960bce57b9631..8ae6a366a8ba6 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -82,7 +82,7 @@ public void add(Page page, GroupingAggregatorFunction.AddInput addInput) { } return; } - try (IntVector groupIds = add(vector)) { + try (IntBlock groupIds = add(vector)) { addInput.add(0, groupIds); } } @@ -156,7 +156,7 @@ private boolean isTopComplete() { /** * Adds the vector values to the hash, and returns a new vector with the group IDs for those positions. */ - IntVector add(LongVector vector) { + IntBlock add(LongVector vector) { int positions = vector.getPositionCount(); // Add all values to the top set, so we don't end up sending invalid values later @@ -166,11 +166,13 @@ IntVector add(LongVector vector) { } // Create a vector with the groups - try (var builder = blockFactory.newIntVectorFixedBuilder(positions)) { + try (var builder = blockFactory.newIntBlockBuilder(positions)) { for (int i = 0; i < positions; i++) { long v = vector.getLong(i); if (isAcceptable(v)) { builder.appendInt(Math.toIntExact(hashOrdToGroupNullReserved(hash.add(v)))); + } else { + builder.appendNull(); } } return builder.build(); diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java index 9790186423109..d3fb9eef9b454 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java @@ -202,4 +202,8 @@ protected void assertKeys(Block[] actualKeys, Object[][] expectedKeys) { protected IntVector intRange(int startInclusive, int endExclusive) { return IntVector.range(startInclusive, endExclusive, TestBlockFactory.getNonBreakingInstance()); } + + protected IntVector intVector(int ...values) { + return TestBlockFactory.getNonBreakingInstance().newIntArrayVector(values, values.length); + } } diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java index a46132d92ea50..138c2458394cc 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java @@ -29,6 +29,9 @@ public class TopNBlockHashTests extends BlockHashTestCase { + private static final int LIMIT_TWO = 2; + private static final int LIMIT_HIGH = 10000; + @ParametersFactory public static List params() { List params = new ArrayList<>(); @@ -37,7 +40,7 @@ public static List params() { for (boolean forcePackedHash : new boolean[]{/*true,*/false}) { for (boolean asc : new boolean[]{true, false}) { for (boolean nullsFirst : new boolean[]{true, false}) { - for (int limit : new int[]{2, 10000}) { + for (int limit : new int[]{LIMIT_TWO, LIMIT_HIGH}) { params.add(new Object[] { forcePackedHash, asc, nullsFirst, limit }); } } @@ -69,16 +72,27 @@ public void testLongHash() { hash(ordsAndKeys -> { if (forcePackedHash) { - // TODO: Not tested - assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:LONG], entries=4, size=")); - assertOrds(ordsAndKeys.ords(), 0, 1, 2, 0, 2, 1, 3, 2); - assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); + // TODO: Not tested yet } else { - assertThat(ordsAndKeys.description(), equalTo("LongTopNBlockHash{channel=0, entries=4, seenNull=false}")); - assertOrds(ordsAndKeys.ords(), 1, 2, 3, 1, 3, 2, 4, 3); - assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(1, 5))); + assertThat(ordsAndKeys.description(), equalTo( + "LongTopNBlockHash{channel=0, " + topNParametersString(4) + ", hasNull=false}" + )); + if (limit == LIMIT_HIGH) { + assertKeys(ordsAndKeys.keys(), 2L, 1L, 4L, 3L); + assertOrds(ordsAndKeys.ords(), 1, 2, 3, 1, 3, 2, 4, 3); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(1, 5))); + } else { + if (asc) { + assertKeys(ordsAndKeys.keys(), 2L, 1L); + assertOrds(ordsAndKeys.ords(), 1, 2, null, 1, null, 2, null, null); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intVector(1, 2))); + } else { + assertKeys(ordsAndKeys.keys(), 4L, 3L); + assertOrds(ordsAndKeys.ords(), null, null, 1, null, 1, null, 2, 1); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intVector(1, 2))); + } + } } - assertKeys(ordsAndKeys.keys(), 2L, 1L, 4L, 3L); }, blockFactory.newLongArrayVector(values, values.length).asBlock()); } @@ -215,4 +229,11 @@ private BlockHash buildBlockHash(int emitBatchSize, Block... values) { return new LongTopNBlockHash(specs.get(0).channel(), asc, nullsFirst, limit, blockFactory); } + + /** + * Returns the common toString() part of the TopNBlockHash using the test parameters. + */ + private String topNParametersString(int differentValues) { + return "asc=" + asc + ", nullsFirst=" + nullsFirst + ", limit=" + limit + ", entries=" + Math.min(differentValues, limit); + } } From 6616fdf4f769fa6691e48a1ea6f9a6cd6ba4c95c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Tue, 22 Apr 2025 13:27:16 +0200 Subject: [PATCH 07/39] Fix BlockHashTestCase keys assertion early return not checking all keys --- .../compute/aggregation/blockhash/BlockHashTestCase.java | 6 +++--- .../compute/aggregation/blockhash/BlockHashTests.java | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java index d3fb9eef9b454..ee4c0fab89baa 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java @@ -178,10 +178,10 @@ protected void assertKeys(Block[] actualKeys, Object[][] expectedKeys) { for (int r = 0; r < expectedKeys.length; r++) { for (int c = 0; c < actualKeys.length; c++) { if (expectedKeys[r][c] == null) { - assertThat("expected null", actualKeys[c].isNull(r), equalTo(true)); - return; + assertThat("expected null key", actualKeys[c].isNull(r), equalTo(true)); + continue; } - assertThat(actualKeys[c].isNull(r), equalTo(false)); + assertThat("expected non-null key", actualKeys[c].isNull(r), equalTo(false)); if (expectedKeys[r][c] instanceof Integer v) { assertThat(((IntBlock) actualKeys[c]).getInt(r), equalTo(v)); } else if (expectedKeys[r][c] instanceof Long v) { diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java index 2acc240ef44bb..3a624f583ce4c 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java @@ -1042,7 +1042,7 @@ public void testLongBytesRefHashWithNull() { new Object[] { 1L, "cat" }, new Object[] { null, null }, new Object[] { 0L, "dog" }, - new Object[] { 1L, null }, + new Object[] { 0L, null }, new Object[] { null, "nn" } } ); assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 5))); From d8380576f70358eb6a156b7ed940a28312543a60 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Tue, 22 Apr 2025 13:30:24 +0200 Subject: [PATCH 08/39] Added nulls tests, fixed dedupe lookup nulls handling and nulls error in hash --- .../blockhash/LongTopNBlockHash.java | 11 ++-- .../mvdedupe/TopNMultivalueDedupeLong.java | 10 +++- .../blockhash/TopNBlockHashTests.java | 52 +++++++++++++------ 3 files changed, 50 insertions(+), 23 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 8ae6a366a8ba6..31f57a09c5c34 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -115,7 +115,7 @@ private boolean acceptNull() { * Tries to add the value to the top values, and returns true if it was successful. */ private boolean acceptValue(long value) { - if (isAcceptable(value) == false && isTopComplete()) { + if (isAcceptable(value) == false) { return false; } @@ -136,11 +136,14 @@ private boolean acceptValue(long value) { * Returns true if the value is in, or can be added to the top; false otherwise. */ private boolean isAcceptable(long value) { - return isTopComplete() == false || isInTop(value); + return isTopComplete() == false || (hasNull && nullsFirst == false) || isInTop(value); } /** * Returns true if the value is in the top; false otherwise. + *

+ * This method does not check if the value is currently part of the top; only if it's better or equal than the current worst value. + *

*/ private boolean isInTop(long value) { return asc ? value <= topValues.last() : value >= topValues.last(); @@ -229,7 +232,7 @@ private IntBlock lookup(LongVector vector) { for (int i = 0; i < positions; i++) { long v = vector.getLong(i); long found = hash.find(v); - if (found < 0) { + if (found < 0 || isAcceptable(v) == false) { builder.appendNull(); } else { builder.appendInt(Math.toIntExact(hashOrdToGroupNullReserved(found))); @@ -240,7 +243,7 @@ private IntBlock lookup(LongVector vector) { } private IntBlock lookup(LongBlock block) { - return new MultivalueDedupeLong(block).hashLookup(blockFactory, hash); + return new TopNMultivalueDedupeLong(block, hasNull, this::isAcceptable).hashLookup(blockFactory, hash); } @Override diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java index 8fe3a59557240..4dc2f374a9147 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java @@ -236,7 +236,13 @@ public IntBlock hashLookup(BlockFactory blockFactory, LongHash hash) { int count = block.getValueCount(p); int first = block.getFirstValueIndex(p); switch (count) { - case 0 -> builder.appendInt(0); + case 0 -> { + if (hasNull) { + builder.appendInt(0); + } else { + builder.appendNull(); + } + } case 1 -> { long v = block.getLong(first); hashLookupSingle(builder, hash, v); @@ -626,7 +632,7 @@ private void hashAddNoCheck(IntBlock.Builder builder, LongHash hash, long v) { } private long hashLookup(LongHash hash, long v) { - return hash.find(v); + return isAcceptable.test(v) ? hash.find(v) : -1; } private void hashLookupSingle(IntBlock.Builder builder, LongHash hash, long v) { diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java index 138c2458394cc..a6b471815b2b8 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java @@ -96,7 +96,7 @@ public void testLongHash() { }, blockFactory.newLongArrayVector(values, values.length).asBlock()); } - /*public void testLongHashWithNulls() { + public void testLongHashWithNulls() { try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder(4)) { builder.appendLong(0); builder.appendNull(); @@ -105,20 +105,42 @@ public void testLongHash() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:LONG], entries=3, size=")); - assertOrds(ordsAndKeys.ords(), 0, 1, 2, 1); - assertKeys(ordsAndKeys.keys(), 0L, null, 2L); + // TODO: Not tested yet } else { - assertThat(ordsAndKeys.description(), equalTo("LongBlockHash{channel=0, entries=2, seenNull=true}")); - assertOrds(ordsAndKeys.ords(), 1, 0, 2, 0); - assertKeys(ordsAndKeys.keys(), null, 0L, 2L); + boolean hasTwoNonNullValues = nullsFirst == false || limit == LIMIT_HIGH; + boolean hasNull = nullsFirst || limit == LIMIT_HIGH; + assertThat(ordsAndKeys.description(), equalTo( + "LongTopNBlockHash{channel=0, " + + topNParametersString(hasTwoNonNullValues ? 2 : 1) + + ", hasNull=" + hasNull + "}" + )); + if (limit == LIMIT_HIGH) { + assertKeys(ordsAndKeys.keys(), null, 0L, 2L); + assertOrds(ordsAndKeys.ords(), 1, 0, 2, 0); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intVector(0, 1, 2))); + } else { + if (nullsFirst) { + if (asc) { + assertKeys(ordsAndKeys.keys(), null, 0L); + assertOrds(ordsAndKeys.ords(), 1, 0, null, 0); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intVector(0, 1))); + } else { + assertKeys(ordsAndKeys.keys(), null, 2L); + assertOrds(ordsAndKeys.ords(), null, 0, 1, 0); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intVector(0, 1))); + } + } else { + assertKeys(ordsAndKeys.keys(), 0L, 2L); + assertOrds(ordsAndKeys.ords(), 1, null, 2, null); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intVector(1, 2))); + } + } } - assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 3))); }, builder); } } - public void testLongHashWithMultiValuedFields() { + /*public void testLongHashWithMultiValuedFields() { try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder(8)) { builder.appendLong(1); builder.beginPositionEntry(); @@ -192,14 +214,10 @@ private void hash(Consumer callback, Block... values) { } called[0] = true; callback.accept(ordsAndKeys); - if (hash instanceof LongLongBlockHash == false - && hash instanceof BytesRefLongBlockHash == false - && hash instanceof BytesRef3BlockHash == false) { - try (ReleasableIterator lookup = hash.lookup(new Page(values), ByteSizeValue.ofKb(between(1, 100)))) { - assertThat(lookup.hasNext(), equalTo(true)); - try (IntBlock ords = lookup.next()) { - assertThat(ords, equalTo(ordsAndKeys.ords())); - } + try (ReleasableIterator lookup = hash.lookup(new Page(values), ByteSizeValue.ofKb(between(1, 100)))) { + assertThat(lookup.hasNext(), equalTo(true)); + try (IntBlock ords = lookup.next()) { + assertThat(ords, equalTo(ordsAndKeys.ords())); } } }, values); From e78fac581d898f545f8f1eae86a03a91dc230aac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Tue, 22 Apr 2025 14:36:20 +0200 Subject: [PATCH 09/39] Added multivalue tests and fixed dedupe with multivalues and no matches --- .../mvdedupe/TopNMultivalueDedupeLong.java | 16 +++ .../blockhash/TopNBlockHashTests.java | 110 +++++++++++++----- 2 files changed, 100 insertions(+), 26 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java index 4dc2f374a9147..cbcc5769fef09 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java @@ -351,6 +351,18 @@ void copyMissing(int first, int count) { grow(count); int end = first + count; + // Find the first acceptable value + for (; first < end; first++) { + long v = block.getLong(first); + if (isAcceptable.test(v)) { + break; + } + } + if (first == end) { + w = 0; + return; + } + work[0] = block.getLong(first); w = 1; i: for (int i = first + 1; i < end; i++) { @@ -463,6 +475,10 @@ private void hashAddSortedWork(LongHash hash, IntBlock.Builder builder) { * Looks up an already deduplicated {@link #work} to a hash. */ private void hashLookupUniquedWork(LongHash hash, IntBlock.Builder builder) { + if (w == 0) { + builder.appendNull(); + return; + } if (w == 1) { hashLookupSingle(builder, hash, work[0]); return; diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java index a6b471815b2b8..c3847a6792d17 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java @@ -36,7 +36,7 @@ public class TopNBlockHashTests extends BlockHashTestCase { public static List params() { List params = new ArrayList<>(); - // TODO: Uncomment "true" when implemented + // TODO: Uncomment this "true" when implemented for (boolean forcePackedHash : new boolean[]{/*true,*/false}) { for (boolean asc : new boolean[]{true, false}) { for (boolean nullsFirst : new boolean[]{true, false}) { @@ -140,7 +140,7 @@ public void testLongHashWithNulls() { } } - /*public void testLongHashWithMultiValuedFields() { + public void testLongHashWithMultiValuedFields() { try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder(8)) { builder.appendLong(1); builder.beginPositionEntry(); @@ -164,34 +164,92 @@ public void testLongHashWithNulls() { hash(ordsAndKeys -> { if (forcePackedHash) { - assertThat(ordsAndKeys.description(), startsWith("PackedValuesBlockHash{groups=[0:LONG], entries=4, size=")); - assertOrds( - ordsAndKeys.ords(), - new int[] { 0 }, - new int[] { 0, 1, 2 }, - new int[] { 0 }, - new int[] { 2 }, - new int[] { 3 }, - new int[] { 2, 1, 0 } - ); - assertKeys(ordsAndKeys.keys(), 1L, 2L, 3L, null); + // TODO: Not tested yet } else { - assertThat(ordsAndKeys.description(), equalTo("LongBlockHash{channel=0, entries=3, seenNull=true}")); - assertOrds( - ordsAndKeys.ords(), - new int[] { 1 }, - new int[] { 1, 2, 3 }, - new int[] { 1 }, - new int[] { 3 }, - new int[] { 0 }, - new int[] { 3, 2, 1 } - ); - assertKeys(ordsAndKeys.keys(), null, 1L, 2L, 3L); + if (limit == LIMIT_HIGH) { + assertThat(ordsAndKeys.description(), equalTo( + "LongTopNBlockHash{channel=0, " + + topNParametersString(3) + + ", hasNull=true}" + )); + assertOrds( + ordsAndKeys.ords(), + new int[] { 1 }, + new int[] { 1, 2, 3 }, + new int[] { 1 }, + new int[] { 3 }, + new int[] { 0 }, + new int[] { 3, 2, 1 } + ); + assertKeys(ordsAndKeys.keys(), null, 1L, 2L, 3L); + } else { + assertThat(ordsAndKeys.description(), equalTo( + "LongTopNBlockHash{channel=0, " + + topNParametersString(nullsFirst ? 1 : 2) + + ", hasNull=" + nullsFirst + "}" + )); + if (nullsFirst) { + if (asc) { + assertKeys(ordsAndKeys.keys(), null, 1L); + assertOrds( + ordsAndKeys.ords(), + new int[] { 1 }, + new int[] { 1 }, + new int[] { 1 }, + null, + new int[] { 0 }, + new int[] { 1 } + ); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intVector(0, 1))); + } else { + assertKeys(ordsAndKeys.keys(), null, 3L); + assertOrds( + ordsAndKeys.ords(), + null, + new int[] { 1 }, + null, + new int[] { 1 }, + new int[] { 0 }, + new int[] { 1 } + ); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intVector(0, 1))); + } + } else { + if (asc) { + assertKeys(ordsAndKeys.keys(), 1L, 2L); + assertOrds( + ordsAndKeys.ords(), + new int[] { 1 }, + new int[] { 1, 2 }, + new int[] { 1 }, + null, + null, + new int[] { 2, 1 } + ); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intVector(1, 2))); + } else { + assertKeys(ordsAndKeys.keys(), 2L, 3L); + assertOrds( + ordsAndKeys.ords(), + null, + new int[] { 1, 2 }, + null, + new int[] { 2 }, + null, + new int[] { 2, 1 } + ); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intVector(1, 2))); + } + } + } } - assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(0, 4))); }, builder); } - }*/ + } + + // TODO: Test adding multiple blocks, as it triggers different logics like: + // - Keeping older unused ords + // - Returning nonEmpty ords greater than 1 /** * Hash some values into a single block of group ids. If the hash produces From 143d86f70231621265fbf5e1f0592fadd841572a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Tue, 22 Apr 2025 14:59:00 +0200 Subject: [PATCH 10/39] Update docs/changelog/127148.yaml --- docs/changelog/127148.yaml | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 docs/changelog/127148.yaml diff --git a/docs/changelog/127148.yaml b/docs/changelog/127148.yaml new file mode 100644 index 0000000000000..db98b21a944b2 --- /dev/null +++ b/docs/changelog/127148.yaml @@ -0,0 +1,5 @@ +pr: 127148 +summary: Skip unused STATS groups by adding a Top N `BlockHash` implementation +area: ES|QL +type: enhancement +issues: [] From fa3a77988ced129666fdd4259905d50b983aebe5 Mon Sep 17 00:00:00 2001 From: elasticsearchmachine Date: Tue, 22 Apr 2025 13:05:28 +0000 Subject: [PATCH 11/39] [CI] Auto commit changes from spotless --- .../blockhash/LongTopNBlockHash.java | 1 - .../blockhash/BlockHashTestCase.java | 2 +- .../aggregation/blockhash/BlockHashTests.java | 2 - .../blockhash/TopNBlockHashTests.java | 63 +++++++++---------- 4 files changed, 30 insertions(+), 38 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 31f57a09c5c34..e599b0795721a 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -20,7 +20,6 @@ import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.mvdedupe.MultivalueDedupe; -import org.elasticsearch.compute.operator.mvdedupe.MultivalueDedupeLong; import org.elasticsearch.compute.operator.mvdedupe.TopNMultivalueDedupeLong; import org.elasticsearch.core.ReleasableIterator; diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java index ee4c0fab89baa..5bcf51ea8e527 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java @@ -203,7 +203,7 @@ protected IntVector intRange(int startInclusive, int endExclusive) { return IntVector.range(startInclusive, endExclusive, TestBlockFactory.getNonBreakingInstance()); } - protected IntVector intVector(int ...values) { + protected IntVector intVector(int... values) { return TestBlockFactory.getNonBreakingInstance().newIntArrayVector(values, values.length); } } diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java index 3a624f583ce4c..b12f0c9456bd5 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java @@ -29,7 +29,6 @@ import org.elasticsearch.core.Releasable; import org.elasticsearch.core.ReleasableIterator; import org.elasticsearch.core.Releasables; -import org.junit.After; import java.util.ArrayList; import java.util.List; @@ -41,7 +40,6 @@ import static org.hamcrest.Matchers.endsWith; import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.greaterThan; -import static org.hamcrest.Matchers.is; import static org.hamcrest.Matchers.startsWith; public class BlockHashTests extends BlockHashTestCase { diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java index c3847a6792d17..ef316786c0232 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java @@ -17,15 +17,12 @@ import org.elasticsearch.compute.data.Page; import org.elasticsearch.core.ReleasableIterator; import org.elasticsearch.core.Releasables; -import org.junit.After; import java.util.ArrayList; import java.util.List; import java.util.function.Consumer; import static org.hamcrest.Matchers.equalTo; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.startsWith; public class TopNBlockHashTests extends BlockHashTestCase { @@ -37,10 +34,10 @@ public static List params() { List params = new ArrayList<>(); // TODO: Uncomment this "true" when implemented - for (boolean forcePackedHash : new boolean[]{/*true,*/false}) { - for (boolean asc : new boolean[]{true, false}) { - for (boolean nullsFirst : new boolean[]{true, false}) { - for (int limit : new int[]{LIMIT_TWO, LIMIT_HIGH}) { + for (boolean forcePackedHash : new boolean[] { /*true,*/false }) { + for (boolean asc : new boolean[] { true, false }) { + for (boolean nullsFirst : new boolean[] { true, false }) { + for (int limit : new int[] { LIMIT_TWO, LIMIT_HIGH }) { params.add(new Object[] { forcePackedHash, asc, nullsFirst, limit }); } } @@ -74,9 +71,10 @@ public void testLongHash() { if (forcePackedHash) { // TODO: Not tested yet } else { - assertThat(ordsAndKeys.description(), equalTo( - "LongTopNBlockHash{channel=0, " + topNParametersString(4) + ", hasNull=false}" - )); + assertThat( + ordsAndKeys.description(), + equalTo("LongTopNBlockHash{channel=0, " + topNParametersString(4) + ", hasNull=false}") + ); if (limit == LIMIT_HIGH) { assertKeys(ordsAndKeys.keys(), 2L, 1L, 4L, 3L); assertOrds(ordsAndKeys.ords(), 1, 2, 3, 1, 3, 2, 4, 3); @@ -109,11 +107,16 @@ public void testLongHashWithNulls() { } else { boolean hasTwoNonNullValues = nullsFirst == false || limit == LIMIT_HIGH; boolean hasNull = nullsFirst || limit == LIMIT_HIGH; - assertThat(ordsAndKeys.description(), equalTo( - "LongTopNBlockHash{channel=0, " - + topNParametersString(hasTwoNonNullValues ? 2 : 1) - + ", hasNull=" + hasNull + "}" - )); + assertThat( + ordsAndKeys.description(), + equalTo( + "LongTopNBlockHash{channel=0, " + + topNParametersString(hasTwoNonNullValues ? 2 : 1) + + ", hasNull=" + + hasNull + + "}" + ) + ); if (limit == LIMIT_HIGH) { assertKeys(ordsAndKeys.keys(), null, 0L, 2L); assertOrds(ordsAndKeys.ords(), 1, 0, 2, 0); @@ -167,11 +170,10 @@ public void testLongHashWithMultiValuedFields() { // TODO: Not tested yet } else { if (limit == LIMIT_HIGH) { - assertThat(ordsAndKeys.description(), equalTo( - "LongTopNBlockHash{channel=0, " - + topNParametersString(3) - + ", hasNull=true}" - )); + assertThat( + ordsAndKeys.description(), + equalTo("LongTopNBlockHash{channel=0, " + topNParametersString(3) + ", hasNull=true}") + ); assertOrds( ordsAndKeys.ords(), new int[] { 1 }, @@ -183,11 +185,12 @@ public void testLongHashWithMultiValuedFields() { ); assertKeys(ordsAndKeys.keys(), null, 1L, 2L, 3L); } else { - assertThat(ordsAndKeys.description(), equalTo( - "LongTopNBlockHash{channel=0, " - + topNParametersString(nullsFirst ? 1 : 2) - + ", hasNull=" + nullsFirst + "}" - )); + assertThat( + ordsAndKeys.description(), + equalTo( + "LongTopNBlockHash{channel=0, " + topNParametersString(nullsFirst ? 1 : 2) + ", hasNull=" + nullsFirst + "}" + ) + ); if (nullsFirst) { if (asc) { assertKeys(ordsAndKeys.keys(), null, 1L); @@ -229,15 +232,7 @@ public void testLongHashWithMultiValuedFields() { assertThat(ordsAndKeys.nonEmpty(), equalTo(intVector(1, 2))); } else { assertKeys(ordsAndKeys.keys(), 2L, 3L); - assertOrds( - ordsAndKeys.ords(), - null, - new int[] { 1, 2 }, - null, - new int[] { 2 }, - null, - new int[] { 2, 1 } - ); + assertOrds(ordsAndKeys.ords(), null, new int[] { 1, 2 }, null, new int[] { 2 }, null, new int[] { 2, 1 }); assertThat(ordsAndKeys.nonEmpty(), equalTo(intVector(1, 2))); } } From 4b212cd4c4eaa5028d07dac9351cc97988901a5f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Tue, 22 Apr 2025 15:25:04 +0200 Subject: [PATCH 12/39] Remove TopNBlockHash abstract class --- .../blockhash/LongTopNBlockHash.java | 2 +- .../aggregation/blockhash/TopNBlockHash.java | 52 ------------------- 2 files changed, 1 insertion(+), 53 deletions(-) delete mode 100644 x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHash.java diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index e599b0795721a..e494958fd08a0 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -31,7 +31,7 @@ * Maps a {@link LongBlock} column to group ids, keeping only the top N values. */ // TODO: package-private instead of public? -public final class LongTopNBlockHash extends TopNBlockHash { +public final class LongTopNBlockHash extends BlockHash { private final int channel; private final boolean asc; private final boolean nullsFirst; diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHash.java deleted file mode 100644 index 83742be8cbf26..0000000000000 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHash.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * 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.blockhash; - -import org.elasticsearch.common.unit.ByteSizeValue; -import org.elasticsearch.common.util.BigArrays; -import org.elasticsearch.common.util.BitArray; -import org.elasticsearch.compute.aggregation.GroupingAggregatorFunction; -import org.elasticsearch.compute.data.Block; -import org.elasticsearch.compute.data.BlockFactory; -import org.elasticsearch.compute.data.IntBlock; -import org.elasticsearch.compute.data.IntVector; -import org.elasticsearch.compute.data.Page; -import org.elasticsearch.core.ReleasableIterator; - -// TODO: Do we need this class? -/** - * {@link BlockHash} specialization for hashes that store only the top N elements. - */ -public abstract class TopNBlockHash extends BlockHash { - - TopNBlockHash(BlockFactory blockFactory) { - super(blockFactory); - } - - // TODO: Insert only if the value is within the top N - @Override - public abstract void add(Page page, GroupingAggregatorFunction.AddInput addInput); - - // TODO: Something to do with this? - @Override - public abstract ReleasableIterator lookup(Page page, ByteSizeValue targetBlockSize); - - // TODO: What happens with inserted but then ignored groups? (e.g. Top 2 DESC; 5, 4, 6 -> [6, 5], 4 discarded) - @Override - public abstract Block[] getKeys(); - - // TODO: What to do with nonEmpty? - @Override - public abstract IntVector nonEmpty(); - - // TODO: What to do with seenGroupIds? - @Override - public abstract BitArray seenGroupIds(BigArrays bigArrays); - - // TODO: Implement build() methods like in BlockHash -} From 87eb13540760fa798f2df34a2c15bfe21d410edc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Wed, 23 Apr 2025 10:57:52 +0200 Subject: [PATCH 13/39] Remove unused class --- .../compute/data/sort/LongSortedSet.java | 40 ------------------- 1 file changed, 40 deletions(-) delete mode 100644 x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongSortedSet.java diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongSortedSet.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongSortedSet.java deleted file mode 100644 index acd15a5e2e0f9..0000000000000 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongSortedSet.java +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one - * or more contributor license agreements. Licensed under the Elastic License - * 2.0; you may not use this file except in compliance with the Elastic License - * 2.0. - */ - -package org.elasticsearch.compute.data.sort; - -import org.elasticsearch.common.util.BigArrays; -import org.elasticsearch.common.util.LongArray; -import org.elasticsearch.core.Releasable; -import org.elasticsearch.search.sort.SortOrder; - -public class LongSortedSet implements Releasable { - private final SortOrder order; - private final boolean nullsFirst; - - private final LongArray values; - private boolean hasNull; - private int valuesSize; - - public LongSortedSet(BigArrays bigArrays, SortOrder order, boolean nullsFirst, int limit) { - this.order = order; - this.nullsFirst = nullsFirst; - - this.values = bigArrays.newLongArray(limit, false); - this.hasNull = false; - this.valuesSize = 0; - } - - public boolean add(long value) { - throw new RuntimeException("Not implemented yet"); - } - - @Override - public void close() { - values.close(); - } -} From 29fa4d1a7c2647884e1cd5c51da8ee54e23767e0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Wed, 23 Apr 2025 15:03:50 +0200 Subject: [PATCH 14/39] Fix SeenGroupIds and added extra tests for it --- .../blockhash/LongTopNBlockHash.java | 13 ++- .../blockhash/BlockHashTestCase.java | 17 +++ .../blockhash/TopNBlockHashTests.java | 101 ++++++++++++++++-- 3 files changed, 119 insertions(+), 12 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index e494958fd08a0..da54470a2dfa4 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -289,7 +289,18 @@ public IntVector nonEmpty() { @Override public BitArray seenGroupIds(BigArrays bigArrays) { - return new Range(hasNull ? 0 : 1, Math.toIntExact(hash.size() + 1)).seenGroupIds(bigArrays); + BitArray seenGroups = new BitArray(111, bigArrays); + if (hasNull) { + seenGroups.set(0); + } + // TODO: Can we instead iterate the top and take the ids from the hash? To avoid checking unused values + for (int i = 1; i < hash.size() + 1; i++) { + long value = hash.get(i - 1); + if (isInTop(value)) { + seenGroups.set(i); + } + } + return seenGroups; } @Override diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java index 5bcf51ea8e527..974227561a8cb 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTestCase.java @@ -11,6 +11,7 @@ import org.elasticsearch.common.breaker.CircuitBreaker; import org.elasticsearch.common.unit.ByteSizeValue; import org.elasticsearch.common.util.BigArrays; +import org.elasticsearch.common.util.BitArray; import org.elasticsearch.common.util.MockBigArrays; import org.elasticsearch.common.util.PageCacheRecycler; import org.elasticsearch.compute.aggregation.GroupingAggregatorFunction; @@ -108,6 +109,7 @@ public void close() { fail("hashes should not close AddInput"); } }); + assertSeenGroupIdsAndNonEmpty(blockHash); if (blockHash instanceof LongLongBlockHash == false && blockHash instanceof BytesRefLongBlockHash == false && blockHash instanceof BytesRef2BlockHash == false @@ -127,6 +129,21 @@ public void close() { } } + private static void assertSeenGroupIdsAndNonEmpty(BlockHash blockHash) { + try (BitArray seenGroupIds = blockHash.seenGroupIds(BigArrays.NON_RECYCLING_INSTANCE); IntVector nonEmpty = blockHash.nonEmpty()) { + assertThat( + "seenGroupIds cardinality doesn't match with nonEmpty size", + seenGroupIds.cardinality(), + equalTo((long) nonEmpty.getPositionCount()) + ); + + for (int position = 0; position < nonEmpty.getPositionCount(); position++) { + int groupId = nonEmpty.getInt(position); + assertThat("group " + groupId + " from nonEmpty isn't set in seenGroupIds", seenGroupIds.get(groupId), is(true)); + } + } + } + protected void assertOrds(IntBlock ordsBlock, Integer... expectedOrds) { assertOrds(ordsBlock, Arrays.stream(expectedOrds).map(l -> l == null ? null : new int[] { l }).toArray(int[][]::new)); } diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java index ef316786c0232..623fe48ad42a4 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java @@ -19,10 +19,12 @@ import org.elasticsearch.core.Releasables; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; import java.util.function.Consumer; import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.greaterThan; public class TopNBlockHashTests extends BlockHashTestCase { @@ -73,7 +75,7 @@ public void testLongHash() { } else { assertThat( ordsAndKeys.description(), - equalTo("LongTopNBlockHash{channel=0, " + topNParametersString(4) + ", hasNull=false}") + equalTo("LongTopNBlockHash{channel=0, " + topNParametersString(4, 0) + ", hasNull=false}") ); if (limit == LIMIT_HIGH) { assertKeys(ordsAndKeys.keys(), 2L, 1L, 4L, 3L); @@ -94,6 +96,40 @@ public void testLongHash() { }, blockFactory.newLongArrayVector(values, values.length).asBlock()); } + public void testLongHashBatched() { + long[][] arrays = { new long[] { 2, 1, 4, 2 }, new long[] { 4, 1, 3, 4 } }; + + hashBatchesCallbackOnLast(ordsAndKeys -> { + if (forcePackedHash) { + // TODO: Not tested yet + } else { + assertThat( + ordsAndKeys.description(), + equalTo("LongTopNBlockHash{channel=0, " + topNParametersString(4, asc ? 0 : 1) + ", hasNull=false}") + ); + if (limit == LIMIT_HIGH) { + assertKeys(ordsAndKeys.keys(), 2L, 1L, 4L, 3L); + assertOrds(ordsAndKeys.ords(), 3, 2, 4, 3); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intRange(1, 5))); + } else { + if (asc) { + assertKeys(ordsAndKeys.keys(), 2L, 1L); + assertOrds(ordsAndKeys.ords(), null, 2, null, null); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intVector(1, 2))); + } else { + assertKeys(ordsAndKeys.keys(), 4L, 3L); + assertOrds(ordsAndKeys.ords(), 2, null, 3, 2); + assertThat(ordsAndKeys.nonEmpty(), equalTo(intVector(2, 3))); + } + } + } + }, + Arrays.stream(arrays) + .map(array -> new Block[] { blockFactory.newLongArrayVector(array, array.length).asBlock() }) + .toArray(Block[][]::new) + ); + } + public void testLongHashWithNulls() { try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder(4)) { builder.appendLong(0); @@ -111,7 +147,7 @@ public void testLongHashWithNulls() { ordsAndKeys.description(), equalTo( "LongTopNBlockHash{channel=0, " - + topNParametersString(hasTwoNonNullValues ? 2 : 1) + + topNParametersString(hasTwoNonNullValues ? 2 : 1, 0) + ", hasNull=" + hasNull + "}" @@ -172,7 +208,7 @@ public void testLongHashWithMultiValuedFields() { if (limit == LIMIT_HIGH) { assertThat( ordsAndKeys.description(), - equalTo("LongTopNBlockHash{channel=0, " + topNParametersString(3) + ", hasNull=true}") + equalTo("LongTopNBlockHash{channel=0, " + topNParametersString(3, 0) + ", hasNull=true}") ); assertOrds( ordsAndKeys.ords(), @@ -188,7 +224,11 @@ public void testLongHashWithMultiValuedFields() { assertThat( ordsAndKeys.description(), equalTo( - "LongTopNBlockHash{channel=0, " + topNParametersString(nullsFirst ? 1 : 2) + ", hasNull=" + nullsFirst + "}" + "LongTopNBlockHash{channel=0, " + + topNParametersString(nullsFirst ? 1 : 2, 0) + + ", hasNull=" + + nullsFirst + + "}" ) ); if (nullsFirst) { @@ -279,12 +319,44 @@ private void hash(Consumer callback, Block... values) { } } - private void hash(Consumer callback, int emitBatchSize, Block.Builder... values) { - Block[] blocks = Block.Builder.buildAll(values); - try (BlockHash hash = buildBlockHash(emitBatchSize, blocks)) { - hash(true, hash, callback, blocks); + // TODO: Randomize this instead? + /** + * Hashes multiple separated batches of values. + * + * @param callback Callback with the OrdsAndKeys for the last batch + */ + private void hashBatchesCallbackOnLast(Consumer callback, Block[]... batches) { + // Ensure all batches share the same specs + assertThat(batches.length, greaterThan(0)); + for (Block[] batch : batches) { + assertThat(batch.length, equalTo(batches[0].length)); + for (int i = 0; i < batch.length; i++) { + assertThat(batches[0][i].elementType(), equalTo(batch[i].elementType())); + } + } + + boolean[] called = new boolean[] { false }; + try (BlockHash hash = buildBlockHash(16 * 1024, batches[0])) { + for (Block[] batch : batches) { + called[0] = false; + hash(true, hash, ordsAndKeys -> { + if (called[0]) { + throw new IllegalStateException("hash produced more than one block"); + } + called[0] = true; + if (batch == batches[batches.length - 1]) { + callback.accept(ordsAndKeys); + } + try (ReleasableIterator lookup = hash.lookup(new Page(batch), ByteSizeValue.ofKb(between(1, 100)))) { + assertThat(lookup.hasNext(), equalTo(true)); + try (IntBlock ords = lookup.next()) { + assertThat(ords, equalTo(ordsAndKeys.ords())); + } + } + }, batch); + } } finally { - Releasables.closeExpectNoException(blocks); + Releasables.close(Arrays.stream(batches).flatMap(Arrays::stream).toList()); } } @@ -304,7 +376,14 @@ private BlockHash buildBlockHash(int emitBatchSize, Block... values) { /** * Returns the common toString() part of the TopNBlockHash using the test parameters. */ - private String topNParametersString(int differentValues) { - return "asc=" + asc + ", nullsFirst=" + nullsFirst + ", limit=" + limit + ", entries=" + Math.min(differentValues, limit); + private String topNParametersString(int differentValues, int unusedInsertedValues) { + return "asc=" + + asc + + ", nullsFirst=" + + nullsFirst + + ", limit=" + + limit + + ", entries=" + + Math.min(differentValues, limit + unusedInsertedValues); } } From 7ca3ce33d6c7fff9e66c9a21aa164fd33eb35640 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Thu, 24 Apr 2025 11:54:29 +0200 Subject: [PATCH 15/39] Included TopNLongBlockHash into BlockHash.ubuild() and GroupSpec logics, and added it to benchmark --- .../compute/operator/AggregatorBenchmark.java | 48 +++++++++++++------ .../aggregation/blockhash/BlockHash.java | 35 ++++++++++++-- .../blockhash/TopNBlockHashTests.java | 6 ++- .../AbstractPhysicalOperationProviders.java | 2 +- 4 files changed, 72 insertions(+), 19 deletions(-) diff --git a/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/AggregatorBenchmark.java b/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/AggregatorBenchmark.java index c6ce939786535..0894ddf4d54d0 100644 --- a/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/AggregatorBenchmark.java +++ b/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/AggregatorBenchmark.java @@ -73,6 +73,7 @@ public class AggregatorBenchmark { static final int BLOCK_LENGTH = 8 * 1024; private static final int OP_COUNT = 1024; private static final int GROUPS = 5; + private static final int TOP_N_LIMIT = 3; private static final BlockFactory blockFactory = BlockFactory.getInstance( new NoopCircuitBreaker("noop"), @@ -90,6 +91,7 @@ public class AggregatorBenchmark { private static final String TWO_ORDINALS = "two_" + ORDINALS; private static final String LONGS_AND_BYTES_REFS = LONGS + "_and_" + BYTES_REFS; private static final String TWO_LONGS_AND_BYTES_REFS = "two_" + LONGS + "_and_" + BYTES_REFS; + private static final String TOP_N_LONGS = "top_n_" + LONGS; private static final String VECTOR_DOUBLES = "vector_doubles"; private static final String HALF_NULL_DOUBLES = "half_null_doubles"; @@ -147,7 +149,8 @@ static void selfTest() { TWO_BYTES_REFS, TWO_ORDINALS, LONGS_AND_BYTES_REFS, - TWO_LONGS_AND_BYTES_REFS } + TWO_LONGS_AND_BYTES_REFS, + TOP_N_LONGS } ) public String grouping; @@ -161,8 +164,7 @@ static void selfTest() { public String filter; private static Operator operator(DriverContext driverContext, String grouping, String op, String dataType, String filter) { - - if (grouping.equals("none")) { + if (grouping.equals(NONE)) { return new AggregationOperator( List.of(supplier(op, dataType, filter).aggregatorFactory(AggregatorMode.SINGLE, List.of(0)).apply(driverContext)), driverContext @@ -188,6 +190,12 @@ private static Operator operator(DriverContext driverContext, String grouping, S new BlockHash.GroupSpec(1, ElementType.LONG), new BlockHash.GroupSpec(2, ElementType.BYTES_REF) ); + case TOP_N_LONGS -> List.of(new BlockHash.GroupSpec( + 0, + ElementType.LONG, + false, + new BlockHash.TopNDef(0, true, true, TOP_N_LIMIT) + )); default -> throw new IllegalArgumentException("unsupported grouping [" + grouping + "]"); }; return new HashAggregationOperator( @@ -271,10 +279,14 @@ private static void checkGrouped(String prefix, String grouping, String op, Stri case BOOLEANS -> 2; default -> GROUPS; }; + int availableGroups = switch (grouping) { + case TOP_N_LONGS -> TOP_N_LIMIT; + default -> groups; + }; switch (op) { case AVG -> { DoubleBlock dValues = (DoubleBlock) values; - for (int g = 0; g < groups; g++) { + for (int g = 0; g < availableGroups; g++) { long group = g; long sum = LongStream.range(0, BLOCK_LENGTH).filter(l -> l % groups == group).sum(); long count = LongStream.range(0, BLOCK_LENGTH).filter(l -> l % groups == group).count(); @@ -286,7 +298,7 @@ private static void checkGrouped(String prefix, String grouping, String op, Stri } case COUNT -> { LongBlock lValues = (LongBlock) values; - for (int g = 0; g < groups; g++) { + for (int g = 0; g < availableGroups; g++) { long group = g; long expected = LongStream.range(0, BLOCK_LENGTH).filter(l -> l % groups == group).count() * opCount; if (lValues.getLong(g) != expected) { @@ -296,7 +308,7 @@ private static void checkGrouped(String prefix, String grouping, String op, Stri } case COUNT_DISTINCT -> { LongBlock lValues = (LongBlock) values; - for (int g = 0; g < groups; g++) { + for (int g = 0; g < availableGroups; g++) { long group = g; long expected = LongStream.range(0, BLOCK_LENGTH).filter(l -> l % groups == group).distinct().count(); long count = lValues.getLong(g); @@ -310,7 +322,7 @@ private static void checkGrouped(String prefix, String grouping, String op, Stri switch (dataType) { case LONGS -> { LongBlock lValues = (LongBlock) values; - for (int g = 0; g < groups; g++) { + for (int g = 0; g < availableGroups; g++) { if (lValues.getLong(g) != (long) g) { throw new AssertionError(prefix + "expected [" + g + "] but was [" + lValues.getLong(g) + "]"); } @@ -318,7 +330,7 @@ private static void checkGrouped(String prefix, String grouping, String op, Stri } case DOUBLES -> { DoubleBlock dValues = (DoubleBlock) values; - for (int g = 0; g < groups; g++) { + for (int g = 0; g < availableGroups; g++) { if (dValues.getDouble(g) != (long) g) { throw new AssertionError(prefix + "expected [" + g + "] but was [" + dValues.getDouble(g) + "]"); } @@ -331,7 +343,7 @@ private static void checkGrouped(String prefix, String grouping, String op, Stri switch (dataType) { case LONGS -> { LongBlock lValues = (LongBlock) values; - for (int g = 0; g < groups; g++) { + for (int g = 0; g < availableGroups; g++) { long group = g; long expected = LongStream.range(0, BLOCK_LENGTH).filter(l -> l % groups == group).max().getAsLong(); if (lValues.getLong(g) != expected) { @@ -341,7 +353,7 @@ private static void checkGrouped(String prefix, String grouping, String op, Stri } case DOUBLES -> { DoubleBlock dValues = (DoubleBlock) values; - for (int g = 0; g < groups; g++) { + for (int g = 0; g < availableGroups; g++) { long group = g; long expected = LongStream.range(0, BLOCK_LENGTH).filter(l -> l % groups == group).max().getAsLong(); if (dValues.getDouble(g) != expected) { @@ -356,7 +368,7 @@ private static void checkGrouped(String prefix, String grouping, String op, Stri switch (dataType) { case LONGS -> { LongBlock lValues = (LongBlock) values; - for (int g = 0; g < groups; g++) { + for (int g = 0; g < availableGroups; g++) { long group = g; long expected = LongStream.range(0, BLOCK_LENGTH).filter(l -> l % groups == group).sum() * opCount; if (lValues.getLong(g) != expected) { @@ -366,7 +378,7 @@ private static void checkGrouped(String prefix, String grouping, String op, Stri } case DOUBLES -> { DoubleBlock dValues = (DoubleBlock) values; - for (int g = 0; g < groups; g++) { + for (int g = 0; g < availableGroups; g++) { long group = g; long expected = LongStream.range(0, BLOCK_LENGTH).filter(l -> l % groups == group).sum() * opCount; if (dValues.getDouble(g) != expected) { @@ -391,6 +403,14 @@ private static void checkGroupingBlock(String prefix, String grouping, Block blo } } } + case TOP_N_LONGS -> { + LongBlock groups = (LongBlock) block; + for (int g = 0; g < TOP_N_LIMIT; g++) { + if (groups.getLong(g) != (long) g) { + throw new AssertionError(prefix + "bad group expected [" + g + "] but was [" + groups.getLong(g) + "]"); + } + } + } case INTS -> { IntBlock groups = (IntBlock) block; for (int g = 0; g < GROUPS; g++) { @@ -495,7 +515,7 @@ private static void checkUngrouped(String prefix, String op, String dataType, Pa private static Page page(BlockFactory blockFactory, String grouping, String blockType) { Block dataBlock = dataBlock(blockFactory, blockType); - if (grouping.equals("none")) { + if (grouping.equals(NONE)) { return new Page(dataBlock); } List blocks = groupingBlocks(grouping, blockType); @@ -564,7 +584,7 @@ private static Block groupingBlock(String grouping, String blockType) { default -> throw new UnsupportedOperationException("bad grouping [" + grouping + "]"); }; return switch (grouping) { - case LONGS -> { + case TOP_N_LONGS, LONGS -> { var builder = blockFactory.newLongBlockBuilder(BLOCK_LENGTH); for (int i = 0; i < BLOCK_LENGTH; i++) { for (int v = 0; v < valuesPerGroup; v++) { diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/BlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/BlockHash.java index 191d6443264ca..f8dd29d041e06 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/BlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/BlockHash.java @@ -23,6 +23,7 @@ import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; import org.elasticsearch.compute.data.Page; +import org.elasticsearch.core.Nullable; import org.elasticsearch.core.Releasable; import org.elasticsearch.core.ReleasableIterator; import org.elasticsearch.index.analysis.AnalysisRegistry; @@ -113,13 +114,30 @@ public abstract class BlockHash implements Releasable, SeenGroupIds { @Override public abstract BitArray seenGroupIds(BigArrays bigArrays); + /** + * Configuration for a BlockHash group spec that is later sorted and limited (Top-N). + *

+ * Part of a performance improvement to avoid aggregating groups that will not be used. + *

+ * + * @param order The order of this group in the sort, starting at 0 + * @param asc True if this group will be sorted ascending. False if descending. + * @param nullsFirst True if the nulls should be the first elements in the TopN. False if they should be kept last. + * @param limit The number of elements to keep, including nulls. + */ + public record TopNDef(int order, boolean asc, boolean nullsFirst, int limit) {} + /** * @param isCategorize Whether this group is a CATEGORIZE() or not. * May be changed in the future when more stateful grouping functions are added. */ - public record GroupSpec(int channel, ElementType elementType, boolean isCategorize) { + public record GroupSpec(int channel, ElementType elementType, boolean isCategorize, @Nullable TopNDef topNDef) { public GroupSpec(int channel, ElementType elementType) { - this(channel, elementType, false); + this(channel, elementType, false, null); + } + + public GroupSpec(int channel, ElementType elementType, boolean isCategorize) { + this(channel, elementType, isCategorize, null); } } @@ -134,7 +152,18 @@ public GroupSpec(int channel, ElementType elementType) { */ public static BlockHash build(List groups, BlockFactory blockFactory, int emitBatchSize, boolean allowBrokenOptimizations) { if (groups.size() == 1) { - return newForElementType(groups.get(0).channel(), groups.get(0).elementType(), blockFactory); + GroupSpec group = groups.get(0); + if (group.topNDef() != null && group.elementType() == ElementType.LONG) { + TopNDef topNDef = group.topNDef(); + return new LongTopNBlockHash( + group.channel(), + topNDef.asc(), + topNDef.nullsFirst(), + topNDef.limit(), + blockFactory + ); + } + return newForElementType(group.channel(), group.elementType(), blockFactory); } if (groups.stream().allMatch(g -> g.elementType == ElementType.BYTES_REF)) { switch (groups.size()) { diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java index 623fe48ad42a4..f96b9d26f075c 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/TopNBlockHashTests.java @@ -363,7 +363,7 @@ private void hashBatchesCallbackOnLast(Consumer callback, Block[].. private BlockHash buildBlockHash(int emitBatchSize, Block... values) { List specs = new ArrayList<>(values.length); for (int c = 0; c < values.length; c++) { - specs.add(new BlockHash.GroupSpec(c, values[c].elementType())); + specs.add(new BlockHash.GroupSpec(c, values[c].elementType(), false, topNDef(c))); } assert forcePackedHash == false : "Packed TopN hash not implemented yet"; /*return forcePackedHash @@ -386,4 +386,8 @@ private String topNParametersString(int differentValues, int unusedInsertedValue + ", entries=" + Math.min(differentValues, limit + unusedInsertedValues); } + + private BlockHash.TopNDef topNDef(int order) { + return new BlockHash.TopNDef(order, asc, nullsFirst, limit); + } } diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/planner/AbstractPhysicalOperationProviders.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/planner/AbstractPhysicalOperationProviders.java index 92e3a7132b010..cf0fb3fe6216e 100644 --- a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/planner/AbstractPhysicalOperationProviders.java +++ b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/planner/AbstractPhysicalOperationProviders.java @@ -360,7 +360,7 @@ BlockHash.GroupSpec toHashGroupSpec() { throw new EsqlIllegalArgumentException("planned to use ordinals but tried to use the hash instead"); } - return new BlockHash.GroupSpec(channel, elementType(), Alias.unwrap(expression) instanceof Categorize); + return new BlockHash.GroupSpec(channel, elementType(), Alias.unwrap(expression) instanceof Categorize, null); } ElementType elementType() { From 13900f62a722a5d5dcdadb1197ca15bb59c5135c Mon Sep 17 00:00:00 2001 From: elasticsearchmachine Date: Thu, 24 Apr 2025 10:00:10 +0000 Subject: [PATCH 16/39] [CI] Auto commit changes from spotless --- .../benchmark/compute/operator/AggregatorBenchmark.java | 9 +++------ .../compute/aggregation/blockhash/BlockHash.java | 8 +------- 2 files changed, 4 insertions(+), 13 deletions(-) diff --git a/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/AggregatorBenchmark.java b/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/AggregatorBenchmark.java index 0894ddf4d54d0..d144d7601349d 100644 --- a/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/AggregatorBenchmark.java +++ b/benchmarks/src/main/java/org/elasticsearch/benchmark/compute/operator/AggregatorBenchmark.java @@ -190,12 +190,9 @@ private static Operator operator(DriverContext driverContext, String grouping, S new BlockHash.GroupSpec(1, ElementType.LONG), new BlockHash.GroupSpec(2, ElementType.BYTES_REF) ); - case TOP_N_LONGS -> List.of(new BlockHash.GroupSpec( - 0, - ElementType.LONG, - false, - new BlockHash.TopNDef(0, true, true, TOP_N_LIMIT) - )); + case TOP_N_LONGS -> List.of( + new BlockHash.GroupSpec(0, ElementType.LONG, false, new BlockHash.TopNDef(0, true, true, TOP_N_LIMIT)) + ); default -> throw new IllegalArgumentException("unsupported grouping [" + grouping + "]"); }; return new HashAggregationOperator( diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/BlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/BlockHash.java index f8dd29d041e06..1cae296f09c02 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/BlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/BlockHash.java @@ -155,13 +155,7 @@ public static BlockHash build(List groups, BlockFactory blockFactory, GroupSpec group = groups.get(0); if (group.topNDef() != null && group.elementType() == ElementType.LONG) { TopNDef topNDef = group.topNDef(); - return new LongTopNBlockHash( - group.channel(), - topNDef.asc(), - topNDef.nullsFirst(), - topNDef.limit(), - blockFactory - ); + return new LongTopNBlockHash(group.channel(), topNDef.asc(), topNDef.nullsFirst(), topNDef.limit(), blockFactory); } return newForElementType(group.channel(), group.elementType(), blockFactory); } From c778b3b95e394b3ae4c76240f6ab4837a03ac75a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Fri, 25 Apr 2025 12:17:11 +0200 Subject: [PATCH 17/39] Keep the last value in the top while using TreeSet, for performance --- .../blockhash/LongTopNBlockHash.java | 45 ++++++++++++++++--- 1 file changed, 38 insertions(+), 7 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index da54470a2dfa4..fc281d784b80a 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -38,6 +38,13 @@ public final class LongTopNBlockHash extends BlockHash { private final int limit; private final LongHash hash; private final TreeSet topValues; + /** + * Helper field to keep track of the last top value. + *

+ * Used temporarily as TreeSet#last() is O(log(n)) and would slow every insertion. + *

+ */ + private long lastTopValue; /** * Have we seen any {@code null} values? @@ -57,6 +64,7 @@ public LongTopNBlockHash(int channel, boolean asc, boolean nullsFirst, int limit this.limit = limit; this.hash = new LongHash(1, blockFactory.bigArrays()); this.topValues = new TreeSet<>(asc ? Comparator.naturalOrder() : Comparator.reverseOrder()); + this.lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; assert limit > 0 : "LongTopNBlockHash requires a limit greater than 0"; } @@ -98,6 +106,11 @@ private boolean acceptNull() { hasNull = true; if (topValues.size() == limit) { topValues.remove(topValues.last()); + if (topValues.isEmpty()) { + lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; + } else { + lastTopValue = topValues.last(); + } } return true; } @@ -118,19 +131,37 @@ private boolean acceptValue(long value) { return false; } - topValues.add(value); + if (hash.find(value) >= 0) { + // Already in the hash, no need to add it again + return true; + } - if (topValues.size() > limit - (hasNull ? 1 : 0)) { - if (hasNull && nullsFirst == false) { - hasNull = false; - } else { - topValues.remove(topValues.last()); + if (topValues.add(value)) { + if (isBetterThan(lastTopValue, value) || topValues.size() == 1) { + lastTopValue = value; + } + + if (topValues.size() > limit - (hasNull ? 1 : 0)) { + if (hasNull && nullsFirst == false) { + hasNull = false; + } else { + topValues.remove(topValues.last()); + if (topValues.isEmpty()) { + lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; + } else { + lastTopValue = topValues.last(); + } + } } } return true; } + private boolean isBetterThan(long value, long other) { + return asc ? value < other : value > other; + } + /** * Returns true if the value is in, or can be added to the top; false otherwise. */ @@ -145,7 +176,7 @@ private boolean isAcceptable(long value) { *

*/ private boolean isInTop(long value) { - return asc ? value <= topValues.last() : value >= topValues.last(); + return asc ? value <= lastTopValue : value >= lastTopValue; } /** From 5483dc2f81aa97e9526ed7faab613066fd3187d0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Fri, 25 Apr 2025 18:08:17 +0200 Subject: [PATCH 18/39] Use LongBucketedSort and LongHash for unique seen values --- .../compute/data/sort/DoubleBucketedSort.java | 49 ++++++++ .../compute/data/sort/FloatBucketedSort.java | 49 ++++++++ .../compute/data/sort/IntBucketedSort.java | 49 ++++++++ .../compute/data/sort/LongBucketedSort.java | 49 ++++++++ .../blockhash/LongTopNBlockHash.java | 111 ++++++++++++------ .../compute/data/sort/X-BucketedSort.java.st | 49 ++++++++ .../data/sort/BucketedSortTestCase.java | 16 +++ 7 files changed, 339 insertions(+), 33 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/DoubleBucketedSort.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/DoubleBucketedSort.java index ca89e6f999641..a79f7bb84b9aa 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/DoubleBucketedSort.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/DoubleBucketedSort.java @@ -91,6 +91,10 @@ public DoubleBucketedSort(BigArrays bigArrays, SortOrder order, int bucketSize) *

*/ public void collect(double value, int bucket) { + if (bucketSize == 0) { + return; + } + long rootIndex = (long) bucket * bucketSize; if (inHeapMode(bucket)) { if (betterThan(value, values.get(rootIndex))) { @@ -146,6 +150,51 @@ private Tuple getBucketValuesIndexes(int bucket) { return Tuple.tuple(start, end); } + /** + * Returns the amount of elements in the given bucket. + */ + public int getBucketCount(int bucket) { + long rootIndex = (long) bucket * bucketSize; + if (rootIndex >= values.size()) { + // We've never seen this bucket. + return 0; + } + long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); + long end = rootIndex + bucketSize; + + return (int) (end - start); + } + + /** + * Returns the worst value in the given bucket. + *

+ * This method shouldn't be called if the bucket is empty. + *

+ *

+ * This method is O(1) if the bucket is full; O(n) otherwise. + *

+ */ + public double getWorstValue(int bucket) { + assert getBucketCount(bucket) > 0 : "Cannot get the worst value of an empty bucket"; + + long rootIndex = (long) bucket * bucketSize; + long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); + long end = rootIndex + bucketSize; + + if (inHeapMode(bucket)) { + return values.get(start); + } + + double worstValue = values.get(start); + for (long i = start + 1; i < end; i++) { + if (betterThan(worstValue, values.get(i))) { + worstValue = values.get(i); + } + } + + return worstValue; + } + /** * Merge the values from {@code other}'s {@code otherGroupId} into {@code groupId}. */ diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/FloatBucketedSort.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/FloatBucketedSort.java index 2bf8edd99f48c..e5fa912fe84da 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/FloatBucketedSort.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/FloatBucketedSort.java @@ -91,6 +91,10 @@ public FloatBucketedSort(BigArrays bigArrays, SortOrder order, int bucketSize) { *

*/ public void collect(float value, int bucket) { + if (bucketSize == 0) { + return; + } + long rootIndex = (long) bucket * bucketSize; if (inHeapMode(bucket)) { if (betterThan(value, values.get(rootIndex))) { @@ -146,6 +150,51 @@ private Tuple getBucketValuesIndexes(int bucket) { return Tuple.tuple(start, end); } + /** + * Returns the amount of elements in the given bucket. + */ + public int getBucketCount(int bucket) { + long rootIndex = (long) bucket * bucketSize; + if (rootIndex >= values.size()) { + // We've never seen this bucket. + return 0; + } + long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); + long end = rootIndex + bucketSize; + + return (int) (end - start); + } + + /** + * Returns the worst value in the given bucket. + *

+ * This method shouldn't be called if the bucket is empty. + *

+ *

+ * This method is O(1) if the bucket is full; O(n) otherwise. + *

+ */ + public float getWorstValue(int bucket) { + assert getBucketCount(bucket) > 0 : "Cannot get the worst value of an empty bucket"; + + long rootIndex = (long) bucket * bucketSize; + long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); + long end = rootIndex + bucketSize; + + if (inHeapMode(bucket)) { + return values.get(start); + } + + float worstValue = values.get(start); + for (long i = start + 1; i < end; i++) { + if (betterThan(worstValue, values.get(i))) { + worstValue = values.get(i); + } + } + + return worstValue; + } + /** * Merge the values from {@code other}'s {@code otherGroupId} into {@code groupId}. */ diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/IntBucketedSort.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/IntBucketedSort.java index 257dfe2ebb0bd..ed8bc299e3f22 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/IntBucketedSort.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/IntBucketedSort.java @@ -91,6 +91,10 @@ public IntBucketedSort(BigArrays bigArrays, SortOrder order, int bucketSize) { *

*/ public void collect(int value, int bucket) { + if (bucketSize == 0) { + return; + } + long rootIndex = (long) bucket * bucketSize; if (inHeapMode(bucket)) { if (betterThan(value, values.get(rootIndex))) { @@ -146,6 +150,51 @@ private Tuple getBucketValuesIndexes(int bucket) { return Tuple.tuple(start, end); } + /** + * Returns the amount of elements in the given bucket. + */ + public int getBucketCount(int bucket) { + long rootIndex = (long) bucket * bucketSize; + if (rootIndex >= values.size()) { + // We've never seen this bucket. + return 0; + } + long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); + long end = rootIndex + bucketSize; + + return (int) (end - start); + } + + /** + * Returns the worst value in the given bucket. + *

+ * This method shouldn't be called if the bucket is empty. + *

+ *

+ * This method is O(1) if the bucket is full; O(n) otherwise. + *

+ */ + public int getWorstValue(int bucket) { + assert getBucketCount(bucket) > 0 : "Cannot get the worst value of an empty bucket"; + + long rootIndex = (long) bucket * bucketSize; + long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); + long end = rootIndex + bucketSize; + + if (inHeapMode(bucket)) { + return values.get(start); + } + + int worstValue = values.get(start); + for (long i = start + 1; i < end; i++) { + if (betterThan(worstValue, values.get(i))) { + worstValue = values.get(i); + } + } + + return worstValue; + } + /** * Merge the values from {@code other}'s {@code otherGroupId} into {@code groupId}. */ diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/LongBucketedSort.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/LongBucketedSort.java index c27467ebb60ff..1cabbc50b74bd 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/LongBucketedSort.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/LongBucketedSort.java @@ -91,6 +91,10 @@ public LongBucketedSort(BigArrays bigArrays, SortOrder order, int bucketSize) { *

*/ public void collect(long value, int bucket) { + if (bucketSize == 0) { + return; + } + long rootIndex = (long) bucket * bucketSize; if (inHeapMode(bucket)) { if (betterThan(value, values.get(rootIndex))) { @@ -146,6 +150,51 @@ private Tuple getBucketValuesIndexes(int bucket) { return Tuple.tuple(start, end); } + /** + * Returns the amount of elements in the given bucket. + */ + public int getBucketCount(int bucket) { + long rootIndex = (long) bucket * bucketSize; + if (rootIndex >= values.size()) { + // We've never seen this bucket. + return 0; + } + long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); + long end = rootIndex + bucketSize; + + return (int) (end - start); + } + + /** + * Returns the worst value in the given bucket. + *

+ * This method shouldn't be called if the bucket is empty. + *

+ *

+ * This method is O(1) if the bucket is full; O(n) otherwise. + *

+ */ + public long getWorstValue(int bucket) { + assert getBucketCount(bucket) > 0 : "Cannot get the worst value of an empty bucket"; + + long rootIndex = (long) bucket * bucketSize; + long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); + long end = rootIndex + bucketSize; + + if (inHeapMode(bucket)) { + return values.get(start); + } + + long worstValue = values.get(start); + for (long i = start + 1; i < end; i++) { + if (betterThan(worstValue, values.get(i))) { + worstValue = values.get(i); + } + } + + return worstValue; + } + /** * Merge the values from {@code other}'s {@code otherGroupId} into {@code groupId}. */ diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index fc281d784b80a..86b9083163db9 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -19,13 +19,14 @@ import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; +import org.elasticsearch.compute.data.sort.LongBucketedSort; import org.elasticsearch.compute.operator.mvdedupe.MultivalueDedupe; import org.elasticsearch.compute.operator.mvdedupe.TopNMultivalueDedupeLong; import org.elasticsearch.core.ReleasableIterator; +import org.elasticsearch.core.Releasables; +import org.elasticsearch.search.sort.SortOrder; import java.util.BitSet; -import java.util.Comparator; -import java.util.TreeSet; /** * Maps a {@link LongBlock} column to group ids, keeping only the top N values. @@ -37,12 +38,10 @@ public final class LongTopNBlockHash extends BlockHash { private final boolean nullsFirst; private final int limit; private final LongHash hash; - private final TreeSet topValues; + private LongBucketedSort topValues; + private final LongHash seenUniqueValues; /** - * Helper field to keep track of the last top value. - *

- * Used temporarily as TreeSet#last() is O(log(n)) and would slow every insertion. - *

+ * Helper field to keep track of the last top value, and avoid expensive searches. */ private long lastTopValue; @@ -63,7 +62,8 @@ public LongTopNBlockHash(int channel, boolean asc, boolean nullsFirst, int limit this.nullsFirst = nullsFirst; this.limit = limit; this.hash = new LongHash(1, blockFactory.bigArrays()); - this.topValues = new TreeSet<>(asc ? Comparator.naturalOrder() : Comparator.reverseOrder()); + this.topValues = new LongBucketedSort(blockFactory.bigArrays(), asc ? SortOrder.ASC : SortOrder.DESC, limit); + this.seenUniqueValues = new LongHash(1, blockFactory.bigArrays()); this.lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; assert limit > 0 : "LongTopNBlockHash requires a limit greater than 0"; @@ -102,20 +102,22 @@ private boolean acceptNull() { return true; } + int valuesInTop = nonNullValueCount(); + if (nullsFirst) { hasNull = true; - if (topValues.size() == limit) { - topValues.remove(topValues.last()); - if (topValues.isEmpty()) { + if (valuesInTop == limit) { + migrateToSmallTop(); + if (valuesInTop == 1) { lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; } else { - lastTopValue = topValues.last(); + lastTopValue = topValues.getWorstValue(0); } } return true; } - if (topValues.size() < limit) { + if (valuesInTop < limit) { hasNull = true; return true; } @@ -127,37 +129,69 @@ private boolean acceptNull() { * Tries to add the value to the top values, and returns true if it was successful. */ private boolean acceptValue(long value) { + // Ignore values that are worse than the current worst value if (isAcceptable(value) == false) { return false; } - if (hash.find(value) >= 0) { - // Already in the hash, no need to add it again + // O(1) operation to check if the value is already in the hash, and avoid adding it again + if (seenUniqueValues.find(value) >= 0) { return true; } - if (topValues.add(value)) { - if (isBetterThan(lastTopValue, value) || topValues.size() == 1) { - lastTopValue = value; - } + // TODO: On multiple passes, this will ingest duplicated values and break the structure! + topValues.collect(value, 0); + seenUniqueValues.add(value); + + int valuesInTop = nonNullValueCount(); - if (topValues.size() > limit - (hasNull ? 1 : 0)) { - if (hasNull && nullsFirst == false) { - hasNull = false; + if (valuesInTop == limit) { + lastTopValue = topValues.getWorstValue(0); + } else if (valuesInTop == 1 || isBetterThan(lastTopValue, value)) { + lastTopValue = value; + } + + // Full top and null, there's an extra value/null we must remove + if (valuesInTop == limit && hasNull) { + if (nullsFirst) { + migrateToSmallTop(); + if (valuesInTop == 1) { + lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; } else { - topValues.remove(topValues.last()); - if (topValues.isEmpty()) { - lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; - } else { - lastTopValue = topValues.last(); - } + lastTopValue = topValues.getWorstValue(0); } + } else { + hasNull = false; } } return true; } + /** + * Converts the current BucketedSort to one with {@code limit - 1} values, as one value is a null. + */ + private void migrateToSmallTop() { + assert nullsFirst : "The small top is only used when nulls are first"; + assert topValues.getBucketSize() == limit : "The top values can't be migrated twice"; + + LongBucketedSort oldTopValues = topValues; + LongBucketedSort newTopValues = new LongBucketedSort(blockFactory.bigArrays(), topValues.getOrder(), limit - 1); + try { + newTopValues.merge(0, topValues, 0); + + topValues = newTopValues; + } finally { + if (topValues == oldTopValues) { + // If there was an error, close the new sort + newTopValues.close(); + } else { + // Otherwise, close the old one + oldTopValues.close(); + } + } + } + private boolean isBetterThan(long value, long other) { return asc ? value < other : value > other; } @@ -176,6 +210,7 @@ private boolean isAcceptable(long value) { *

*/ private boolean isInTop(long value) { + // TODO: Remove lastTopValue and use: long currentWorstValue = topValues.getWorstValue(0); return asc ? value <= lastTopValue : value >= lastTopValue; } @@ -183,7 +218,14 @@ private boolean isInTop(long value) { * Returns true if there are {@code limit} values in the blockhash; false otherwise. */ private boolean isTopComplete() { - return topValues.size() >= limit - (hasNull ? 1 : 0); + return nonNullValueCount() >= limit - (hasNull ? 1 : 0); + } + + /** + * Returns the number of non-null values in the top. + */ + private int nonNullValueCount() { + return topValues.getBucketCount(0); } /** @@ -198,6 +240,8 @@ IntBlock add(LongVector vector) { acceptValue(v); } + // TODO: Count how many values were denied, to try to reduce the size of the block. Check the same for add(block) + // Create a vector with the groups try (var builder = blockFactory.newIntBlockBuilder(positions)) { for (int i = 0; i < positions; i++) { @@ -278,8 +322,9 @@ private IntBlock lookup(LongBlock block) { @Override public LongBlock[] getKeys() { + int valuesInTop = nonNullValueCount(); if (hasNull) { - final long[] keys = new long[topValues.size() + 1]; + final long[] keys = new long[valuesInTop + 1]; int keysIndex = 1; for (int i = 1; i < hash.size() + 1; i++) { long value = hash.get(i - 1); @@ -292,7 +337,7 @@ public LongBlock[] getKeys() { return new LongBlock[] { blockFactory.newLongArrayBlock(keys, keys.length, null, nulls, Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING) }; } - final long[] keys = new long[topValues.size()]; + final long[] keys = new long[valuesInTop]; int keysIndex = 0; for (int i = 0; i < hash.size(); i++) { long value = hash.get(i); @@ -306,7 +351,7 @@ public LongBlock[] getKeys() { @Override public IntVector nonEmpty() { int nullOffset = hasNull ? 1 : 0; - final int[] ids = new int[topValues.size() + nullOffset]; + final int[] ids = new int[nonNullValueCount() + nullOffset]; int idsIndex = nullOffset; // TODO: Can we instead iterate the top and take the ids from the hash? To avoid checking unused values for (int i = 1; i < hash.size() + 1; i++) { @@ -336,7 +381,7 @@ public BitArray seenGroupIds(BigArrays bigArrays) { @Override public void close() { - hash.close(); + Releasables.close(hash, topValues, seenUniqueValues); } @Override diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/X-BucketedSort.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/X-BucketedSort.java.st index 095d48021e9c1..f20d5320a5d76 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/X-BucketedSort.java.st +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/X-BucketedSort.java.st @@ -91,6 +91,10 @@ public class $Type$BucketedSort implements Releasable { *

*/ public void collect($type$ value, int bucket) { + if (bucketSize == 0) { + return; + } + long rootIndex = (long) bucket * bucketSize; if (inHeapMode(bucket)) { if (betterThan(value, values.get(rootIndex))) { @@ -146,6 +150,51 @@ public class $Type$BucketedSort implements Releasable { return Tuple.tuple(start, end); } + /** + * Returns the amount of elements in the given bucket. + */ + public int getBucketCount(int bucket) { + long rootIndex = (long) bucket * bucketSize; + if (rootIndex >= values.size()) { + // We've never seen this bucket. + return 0; + } + long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); + long end = rootIndex + bucketSize; + + return (int) (end - start); + } + + /** + * Returns the worst value in the given bucket. + *

+ * This method shouldn't be called if the bucket is empty. + *

+ *

+ * This method is O(1) if the bucket is full; O(n) otherwise. + *

+ */ + public $type$ getWorstValue(int bucket) { + assert getBucketCount(bucket) > 0 : "Cannot get the worst value of an empty bucket"; + + long rootIndex = (long) bucket * bucketSize; + long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); + long end = rootIndex + bucketSize; + + if (inHeapMode(bucket)) { + return values.get(start); + } + + $type$ worstValue = values.get(start); + for (long i = start + 1; i < end; i++) { + if (betterThan(worstValue, values.get(i))) { + worstValue = values.get(i); + } + } + + return worstValue; + } + /** * Merge the values from {@code other}'s {@code otherGroupId} into {@code groupId}. */ diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/BucketedSortTestCase.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/BucketedSortTestCase.java index 2358643dc089e..3d92221f32013 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/BucketedSortTestCase.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/BucketedSortTestCase.java @@ -445,6 +445,22 @@ public final void testMergePastEnd() { } } + public final void testZeroBucketSize() { + try (T sort = build(randomFrom(SortOrder.values()), 0)) { + collect(sort, randomValue(), 0); + + try (T otherSort = build(randomFrom(SortOrder.values()), randomIntBetween(1, 3))) { + for (int i = 0; i < randomIntBetween(0, 3); i++) { + collect(otherSort, randomValue(), 0); + } + + merge(sort, 0, otherSort, 0); + } + + assertBlock(sort, 0, List.of()); + } + } + protected void assertBlock(T sort, int groupId, List values) { var blockFactory = TestBlockFactory.getNonBreakingInstance(); From 3a775ac0293fa8d5a3a18f8072f79dc47520fa7c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Fri, 25 Apr 2025 18:17:00 +0200 Subject: [PATCH 19/39] Add field recording amount on values in top structure --- .../blockhash/LongTopNBlockHash.java | 27 +++++++------------ 1 file changed, 10 insertions(+), 17 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 86b9083163db9..8f4e5e2a25022 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -44,6 +44,7 @@ public final class LongTopNBlockHash extends BlockHash { * Helper field to keep track of the last top value, and avoid expensive searches. */ private long lastTopValue; + private int valuesInTop; /** * Have we seen any {@code null} values? @@ -65,6 +66,7 @@ public LongTopNBlockHash(int channel, boolean asc, boolean nullsFirst, int limit this.topValues = new LongBucketedSort(blockFactory.bigArrays(), asc ? SortOrder.ASC : SortOrder.DESC, limit); this.seenUniqueValues = new LongHash(1, blockFactory.bigArrays()); this.lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; + this.valuesInTop = 0; assert limit > 0 : "LongTopNBlockHash requires a limit greater than 0"; } @@ -102,8 +104,6 @@ private boolean acceptNull() { return true; } - int valuesInTop = nonNullValueCount(); - if (nullsFirst) { hasNull = true; if (valuesInTop == limit) { @@ -114,6 +114,7 @@ private boolean acceptNull() { lastTopValue = topValues.getWorstValue(0); } } + migrateToSmallTop(); return true; } @@ -135,21 +136,18 @@ private boolean acceptValue(long value) { } // O(1) operation to check if the value is already in the hash, and avoid adding it again - if (seenUniqueValues.find(value) >= 0) { + if (seenUniqueValues.add(value) < 0) { return true; } - // TODO: On multiple passes, this will ingest duplicated values and break the structure! topValues.collect(value, 0); - seenUniqueValues.add(value); - - int valuesInTop = nonNullValueCount(); if (valuesInTop == limit) { lastTopValue = topValues.getWorstValue(0); } else if (valuesInTop == 1 || isBetterThan(lastTopValue, value)) { lastTopValue = value; } + valuesInTop = Math.min(valuesInTop + 1, limit - (hasNull && nullsFirst ? 1 : 0)); // Full top and null, there's an extra value/null we must remove if (valuesInTop == limit && hasNull) { @@ -163,6 +161,8 @@ private boolean acceptValue(long value) { } else { hasNull = false; } + if (valuesInTop == limit && hasNull && nullsFirst == false) { + hasNull = false; } return true; @@ -181,6 +181,7 @@ private void migrateToSmallTop() { newTopValues.merge(0, topValues, 0); topValues = newTopValues; + valuesInTop = Math.min(valuesInTop, limit - 1); } finally { if (topValues == oldTopValues) { // If there was an error, close the new sort @@ -218,14 +219,7 @@ private boolean isInTop(long value) { * Returns true if there are {@code limit} values in the blockhash; false otherwise. */ private boolean isTopComplete() { - return nonNullValueCount() >= limit - (hasNull ? 1 : 0); - } - - /** - * Returns the number of non-null values in the top. - */ - private int nonNullValueCount() { - return topValues.getBucketCount(0); + return valuesInTop >= limit - (hasNull ? 1 : 0); } /** @@ -322,7 +316,6 @@ private IntBlock lookup(LongBlock block) { @Override public LongBlock[] getKeys() { - int valuesInTop = nonNullValueCount(); if (hasNull) { final long[] keys = new long[valuesInTop + 1]; int keysIndex = 1; @@ -351,7 +344,7 @@ public LongBlock[] getKeys() { @Override public IntVector nonEmpty() { int nullOffset = hasNull ? 1 : 0; - final int[] ids = new int[nonNullValueCount() + nullOffset]; + final int[] ids = new int[valuesInTop + nullOffset]; int idsIndex = nullOffset; // TODO: Can we instead iterate the top and take the ids from the hash? To avoid checking unused values for (int i = 1; i < hash.size() + 1; i++) { From 2dde5c13f2810b62b5a042ae134cdc0761be5115 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Tue, 29 Apr 2025 13:49:43 +0200 Subject: [PATCH 20/39] Fixed to have both last top value and value count --- .../compute/aggregation/blockhash/LongTopNBlockHash.java | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 8f4e5e2a25022..2e0093877932e 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -108,13 +108,12 @@ private boolean acceptNull() { hasNull = true; if (valuesInTop == limit) { migrateToSmallTop(); - if (valuesInTop == 1) { + if (valuesInTop == 0) { lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; } else { lastTopValue = topValues.getWorstValue(0); } } - migrateToSmallTop(); return true; } @@ -142,17 +141,16 @@ private boolean acceptValue(long value) { topValues.collect(value, 0); + valuesInTop = Math.min(valuesInTop + 1, limit - (hasNull && nullsFirst ? 1 : 0)); if (valuesInTop == limit) { lastTopValue = topValues.getWorstValue(0); } else if (valuesInTop == 1 || isBetterThan(lastTopValue, value)) { lastTopValue = value; } - valuesInTop = Math.min(valuesInTop + 1, limit - (hasNull && nullsFirst ? 1 : 0)); // Full top and null, there's an extra value/null we must remove if (valuesInTop == limit && hasNull) { if (nullsFirst) { - migrateToSmallTop(); if (valuesInTop == 1) { lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; } else { @@ -161,8 +159,6 @@ private boolean acceptValue(long value) { } else { hasNull = false; } - if (valuesInTop == limit && hasNull && nullsFirst == false) { - hasNull = false; } return true; @@ -211,7 +207,6 @@ private boolean isAcceptable(long value) { *

*/ private boolean isInTop(long value) { - // TODO: Remove lastTopValue and use: long currentWorstValue = topValues.getWorstValue(0); return asc ? value <= lastTopValue : value >= lastTopValue; } From a5855c16640af36a4eb0b5227e68d7eb32299444 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Wed, 30 Apr 2025 13:01:55 +0200 Subject: [PATCH 21/39] Specialize block parameters on AddInput --- .../gen/GroupingAggregatorImplementer.java | 29 +-- .../org/elasticsearch/compute/gen/Types.java | 3 + .../compute/data/BooleanArrayBlock.java | 2 +- .../compute/data/BytesRefArrayBlock.java | 2 +- .../compute/data/DoubleArrayBlock.java | 2 +- .../compute/data/FloatArrayBlock.java | 2 +- .../compute/data/IntArrayBlock.java | 2 +- .../compute/data/LongArrayBlock.java | 2 +- ...inctBooleanGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...nctBytesRefGroupingAggregatorFunction.java | 168 +++++++++++++++-- ...tinctDoubleGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...stinctFloatGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...DistinctIntGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...istinctLongGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...rTimeDoubleGroupingAggregatorFunction.java | 173 ++++++++++++++++-- ...erTimeFloatGroupingAggregatorFunction.java | 173 ++++++++++++++++-- ...OverTimeIntGroupingAggregatorFunction.java | 173 ++++++++++++++++-- ...verTimeLongGroupingAggregatorFunction.java | 173 ++++++++++++++++-- .../MaxBooleanGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...MaxBytesRefGroupingAggregatorFunction.java | 168 +++++++++++++++-- .../MaxDoubleGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../MaxFloatGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../MaxIntGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../MaxIpGroupingAggregatorFunction.java | 168 +++++++++++++++-- .../MaxLongGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...ationDoubleGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...iationFloatGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...eviationIntGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...viationLongGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../MinBooleanGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...MinBytesRefGroupingAggregatorFunction.java | 168 +++++++++++++++-- .../MinDoubleGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../MinFloatGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../MinIntGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../MinIpGroupingAggregatorFunction.java | 168 +++++++++++++++-- .../MinLongGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...ntileDoubleGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...entileFloatGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...rcentileIntGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...centileLongGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../RateDoubleGroupingAggregatorFunction.java | 173 ++++++++++++++++-- .../RateFloatGroupingAggregatorFunction.java | 173 ++++++++++++++++-- .../RateIntGroupingAggregatorFunction.java | 173 ++++++++++++++++-- .../RateLongGroupingAggregatorFunction.java | 173 ++++++++++++++++-- ...tdDevDoubleGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...StdDevFloatGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../StdDevIntGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../StdDevLongGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../SumDoubleGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../SumFloatGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../SumIntGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../SumLongGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../TopBooleanGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...TopBytesRefGroupingAggregatorFunction.java | 168 +++++++++++++++-- .../TopDoubleGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../TopFloatGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../TopIntGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../TopIpGroupingAggregatorFunction.java | 168 +++++++++++++++-- .../TopLongGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...luesBooleanGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...uesBytesRefGroupingAggregatorFunction.java | 168 +++++++++++++++-- ...aluesDoubleGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...ValuesFloatGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../ValuesIntGroupingAggregatorFunction.java | 162 ++++++++++++++-- .../ValuesLongGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...ntDocValuesGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...ourceValuesGroupingAggregatorFunction.java | 168 +++++++++++++++-- ...ntDocValuesGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...ourceValuesGroupingAggregatorFunction.java | 168 +++++++++++++++-- ...ntDocValuesGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...ourceValuesGroupingAggregatorFunction.java | 168 +++++++++++++++-- ...peDocValuesGroupingAggregatorFunction.java | 138 ++++++++++++-- ...ourceValuesGroupingAggregatorFunction.java | 168 +++++++++++++++-- ...ntDocValuesGroupingAggregatorFunction.java | 162 ++++++++++++++-- ...ourceValuesGroupingAggregatorFunction.java | 168 +++++++++++++++-- ...peDocValuesGroupingAggregatorFunction.java | 138 ++++++++++++-- ...ourceValuesGroupingAggregatorFunction.java | 168 +++++++++++++++-- .../GroupingAggregatorFunction.java | 33 ++++ .../blockhash/LongTopNBlockHash.java | 4 +- .../compute/data/X-ArrayBlock.java.st | 2 +- 80 files changed, 10526 insertions(+), 859 deletions(-) diff --git a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/GroupingAggregatorImplementer.java b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/GroupingAggregatorImplementer.java index f42138c3eceb6..41947a39aed44 100644 --- a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/GroupingAggregatorImplementer.java +++ b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/GroupingAggregatorImplementer.java @@ -54,8 +54,11 @@ import static org.elasticsearch.compute.gen.Types.GROUPING_AGGREGATOR_FUNCTION; import static org.elasticsearch.compute.gen.Types.GROUPING_AGGREGATOR_FUNCTION_ADD_INPUT; import static org.elasticsearch.compute.gen.Types.INTERMEDIATE_STATE_DESC; +import static org.elasticsearch.compute.gen.Types.INT_ARRAY_BLOCK; +import static org.elasticsearch.compute.gen.Types.INT_BIG_ARRAY_BLOCK; import static org.elasticsearch.compute.gen.Types.INT_BLOCK; import static org.elasticsearch.compute.gen.Types.INT_VECTOR; +import static org.elasticsearch.compute.gen.Types.INT_VECTOR_BLOCK; import static org.elasticsearch.compute.gen.Types.LIST_AGG_FUNC_DESC; import static org.elasticsearch.compute.gen.Types.LIST_INTEGER; import static org.elasticsearch.compute.gen.Types.LONG_BLOCK; @@ -76,6 +79,9 @@ * and break-point-able as possible. */ public class GroupingAggregatorImplementer { + private static final List GROUP_IDS_CLASSES = + List.of(INT_BLOCK, INT_ARRAY_BLOCK, INT_VECTOR_BLOCK, INT_BIG_ARRAY_BLOCK, INT_VECTOR); + private final TypeElement declarationType; private final List warnExceptions; private final ExecutableElement init; @@ -196,10 +202,10 @@ private TypeSpec type() { builder.addMethod(intermediateStateDesc()); builder.addMethod(intermediateBlockCount()); builder.addMethod(prepareProcessPage()); - builder.addMethod(addRawInputLoop(INT_VECTOR, blockType(aggParam.type()))); - builder.addMethod(addRawInputLoop(INT_VECTOR, vectorType(aggParam.type()))); - builder.addMethod(addRawInputLoop(INT_BLOCK, blockType(aggParam.type()))); - builder.addMethod(addRawInputLoop(INT_BLOCK, vectorType(aggParam.type()))); + for (ClassName groupIdClass : GROUP_IDS_CLASSES) { + builder.addMethod(addRawInputLoop(groupIdClass, blockType(aggParam.type()))); + builder.addMethod(addRawInputLoop(groupIdClass, vectorType(aggParam.type()))); + } builder.addMethod(selectedMayContainUnseenGroups()); builder.addMethod(addIntermediateInput()); builder.addMethod(addIntermediateRowInput()); @@ -347,15 +353,12 @@ private TypeSpec addInput(Consumer addBlock) { TypeSpec.Builder builder = TypeSpec.anonymousClassBuilder(""); builder.addSuperinterface(GROUPING_AGGREGATOR_FUNCTION_ADD_INPUT); - MethodSpec.Builder block = MethodSpec.methodBuilder("add").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC); - block.addParameter(TypeName.INT, "positionOffset").addParameter(INT_BLOCK, "groupIds"); - addBlock.accept(block); - builder.addMethod(block.build()); - - MethodSpec.Builder vector = MethodSpec.methodBuilder("add").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC); - vector.addParameter(TypeName.INT, "positionOffset").addParameter(INT_VECTOR, "groupIds"); - addBlock.accept(vector); - builder.addMethod(vector.build()); + for (ClassName groupIdsType : GROUP_IDS_CLASSES) { + MethodSpec.Builder vector = MethodSpec.methodBuilder("add").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC); + vector.addParameter(TypeName.INT, "positionOffset").addParameter(groupIdsType, "groupIds"); + addBlock.accept(vector); + builder.addMethod(vector.build()); + } MethodSpec.Builder close = MethodSpec.methodBuilder("close").addAnnotation(Override.class).addModifiers(Modifier.PUBLIC); builder.addMethod(close.build()); diff --git a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/Types.java b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/Types.java index 62ecee6b5c6e9..a86e521f5a1b5 100644 --- a/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/Types.java +++ b/x-pack/plugin/esql/compute/gen/src/main/java/org/elasticsearch/compute/gen/Types.java @@ -46,6 +46,9 @@ public class Types { static final ClassName BOOLEAN_BLOCK = ClassName.get(DATA_PACKAGE, "BooleanBlock"); static final ClassName BYTES_REF_BLOCK = ClassName.get(DATA_PACKAGE, "BytesRefBlock"); static final ClassName INT_BLOCK = ClassName.get(DATA_PACKAGE, "IntBlock"); + static final ClassName INT_VECTOR_BLOCK = ClassName.get(DATA_PACKAGE, "IntVectorBlock"); + static final ClassName INT_ARRAY_BLOCK = ClassName.get(DATA_PACKAGE, "IntArrayBlock"); + static final ClassName INT_BIG_ARRAY_BLOCK = ClassName.get(DATA_PACKAGE, "IntBigArrayBlock"); static final ClassName LONG_BLOCK = ClassName.get(DATA_PACKAGE, "LongBlock"); static final ClassName DOUBLE_BLOCK = ClassName.get(DATA_PACKAGE, "DoubleBlock"); static final ClassName FLOAT_BLOCK = ClassName.get(DATA_PACKAGE, "FloatBlock"); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanArrayBlock.java index 47d386d0bd690..f9ea9952ebd1c 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanArrayBlock.java @@ -20,7 +20,7 @@ * Block implementation that stores values in a {@link BooleanArrayVector}. * This class is generated. Edit {@code X-ArrayBlock.java.st} instead. */ -final class BooleanArrayBlock extends AbstractArrayBlock implements BooleanBlock { +public final class BooleanArrayBlock extends AbstractArrayBlock implements BooleanBlock { static final long BASE_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance(BooleanArrayBlock.class); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayBlock.java index a85b75d8fdc2a..5fddfd277111f 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayBlock.java @@ -23,7 +23,7 @@ * Does not take ownership of the given {@link BytesRefArray} and does not adjust circuit breakers to account for it. * This class is generated. Edit {@code X-ArrayBlock.java.st} instead. */ -final class BytesRefArrayBlock extends AbstractArrayBlock implements BytesRefBlock { +public final class BytesRefArrayBlock extends AbstractArrayBlock implements BytesRefBlock { static final long BASE_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance(BytesRefArrayBlock.class); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleArrayBlock.java index 83c7b85a7ff5a..4eb5a591f6b0a 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleArrayBlock.java @@ -20,7 +20,7 @@ * Block implementation that stores values in a {@link DoubleArrayVector}. * This class is generated. Edit {@code X-ArrayBlock.java.st} instead. */ -final class DoubleArrayBlock extends AbstractArrayBlock implements DoubleBlock { +public final class DoubleArrayBlock extends AbstractArrayBlock implements DoubleBlock { static final long BASE_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance(DoubleArrayBlock.class); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/FloatArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/FloatArrayBlock.java index 749041d80d668..d9f163585a5eb 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/FloatArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/FloatArrayBlock.java @@ -20,7 +20,7 @@ * Block implementation that stores values in a {@link FloatArrayVector}. * This class is generated. Edit {@code X-ArrayBlock.java.st} instead. */ -final class FloatArrayBlock extends AbstractArrayBlock implements FloatBlock { +public final class FloatArrayBlock extends AbstractArrayBlock implements FloatBlock { static final long BASE_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance(FloatArrayBlock.class); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntArrayBlock.java index 0be8b6db78343..787b399c268e8 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntArrayBlock.java @@ -20,7 +20,7 @@ * Block implementation that stores values in a {@link IntArrayVector}. * This class is generated. Edit {@code X-ArrayBlock.java.st} instead. */ -final class IntArrayBlock extends AbstractArrayBlock implements IntBlock { +public final class IntArrayBlock extends AbstractArrayBlock implements IntBlock { static final long BASE_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance(IntArrayBlock.class); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongArrayBlock.java index 9b9b7a694ebb2..06adda6bb8617 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongArrayBlock.java @@ -20,7 +20,7 @@ * Block implementation that stores values in a {@link LongArrayVector}. * This class is generated. Edit {@code X-ArrayBlock.java.st} instead. */ -final class LongArrayBlock extends AbstractArrayBlock implements LongBlock { +public final class LongArrayBlock extends AbstractArrayBlock implements LongBlock { static final long BASE_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance(LongArrayBlock.class); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBooleanGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBooleanGroupingAggregatorFunction.java index d031450a77f56..5d0bde1045e29 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBooleanGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBooleanGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.BooleanVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -69,6 +72,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -85,6 +103,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -96,28 +129,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BooleanBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + int 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++) { + CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BooleanVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + 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); + CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -138,7 +185,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BooleanBlock value } } - private void addRawInput(int positionOffset, IntBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -152,6 +199,97 @@ private void addRawInput(int positionOffset, IntBlock groups, BooleanVector valu } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BooleanBlock values) { + 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++) { + CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BooleanVector values) { + 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); + CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock values) { + 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++) { + CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector values) { + 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); + CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + 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++) { + CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + CountDistinctBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBytesRefGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBytesRefGroupingAggregatorFunction.java index fec083927d5d6..c715adea5b43a 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBytesRefGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctBytesRefGroupingAggregatorFunction.java @@ -14,8 +14,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -72,6 +75,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -88,6 +106,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -99,30 +132,44 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int 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++) { + CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + 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); + CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -144,7 +191,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock valu } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -159,6 +206,103 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector val } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + CountDistinctBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctDoubleGroupingAggregatorFunction.java index 756e922913841..9df957d57c593 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctDoubleGroupingAggregatorFunction.java @@ -16,8 +16,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -74,6 +77,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -90,6 +108,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -101,28 +134,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int 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++) { + CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + 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); + CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -143,7 +190,7 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -157,6 +204,97 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleVector value } } + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleBlock values) { + 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++) { + CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleVector values) { + 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); + CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + 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++) { + CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + 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); + CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + 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++) { + CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + CountDistinctDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctFloatGroupingAggregatorFunction.java index 1462deb1aab91..88b0f37ab722e 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctFloatGroupingAggregatorFunction.java @@ -16,8 +16,11 @@ import org.elasticsearch.compute.data.ElementType; import org.elasticsearch.compute.data.FloatBlock; import org.elasticsearch.compute.data.FloatVector; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -74,6 +77,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -90,6 +108,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -101,28 +134,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(v)); + int 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++) { + CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + 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); + CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -143,7 +190,7 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -157,6 +204,97 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatVector values } } + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatBlock values) { + 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++) { + CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatVector values) { + 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); + CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + 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++) { + CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + 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); + CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + 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++) { + CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + CountDistinctFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctIntGroupingAggregatorFunction.java index 2145489c67096..735f1e262f4b3 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctIntGroupingAggregatorFunction.java @@ -14,8 +14,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -72,6 +75,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -88,6 +106,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -99,28 +132,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctIntAggregator.combine(state, groupId, values.getInt(v)); + int 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++) { + CountDistinctIntAggregator.combine(state, groupId, values.getInt(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - CountDistinctIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + 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); + CountDistinctIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -141,7 +188,7 @@ private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { } } - private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -155,6 +202,97 @@ private void addRawInput(int positionOffset, IntBlock groups, IntVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, IntBlock values) { + 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++) { + CountDistinctIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntVector values) { + 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); + CountDistinctIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + 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++) { + CountDistinctIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + 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); + CountDistinctIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + 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++) { + CountDistinctIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + CountDistinctIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctLongGroupingAggregatorFunction.java index 20ae39cdbcd19..861d6d21c6491 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/CountDistinctLongGroupingAggregatorFunction.java @@ -14,8 +14,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -74,6 +77,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -90,6 +108,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -101,28 +134,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - CountDistinctLongAggregator.combine(state, groupId, values.getLong(v)); + int 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++) { + CountDistinctLongAggregator.combine(state, groupId, values.getLong(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - CountDistinctLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + 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); + CountDistinctLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -143,7 +190,7 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -157,6 +204,97 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, LongBlock values) { + 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++) { + CountDistinctLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values) { + 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); + CountDistinctLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + 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++) { + CountDistinctLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + 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); + CountDistinctLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + 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++) { + CountDistinctLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + CountDistinctLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeDoubleGroupingAggregatorFunction.java index 2ca6ab02875a2..a69d49e8ba8fe 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeDoubleGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -76,6 +79,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); @@ -92,6 +110,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); @@ -103,31 +136,45 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values, + private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + int 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++) { + LastOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values, + private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - LastOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + 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; + LastOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values, + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -149,7 +196,45 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values, + private void addRawInput(int positionOffset, IntArrayBlock 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; + LastOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock 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++) { + LastOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -165,6 +250,68 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleVector value } } + private void addRawInput(int positionOffset, IntBigArrayBlock 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++) { + LastOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock 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; + LastOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + } + } + } + + 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++) { + LastOverTimeDoubleAggregator.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; + LastOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeFloatGroupingAggregatorFunction.java index 38a3b23ee8cc5..5d53c761b4848 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeFloatGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.ElementType; import org.elasticsearch.compute.data.FloatBlock; import org.elasticsearch.compute.data.FloatVector; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -76,6 +79,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); @@ -92,6 +110,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); @@ -103,31 +136,45 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values, + private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + int 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++) { + LastOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values, + private void addRawInput(int positionOffset, IntBlock groups, FloatVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - LastOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + 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; + LastOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values, + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -149,7 +196,45 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values, } } - private void addRawInput(int positionOffset, IntBlock groups, FloatVector values, + private void addRawInput(int positionOffset, IntArrayBlock 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; + LastOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock 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++) { + LastOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -165,6 +250,68 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatVector values } } + private void addRawInput(int positionOffset, IntBigArrayBlock 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++) { + LastOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock 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; + LastOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + } + } + } + + 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++) { + LastOverTimeFloatAggregator.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; + LastOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeIntGroupingAggregatorFunction.java index f03728a905ac3..015c1d456bd11 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeIntGroupingAggregatorFunction.java @@ -11,8 +11,11 @@ import java.util.List; import org.elasticsearch.compute.data.Block; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -74,6 +77,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); @@ -90,6 +108,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); @@ -101,31 +134,45 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values, + private void addRawInput(int positionOffset, IntBlock groups, IntBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + int 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++) { + LastOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values, + private void addRawInput(int positionOffset, IntBlock groups, IntVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - LastOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + 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; + LastOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, IntBlock values, + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -147,7 +194,45 @@ private void addRawInput(int positionOffset, IntBlock groups, IntBlock values, } } - private void addRawInput(int positionOffset, IntBlock groups, IntVector values, + private void addRawInput(int positionOffset, IntArrayBlock 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; + LastOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock 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++) { + LastOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -163,6 +248,68 @@ private void addRawInput(int positionOffset, IntBlock groups, IntVector values, } } + private void addRawInput(int positionOffset, IntBigArrayBlock 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++) { + LastOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock 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; + LastOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + } + } + } + + 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++) { + LastOverTimeIntAggregator.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; + LastOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeLongGroupingAggregatorFunction.java index c9ee5fbad3707..8a939a8206e39 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/LastOverTimeLongGroupingAggregatorFunction.java @@ -11,8 +11,11 @@ import java.util.List; import org.elasticsearch.compute.data.Block; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -74,6 +77,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); @@ -90,6 +108,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); @@ -101,31 +134,45 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values, + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - LastOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + int 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++) { + LastOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values, + private void addRawInput(int positionOffset, IntBlock groups, LongVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - LastOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + 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; + LastOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values, + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -147,7 +194,45 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values, } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values, + private void addRawInput(int positionOffset, IntArrayBlock 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; + LastOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock 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++) { + LastOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -163,6 +248,68 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values, } } + private void addRawInput(int positionOffset, IntBigArrayBlock 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++) { + LastOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock 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; + LastOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + } + } + } + + 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++) { + LastOverTimeLongAggregator.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; + LastOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBooleanGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBooleanGroupingAggregatorFunction.java index 5e2684b85c8db..61f8c2306c44c 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBooleanGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBooleanGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.BooleanVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -69,6 +72,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -85,6 +103,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -96,28 +129,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BooleanBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + int 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++) { + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BooleanVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + 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); + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -138,7 +185,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BooleanBlock value } } - private void addRawInput(int positionOffset, IntBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -152,6 +199,97 @@ private void addRawInput(int positionOffset, IntBlock groups, BooleanVector valu } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BooleanBlock values) { + 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++) { + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BooleanVector values) { + 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); + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock values) { + 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++) { + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector values) { + 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); + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + 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++) { + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + state.set(groupId, MaxBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBytesRefGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBytesRefGroupingAggregatorFunction.java index 52bc763449f59..d23d40f26573e 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBytesRefGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxBytesRefGroupingAggregatorFunction.java @@ -16,8 +16,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -72,6 +75,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -88,6 +106,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -99,30 +132,44 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int 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++) { + MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + 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); + MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -144,7 +191,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock valu } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -159,6 +206,103 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector val } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + MaxBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxDoubleGroupingAggregatorFunction.java index 0b2e5cca5d244..f2c03e1be72c0 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxDoubleGroupingAggregatorFunction.java @@ -15,8 +15,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -71,6 +74,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -87,6 +105,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -98,28 +131,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + int 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++) { + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + 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); + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + } } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -140,7 +187,7 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -154,6 +201,97 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleVector value } } + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleBlock values) { + 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++) { + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleVector values) { + 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); + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + 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++) { + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + 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); + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + 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++) { + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + state.set(groupId, MaxDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxFloatGroupingAggregatorFunction.java index 4ec8212a2da62..fbca3791d98ef 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxFloatGroupingAggregatorFunction.java @@ -15,8 +15,11 @@ import org.elasticsearch.compute.data.ElementType; import org.elasticsearch.compute.data.FloatBlock; import org.elasticsearch.compute.data.FloatVector; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -71,6 +74,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -87,6 +105,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -98,28 +131,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + int 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++) { + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + 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); + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + } } } - private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -140,7 +187,7 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -154,6 +201,97 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatVector values } } + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatBlock values) { + 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++) { + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatVector values) { + 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); + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + 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++) { + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + 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); + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + 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++) { + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + state.set(groupId, MaxFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIntGroupingAggregatorFunction.java index 024d0db097b29..18b69154dcffb 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIntGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.BooleanVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -69,6 +72,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -85,6 +103,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -96,28 +129,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + int 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++) { + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + } } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + 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); + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + } } } - private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -138,7 +185,7 @@ private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { } } - private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -152,6 +199,97 @@ private void addRawInput(int positionOffset, IntBlock groups, IntVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, IntBlock values) { + 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++) { + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntVector values) { + 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); + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + 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++) { + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + 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); + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + 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++) { + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + state.set(groupId, MaxIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIpGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIpGroupingAggregatorFunction.java index 805fc77aa9306..5e0f3bed949f9 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIpGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxIpGroupingAggregatorFunction.java @@ -16,8 +16,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -72,6 +75,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -88,6 +106,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -99,30 +132,44 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MaxIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int 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++) { + MaxIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - MaxIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + 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); + MaxIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -144,7 +191,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock valu } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -159,6 +206,103 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector val } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + MaxIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + MaxIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + MaxIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + MaxIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + MaxIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + MaxIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxLongGroupingAggregatorFunction.java index 5d6fa43723e7b..a48341a50bacc 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MaxLongGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.BooleanVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -71,6 +74,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -87,6 +105,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -98,28 +131,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + int 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++) { + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + 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); + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -140,7 +187,7 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -154,6 +201,97 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, LongBlock values) { + 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++) { + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values) { + 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); + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + 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++) { + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + 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); + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + 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++) { + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + state.set(groupId, MaxLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleGroupingAggregatorFunction.java index 9091515805dff..6ec28fe565cfd 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationDoubleGroupingAggregatorFunction.java @@ -16,8 +16,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -71,6 +74,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -87,6 +105,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -98,28 +131,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int 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++) { + MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + 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); + MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -140,7 +187,7 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -154,6 +201,97 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleVector value } } + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleBlock values) { + 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++) { + MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleVector values) { + 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); + MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + 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++) { + MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + 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); + MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + 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++) { + MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + MedianAbsoluteDeviationDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationFloatGroupingAggregatorFunction.java index 1649e40d9045d..21bd8fb17cfdb 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationFloatGroupingAggregatorFunction.java @@ -16,8 +16,11 @@ import org.elasticsearch.compute.data.ElementType; import org.elasticsearch.compute.data.FloatBlock; import org.elasticsearch.compute.data.FloatVector; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -71,6 +74,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -87,6 +105,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -98,28 +131,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(v)); + int 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++) { + MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + 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); + MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -140,7 +187,7 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -154,6 +201,97 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatVector values } } + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatBlock values) { + 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++) { + MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatVector values) { + 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); + MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + 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++) { + MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + 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); + MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + 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++) { + MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + MedianAbsoluteDeviationFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntGroupingAggregatorFunction.java index 5904bef3956d3..d4c3357e6e497 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationIntGroupingAggregatorFunction.java @@ -14,8 +14,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -69,6 +72,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -85,6 +103,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -96,28 +129,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(v)); + int 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++) { + MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + 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); + MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -138,7 +185,7 @@ private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { } } - private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -152,6 +199,97 @@ private void addRawInput(int positionOffset, IntBlock groups, IntVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, IntBlock values) { + 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++) { + MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntVector values) { + 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); + MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + 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++) { + MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + 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); + MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + 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++) { + MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + MedianAbsoluteDeviationIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongGroupingAggregatorFunction.java index bb50db9998a59..0a4181555c631 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MedianAbsoluteDeviationLongGroupingAggregatorFunction.java @@ -14,8 +14,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -71,6 +74,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -87,6 +105,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -98,28 +131,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(v)); + int 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++) { + MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + 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); + MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -140,7 +187,7 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -154,6 +201,97 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, LongBlock values) { + 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++) { + MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values) { + 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); + MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + 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++) { + MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + 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); + MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + 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++) { + MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + MedianAbsoluteDeviationLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBooleanGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBooleanGroupingAggregatorFunction.java index 10bb3ca5c60bf..539f96a4fd5db 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBooleanGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBooleanGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.BooleanVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -69,6 +72,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -85,6 +103,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -96,28 +129,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BooleanBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + int 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++) { + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BooleanVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + 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); + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -138,7 +185,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BooleanBlock value } } - private void addRawInput(int positionOffset, IntBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -152,6 +199,97 @@ private void addRawInput(int positionOffset, IntBlock groups, BooleanVector valu } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BooleanBlock values) { + 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++) { + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BooleanVector values) { + 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); + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock values) { + 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++) { + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector values) { + 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); + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + 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++) { + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(v))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + state.set(groupId, MinBooleanAggregator.combine(state.getOrDefault(groupId), values.getBoolean(groupPosition + positionOffset))); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBytesRefGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBytesRefGroupingAggregatorFunction.java index 29d96b63a8e59..d7e1c9bfb7328 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBytesRefGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinBytesRefGroupingAggregatorFunction.java @@ -16,8 +16,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -72,6 +75,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -88,6 +106,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -99,30 +132,44 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int 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++) { + MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + 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); + MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -144,7 +191,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock valu } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -159,6 +206,103 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector val } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + MinBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinDoubleGroupingAggregatorFunction.java index c1396235fef0c..f7a2e449725a2 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinDoubleGroupingAggregatorFunction.java @@ -15,8 +15,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -71,6 +74,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -87,6 +105,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -98,28 +131,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + int 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++) { + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + 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); + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + } } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -140,7 +187,7 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -154,6 +201,97 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleVector value } } + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleBlock values) { + 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++) { + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleVector values) { + 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); + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + 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++) { + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + 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); + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + 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++) { + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(v))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + state.set(groupId, MinDoubleAggregator.combine(state.getOrDefault(groupId), values.getDouble(groupPosition + positionOffset))); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinFloatGroupingAggregatorFunction.java index daadf3d7dbb53..688c220afa451 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinFloatGroupingAggregatorFunction.java @@ -15,8 +15,11 @@ import org.elasticsearch.compute.data.ElementType; import org.elasticsearch.compute.data.FloatBlock; import org.elasticsearch.compute.data.FloatVector; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -71,6 +74,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -87,6 +105,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -98,28 +131,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + int 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++) { + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + 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); + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + } } } - private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -140,7 +187,7 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -154,6 +201,97 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatVector values } } + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatBlock values) { + 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++) { + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatVector values) { + 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); + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + 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++) { + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + 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); + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + 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++) { + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(v))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + state.set(groupId, MinFloatAggregator.combine(state.getOrDefault(groupId), values.getFloat(groupPosition + positionOffset))); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIntGroupingAggregatorFunction.java index 8f92c63096766..26f362ee4c2f1 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIntGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.BooleanVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -69,6 +72,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -85,6 +103,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -96,28 +129,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + int 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++) { + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + } } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + 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); + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + } } } - private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -138,7 +185,7 @@ private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { } } - private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -152,6 +199,97 @@ private void addRawInput(int positionOffset, IntBlock groups, IntVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, IntBlock values) { + 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++) { + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntVector values) { + 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); + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + 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++) { + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + 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); + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + 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++) { + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + state.set(groupId, MinIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIpGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIpGroupingAggregatorFunction.java index 05a5c3b57e2a6..14db59fbeeac3 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIpGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinIpGroupingAggregatorFunction.java @@ -16,8 +16,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -72,6 +75,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -88,6 +106,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -99,30 +132,44 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - MinIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int 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++) { + MinIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - MinIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + 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); + MinIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -144,7 +191,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock valu } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -159,6 +206,103 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector val } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + MinIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + MinIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + MinIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + MinIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + MinIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + MinIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinLongGroupingAggregatorFunction.java index c6421afa46211..55b54827c9add 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/MinLongGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.BooleanVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -71,6 +74,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -87,6 +105,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -98,28 +131,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + int 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++) { + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + 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); + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -140,7 +187,7 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -154,6 +201,97 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, LongBlock values) { + 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++) { + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values) { + 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); + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + 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++) { + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + 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); + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + 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++) { + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + state.set(groupId, MinLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileDoubleGroupingAggregatorFunction.java index a2ba67333a05d..b24f7c5b11281 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileDoubleGroupingAggregatorFunction.java @@ -16,8 +16,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -74,6 +77,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -90,6 +108,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -101,28 +134,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int 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++) { + PercentileDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - PercentileDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + 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); + PercentileDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -143,7 +190,7 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -157,6 +204,97 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleVector value } } + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleBlock values) { + 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++) { + PercentileDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleVector values) { + 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); + PercentileDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + 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++) { + PercentileDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + 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); + PercentileDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + 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++) { + PercentileDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + PercentileDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileFloatGroupingAggregatorFunction.java index 4c24b1b4221c6..e3e5d77ed5805 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileFloatGroupingAggregatorFunction.java @@ -16,8 +16,11 @@ import org.elasticsearch.compute.data.ElementType; import org.elasticsearch.compute.data.FloatBlock; import org.elasticsearch.compute.data.FloatVector; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -74,6 +77,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -90,6 +108,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -101,28 +134,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileFloatAggregator.combine(state, groupId, values.getFloat(v)); + int 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++) { + PercentileFloatAggregator.combine(state, groupId, values.getFloat(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - PercentileFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + 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); + PercentileFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -143,7 +190,7 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -157,6 +204,97 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatVector values } } + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatBlock values) { + 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++) { + PercentileFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatVector values) { + 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); + PercentileFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + 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++) { + PercentileFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + 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); + PercentileFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + 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++) { + PercentileFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + PercentileFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileIntGroupingAggregatorFunction.java index 97ce87021f4f8..37bcb43c8934a 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileIntGroupingAggregatorFunction.java @@ -14,8 +14,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -72,6 +75,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -88,6 +106,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -99,28 +132,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileIntAggregator.combine(state, groupId, values.getInt(v)); + int 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++) { + PercentileIntAggregator.combine(state, groupId, values.getInt(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - PercentileIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + 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); + PercentileIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -141,7 +188,7 @@ private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { } } - private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -155,6 +202,97 @@ private void addRawInput(int positionOffset, IntBlock groups, IntVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, IntBlock values) { + 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++) { + PercentileIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntVector values) { + 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); + PercentileIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + 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++) { + PercentileIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + 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); + PercentileIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + 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++) { + PercentileIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + PercentileIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileLongGroupingAggregatorFunction.java index f2680fd7b5bef..5f6ad9031f63d 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/PercentileLongGroupingAggregatorFunction.java @@ -14,8 +14,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -74,6 +77,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -90,6 +108,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -101,28 +134,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - PercentileLongAggregator.combine(state, groupId, values.getLong(v)); + int 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++) { + PercentileLongAggregator.combine(state, groupId, values.getLong(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - PercentileLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + 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); + PercentileLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -143,7 +190,7 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -157,6 +204,97 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, LongBlock values) { + 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++) { + PercentileLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values) { + 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); + PercentileLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + 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++) { + PercentileLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + 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); + PercentileLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + 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++) { + PercentileLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + PercentileLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateDoubleGroupingAggregatorFunction.java index e12686f2a66fa..f619398f62f1e 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateDoubleGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -78,6 +81,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); @@ -94,6 +112,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); @@ -105,31 +138,45 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values, + private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + int 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++) { + RateDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values, + private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - RateDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + 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; + RateDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values, + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -151,7 +198,45 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values, + private void addRawInput(int positionOffset, IntArrayBlock 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; + RateDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock 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++) { + RateDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -167,6 +252,68 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleVector value } } + private void addRawInput(int positionOffset, IntBigArrayBlock 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++) { + RateDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock 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; + RateDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + } + } + } + + 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++) { + RateDoubleAggregator.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; + RateDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateFloatGroupingAggregatorFunction.java index 5e2aced928554..e29a5064c8e4e 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateFloatGroupingAggregatorFunction.java @@ -15,8 +15,11 @@ import org.elasticsearch.compute.data.ElementType; import org.elasticsearch.compute.data.FloatBlock; import org.elasticsearch.compute.data.FloatVector; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -80,6 +83,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); @@ -96,6 +114,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); @@ -107,31 +140,45 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values, + private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + int 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++) { + RateFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values, + private void addRawInput(int positionOffset, IntBlock groups, FloatVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - RateFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + 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; + RateFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values, + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -153,7 +200,45 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values, } } - private void addRawInput(int positionOffset, IntBlock groups, FloatVector values, + private void addRawInput(int positionOffset, IntArrayBlock 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; + RateFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock 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++) { + RateFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -169,6 +254,68 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatVector values } } + private void addRawInput(int positionOffset, IntBigArrayBlock 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++) { + RateFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock 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; + RateFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + } + } + } + + 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++) { + RateFloatAggregator.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; + RateFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateIntGroupingAggregatorFunction.java index c85a0ac5b9fe0..5cce5d5c087eb 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateIntGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -78,6 +81,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); @@ -94,6 +112,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); @@ -105,31 +138,45 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values, + private void addRawInput(int positionOffset, IntBlock groups, IntBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + int 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++) { + RateIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values, + private void addRawInput(int positionOffset, IntBlock groups, IntVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - RateIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + 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; + RateIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, IntBlock values, + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -151,7 +198,45 @@ private void addRawInput(int positionOffset, IntBlock groups, IntBlock values, } } - private void addRawInput(int positionOffset, IntBlock groups, IntVector values, + private void addRawInput(int positionOffset, IntArrayBlock 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; + RateIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock 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++) { + RateIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -167,6 +252,68 @@ private void addRawInput(int positionOffset, IntBlock groups, IntVector values, } } + private void addRawInput(int positionOffset, IntBigArrayBlock 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++) { + RateIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock 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; + RateIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + } + } + } + + 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++) { + RateIntAggregator.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; + RateIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateLongGroupingAggregatorFunction.java index 98996069fe554..21bba3a723db5 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/RateLongGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -78,6 +81,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); @@ -94,6 +112,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); @@ -105,31 +138,45 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values, + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - RateLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + int 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++) { + RateLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values, + private void addRawInput(int positionOffset, IntBlock groups, LongVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - RateLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + 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; + RateLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values, + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -151,7 +198,45 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values, } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values, + private void addRawInput(int positionOffset, IntArrayBlock 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; + RateLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock 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++) { + RateLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -167,6 +252,68 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values, } } + private void addRawInput(int positionOffset, IntBigArrayBlock 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++) { + RateLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock 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; + RateLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + } + } + } + + 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++) { + RateLongAggregator.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; + RateLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevDoubleGroupingAggregatorFunction.java index bbf1930cf0524..f565a9d30a1fa 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevDoubleGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -72,6 +75,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -88,6 +106,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -99,28 +132,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int 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++) { + StdDevDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - StdDevDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + 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); + StdDevDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -141,7 +188,7 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -155,6 +202,97 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleVector value } } + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleBlock values) { + 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++) { + StdDevDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleVector values) { + 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); + StdDevDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + 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++) { + StdDevDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + 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); + StdDevDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + 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++) { + StdDevDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + StdDevDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevFloatGroupingAggregatorFunction.java index 818dd28386b9f..19639215f7312 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevFloatGroupingAggregatorFunction.java @@ -15,8 +15,11 @@ import org.elasticsearch.compute.data.ElementType; import org.elasticsearch.compute.data.FloatBlock; import org.elasticsearch.compute.data.FloatVector; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -74,6 +77,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -90,6 +108,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -101,28 +134,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevFloatAggregator.combine(state, groupId, values.getFloat(v)); + int 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++) { + StdDevFloatAggregator.combine(state, groupId, values.getFloat(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - StdDevFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + 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); + StdDevFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -143,7 +190,7 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -157,6 +204,97 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatVector values } } + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatBlock values) { + 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++) { + StdDevFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatVector values) { + 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); + StdDevFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + 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++) { + StdDevFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + 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); + StdDevFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + 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++) { + StdDevFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + StdDevFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevIntGroupingAggregatorFunction.java index d8417d71dc784..5c691e4f1f4a2 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevIntGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -72,6 +75,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -88,6 +106,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -99,28 +132,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevIntAggregator.combine(state, groupId, values.getInt(v)); + int 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++) { + StdDevIntAggregator.combine(state, groupId, values.getInt(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - StdDevIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + 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); + StdDevIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -141,7 +188,7 @@ private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { } } - private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -155,6 +202,97 @@ private void addRawInput(int positionOffset, IntBlock groups, IntVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, IntBlock values) { + 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++) { + StdDevIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntVector values) { + 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); + StdDevIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + 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++) { + StdDevIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + 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); + StdDevIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + 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++) { + StdDevIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + StdDevIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevLongGroupingAggregatorFunction.java index fc5f061a04620..e627f3bb2848e 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/StdDevLongGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -72,6 +75,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -88,6 +106,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -99,28 +132,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - StdDevLongAggregator.combine(state, groupId, values.getLong(v)); + int 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++) { + StdDevLongAggregator.combine(state, groupId, values.getLong(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - StdDevLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + 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); + StdDevLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -141,7 +188,7 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -155,6 +202,97 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, LongBlock values) { + 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++) { + StdDevLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values) { + 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); + StdDevLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + 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++) { + StdDevLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + 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); + StdDevLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + 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++) { + StdDevLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + StdDevLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumDoubleGroupingAggregatorFunction.java index d566756ca3282..452ebe1ee21a0 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumDoubleGroupingAggregatorFunction.java @@ -15,8 +15,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -72,6 +75,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -88,6 +106,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -99,28 +132,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SumDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int 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++) { + SumDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - SumDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + 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); + SumDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -141,7 +188,7 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -155,6 +202,97 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleVector value } } + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleBlock values) { + 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++) { + SumDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleVector values) { + 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); + SumDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + 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++) { + SumDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + 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); + SumDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + 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++) { + SumDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + SumDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumFloatGroupingAggregatorFunction.java index e12f91f4451a8..dc0ea3d605ebc 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumFloatGroupingAggregatorFunction.java @@ -17,8 +17,11 @@ import org.elasticsearch.compute.data.ElementType; import org.elasticsearch.compute.data.FloatBlock; import org.elasticsearch.compute.data.FloatVector; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -74,6 +77,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -90,6 +108,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -101,28 +134,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SumFloatAggregator.combine(state, groupId, values.getFloat(v)); + int 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++) { + SumFloatAggregator.combine(state, groupId, values.getFloat(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - SumFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + 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); + SumFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -143,7 +190,7 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -157,6 +204,97 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatVector values } } + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatBlock values) { + 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++) { + SumFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatVector values) { + 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); + SumFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + 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++) { + SumFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + 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); + SumFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + 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++) { + SumFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + SumFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumIntGroupingAggregatorFunction.java index 91c04d9370060..68281b8eb12f0 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumIntGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.BooleanVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -71,6 +74,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -87,6 +105,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -98,28 +131,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + int 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++) { + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + } } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + 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); + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + } } } - private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -140,7 +187,7 @@ private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { } } - private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -154,6 +201,97 @@ private void addRawInput(int positionOffset, IntBlock groups, IntVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, IntBlock values) { + 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++) { + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntVector values) { + 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); + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + 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++) { + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + 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); + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + 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++) { + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(v))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + state.set(groupId, SumIntAggregator.combine(state.getOrDefault(groupId), values.getInt(groupPosition + positionOffset))); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumLongGroupingAggregatorFunction.java index e53dfa3857753..54b06690d281e 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/SumLongGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.BooleanVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -71,6 +74,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -87,6 +105,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -98,28 +131,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + int 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++) { + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + 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); + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -140,7 +187,7 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -154,6 +201,97 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, LongBlock values) { + 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++) { + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values) { + 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); + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + 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++) { + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + 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); + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + 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++) { + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(v))); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + state.set(groupId, SumLongAggregator.combine(state.getOrDefault(groupId), values.getLong(groupPosition + positionOffset))); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBooleanGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBooleanGroupingAggregatorFunction.java index dc0e2831ee3ea..bd8dce74df88e 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBooleanGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBooleanGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.BooleanVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -75,6 +78,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -91,6 +109,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -102,28 +135,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BooleanBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + int 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++) { + TopBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BooleanVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - TopBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + 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); + TopBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -144,7 +191,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BooleanBlock value } } - private void addRawInput(int positionOffset, IntBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -158,6 +205,97 @@ private void addRawInput(int positionOffset, IntBlock groups, BooleanVector valu } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BooleanBlock values) { + 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++) { + TopBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BooleanVector values) { + 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); + TopBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock values) { + 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++) { + TopBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector values) { + 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); + TopBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + 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++) { + TopBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + TopBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBytesRefGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBytesRefGroupingAggregatorFunction.java index aa779dfc4afad..594b06f6463ec 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBytesRefGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopBytesRefGroupingAggregatorFunction.java @@ -14,8 +14,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -76,6 +79,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -92,6 +110,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -103,30 +136,44 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int 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++) { + TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + 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); + TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -148,7 +195,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock valu } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -163,6 +210,103 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector val } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + TopBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopDoubleGroupingAggregatorFunction.java index 68bdee76e48aa..39abd06f5c6ef 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopDoubleGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -75,6 +78,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -91,6 +109,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -102,28 +135,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int 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++) { + TopDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - TopDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + 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); + TopDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -144,7 +191,7 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -158,6 +205,97 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleVector value } } + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleBlock values) { + 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++) { + TopDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleVector values) { + 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); + TopDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + 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++) { + TopDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + 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); + TopDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + 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++) { + TopDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + TopDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopFloatGroupingAggregatorFunction.java index cf1063a02fcbf..1506849737876 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopFloatGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.ElementType; import org.elasticsearch.compute.data.FloatBlock; import org.elasticsearch.compute.data.FloatVector; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -75,6 +78,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -91,6 +109,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -102,28 +135,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopFloatAggregator.combine(state, groupId, values.getFloat(v)); + int 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++) { + TopFloatAggregator.combine(state, groupId, values.getFloat(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - TopFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + 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); + TopFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -144,7 +191,7 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -158,6 +205,97 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatVector values } } + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatBlock values) { + 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++) { + TopFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatVector values) { + 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); + TopFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + 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++) { + TopFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + 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); + TopFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + 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++) { + TopFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + TopFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIntGroupingAggregatorFunction.java index 67fa432b87995..19742383aca53 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIntGroupingAggregatorFunction.java @@ -11,8 +11,11 @@ import java.util.List; import org.elasticsearch.compute.data.Block; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -73,6 +76,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -89,6 +107,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -100,28 +133,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopIntAggregator.combine(state, groupId, values.getInt(v)); + int 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++) { + TopIntAggregator.combine(state, groupId, values.getInt(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - TopIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + 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); + TopIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -142,7 +189,7 @@ private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { } } - private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -156,6 +203,97 @@ private void addRawInput(int positionOffset, IntBlock groups, IntVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, IntBlock values) { + 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++) { + TopIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntVector values) { + 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); + TopIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + 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++) { + TopIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + 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); + TopIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + 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++) { + TopIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + TopIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIpGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIpGroupingAggregatorFunction.java index eb5631c68d173..8ae7295cd0ce7 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIpGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopIpGroupingAggregatorFunction.java @@ -14,8 +14,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -76,6 +79,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -92,6 +110,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -103,30 +136,44 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int 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++) { + TopIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - TopIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + 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); + TopIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -148,7 +195,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock valu } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -163,6 +210,103 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector val } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + TopIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + TopIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + TopIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + TopIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + TopIpAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + TopIpAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopLongGroupingAggregatorFunction.java index 58b62c211a0b9..d07ac88a024f5 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/TopLongGroupingAggregatorFunction.java @@ -11,8 +11,11 @@ import java.util.List; import org.elasticsearch.compute.data.Block; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -75,6 +78,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -91,6 +109,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -102,28 +135,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - TopLongAggregator.combine(state, groupId, values.getLong(v)); + int 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++) { + TopLongAggregator.combine(state, groupId, values.getLong(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - TopLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + 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); + TopLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -144,7 +191,7 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -158,6 +205,97 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, LongBlock values) { + 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++) { + TopLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values) { + 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); + TopLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + 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++) { + TopLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + 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); + TopLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + 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++) { + TopLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + TopLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBooleanGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBooleanGroupingAggregatorFunction.java index 772de15468ef3..e458d45ca5ef2 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBooleanGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBooleanGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.BooleanBlock; import org.elasticsearch.compute.data.BooleanVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -68,6 +71,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -84,6 +102,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -95,28 +128,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BooleanBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + int 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++) { + ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BooleanVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + 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); + ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BooleanBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -137,7 +184,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BooleanBlock value } } - private void addRawInput(int positionOffset, IntBlock groups, BooleanVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BooleanVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -151,6 +198,97 @@ private void addRawInput(int positionOffset, IntBlock groups, BooleanVector valu } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BooleanBlock values) { + 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++) { + ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BooleanVector values) { + 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); + ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanBlock values) { + 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++) { + ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BooleanVector values) { + 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); + ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BooleanBlock values) { + 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++) { + ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BooleanVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + ValuesBooleanAggregator.combine(state, groupId, values.getBoolean(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBytesRefGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBytesRefGroupingAggregatorFunction.java index 93d060889d28f..502bc14e05ab4 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBytesRefGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesBytesRefGroupingAggregatorFunction.java @@ -14,8 +14,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -69,6 +72,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -85,6 +103,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -96,30 +129,44 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int 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++) { + ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + 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); + ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -141,7 +188,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock valu } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -156,6 +203,103 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector val } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + ValuesBytesRefAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesDoubleGroupingAggregatorFunction.java index 04984d5c0640a..228fdb337cad6 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesDoubleGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -68,6 +71,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -84,6 +102,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -95,28 +128,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesDoubleAggregator.combine(state, groupId, values.getDouble(v)); + int 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++) { + ValuesDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - ValuesDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + 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); + ValuesDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -137,7 +184,7 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -151,6 +198,97 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleVector value } } + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleBlock values) { + 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++) { + ValuesDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleVector values) { + 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); + ValuesDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleBlock values) { + 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++) { + ValuesDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, DoubleVector values) { + 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); + ValuesDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values) { + 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++) { + ValuesDoubleAggregator.combine(state, groupId, values.getDouble(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, DoubleVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + ValuesDoubleAggregator.combine(state, groupId, values.getDouble(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesFloatGroupingAggregatorFunction.java index 1848b9e4f141b..49a429058c1f8 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesFloatGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.ElementType; import org.elasticsearch.compute.data.FloatBlock; import org.elasticsearch.compute.data.FloatVector; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -68,6 +71,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -84,6 +102,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -95,28 +128,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesFloatAggregator.combine(state, groupId, values.getFloat(v)); + int 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++) { + ValuesFloatAggregator.combine(state, groupId, values.getFloat(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - ValuesFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + 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); + ValuesFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -137,7 +184,7 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, FloatVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -151,6 +198,97 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatVector values } } + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatBlock values) { + 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++) { + ValuesFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatVector values) { + 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); + ValuesFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatBlock values) { + 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++) { + ValuesFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, FloatVector values) { + 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); + ValuesFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatBlock values) { + 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++) { + ValuesFloatAggregator.combine(state, groupId, values.getFloat(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, FloatVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + ValuesFloatAggregator.combine(state, groupId, values.getFloat(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesIntGroupingAggregatorFunction.java index f0878fb085e6a..a5065a9a108f8 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesIntGroupingAggregatorFunction.java @@ -11,8 +11,11 @@ import java.util.List; import org.elasticsearch.compute.data.Block; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -66,6 +69,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -82,6 +100,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -93,28 +126,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesIntAggregator.combine(state, groupId, values.getInt(v)); + int 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++) { + ValuesIntAggregator.combine(state, groupId, values.getInt(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - ValuesIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + 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); + ValuesIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -135,7 +182,7 @@ private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { } } - private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -149,6 +196,97 @@ private void addRawInput(int positionOffset, IntBlock groups, IntVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, IntBlock values) { + 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++) { + ValuesIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntVector values) { + 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); + ValuesIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + 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++) { + ValuesIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + 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); + ValuesIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + 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++) { + ValuesIntAggregator.combine(state, groupId, values.getInt(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + ValuesIntAggregator.combine(state, groupId, values.getInt(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesLongGroupingAggregatorFunction.java index 00bd36cda2523..182552dbb1e9f 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/ValuesLongGroupingAggregatorFunction.java @@ -11,8 +11,11 @@ import java.util.List; import org.elasticsearch.compute.data.Block; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -68,6 +71,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -84,6 +102,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -95,28 +128,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - ValuesLongAggregator.combine(state, groupId, values.getLong(v)); + int 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++) { + ValuesLongAggregator.combine(state, groupId, values.getLong(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - ValuesLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + 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); + ValuesLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -137,7 +184,7 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -151,6 +198,97 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, LongBlock values) { + 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++) { + ValuesLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values) { + 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); + ValuesLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + 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++) { + ValuesLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + 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); + ValuesLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + 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++) { + ValuesLongAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + ValuesLongAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointDocValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointDocValuesGroupingAggregatorFunction.java index 9a6328f075bca..15be0ef05773a 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointDocValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointDocValuesGroupingAggregatorFunction.java @@ -17,8 +17,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -78,6 +81,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -94,6 +112,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -105,28 +138,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int 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++) { + SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + 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); + SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -147,7 +194,7 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -161,6 +208,97 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, LongBlock values) { + 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++) { + SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values) { + 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); + SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + 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++) { + SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + 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); + SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + 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++) { + SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + SpatialCentroidCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointSourceValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointSourceValuesGroupingAggregatorFunction.java index 1681b1a210d3c..2852605288a04 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointSourceValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidCartesianPointSourceValuesGroupingAggregatorFunction.java @@ -20,8 +20,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -81,6 +84,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -97,6 +115,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -108,30 +141,44 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int 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++) { + SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + 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); + SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -153,7 +200,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock valu } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -168,6 +215,103 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector val } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + SpatialCentroidCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointDocValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointDocValuesGroupingAggregatorFunction.java index 36413308e967f..a8eb1fdad16bb 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointDocValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointDocValuesGroupingAggregatorFunction.java @@ -17,8 +17,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -78,6 +81,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -94,6 +112,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -105,28 +138,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int 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++) { + SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + 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); + SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -147,7 +194,7 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -161,6 +208,97 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, LongBlock values) { + 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++) { + SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values) { + 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); + SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + 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++) { + SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + 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); + SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + 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++) { + SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + SpatialCentroidGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointSourceValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointSourceValuesGroupingAggregatorFunction.java index 935dd8f56887a..c2fda53aa585a 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointSourceValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialCentroidGeoPointSourceValuesGroupingAggregatorFunction.java @@ -20,8 +20,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -81,6 +84,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -97,6 +115,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -108,30 +141,44 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int 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++) { + SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + 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); + SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -153,7 +200,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock valu } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -168,6 +215,103 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector val } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + SpatialCentroidGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointDocValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointDocValuesGroupingAggregatorFunction.java index 8a9807be22ef5..d593273a6064e 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointDocValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointDocValuesGroupingAggregatorFunction.java @@ -15,8 +15,11 @@ import org.elasticsearch.compute.aggregation.SeenGroupIds; import org.elasticsearch.compute.data.Block; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -75,6 +78,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -91,6 +109,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -102,28 +135,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int 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++) { + SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + 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); + SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -144,7 +191,7 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -158,6 +205,97 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, LongBlock values) { + 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++) { + SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values) { + 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); + SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + 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++) { + SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + 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); + SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + 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++) { + SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + SpatialExtentCartesianPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointSourceValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointSourceValuesGroupingAggregatorFunction.java index 49198bbd74c69..723bb68703583 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointSourceValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianPointSourceValuesGroupingAggregatorFunction.java @@ -18,8 +18,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -76,6 +79,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -92,6 +110,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -103,30 +136,44 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int 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++) { + SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + 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); + SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -148,7 +195,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock valu } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -163,6 +210,103 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector val } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + SpatialExtentCartesianPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeDocValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeDocValuesGroupingAggregatorFunction.java index ca6b567810ae7..c885614b1efbc 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeDocValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeDocValuesGroupingAggregatorFunction.java @@ -15,8 +15,11 @@ import org.elasticsearch.compute.aggregation.SeenGroupIds; import org.elasticsearch.compute.data.Block; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -73,6 +76,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -89,6 +107,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -100,27 +133,34 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - int[] valuesArray = new int[valuesEnd - valuesStart]; - for (int v = valuesStart; v < valuesEnd; v++) { - valuesArray[v-valuesStart] = values.getInt(v); + 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); + int[] valuesArray = new int[valuesEnd - valuesStart]; + for (int v = valuesStart; v < valuesEnd; v++) { + valuesArray[v-valuesStart] = values.getInt(v); + } + SpatialExtentCartesianShapeDocValuesAggregator.combine(state, groupId, valuesArray); } - SpatialExtentCartesianShapeDocValuesAggregator.combine(state, groupId, valuesArray); } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { // This type does not support vectors because all values are multi-valued } - private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -143,7 +183,81 @@ private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { } } - private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { + // This type does not support vectors because all values are multi-valued + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntBlock values) { + 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); + int[] valuesArray = new int[valuesEnd - valuesStart]; + for (int v = valuesStart; v < valuesEnd; v++) { + valuesArray[v-valuesStart] = values.getInt(v); + } + SpatialExtentCartesianShapeDocValuesAggregator.combine(state, groupId, valuesArray); + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntVector values) { + // This type does not support vectors because all values are multi-valued + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + 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); + int[] valuesArray = new int[valuesEnd - valuesStart]; + for (int v = valuesStart; v < valuesEnd; v++) { + valuesArray[v-valuesStart] = values.getInt(v); + } + SpatialExtentCartesianShapeDocValuesAggregator.combine(state, groupId, valuesArray); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + // This type does not support vectors because all values are multi-valued + } + + private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + 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); + int[] valuesArray = new int[valuesEnd - valuesStart]; + for (int v = valuesStart; v < valuesEnd; v++) { + valuesArray[v-valuesStart] = values.getInt(v); + } + SpatialExtentCartesianShapeDocValuesAggregator.combine(state, groupId, valuesArray); + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntVector values) { // This type does not support vectors because all values are multi-valued } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeSourceValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeSourceValuesGroupingAggregatorFunction.java index bf7e95c4f040f..d4a392a24b87b 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeSourceValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentCartesianShapeSourceValuesGroupingAggregatorFunction.java @@ -18,8 +18,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -76,6 +79,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -92,6 +110,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -103,30 +136,44 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int 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++) { + SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + 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); + SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -148,7 +195,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock valu } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -163,6 +210,103 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector val } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + SpatialExtentCartesianShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointDocValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointDocValuesGroupingAggregatorFunction.java index 71abb7296232a..943ca59c85398 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointDocValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointDocValuesGroupingAggregatorFunction.java @@ -15,8 +15,11 @@ import org.elasticsearch.compute.aggregation.SeenGroupIds; import org.elasticsearch.compute.data.Block; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -77,6 +80,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -93,6 +111,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -104,28 +137,42 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + int 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++) { + SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + 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); + SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -146,7 +193,7 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values) } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, LongVector values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -160,6 +207,97 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values) } } + private void addRawInput(int positionOffset, IntVectorBlock groups, LongBlock values) { + 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++) { + SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values) { + 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); + SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongBlock values) { + 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++) { + SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, LongVector values) { + 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); + SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongBlock values) { + 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++) { + SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(v)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, LongVector values) { + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + SpatialExtentGeoPointDocValuesAggregator.combine(state, groupId, values.getLong(groupPosition + positionOffset)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointSourceValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointSourceValuesGroupingAggregatorFunction.java index 437c1f017ebc9..e482c48731ec9 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointSourceValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoPointSourceValuesGroupingAggregatorFunction.java @@ -18,8 +18,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -78,6 +81,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -94,6 +112,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -105,30 +138,44 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int 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++) { + SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + 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); + SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -150,7 +197,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock valu } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -165,6 +212,103 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector val } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + SpatialExtentGeoPointSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeDocValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeDocValuesGroupingAggregatorFunction.java index b0a01d268280c..e5fca370f7717 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeDocValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeDocValuesGroupingAggregatorFunction.java @@ -15,8 +15,11 @@ import org.elasticsearch.compute.aggregation.SeenGroupIds; import org.elasticsearch.compute.data.Block; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -75,6 +78,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -91,6 +109,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -102,27 +135,34 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - int[] valuesArray = new int[valuesEnd - valuesStart]; - for (int v = valuesStart; v < valuesEnd; v++) { - valuesArray[v-valuesStart] = values.getInt(v); + 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); + int[] valuesArray = new int[valuesEnd - valuesStart]; + for (int v = valuesStart; v < valuesEnd; v++) { + valuesArray[v-valuesStart] = values.getInt(v); + } + SpatialExtentGeoShapeDocValuesAggregator.combine(state, groupId, valuesArray); } - SpatialExtentGeoShapeDocValuesAggregator.combine(state, groupId, valuesArray); } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values) { + private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { // This type does not support vectors because all values are multi-valued } - private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { continue; @@ -145,7 +185,81 @@ private void addRawInput(int positionOffset, IntBlock groups, IntBlock values) { } } - private void addRawInput(int positionOffset, IntBlock groups, IntVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, IntVector values) { + // This type does not support vectors because all values are multi-valued + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntBlock values) { + 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); + int[] valuesArray = new int[valuesEnd - valuesStart]; + for (int v = valuesStart; v < valuesEnd; v++) { + valuesArray[v-valuesStart] = values.getInt(v); + } + SpatialExtentGeoShapeDocValuesAggregator.combine(state, groupId, valuesArray); + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntVector values) { + // This type does not support vectors because all values are multi-valued + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntBlock values) { + 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); + int[] valuesArray = new int[valuesEnd - valuesStart]; + for (int v = valuesStart; v < valuesEnd; v++) { + valuesArray[v-valuesStart] = values.getInt(v); + } + SpatialExtentGeoShapeDocValuesAggregator.combine(state, groupId, valuesArray); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, IntVector values) { + // This type does not support vectors because all values are multi-valued + } + + private void addRawInput(int positionOffset, IntVector groups, IntBlock values) { + 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); + int[] valuesArray = new int[valuesEnd - valuesStart]; + for (int v = valuesStart; v < valuesEnd; v++) { + valuesArray[v-valuesStart] = values.getInt(v); + } + SpatialExtentGeoShapeDocValuesAggregator.combine(state, groupId, valuesArray); + } + } + + private void addRawInput(int positionOffset, IntVector groups, IntVector values) { // This type does not support vectors because all values are multi-valued } diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeSourceValuesGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeSourceValuesGroupingAggregatorFunction.java index 029e935f4765e..e53fa3fe29ac8 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeSourceValuesGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/spatial/SpatialExtentGeoShapeSourceValuesGroupingAggregatorFunction.java @@ -18,8 +18,11 @@ import org.elasticsearch.compute.data.BytesRefBlock; import org.elasticsearch.compute.data.BytesRefVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.operator.DriverContext; @@ -78,6 +81,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock); @@ -94,6 +112,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector); @@ -105,30 +138,44 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + int 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++) { + SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + 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); + SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefBlock values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -150,7 +197,7 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefBlock valu } } - private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector values) { + private void addRawInput(int positionOffset, IntArrayBlock groups, BytesRefVector values) { BytesRef scratch = new BytesRef(); for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -165,6 +212,103 @@ private void addRawInput(int positionOffset, IntBlock groups, BytesRefVector val } } + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + 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); + SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefBlock values) { + BytesRef scratch = new BytesRef(); + 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++) { + SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(v, scratch)); + } + } + } + + private void addRawInput(int positionOffset, IntVector groups, BytesRefVector values) { + BytesRef scratch = new BytesRef(); + for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { + int groupId = groups.getInt(groupPosition); + SpatialExtentGeoShapeSourceValuesAggregator.combine(state, groupId, values.getBytesRef(groupPosition + positionOffset, scratch)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/GroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/GroupingAggregatorFunction.java index d5d432655620f..e82a53994b6fb 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/GroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/GroupingAggregatorFunction.java @@ -8,8 +8,11 @@ package org.elasticsearch.compute.aggregation; import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.data.Vector; import org.elasticsearch.core.Releasable; @@ -55,6 +58,36 @@ interface AddInput extends Releasable { */ void add(int positionOffset, IntBlock groupIds); + /** + * Implementation of {@link #add(int, IntBlock)} for a specific type of block. + *

+ * If not implemented, defaults to the generic implementation. + *

+ */ + default void add(int positionOffset, IntArrayBlock groupIds) { + add(positionOffset, (IntBlock) groupIds); + } + + /** + * Implementation of {@link #add(int, IntBlock)} for a specific type of block. + *

+ * If not implemented, defaults to the generic implementation. + *

+ */ + default void add(int positionOffset, IntVectorBlock groupIds) { + add(positionOffset, (IntBlock) groupIds); + } + + /** + * Implementation of {@link #add(int, IntBlock)} for a specific type of block. + *

+ * If not implemented, defaults to the generic implementation. + *

+ */ + default void add(int positionOffset, IntBigArrayBlock groupIds) { + add(positionOffset, (IntBlock) groupIds); + } + /** * Send a batch of group ids to the aggregator. The {@code groupIds} * may be offset from the start of the block to allow for sending chunks diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 2e0093877932e..6d5ed705f3e67 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -229,9 +229,7 @@ IntBlock add(LongVector vector) { acceptValue(v); } - // TODO: Count how many values were denied, to try to reduce the size of the block. Check the same for add(block) - - // Create a vector with the groups + // Create a block with the groups try (var builder = blockFactory.newIntBlockBuilder(positions)) { for (int i = 0; i < positions; i++) { long v = vector.getLong(i); diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayBlock.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayBlock.java.st index 707b19165bb3b..b8c8107d7aa4d 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayBlock.java.st +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayBlock.java.st @@ -31,7 +31,7 @@ $if(BytesRef)$ $endif$ * This class is generated. Edit {@code X-ArrayBlock.java.st} instead. */ -final class $Type$ArrayBlock extends AbstractArrayBlock implements $Type$Block { +public final class $Type$ArrayBlock extends AbstractArrayBlock implements $Type$Block { static final long BASE_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance($Type$ArrayBlock.class); From 5176663f4317322680f6f2776f7cbaf87f22d016 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Wed, 30 Apr 2025 13:24:12 +0200 Subject: [PATCH 22/39] Call the specific add() methods for eacj block type --- .../GroupingAggregatorFunction.java | 20 +++++++++++++++++++ .../blockhash/LongTopNBlockHash.java | 4 ++-- 2 files changed, 22 insertions(+), 2 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/GroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/GroupingAggregatorFunction.java index e82a53994b6fb..8347fa1a6e8cc 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/GroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/GroupingAggregatorFunction.java @@ -88,6 +88,26 @@ default void add(int positionOffset, IntBigArrayBlock groupIds) { add(positionOffset, (IntBlock) groupIds); } + /** + * Calls an {@code add()} implementation given the specific {@code groupIds} block type. + */ + default void addSpecific(int positionOffset, IntBlock groupIds) { + switch (groupIds) { + case IntVectorBlock b: + add(positionOffset, b); + break; + case IntArrayBlock b: + add(positionOffset, b); + break; + case IntBigArrayBlock b: + add(positionOffset, b); + break; + default: + add(positionOffset, groupIds); + break; + } + } + /** * Send a batch of group ids to the aggregator. The {@code groupIds} * may be offset from the start of the block to allow for sending chunks diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 6d5ed705f3e67..deee38a324c5d 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -87,12 +87,12 @@ public void add(Page page, GroupingAggregatorFunction.AddInput addInput) { LongVector vector = castBlock.asVector(); if (vector == null) { try (IntBlock groupIds = add(castBlock)) { - addInput.add(0, groupIds); + addInput.addSpecific(0, groupIds); } return; } try (IntBlock groupIds = add(vector)) { - addInput.add(0, groupIds); + addInput.addSpecific(0, groupIds); } } From fb670bdbbcf0ad4e29e22a4e5e48853775d1a87c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Wed, 30 Apr 2025 13:41:17 +0200 Subject: [PATCH 23/39] Implement custom add in HashAggregationOperator --- .../operator/HashAggregationOperator.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/HashAggregationOperator.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/HashAggregationOperator.java index 75d5a5bc51323..7d3caa2a3dcff 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/HashAggregationOperator.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/HashAggregationOperator.java @@ -20,8 +20,11 @@ import org.elasticsearch.compute.aggregation.GroupingAggregatorFunction; import org.elasticsearch.compute.aggregation.blockhash.BlockHash; import org.elasticsearch.compute.data.Block; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.Page; import org.elasticsearch.core.Releasables; import org.elasticsearch.core.TimeValue; @@ -158,6 +161,30 @@ public void add(int positionOffset, IntBlock groupIds) { } } + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + IntVector groupIdsVector = groupIds.asVector(); + add(positionOffset, groupIdsVector); + } + + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + startAggEndHash(); + for (GroupingAggregatorFunction.AddInput p : prepared) { + p.add(positionOffset, groupIds); + } + end(); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + startAggEndHash(); + for (GroupingAggregatorFunction.AddInput p : prepared) { + p.add(positionOffset, groupIds); + } + end(); + } + @Override public void add(int positionOffset, IntVector groupIds) { startAggEndHash(); From fd97a8c3d0db55690dacf9948ca635f1cb17f5c5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Mon, 5 May 2025 13:24:27 +0200 Subject: [PATCH 24/39] Updated new aggs --- ...rTimeDoubleGroupingAggregatorFunction.java | 173 ++++++++++++++++-- ...erTimeFloatGroupingAggregatorFunction.java | 173 ++++++++++++++++-- ...OverTimeIntGroupingAggregatorFunction.java | 173 ++++++++++++++++-- ...verTimeLongGroupingAggregatorFunction.java | 173 ++++++++++++++++-- .../compute/data/sort/X-BucketedSort.java.st | 2 +- 5 files changed, 641 insertions(+), 53 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeDoubleGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeDoubleGroupingAggregatorFunction.java index b9ee302f45b24..311cfa0cfc7e4 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeDoubleGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeDoubleGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.DoubleBlock; import org.elasticsearch.compute.data.DoubleVector; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -76,6 +79,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); @@ -92,6 +110,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); @@ -103,31 +136,45 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, DoubleBlock values, + private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + int 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++) { + FirstOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, DoubleVector values, + private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + 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; + FirstOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values, + private void addRawInput(int positionOffset, IntArrayBlock groups, DoubleBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -149,7 +196,45 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleBlock values } } - private void addRawInput(int positionOffset, IntBlock groups, DoubleVector values, + private void addRawInput(int positionOffset, IntArrayBlock 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; + FirstOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock 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++) { + FirstOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, DoubleVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -165,6 +250,68 @@ private void addRawInput(int positionOffset, IntBlock groups, DoubleVector value } } + private void addRawInput(int positionOffset, IntBigArrayBlock 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++) { + FirstOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(v), values.getDouble(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock 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; + FirstOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + } + } + } + + 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++) { + FirstOverTimeDoubleAggregator.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; + FirstOverTimeDoubleAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getDouble(valuePosition)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeFloatGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeFloatGroupingAggregatorFunction.java index ad3f37cd22a00..4d4f0d761ff0a 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeFloatGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeFloatGroupingAggregatorFunction.java @@ -13,8 +13,11 @@ import org.elasticsearch.compute.data.ElementType; import org.elasticsearch.compute.data.FloatBlock; import org.elasticsearch.compute.data.FloatVector; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -76,6 +79,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); @@ -92,6 +110,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); @@ -103,31 +136,45 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, FloatBlock values, + private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + int 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++) { + FirstOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, FloatVector values, + private void addRawInput(int positionOffset, IntBlock groups, FloatVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + 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; + FirstOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values, + private void addRawInput(int positionOffset, IntArrayBlock groups, FloatBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -149,7 +196,45 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatBlock values, } } - private void addRawInput(int positionOffset, IntBlock groups, FloatVector values, + private void addRawInput(int positionOffset, IntArrayBlock 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; + FirstOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock 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++) { + FirstOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, FloatVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -165,6 +250,68 @@ private void addRawInput(int positionOffset, IntBlock groups, FloatVector values } } + private void addRawInput(int positionOffset, IntBigArrayBlock 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++) { + FirstOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(v), values.getFloat(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock 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; + FirstOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + } + } + } + + 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++) { + FirstOverTimeFloatAggregator.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; + FirstOverTimeFloatAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getFloat(valuePosition)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeIntGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeIntGroupingAggregatorFunction.java index 9253aa51831b2..ad2822f0ebfeb 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeIntGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeIntGroupingAggregatorFunction.java @@ -11,8 +11,11 @@ import java.util.List; import org.elasticsearch.compute.data.Block; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -74,6 +77,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); @@ -90,6 +108,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); @@ -101,31 +134,45 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, IntBlock values, + private void addRawInput(int positionOffset, IntBlock groups, IntBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + int 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++) { + FirstOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, IntVector values, + private void addRawInput(int positionOffset, IntBlock groups, IntVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + 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; + FirstOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, IntBlock values, + private void addRawInput(int positionOffset, IntArrayBlock groups, IntBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -147,7 +194,45 @@ private void addRawInput(int positionOffset, IntBlock groups, IntBlock values, } } - private void addRawInput(int positionOffset, IntBlock groups, IntVector values, + private void addRawInput(int positionOffset, IntArrayBlock 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; + FirstOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock 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++) { + FirstOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, IntVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -163,6 +248,68 @@ private void addRawInput(int positionOffset, IntBlock groups, IntVector values, } } + private void addRawInput(int positionOffset, IntBigArrayBlock 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++) { + FirstOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(v), values.getInt(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock 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; + FirstOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + } + } + } + + 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++) { + FirstOverTimeIntAggregator.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; + FirstOverTimeIntAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getInt(valuePosition)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeLongGroupingAggregatorFunction.java b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeLongGroupingAggregatorFunction.java index e5a372c767b73..26e823e8ff992 100644 --- a/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeLongGroupingAggregatorFunction.java +++ b/x-pack/plugin/esql/compute/src/main/generated/org/elasticsearch/compute/aggregation/FirstOverTimeLongGroupingAggregatorFunction.java @@ -11,8 +11,11 @@ import java.util.List; import org.elasticsearch.compute.data.Block; import org.elasticsearch.compute.data.ElementType; +import org.elasticsearch.compute.data.IntArrayBlock; +import org.elasticsearch.compute.data.IntBigArrayBlock; import org.elasticsearch.compute.data.IntBlock; import org.elasticsearch.compute.data.IntVector; +import org.elasticsearch.compute.data.IntVectorBlock; import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; @@ -74,6 +77,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesBlock, timestampsVector); @@ -90,6 +108,21 @@ public void add(int positionOffset, IntBlock groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); } + @Override + public void add(int positionOffset, IntArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntVectorBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + + @Override + public void add(int positionOffset, IntBigArrayBlock groupIds) { + addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); + } + @Override public void add(int positionOffset, IntVector groupIds) { addRawInput(positionOffset, groupIds, valuesVector, timestampsVector); @@ -101,31 +134,45 @@ public void close() { }; } - private void addRawInput(int positionOffset, IntVector groups, LongBlock values, + private void addRawInput(int positionOffset, IntBlock groups, LongBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - if (values.isNull(groupPosition + positionOffset)) { + if (groups.isNull(groupPosition)) { continue; } - int valuesStart = values.getFirstValueIndex(groupPosition + positionOffset); - int valuesEnd = valuesStart + values.getValueCount(groupPosition + positionOffset); - for (int v = valuesStart; v < valuesEnd; v++) { - FirstOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + int 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++) { + FirstOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + } } } } - private void addRawInput(int positionOffset, IntVector groups, LongVector values, + private void addRawInput(int positionOffset, IntBlock groups, LongVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { - int groupId = groups.getInt(groupPosition); - var valuePosition = groupPosition + positionOffset; - FirstOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + 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; + FirstOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + } } } - private void addRawInput(int positionOffset, IntBlock groups, LongBlock values, + private void addRawInput(int positionOffset, IntArrayBlock groups, LongBlock values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -147,7 +194,45 @@ private void addRawInput(int positionOffset, IntBlock groups, LongBlock values, } } - private void addRawInput(int positionOffset, IntBlock groups, LongVector values, + private void addRawInput(int positionOffset, IntArrayBlock 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; + FirstOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock 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++) { + FirstOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntVectorBlock groups, LongVector values, LongVector timestamps) { for (int groupPosition = 0; groupPosition < groups.getPositionCount(); groupPosition++) { if (groups.isNull(groupPosition)) { @@ -163,6 +248,68 @@ private void addRawInput(int positionOffset, IntBlock groups, LongVector values, } } + private void addRawInput(int positionOffset, IntBigArrayBlock 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++) { + FirstOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(v), values.getLong(v)); + } + } + } + } + + private void addRawInput(int positionOffset, IntBigArrayBlock 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; + FirstOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + } + } + } + + 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++) { + FirstOverTimeLongAggregator.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; + FirstOverTimeLongAggregator.combine(state, groupId, timestamps.getLong(valuePosition), values.getLong(valuePosition)); + } + } + @Override public void selectedMayContainUnseenGroups(SeenGroupIds seenGroupIds) { state.enableGroupIdTracking(seenGroupIds); diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/X-BucketedSort.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/X-BucketedSort.java.st index f20d5320a5d76..4e40aece04809 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/X-BucketedSort.java.st +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/X-BucketedSort.java.st @@ -162,7 +162,7 @@ public class $Type$BucketedSort implements Releasable { long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); long end = rootIndex + bucketSize; - return (int) (end - start); + return (int) (end - start); } /** From ddb6735bb6c6f554fa9a929083e962b00f249fab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Mon, 5 May 2025 16:35:36 +0200 Subject: [PATCH 25/39] Added custom sorted structure --- .../common/util/BinarySearcher.java | 2 +- .../blockhash/LongTopNBlockHash.java | 35 ++-- .../compute/data/sort/LongTopNUniqueSort.java | 164 ++++++++++++++++++ 3 files changed, 176 insertions(+), 25 deletions(-) create mode 100644 x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java diff --git a/server/src/main/java/org/elasticsearch/common/util/BinarySearcher.java b/server/src/main/java/org/elasticsearch/common/util/BinarySearcher.java index 173399619017e..ea39060447e12 100644 --- a/server/src/main/java/org/elasticsearch/common/util/BinarySearcher.java +++ b/server/src/main/java/org/elasticsearch/common/util/BinarySearcher.java @@ -38,7 +38,7 @@ public abstract class BinarySearcher { /** * @return the index who's underlying value is closest to the value being searched for. */ - private int getClosestIndex(int index1, int index2) { + protected int getClosestIndex(int index1, int index2) { if (distance(index1) < distance(index2)) { return index1; } else { diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index deee38a324c5d..118714be054ec 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -20,6 +20,7 @@ import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; import org.elasticsearch.compute.data.sort.LongBucketedSort; +import org.elasticsearch.compute.data.sort.LongTopNUniqueSort; import org.elasticsearch.compute.operator.mvdedupe.MultivalueDedupe; import org.elasticsearch.compute.operator.mvdedupe.TopNMultivalueDedupeLong; import org.elasticsearch.core.ReleasableIterator; @@ -38,7 +39,7 @@ public final class LongTopNBlockHash extends BlockHash { private final boolean nullsFirst; private final int limit; private final LongHash hash; - private LongBucketedSort topValues; + private LongTopNUniqueSort topValues; private final LongHash seenUniqueValues; /** * Helper field to keep track of the last top value, and avoid expensive searches. @@ -63,7 +64,7 @@ public LongTopNBlockHash(int channel, boolean asc, boolean nullsFirst, int limit this.nullsFirst = nullsFirst; this.limit = limit; this.hash = new LongHash(1, blockFactory.bigArrays()); - this.topValues = new LongBucketedSort(blockFactory.bigArrays(), asc ? SortOrder.ASC : SortOrder.DESC, limit); + this.topValues = new LongTopNUniqueSort(blockFactory.bigArrays(), asc ? SortOrder.ASC : SortOrder.DESC, limit); this.seenUniqueValues = new LongHash(1, blockFactory.bigArrays()); this.lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; this.valuesInTop = 0; @@ -111,7 +112,7 @@ private boolean acceptNull() { if (valuesInTop == 0) { lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; } else { - lastTopValue = topValues.getWorstValue(0); + lastTopValue = topValues.getWorstValue(); } } return true; @@ -139,11 +140,11 @@ private boolean acceptValue(long value) { return true; } - topValues.collect(value, 0); + topValues.collect(value); valuesInTop = Math.min(valuesInTop + 1, limit - (hasNull && nullsFirst ? 1 : 0)); if (valuesInTop == limit) { - lastTopValue = topValues.getWorstValue(0); + lastTopValue = topValues.getWorstValue(); } else if (valuesInTop == 1 || isBetterThan(lastTopValue, value)) { lastTopValue = value; } @@ -154,7 +155,7 @@ private boolean acceptValue(long value) { if (valuesInTop == 1) { lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; } else { - lastTopValue = topValues.getWorstValue(0); + lastTopValue = topValues.getWorstValue(); } } else { hasNull = false; @@ -169,24 +170,10 @@ private boolean acceptValue(long value) { */ private void migrateToSmallTop() { assert nullsFirst : "The small top is only used when nulls are first"; - assert topValues.getBucketSize() == limit : "The top values can't be migrated twice"; - - LongBucketedSort oldTopValues = topValues; - LongBucketedSort newTopValues = new LongBucketedSort(blockFactory.bigArrays(), topValues.getOrder(), limit - 1); - try { - newTopValues.merge(0, topValues, 0); - - topValues = newTopValues; - valuesInTop = Math.min(valuesInTop, limit - 1); - } finally { - if (topValues == oldTopValues) { - // If there was an error, close the new sort - newTopValues.close(); - } else { - // Otherwise, close the old one - oldTopValues.close(); - } - } + assert topValues.getLimit() == limit : "The top values can't be migrated twice"; + + topValues.reduceLimitByOne(); + valuesInTop = Math.min(valuesInTop, limit - 1); } private boolean isBetterThan(long value, long other) { diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java new file mode 100644 index 0000000000000..9133a7c513f41 --- /dev/null +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java @@ -0,0 +1,164 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +package org.elasticsearch.compute.data.sort; + +import org.elasticsearch.common.util.BigArrays; +import org.elasticsearch.common.util.BinarySearcher; +import org.elasticsearch.common.util.LongArray; +import org.elasticsearch.core.Releasable; +import org.elasticsearch.core.Releasables; +import org.elasticsearch.search.sort.BucketedSort; +import org.elasticsearch.search.sort.SortOrder; + +/** + * Aggregates the top N long values per bucket. + * See {@link BucketedSort} for more information. + * This class is generated. Edit @{code X-BucketedSort.java.st} instead of this file. + */ +public class LongTopNUniqueSort implements Releasable { + + private final BigArrays bigArrays; + private final SortOrder order; + private int limit; + + private final LongArray values; + private final LongBinarySearcher searcher; + + private int count; + + public LongTopNUniqueSort(BigArrays bigArrays, SortOrder order, int limit) { + this.bigArrays = bigArrays; + this.order = order; + this.limit = limit; + this.values = bigArrays.newLongArray(limit, false); + this.searcher = new LongBinarySearcher(values, order); + this.count = 0; + } + + public void collect(long value) { + if (limit == 0) { + return; + } + + // Short-circuit if the value is worse than the worst value on the top. + // This avoids a O(log(n)) check in the binary search + if (count == limit && betterThan(values.get(count - 1), value)) { + return; + } + + if (count == 0) { + values.set(0, value); + count++; + return; + } + + int insertionIndex = this.searcher.search(0, count - 1, value); + + if (insertionIndex == count - 1) { + if (betterThan(values.get(count - 1), value)) { + values.set(count, value); + count++; + return; + } + } + + if (values.get(insertionIndex) == value) { + // Only unique values are stored here + return; + } + + // The searcher returns the upper bound, so we move right the elements from there + for (int i = Math.min(count, limit - 1); i > insertionIndex; i--) { + values.set(i, values.get(i - 1)); + } + + values.set(insertionIndex, value); + count = Math.min(count + 1, limit); + } + + /** + * Reduces the limit of the top N by 1. + *

+ * This method is specifically used to count for the null value, and ignore the extra element here without extra cost. + *

+ */ + public void reduceLimitByOne() { + limit--; + count = Math.min(count, limit); + } + + public long getWorstValue() { + assert count > 0; + return values.get(count - 1); + } + + /** + * The order of the sort. + */ + public SortOrder getOrder() { + return order; + } + + public int getLimit() { + return limit; + } + + public int getCount() { + return count; + } + + private static class LongBinarySearcher extends BinarySearcher { + + final LongArray array; + final SortOrder order; + long searchFor; + + LongBinarySearcher(LongArray array, SortOrder order) { + this.array = array; + this.order = order; + this.searchFor = Integer.MIN_VALUE; + } + + @Override + protected int compare(int index) { + // Prevent use of BinarySearcher.search() and force the use of DoubleBinarySearcher.search() + assert this.searchFor != Integer.MIN_VALUE; + + return order.reverseMul() * Long.compare(array.get(index), searchFor); + } + + @Override + protected int getClosestIndex(int index1, int index2) { + // Overridden to always return the upper bound + return Math.max(index1, index2); + } + + @Override + protected double distance(int index) { + throw new UnsupportedOperationException("getClosestIndex() is overridden and doesn't depend on this"); + } + + public int search(int from, int to, long searchFor) { + this.searchFor = searchFor; + return super.search(from, to); + } + } + + /** + * {@code true} if {@code lhs} is "better" than {@code rhs}. + * "Better" in this means "lower" for {@link SortOrder#ASC} and "higher" for {@link SortOrder#DESC}. + */ + private boolean betterThan(long lhs, long rhs) { + return getOrder().reverseMul() * Long.compare(lhs, rhs) < 0; + } + + @Override + public final void close() { + Releasables.close(values); + } +} From 3d8378441a5bf1ac8ee7836fa8cd8344c5d026ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Mon, 5 May 2025 17:03:05 +0200 Subject: [PATCH 26/39] Improve limit migration logic --- .../compute/aggregation/blockhash/LongTopNBlockHash.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 118714be054ec..b3f3ba448aab9 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -107,8 +107,8 @@ private boolean acceptNull() { if (nullsFirst) { hasNull = true; - if (valuesInTop == limit) { - migrateToSmallTop(); + migrateToSmallTop(); + if (valuesInTop == limit - 1) { if (valuesInTop == 0) { lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; } else { @@ -173,7 +173,7 @@ private void migrateToSmallTop() { assert topValues.getLimit() == limit : "The top values can't be migrated twice"; topValues.reduceLimitByOne(); - valuesInTop = Math.min(valuesInTop, limit - 1); + valuesInTop = topValues.getCount(); } private boolean isBetterThan(long value, long other) { From a54ba979456ce756dcd72b4158488ad769e80983 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Tue, 20 May 2025 14:00:28 +0200 Subject: [PATCH 27/39] Spotless --- .../compute/aggregation/blockhash/BlockHashTests.java | 4 ---- 1 file changed, 4 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java index d5465053ee714..3ff3be5086ad4 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/aggregation/blockhash/BlockHashTests.java @@ -33,18 +33,14 @@ import org.elasticsearch.core.ReleasableIterator; import org.elasticsearch.core.Releasables; import org.elasticsearch.xpack.esql.core.util.Holder; -import org.junit.After; import java.util.ArrayList; import java.util.List; import java.util.Locale; -import java.util.Set; import java.util.function.Consumer; import java.util.stream.IntStream; import java.util.stream.LongStream; -import static org.hamcrest.Matchers.arrayWithSize; -import static org.hamcrest.Matchers.either; import static org.hamcrest.Matchers.endsWith; import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.greaterThan; From 8d101fb3f24a5fd4eede68993be2f61a47c5a41c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Wed, 21 May 2025 19:45:02 +0200 Subject: [PATCH 28/39] Remove count var --- .../blockhash/LongTopNBlockHash.java | 28 ++++++++----------- 1 file changed, 12 insertions(+), 16 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 8e56ef9515226..022fcbf0e71a4 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -41,10 +41,9 @@ public final class LongTopNBlockHash extends BlockHash { private LongTopNUniqueSort topValues; private final LongHash seenUniqueValues; /** - * Helper field to keep track of the last top value, and avoid expensive searches. + * Helper field to keep track of the last top value, and avoid expensive accesses. */ private long lastTopValue; - private int valuesInTop; /** * Have we seen any {@code null} values? @@ -66,7 +65,6 @@ public LongTopNBlockHash(int channel, boolean asc, boolean nullsFirst, int limit this.topValues = new LongTopNUniqueSort(blockFactory.bigArrays(), asc ? SortOrder.ASC : SortOrder.DESC, limit); this.seenUniqueValues = new LongHash(1, blockFactory.bigArrays()); this.lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; - this.valuesInTop = 0; assert limit > 0 : "LongTopNBlockHash requires a limit greater than 0"; } @@ -107,8 +105,8 @@ private boolean acceptNull() { if (nullsFirst) { hasNull = true; migrateToSmallTop(); - if (valuesInTop == limit - 1) { - if (valuesInTop == 0) { + if (topValues.getCount() == limit - 1) { + if (topValues.getCount() == 0) { lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; } else { lastTopValue = topValues.getWorstValue(); @@ -117,7 +115,7 @@ private boolean acceptNull() { return true; } - if (valuesInTop < limit) { + if (topValues.getCount() < limit) { hasNull = true; return true; } @@ -141,17 +139,16 @@ private boolean acceptValue(long value) { topValues.collect(value); - valuesInTop = Math.min(valuesInTop + 1, limit - (hasNull && nullsFirst ? 1 : 0)); - if (valuesInTop == limit) { + if (topValues.getCount() == limit) { lastTopValue = topValues.getWorstValue(); - } else if (valuesInTop == 1 || isBetterThan(lastTopValue, value)) { + } else if (topValues.getCount() == 1 || isBetterThan(lastTopValue, value)) { lastTopValue = value; } // Full top and null, there's an extra value/null we must remove - if (valuesInTop == limit && hasNull) { + if (topValues.getCount() == limit && hasNull) { if (nullsFirst) { - if (valuesInTop == 1) { + if (topValues.getCount() == 1) { lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; } else { lastTopValue = topValues.getWorstValue(); @@ -172,7 +169,6 @@ private void migrateToSmallTop() { assert topValues.getLimit() == limit : "The top values can't be migrated twice"; topValues.reduceLimitByOne(); - valuesInTop = topValues.getCount(); } private boolean isBetterThan(long value, long other) { @@ -200,7 +196,7 @@ private boolean isInTop(long value) { * Returns true if there are {@code limit} values in the blockhash; false otherwise. */ private boolean isTopComplete() { - return valuesInTop >= limit - (hasNull ? 1 : 0); + return topValues.getCount() >= limit - (hasNull ? 1 : 0); } /** @@ -296,7 +292,7 @@ private IntBlock lookup(LongBlock block) { @Override public LongBlock[] getKeys() { if (hasNull) { - final long[] keys = new long[valuesInTop + 1]; + final long[] keys = new long[topValues.getCount() + 1]; int keysIndex = 1; for (int i = 1; i < hash.size() + 1; i++) { long value = hash.get(i - 1); @@ -309,7 +305,7 @@ public LongBlock[] getKeys() { return new LongBlock[] { blockFactory.newLongArrayBlock(keys, keys.length, null, nulls, Block.MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING) }; } - final long[] keys = new long[valuesInTop]; + final long[] keys = new long[topValues.getCount()]; int keysIndex = 0; for (int i = 0; i < hash.size(); i++) { long value = hash.get(i); @@ -323,7 +319,7 @@ public LongBlock[] getKeys() { @Override public IntVector nonEmpty() { int nullOffset = hasNull ? 1 : 0; - final int[] ids = new int[valuesInTop + nullOffset]; + final int[] ids = new int[topValues.getCount() + nullOffset]; int idsIndex = nullOffset; // TODO: Can we instead iterate the top and take the ids from the hash? To avoid checking unused values for (int i = 1; i < hash.size() + 1; i++) { From c27faa0d7ac393bd1949d81c5bbe9c4aef1f1c98 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Thu, 22 May 2025 13:09:29 +0200 Subject: [PATCH 29/39] Removed lastValue field --- .../blockhash/LongTopNBlockHash.java | 52 +++---------------- .../compute/data/sort/LongTopNUniqueSort.java | 22 ++++---- 2 files changed, 17 insertions(+), 57 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 022fcbf0e71a4..9867f7f6f5c5f 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -38,12 +38,7 @@ public final class LongTopNBlockHash extends BlockHash { private final boolean nullsFirst; private final int limit; private final LongHash hash; - private LongTopNUniqueSort topValues; - private final LongHash seenUniqueValues; - /** - * Helper field to keep track of the last top value, and avoid expensive accesses. - */ - private long lastTopValue; + private final LongTopNUniqueSort topValues; /** * Have we seen any {@code null} values? @@ -63,8 +58,6 @@ public LongTopNBlockHash(int channel, boolean asc, boolean nullsFirst, int limit this.limit = limit; this.hash = new LongHash(1, blockFactory.bigArrays()); this.topValues = new LongTopNUniqueSort(blockFactory.bigArrays(), asc ? SortOrder.ASC : SortOrder.DESC, limit); - this.seenUniqueValues = new LongHash(1, blockFactory.bigArrays()); - this.lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; assert limit > 0 : "LongTopNBlockHash requires a limit greater than 0"; } @@ -105,13 +98,6 @@ private boolean acceptNull() { if (nullsFirst) { hasNull = true; migrateToSmallTop(); - if (topValues.getCount() == limit - 1) { - if (topValues.getCount() == 0) { - lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; - } else { - lastTopValue = topValues.getWorstValue(); - } - } return true; } @@ -127,35 +113,13 @@ private boolean acceptNull() { * Tries to add the value to the top values, and returns true if it was successful. */ private boolean acceptValue(long value) { - // Ignore values that are worse than the current worst value - if (isAcceptable(value) == false) { + if (topValues.collect(value) == false) { return false; } - // O(1) operation to check if the value is already in the hash, and avoid adding it again - if (seenUniqueValues.add(value) < 0) { - return true; - } - - topValues.collect(value); - - if (topValues.getCount() == limit) { - lastTopValue = topValues.getWorstValue(); - } else if (topValues.getCount() == 1 || isBetterThan(lastTopValue, value)) { - lastTopValue = value; - } - // Full top and null, there's an extra value/null we must remove - if (topValues.getCount() == limit && hasNull) { - if (nullsFirst) { - if (topValues.getCount() == 1) { - lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE; - } else { - lastTopValue = topValues.getWorstValue(); - } - } else { - hasNull = false; - } + if (topValues.getCount() == limit && hasNull && nullsFirst == false) { + hasNull = false; } return true; @@ -171,10 +135,6 @@ private void migrateToSmallTop() { topValues.reduceLimitByOne(); } - private boolean isBetterThan(long value, long other) { - return asc ? value < other : value > other; - } - /** * Returns true if the value is in, or can be added to the top; false otherwise. */ @@ -189,7 +149,7 @@ private boolean isAcceptable(long value) { *

*/ private boolean isInTop(long value) { - return asc ? value <= lastTopValue : value >= lastTopValue; + return asc ? value <= topValues.getWorstValue() : value >= topValues.getWorstValue(); } /** @@ -349,7 +309,7 @@ public BitArray seenGroupIds(BigArrays bigArrays) { @Override public void close() { - Releasables.close(hash, topValues, seenUniqueValues); + Releasables.close(hash, topValues); } @Override diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java index 9133a7c513f41..cc070cb95c0a2 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java @@ -22,7 +22,6 @@ */ public class LongTopNUniqueSort implements Releasable { - private final BigArrays bigArrays; private final SortOrder order; private int limit; @@ -32,44 +31,43 @@ public class LongTopNUniqueSort implements Releasable { private int count; public LongTopNUniqueSort(BigArrays bigArrays, SortOrder order, int limit) { - this.bigArrays = bigArrays; this.order = order; this.limit = limit; + this.count = 0; this.values = bigArrays.newLongArray(limit, false); this.searcher = new LongBinarySearcher(values, order); - this.count = 0; } - public void collect(long value) { + public boolean collect(long value) { if (limit == 0) { - return; + return false; } // Short-circuit if the value is worse than the worst value on the top. // This avoids a O(log(n)) check in the binary search - if (count == limit && betterThan(values.get(count - 1), value)) { - return; + if (count == limit && betterThan(getWorstValue(), value)) { + return false; } if (count == 0) { values.set(0, value); count++; - return; + return true; } int insertionIndex = this.searcher.search(0, count - 1, value); if (insertionIndex == count - 1) { - if (betterThan(values.get(count - 1), value)) { + if (betterThan(getWorstValue(), value)) { values.set(count, value); count++; - return; + return true; } } if (values.get(insertionIndex) == value) { // Only unique values are stored here - return; + return true; } // The searcher returns the upper bound, so we move right the elements from there @@ -79,6 +77,8 @@ public void collect(long value) { values.set(insertionIndex, value); count = Math.min(count + 1, limit); + + return true; } /** From 9cff74428ab1282ccd61fa5d0507d6320f203e95 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Thu, 22 May 2025 15:19:21 +0200 Subject: [PATCH 30/39] Added LonghHash for early detection of existing values --- .../compute/data/sort/LongTopNUniqueSort.java | 26 ++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java index cc070cb95c0a2..397cb35749826 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java @@ -10,6 +10,7 @@ import org.elasticsearch.common.util.BigArrays; import org.elasticsearch.common.util.BinarySearcher; import org.elasticsearch.common.util.LongArray; +import org.elasticsearch.common.util.LongHash; import org.elasticsearch.core.Releasable; import org.elasticsearch.core.Releasables; import org.elasticsearch.search.sort.BucketedSort; @@ -27,6 +28,11 @@ public class LongTopNUniqueSort implements Releasable { private final LongArray values; private final LongBinarySearcher searcher; + /** + * Hash holding the unique seen values. + * Adding is an O(1) operation to check if the new value is already in the top, and avoid trying to add it again, which is O(log(n)). + */ + private final LongHash seenUniqueValues; private int count; @@ -34,8 +40,18 @@ public LongTopNUniqueSort(BigArrays bigArrays, SortOrder order, int limit) { this.order = order; this.limit = limit; this.count = 0; - this.values = bigArrays.newLongArray(limit, false); - this.searcher = new LongBinarySearcher(values, order); + + boolean success = false; + try { + this.values = bigArrays.newLongArray(limit, false); + this.seenUniqueValues = new LongHash(1, bigArrays); + this.searcher = new LongBinarySearcher(values, order); + success = true; + } finally { + if (success == false) { + close(); + } + } } public boolean collect(long value) { @@ -49,6 +65,10 @@ public boolean collect(long value) { return false; } + if (seenUniqueValues.add(value) < 0) { + return true; + } + if (count == 0) { values.set(0, value); count++; @@ -159,6 +179,6 @@ private boolean betterThan(long lhs, long rhs) { @Override public final void close() { - Releasables.close(values); + Releasables.close(values, seenUniqueValues); } } From 22da89ede4cc060698b7724bf54b2a09ffd411bc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Thu, 22 May 2025 15:21:05 +0200 Subject: [PATCH 31/39] Revert "Added LonghHash for early detection of existing values" This reverts commit 9cff74428ab1282ccd61fa5d0507d6320f203e95. --- .../compute/data/sort/LongTopNUniqueSort.java | 26 +++---------------- 1 file changed, 3 insertions(+), 23 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java index 397cb35749826..cc070cb95c0a2 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java @@ -10,7 +10,6 @@ import org.elasticsearch.common.util.BigArrays; import org.elasticsearch.common.util.BinarySearcher; import org.elasticsearch.common.util.LongArray; -import org.elasticsearch.common.util.LongHash; import org.elasticsearch.core.Releasable; import org.elasticsearch.core.Releasables; import org.elasticsearch.search.sort.BucketedSort; @@ -28,11 +27,6 @@ public class LongTopNUniqueSort implements Releasable { private final LongArray values; private final LongBinarySearcher searcher; - /** - * Hash holding the unique seen values. - * Adding is an O(1) operation to check if the new value is already in the top, and avoid trying to add it again, which is O(log(n)). - */ - private final LongHash seenUniqueValues; private int count; @@ -40,18 +34,8 @@ public LongTopNUniqueSort(BigArrays bigArrays, SortOrder order, int limit) { this.order = order; this.limit = limit; this.count = 0; - - boolean success = false; - try { - this.values = bigArrays.newLongArray(limit, false); - this.seenUniqueValues = new LongHash(1, bigArrays); - this.searcher = new LongBinarySearcher(values, order); - success = true; - } finally { - if (success == false) { - close(); - } - } + this.values = bigArrays.newLongArray(limit, false); + this.searcher = new LongBinarySearcher(values, order); } public boolean collect(long value) { @@ -65,10 +49,6 @@ public boolean collect(long value) { return false; } - if (seenUniqueValues.add(value) < 0) { - return true; - } - if (count == 0) { values.set(0, value); count++; @@ -179,6 +159,6 @@ private boolean betterThan(long lhs, long rhs) { @Override public final void close() { - Releasables.close(values, seenUniqueValues); + Releasables.close(values); } } From ed18e7c7d32d4bece3211282219d01b74239c6e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Wed, 28 May 2025 14:50:11 +0200 Subject: [PATCH 32/39] Make operator tests not depend directly on the BlockHash implementation --- .../blockhash/LongTopNBlockHash.java | 3 +-- .../HashAggregationOperatorTests.java | 21 +++++++++++-------- 2 files changed, 13 insertions(+), 11 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 9867f7f6f5c5f..35573c39840c7 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -31,8 +31,7 @@ /** * Maps a {@link LongBlock} column to group ids, keeping only the top N values. */ -// TODO: package-private instead of public? -public final class LongTopNBlockHash extends BlockHash { +final class LongTopNBlockHash extends BlockHash { private final int channel; private final boolean asc; private final boolean nullsFirst; diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java index 9c53ccb13fc87..ec84d17045af4 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/operator/HashAggregationOperatorTests.java @@ -15,7 +15,6 @@ import org.elasticsearch.compute.aggregation.SumLongAggregatorFunctionSupplier; import org.elasticsearch.compute.aggregation.SumLongGroupingAggregatorFunctionTests; import org.elasticsearch.compute.aggregation.blockhash.BlockHash; -import org.elasticsearch.compute.aggregation.blockhash.LongTopNBlockHash; import org.elasticsearch.compute.data.Block; import org.elasticsearch.compute.data.BlockFactory; import org.elasticsearch.compute.data.BlockUtils; @@ -113,14 +112,16 @@ public void testTopNNullsLast() { var aggregatorChannels = List.of(1); try ( - var operator = new HashAggregationOperator( + var operator = new HashAggregationOperator.HashAggregationOperatorFactory( + List.of(new BlockHash.GroupSpec(groupChannel, ElementType.LONG, false, new BlockHash.TopNDef(0, ascOrder, false, 3))), + mode, List.of( new SumLongAggregatorFunctionSupplier().groupingAggregatorFactory(mode, aggregatorChannels), new MaxLongAggregatorFunctionSupplier().groupingAggregatorFactory(mode, aggregatorChannels) ), - () -> new LongTopNBlockHash(groupChannel, ascOrder, false, 3, blockFactory()), - driverContext() - ) + randomPageSize(), + null + ).get(driverContext()) ) { var page = new Page( BlockUtils.fromList( @@ -188,14 +189,16 @@ public void testTopNNullsFirst() { var aggregatorChannels = List.of(1); try ( - var operator = new HashAggregationOperator( + var operator = new HashAggregationOperator.HashAggregationOperatorFactory( + List.of(new BlockHash.GroupSpec(groupChannel, ElementType.LONG, false, new BlockHash.TopNDef(0, ascOrder, true, 3))), + mode, List.of( new SumLongAggregatorFunctionSupplier().groupingAggregatorFactory(mode, aggregatorChannels), new MaxLongAggregatorFunctionSupplier().groupingAggregatorFactory(mode, aggregatorChannels) ), - () -> new LongTopNBlockHash(groupChannel, ascOrder, true, 3, blockFactory()), - driverContext() - ) + randomPageSize(), + null + ).get(driverContext()) ) { var page = new Page( BlockUtils.fromList( From 16c88eb968ca3315a6755900d36cd62c2950b4e0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Wed, 28 May 2025 16:57:51 +0200 Subject: [PATCH 33/39] Restore original BucketedSort --- .../compute/data/sort/DoubleBucketedSort.java | 49 ------------------- .../compute/data/sort/FloatBucketedSort.java | 49 ------------------- .../compute/data/sort/IntBucketedSort.java | 49 ------------------- .../compute/data/sort/LongBucketedSort.java | 49 ------------------- .../compute/data/sort/X-BucketedSort.java.st | 49 ------------------- 5 files changed, 245 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/DoubleBucketedSort.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/DoubleBucketedSort.java index 958afb1863bf9..ca89e6f999641 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/DoubleBucketedSort.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/DoubleBucketedSort.java @@ -91,10 +91,6 @@ public DoubleBucketedSort(BigArrays bigArrays, SortOrder order, int bucketSize) *

*/ public void collect(double value, int bucket) { - if (bucketSize == 0) { - return; - } - long rootIndex = (long) bucket * bucketSize; if (inHeapMode(bucket)) { if (betterThan(value, values.get(rootIndex))) { @@ -150,51 +146,6 @@ private Tuple getBucketValuesIndexes(int bucket) { return Tuple.tuple(start, end); } - /** - * Returns the amount of elements in the given bucket. - */ - public int getBucketCount(int bucket) { - long rootIndex = (long) bucket * bucketSize; - if (rootIndex >= values.size()) { - // We've never seen this bucket. - return 0; - } - long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); - long end = rootIndex + bucketSize; - - return (int) (end - start); - } - - /** - * Returns the worst value in the given bucket. - *

- * This method shouldn't be called if the bucket is empty. - *

- *

- * This method is O(1) if the bucket is full; O(n) otherwise. - *

- */ - public double getWorstValue(int bucket) { - assert getBucketCount(bucket) > 0 : "Cannot get the worst value of an empty bucket"; - - long rootIndex = (long) bucket * bucketSize; - long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); - long end = rootIndex + bucketSize; - - if (inHeapMode(bucket)) { - return values.get(start); - } - - double worstValue = values.get(start); - for (long i = start + 1; i < end; i++) { - if (betterThan(worstValue, values.get(i))) { - worstValue = values.get(i); - } - } - - return worstValue; - } - /** * Merge the values from {@code other}'s {@code otherGroupId} into {@code groupId}. */ diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/FloatBucketedSort.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/FloatBucketedSort.java index 0006eece592c4..2bf8edd99f48c 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/FloatBucketedSort.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/FloatBucketedSort.java @@ -91,10 +91,6 @@ public FloatBucketedSort(BigArrays bigArrays, SortOrder order, int bucketSize) { *

*/ public void collect(float value, int bucket) { - if (bucketSize == 0) { - return; - } - long rootIndex = (long) bucket * bucketSize; if (inHeapMode(bucket)) { if (betterThan(value, values.get(rootIndex))) { @@ -150,51 +146,6 @@ private Tuple getBucketValuesIndexes(int bucket) { return Tuple.tuple(start, end); } - /** - * Returns the amount of elements in the given bucket. - */ - public int getBucketCount(int bucket) { - long rootIndex = (long) bucket * bucketSize; - if (rootIndex >= values.size()) { - // We've never seen this bucket. - return 0; - } - long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); - long end = rootIndex + bucketSize; - - return (int) (end - start); - } - - /** - * Returns the worst value in the given bucket. - *

- * This method shouldn't be called if the bucket is empty. - *

- *

- * This method is O(1) if the bucket is full; O(n) otherwise. - *

- */ - public float getWorstValue(int bucket) { - assert getBucketCount(bucket) > 0 : "Cannot get the worst value of an empty bucket"; - - long rootIndex = (long) bucket * bucketSize; - long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); - long end = rootIndex + bucketSize; - - if (inHeapMode(bucket)) { - return values.get(start); - } - - float worstValue = values.get(start); - for (long i = start + 1; i < end; i++) { - if (betterThan(worstValue, values.get(i))) { - worstValue = values.get(i); - } - } - - return worstValue; - } - /** * Merge the values from {@code other}'s {@code otherGroupId} into {@code groupId}. */ diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/IntBucketedSort.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/IntBucketedSort.java index cc4e834d89af5..257dfe2ebb0bd 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/IntBucketedSort.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/IntBucketedSort.java @@ -91,10 +91,6 @@ public IntBucketedSort(BigArrays bigArrays, SortOrder order, int bucketSize) { *

*/ public void collect(int value, int bucket) { - if (bucketSize == 0) { - return; - } - long rootIndex = (long) bucket * bucketSize; if (inHeapMode(bucket)) { if (betterThan(value, values.get(rootIndex))) { @@ -150,51 +146,6 @@ private Tuple getBucketValuesIndexes(int bucket) { return Tuple.tuple(start, end); } - /** - * Returns the amount of elements in the given bucket. - */ - public int getBucketCount(int bucket) { - long rootIndex = (long) bucket * bucketSize; - if (rootIndex >= values.size()) { - // We've never seen this bucket. - return 0; - } - long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); - long end = rootIndex + bucketSize; - - return (int) (end - start); - } - - /** - * Returns the worst value in the given bucket. - *

- * This method shouldn't be called if the bucket is empty. - *

- *

- * This method is O(1) if the bucket is full; O(n) otherwise. - *

- */ - public int getWorstValue(int bucket) { - assert getBucketCount(bucket) > 0 : "Cannot get the worst value of an empty bucket"; - - long rootIndex = (long) bucket * bucketSize; - long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); - long end = rootIndex + bucketSize; - - if (inHeapMode(bucket)) { - return values.get(start); - } - - int worstValue = values.get(start); - for (long i = start + 1; i < end; i++) { - if (betterThan(worstValue, values.get(i))) { - worstValue = values.get(i); - } - } - - return worstValue; - } - /** * Merge the values from {@code other}'s {@code otherGroupId} into {@code groupId}. */ diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/LongBucketedSort.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/LongBucketedSort.java index bbaddb9a87a2b..c27467ebb60ff 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/LongBucketedSort.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/sort/LongBucketedSort.java @@ -91,10 +91,6 @@ public LongBucketedSort(BigArrays bigArrays, SortOrder order, int bucketSize) { *

*/ public void collect(long value, int bucket) { - if (bucketSize == 0) { - return; - } - long rootIndex = (long) bucket * bucketSize; if (inHeapMode(bucket)) { if (betterThan(value, values.get(rootIndex))) { @@ -150,51 +146,6 @@ private Tuple getBucketValuesIndexes(int bucket) { return Tuple.tuple(start, end); } - /** - * Returns the amount of elements in the given bucket. - */ - public int getBucketCount(int bucket) { - long rootIndex = (long) bucket * bucketSize; - if (rootIndex >= values.size()) { - // We've never seen this bucket. - return 0; - } - long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); - long end = rootIndex + bucketSize; - - return (int) (end - start); - } - - /** - * Returns the worst value in the given bucket. - *

- * This method shouldn't be called if the bucket is empty. - *

- *

- * This method is O(1) if the bucket is full; O(n) otherwise. - *

- */ - public long getWorstValue(int bucket) { - assert getBucketCount(bucket) > 0 : "Cannot get the worst value of an empty bucket"; - - long rootIndex = (long) bucket * bucketSize; - long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); - long end = rootIndex + bucketSize; - - if (inHeapMode(bucket)) { - return values.get(start); - } - - long worstValue = values.get(start); - for (long i = start + 1; i < end; i++) { - if (betterThan(worstValue, values.get(i))) { - worstValue = values.get(i); - } - } - - return worstValue; - } - /** * Merge the values from {@code other}'s {@code otherGroupId} into {@code groupId}. */ diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/X-BucketedSort.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/X-BucketedSort.java.st index 4e40aece04809..095d48021e9c1 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/X-BucketedSort.java.st +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/X-BucketedSort.java.st @@ -91,10 +91,6 @@ public class $Type$BucketedSort implements Releasable { *

*/ public void collect($type$ value, int bucket) { - if (bucketSize == 0) { - return; - } - long rootIndex = (long) bucket * bucketSize; if (inHeapMode(bucket)) { if (betterThan(value, values.get(rootIndex))) { @@ -150,51 +146,6 @@ public class $Type$BucketedSort implements Releasable { return Tuple.tuple(start, end); } - /** - * Returns the amount of elements in the given bucket. - */ - public int getBucketCount(int bucket) { - long rootIndex = (long) bucket * bucketSize; - if (rootIndex >= values.size()) { - // We've never seen this bucket. - return 0; - } - long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); - long end = rootIndex + bucketSize; - - return (int) (end - start); - } - - /** - * Returns the worst value in the given bucket. - *

- * This method shouldn't be called if the bucket is empty. - *

- *

- * This method is O(1) if the bucket is full; O(n) otherwise. - *

- */ - public $type$ getWorstValue(int bucket) { - assert getBucketCount(bucket) > 0 : "Cannot get the worst value of an empty bucket"; - - long rootIndex = (long) bucket * bucketSize; - long start = inHeapMode(bucket) ? rootIndex : (rootIndex + getNextGatherOffset(rootIndex) + 1); - long end = rootIndex + bucketSize; - - if (inHeapMode(bucket)) { - return values.get(start); - } - - $type$ worstValue = values.get(start); - for (long i = start + 1; i < end; i++) { - if (betterThan(worstValue, values.get(i))) { - worstValue = values.get(i); - } - } - - return worstValue; - } - /** * Merge the values from {@code other}'s {@code otherGroupId} into {@code groupId}. */ From 2b1f868110a8b638ce84161cbea0cdde4fc3c9a8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Wed, 28 May 2025 17:07:41 +0200 Subject: [PATCH 34/39] Improve migration and remove unused BucketedSort test --- .../aggregation/blockhash/LongTopNBlockHash.java | 14 +++----------- .../compute/data/sort/BucketedSortTestCase.java | 16 ---------------- 2 files changed, 3 insertions(+), 27 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 35573c39840c7..656bd0e41e53c 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -96,7 +96,9 @@ private boolean acceptNull() { if (nullsFirst) { hasNull = true; - migrateToSmallTop(); + // Reduce the limit of the sort by one, as it's not filled with a null + assert topValues.getLimit() == limit : "The top values can't be reduced twice"; + topValues.reduceLimitByOne(); return true; } @@ -124,16 +126,6 @@ private boolean acceptValue(long value) { return true; } - /** - * Converts the current BucketedSort to one with {@code limit - 1} values, as one value is a null. - */ - private void migrateToSmallTop() { - assert nullsFirst : "The small top is only used when nulls are first"; - assert topValues.getLimit() == limit : "The top values can't be migrated twice"; - - topValues.reduceLimitByOne(); - } - /** * Returns true if the value is in, or can be added to the top; false otherwise. */ diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/BucketedSortTestCase.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/BucketedSortTestCase.java index 3d92221f32013..2358643dc089e 100644 --- a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/BucketedSortTestCase.java +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/BucketedSortTestCase.java @@ -445,22 +445,6 @@ public final void testMergePastEnd() { } } - public final void testZeroBucketSize() { - try (T sort = build(randomFrom(SortOrder.values()), 0)) { - collect(sort, randomValue(), 0); - - try (T otherSort = build(randomFrom(SortOrder.values()), randomIntBetween(1, 3))) { - for (int i = 0; i < randomIntBetween(0, 3); i++) { - collect(otherSort, randomValue(), 0); - } - - merge(sort, 0, otherSort, 0); - } - - assertBlock(sort, 0, List.of()); - } - } - protected void assertBlock(T sort, int groupId, List values) { var blockFactory = TestBlockFactory.getNonBreakingInstance(); From f0349f4f93cef00a9b5c50ee41c59f65b473f6b0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Wed, 28 May 2025 17:24:21 +0200 Subject: [PATCH 35/39] Remove fixed TO-DOs --- .../compute/aggregation/blockhash/LongTopNBlockHash.java | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 656bd0e41e53c..9716fbf6675c9 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -48,8 +48,7 @@ final class LongTopNBlockHash extends BlockHash { */ private boolean hasNull; - // TODO: package-private instead of public? - public LongTopNBlockHash(int channel, boolean asc, boolean nullsFirst, int limit, BlockFactory blockFactory) { + LongTopNBlockHash(int channel, boolean asc, boolean nullsFirst, int limit, BlockFactory blockFactory) { super(blockFactory); this.channel = channel; this.asc = asc; @@ -272,7 +271,6 @@ public IntVector nonEmpty() { int nullOffset = hasNull ? 1 : 0; final int[] ids = new int[topValues.getCount() + nullOffset]; int idsIndex = nullOffset; - // TODO: Can we instead iterate the top and take the ids from the hash? To avoid checking unused values for (int i = 1; i < hash.size() + 1; i++) { long value = hash.get(i - 1); if (isInTop(value)) { @@ -284,11 +282,10 @@ public IntVector nonEmpty() { @Override public BitArray seenGroupIds(BigArrays bigArrays) { - BitArray seenGroups = new BitArray(111, bigArrays); + BitArray seenGroups = new BitArray(1, bigArrays); if (hasNull) { seenGroups.set(0); } - // TODO: Can we instead iterate the top and take the ids from the hash? To avoid checking unused values for (int i = 1; i < hash.size() + 1; i++) { long value = hash.get(i - 1); if (isInTop(value)) { From e7ebd0589a76a781bd911370973d48f7bd00f3d9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Wed, 28 May 2025 17:29:53 +0200 Subject: [PATCH 36/39] Fix potential memory leak on circuit breaker error --- .../aggregation/blockhash/LongTopNBlockHash.java | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 9716fbf6675c9..91cb436fc5b95 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -50,14 +50,22 @@ final class LongTopNBlockHash extends BlockHash { LongTopNBlockHash(int channel, boolean asc, boolean nullsFirst, int limit, BlockFactory blockFactory) { super(blockFactory); + assert limit > 0 : "LongTopNBlockHash requires a limit greater than 0"; this.channel = channel; this.asc = asc; this.nullsFirst = nullsFirst; this.limit = limit; - this.hash = new LongHash(1, blockFactory.bigArrays()); - this.topValues = new LongTopNUniqueSort(blockFactory.bigArrays(), asc ? SortOrder.ASC : SortOrder.DESC, limit); - assert limit > 0 : "LongTopNBlockHash requires a limit greater than 0"; + boolean success = false; + try { + this.hash = new LongHash(1, blockFactory.bigArrays()); + this.topValues = new LongTopNUniqueSort(blockFactory.bigArrays(), asc ? SortOrder.ASC : SortOrder.DESC, limit); + } finally { + if (success == false) { + close(); + } + } + } @Override From 76291a6fabce99d27ab56f97a00c96b2e1b075e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Thu, 29 May 2025 13:09:29 +0200 Subject: [PATCH 37/39] Renamed topN set and added tests --- .../blockhash/LongTopNBlockHash.java | 6 +- ...ngTopNUniqueSort.java => LongTopNSet.java} | 21 +- .../compute/data/sort/LongTopNSetTests.java | 52 +++++ .../compute/data/sort/TopNSetTestCase.java | 215 ++++++++++++++++++ 4 files changed, 285 insertions(+), 9 deletions(-) rename x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/{LongTopNUniqueSort.java => LongTopNSet.java} (87%) create mode 100644 x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/LongTopNSetTests.java create mode 100644 x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/TopNSetTestCase.java diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 91cb436fc5b95..3e6f3a471ba66 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -19,7 +19,7 @@ import org.elasticsearch.compute.data.LongBlock; import org.elasticsearch.compute.data.LongVector; import org.elasticsearch.compute.data.Page; -import org.elasticsearch.compute.data.sort.LongTopNUniqueSort; +import org.elasticsearch.compute.data.sort.LongTopNSet; import org.elasticsearch.compute.operator.mvdedupe.MultivalueDedupe; import org.elasticsearch.compute.operator.mvdedupe.TopNMultivalueDedupeLong; import org.elasticsearch.core.ReleasableIterator; @@ -37,7 +37,7 @@ final class LongTopNBlockHash extends BlockHash { private final boolean nullsFirst; private final int limit; private final LongHash hash; - private final LongTopNUniqueSort topValues; + private final LongTopNSet topValues; /** * Have we seen any {@code null} values? @@ -59,7 +59,7 @@ final class LongTopNBlockHash extends BlockHash { boolean success = false; try { this.hash = new LongHash(1, blockFactory.bigArrays()); - this.topValues = new LongTopNUniqueSort(blockFactory.bigArrays(), asc ? SortOrder.ASC : SortOrder.DESC, limit); + this.topValues = new LongTopNSet(blockFactory.bigArrays(), asc ? SortOrder.ASC : SortOrder.DESC, limit); } finally { if (success == false) { close(); diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNSet.java similarity index 87% rename from x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java rename to x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNSet.java index cc070cb95c0a2..dda4a20db9db6 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNSet.java @@ -12,15 +12,15 @@ import org.elasticsearch.common.util.LongArray; import org.elasticsearch.core.Releasable; import org.elasticsearch.core.Releasables; -import org.elasticsearch.search.sort.BucketedSort; import org.elasticsearch.search.sort.SortOrder; /** - * Aggregates the top N long values per bucket. - * See {@link BucketedSort} for more information. - * This class is generated. Edit @{code X-BucketedSort.java.st} instead of this file. + * Aggregates the top N collected values, and keeps them sorted. + *

+ * Collection is O(1) for values out of the current top N. For values better than the worst value, it's O(log(n)). + *

*/ -public class LongTopNUniqueSort implements Releasable { +public class LongTopNSet implements Releasable { private final SortOrder order; private int limit; @@ -30,7 +30,7 @@ public class LongTopNUniqueSort implements Releasable { private int count; - public LongTopNUniqueSort(BigArrays bigArrays, SortOrder order, int limit) { + public LongTopNSet(BigArrays bigArrays, SortOrder order, int limit) { this.order = order; this.limit = limit; this.count = 0; @@ -38,6 +38,9 @@ public LongTopNUniqueSort(BigArrays bigArrays, SortOrder order, int limit) { this.searcher = new LongBinarySearcher(values, order); } + /** + * Adds the value to the top N, as long as it is "better" than the worst value, or the top isn't full yet. + */ public boolean collect(long value) { if (limit == 0) { return false; @@ -92,6 +95,12 @@ public void reduceLimitByOne() { count = Math.min(count, limit); } + /** + * Returns the worst value in the top. + *

+ * The worst is the greatest value for {@link SortOrder#ASC}, and the lowest value for {@link SortOrder#DESC}. + *

+ */ public long getWorstValue() { assert count > 0; return values.get(count - 1); diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/LongTopNSetTests.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/LongTopNSetTests.java new file mode 100644 index 0000000000000..364190fdb5d5a --- /dev/null +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/LongTopNSetTests.java @@ -0,0 +1,52 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +package org.elasticsearch.compute.data.sort; + +import org.elasticsearch.common.util.BigArrays; +import org.elasticsearch.search.sort.SortOrder; + +import java.util.List; + +public class LongTopNSetTests extends TopNSetTestCase { + + @Override + protected LongTopNSet build(BigArrays bigArrays, SortOrder sortOrder, int limit) { + return new LongTopNSet(bigArrays, sortOrder, limit); + } + + @Override + protected Long randomValue() { + return randomLong(); + } + + @Override + protected List threeSortedValues() { + return List.of(Long.MIN_VALUE, randomLong(), Long.MAX_VALUE); + } + + @Override + protected void collect(LongTopNSet sort, Long value) { + sort.collect(value); + } + + @Override + protected void reduceLimitByOne(LongTopNSet sort) { + sort.reduceLimitByOne(); + } + + @Override + protected Long getWorstValue(LongTopNSet sort) { + return sort.getWorstValue(); + } + + @Override + protected int getCount(LongTopNSet sort) { + return sort.getCount(); + } + +} diff --git a/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/TopNSetTestCase.java b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/TopNSetTestCase.java new file mode 100644 index 0000000000000..0df1d6047a30e --- /dev/null +++ b/x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/sort/TopNSetTestCase.java @@ -0,0 +1,215 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +package org.elasticsearch.compute.data.sort; + +import org.elasticsearch.common.breaker.CircuitBreaker; +import org.elasticsearch.common.breaker.CircuitBreakingException; +import org.elasticsearch.common.settings.Settings; +import org.elasticsearch.common.util.BigArrays; +import org.elasticsearch.common.util.MockBigArrays; +import org.elasticsearch.common.util.MockPageCacheRecycler; +import org.elasticsearch.common.util.PageCacheRecycler; +import org.elasticsearch.core.Releasable; +import org.elasticsearch.indices.CrankyCircuitBreakerService; +import org.elasticsearch.indices.breaker.NoneCircuitBreakerService; +import org.elasticsearch.search.sort.SortOrder; +import org.elasticsearch.test.ESTestCase; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; + +import static org.hamcrest.Matchers.equalTo; + +public abstract class TopNSetTestCase> extends ESTestCase { + /** + * Build a {@link T} to test. Sorts built by this method shouldn't need scores. + */ + protected abstract T build(BigArrays bigArrays, SortOrder sortOrder, int limit); + + private T build(SortOrder sortOrder, int limit) { + return build(bigArrays(), sortOrder, limit); + } + + /** + * A random value for testing, with the appropriate precision for the type we're testing. + */ + protected abstract V randomValue(); + + /** + * Returns a list of 3 values, in ascending order. + */ + protected abstract List threeSortedValues(); + + /** + * Collect a value into the top. + * + * @param value value to collect, always sent as double just to have + * a number to test. Subclasses should cast to their favorite types + */ + protected abstract void collect(T sort, V value); + + protected abstract void reduceLimitByOne(T sort); + + protected abstract V getWorstValue(T sort); + + protected abstract int getCount(T sort); + + public final void testNeverCalled() { + SortOrder sortOrder = randomFrom(SortOrder.values()); + int limit = randomIntBetween(0, 10); + try (T sort = build(sortOrder, limit)) { + assertResults(sort, sortOrder, limit, List.of()); + } + } + + public final void testLimit0() { + SortOrder sortOrder = randomFrom(SortOrder.values()); + int limit = 0; + try (T sort = build(sortOrder, limit)) { + var values = threeSortedValues(); + + collect(sort, values.get(0)); + collect(sort, values.get(1)); + + assertResults(sort, sortOrder, limit, List.of()); + } + } + + public final void testSingleValue() { + SortOrder sortOrder = randomFrom(SortOrder.values()); + int limit = 1; + try (T sort = build(sortOrder, limit)) { + var values = threeSortedValues(); + + collect(sort, values.get(0)); + + assertResults(sort, sortOrder, limit, List.of(values.get(0))); + } + } + + public final void testNonCompetitive() { + SortOrder sortOrder = SortOrder.DESC; + int limit = 1; + try (T sort = build(sortOrder, limit)) { + var values = threeSortedValues(); + + collect(sort, values.get(1)); + collect(sort, values.get(0)); + + assertResults(sort, sortOrder, limit, List.of(values.get(1))); + } + } + + public final void testCompetitive() { + SortOrder sortOrder = SortOrder.DESC; + int limit = 1; + try (T sort = build(sortOrder, limit)) { + var values = threeSortedValues(); + + collect(sort, values.get(0)); + collect(sort, values.get(1)); + + assertResults(sort, sortOrder, limit, List.of(values.get(1))); + } + } + + public final void testTwoHitsDesc() { + SortOrder sortOrder = SortOrder.DESC; + int limit = 2; + try (T sort = build(sortOrder, limit)) { + var values = threeSortedValues(); + + collect(sort, values.get(0)); + collect(sort, values.get(1)); + collect(sort, values.get(2)); + + assertResults(sort, sortOrder, limit, List.of(values.get(2), values.get(1))); + } + } + + public final void testTwoHitsAsc() { + SortOrder sortOrder = SortOrder.ASC; + int limit = 2; + try (T sort = build(sortOrder, limit)) { + var values = threeSortedValues(); + + collect(sort, values.get(0)); + collect(sort, values.get(1)); + collect(sort, values.get(2)); + + assertResults(sort, sortOrder, limit, List.of(values.get(0), values.get(1))); + } + } + + public final void testReduceLimit() { + SortOrder sortOrder = randomFrom(SortOrder.values()); + int limit = 3; + try (T sort = build(sortOrder, limit)) { + var values = threeSortedValues(); + + collect(sort, values.get(0)); + collect(sort, values.get(1)); + collect(sort, values.get(2)); + + assertResults(sort, sortOrder, limit, values); + + reduceLimitByOne(sort); + collect(sort, values.get(2)); + + assertResults(sort, sortOrder, limit - 1, values); + } + } + + public final void testCrankyBreaker() { + BigArrays bigArrays = new MockBigArrays(PageCacheRecycler.NON_RECYCLING_INSTANCE, new CrankyCircuitBreakerService()); + SortOrder sortOrder = randomFrom(SortOrder.values()); + int limit = randomIntBetween(0, 3); + + try (T sort = build(bigArrays, sortOrder, limit)) { + List values = new ArrayList<>(); + + for (int i = 0; i < randomIntBetween(0, 4); i++) { + V value = randomValue(); + values.add(value); + collect(sort, value); + } + + if (randomBoolean() && limit > 0) { + reduceLimitByOne(sort); + limit--; + + V value = randomValue(); + values.add(value); + collect(sort, value); + } + + assertResults(sort, sortOrder, limit - 1, values); + } catch (CircuitBreakingException e) { + assertThat(e.getMessage(), equalTo(CrankyCircuitBreakerService.ERROR_MESSAGE)); + } + assertThat(bigArrays.breakerService().getBreaker(CircuitBreaker.REQUEST).getUsed(), equalTo(0L)); + } + + protected void assertResults(T sort, SortOrder sortOrder, int limit, List values) { + var sortedUniqueValues = values.stream() + .distinct() + .sorted(sortOrder == SortOrder.ASC ? Comparator.naturalOrder() : Comparator.reverseOrder()) + .limit(limit) + .toList(); + + assertEquals(sortedUniqueValues.size(), getCount(sort)); + if (sortedUniqueValues.isEmpty() == false) { + assertEquals(sortedUniqueValues.getLast(), getWorstValue(sort)); + } + } + + private BigArrays bigArrays() { + return new MockBigArrays(new MockPageCacheRecycler(Settings.EMPTY), new NoneCircuitBreakerService()); + } +} From dd48d97010cf0c6f59dcc7d0cfaf05ede8f2a929 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Thu, 29 May 2025 13:19:56 +0200 Subject: [PATCH 38/39] Remove unused code from TopNMultivalueDedupeLong --- .../mvdedupe/TopNMultivalueDedupeLong.java | 274 +----------------- 1 file changed, 9 insertions(+), 265 deletions(-) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java index cbcc5769fef09..40cd876b429b7 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/mvdedupe/TopNMultivalueDedupeLong.java @@ -20,7 +20,10 @@ import java.util.function.Predicate; /** - * Removes duplicate values from multivalued positions, and keeps only the top N. + * Removes duplicate values from multivalued positions, and keeps only the ones that pass the filters. + *

+ * Clone of {@link MultivalueDedupeLong}, but for it accepts a predicate and nulls flag to filter the values. + *

*/ public class TopNMultivalueDedupeLong { /** @@ -37,7 +40,7 @@ public class TopNMultivalueDedupeLong { /** * Whether the hash expects nulls or not. */ - final boolean hasNull; + final boolean acceptNulls; /** * A predicate to test if a value is part of the top N or not. */ @@ -54,139 +57,12 @@ public class TopNMultivalueDedupeLong { */ int w; - public TopNMultivalueDedupeLong(LongBlock block, boolean hasNull, Predicate isAcceptable) { + public TopNMultivalueDedupeLong(LongBlock block, boolean acceptNulls, Predicate isAcceptable) { this.block = block; - this.hasNull = hasNull; + this.acceptNulls = acceptNulls; this.isAcceptable = isAcceptable; } - /** - * Remove duplicate values from each position and write the results to a - * {@link Block} using an adaptive algorithm based on the size of the input list. - */ - public LongBlock dedupeToBlockAdaptive(BlockFactory blockFactory) { - if (block.mvDeduplicated()) { - block.incRef(); - return block; - } - try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder(block.getPositionCount())) { - for (int p = 0; p < block.getPositionCount(); p++) { - int count = block.getValueCount(p); - int first = block.getFirstValueIndex(p); - switch (count) { - case 0 -> builder.appendNull(); - case 1 -> builder.appendLong(block.getLong(first)); - default -> { - /* - * It's better to copyMissing when there are few unique values - * and better to copy and sort when there are many unique values. - * The more duplicate values there are the more comparatively worse - * copyAndSort is. But we don't know how many unique values there - * because our job is to find them. So we use the count of values - * as a proxy that is fast to test. It's not always going to be - * optimal but it has the nice property of being quite quick on - * short lists and not n^2 levels of terrible on long ones. - * - * It'd also be possible to make a truly hybrid mechanism that - * switches from copyMissing to copyUnique once it collects enough - * unique values. The trouble is that the switch is expensive and - * makes kind of a "hole" in the performance of that mechanism where - * you may as well have just gone with either of the two other - * strategies. So we just don't try it for now. - */ - if (count < ALWAYS_COPY_MISSING) { - copyMissing(first, count); - writeUniquedWork(builder); - } else { - copyAndSort(first, count); - deduplicatedSortedWork(builder); - } - } - } - } - return builder.build(); - } - } - - /** - * Remove duplicate values from each position and write the results to a - * {@link Block} using an algorithm with very low overhead but {@code n^2} - * case complexity for larger. Prefer {@link #dedupeToBlockAdaptive} - * which picks based on the number of elements at each position. - */ - public LongBlock dedupeToBlockUsingCopyAndSort(BlockFactory blockFactory) { - if (block.mvDeduplicated()) { - block.incRef(); - return block; - } - try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder(block.getPositionCount())) { - for (int p = 0; p < block.getPositionCount(); p++) { - int count = block.getValueCount(p); - int first = block.getFirstValueIndex(p); - switch (count) { - case 0 -> builder.appendNull(); - case 1 -> builder.appendLong(block.getLong(first)); - default -> { - copyAndSort(first, count); - deduplicatedSortedWork(builder); - } - } - } - return builder.build(); - } - } - - /** - * Remove duplicate values from each position and write the results to a - * {@link Block} using an algorithm that sorts all values. It has a higher - * overhead for small numbers of values at each position than - * {@link #dedupeToBlockUsingCopyMissing} for large numbers of values the - * performance is dominated by the {@code n*log n} sort. Prefer - * {@link #dedupeToBlockAdaptive} unless you need the results sorted. - */ - public LongBlock dedupeToBlockUsingCopyMissing(BlockFactory blockFactory) { - if (block.mvDeduplicated()) { - block.incRef(); - return block; - } - try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder(block.getPositionCount())) { - for (int p = 0; p < block.getPositionCount(); p++) { - int count = block.getValueCount(p); - int first = block.getFirstValueIndex(p); - switch (count) { - case 0 -> builder.appendNull(); - case 1 -> builder.appendLong(block.getLong(first)); - default -> { - copyMissing(first, count); - writeUniquedWork(builder); - } - } - } - return builder.build(); - } - } - - /** - * Sort values from each position and write the results to a {@link Block}. - */ - public LongBlock sortToBlock(BlockFactory blockFactory, boolean ascending) { - try (LongBlock.Builder builder = blockFactory.newLongBlockBuilder(block.getPositionCount())) { - for (int p = 0; p < block.getPositionCount(); p++) { - int count = block.getValueCount(p); - int first = block.getFirstValueIndex(p); - switch (count) { - case 0 -> builder.appendNull(); - case 1 -> builder.appendLong(block.getLong(first)); - default -> { - copyAndSort(first, count); - writeSortedWork(builder, ascending); - } - } - } - return builder.build(); - } - } - /** * Dedupe values, add them to the hash, and build an {@link IntBlock} of * their hashes. This block is suitable for passing as the grouping block @@ -200,7 +76,7 @@ public MultivalueDedupe.HashResult hashAdd(BlockFactory blockFactory, LongHash h int first = block.getFirstValueIndex(p); switch (count) { case 0 -> { - if (hasNull) { + if (acceptNulls) { sawNull = true; builder.appendInt(0); } else { @@ -237,7 +113,7 @@ public IntBlock hashLookup(BlockFactory blockFactory, LongHash hash) { int first = block.getFirstValueIndex(p); switch (count) { case 0 -> { - if (hasNull) { + if (acceptNulls) { builder.appendInt(0); } else { builder.appendNull(); @@ -262,68 +138,6 @@ public IntBlock hashLookup(BlockFactory blockFactory, LongHash hash) { } } - /** - * Build a {@link BatchEncoder} which deduplicates values at each position - * and then encodes the results into a {@link byte[]} which can be used for - * things like hashing many fields together. - */ - public BatchEncoder batchEncoder(int batchSize) { - block.incRef(); - return new BatchEncoder.Longs(batchSize) { - @Override - protected void readNextBatch() { - int position = firstPosition(); - if (w > 0) { - // The last block didn't fit so we have to *make* it fit - ensureCapacity(w); - startPosition(); - encodeUniquedWork(this); - endPosition(); - position++; - } - for (; position < block.getPositionCount(); position++) { - int count = block.getValueCount(position); - int first = block.getFirstValueIndex(position); - switch (count) { - case 0 -> encodeNull(); - case 1 -> { - long v = block.getLong(first); - if (hasCapacity(1)) { - startPosition(); - encode(v); - endPosition(); - } else { - work[0] = v; - w = 1; - return; - } - } - default -> { - if (count < ALWAYS_COPY_MISSING) { - copyMissing(first, count); - } else { - copyAndSort(first, count); - convertSortedWorkToUnique(); - } - if (hasCapacity(w)) { - startPosition(); - encodeUniquedWork(this); - endPosition(); - } else { - return; - } - } - } - } - } - - @Override - public void close() { - block.decRef(); - } - }; - } - /** * Copy all value from the position into {@link #work} and then * sorts it {@code n * log(n)}. @@ -378,52 +192,6 @@ void copyMissing(int first, int count) { } } - /** - * Writes an already deduplicated {@link #work} to a {@link LongBlock.Builder}. - */ - private void writeUniquedWork(LongBlock.Builder builder) { - if (w == 1) { - builder.appendLong(work[0]); - return; - } - builder.beginPositionEntry(); - for (int i = 0; i < w; i++) { - builder.appendLong(work[i]); - } - builder.endPositionEntry(); - } - - /** - * Writes a sorted {@link #work} to a {@link LongBlock.Builder}, skipping duplicates. - */ - private void deduplicatedSortedWork(LongBlock.Builder builder) { - builder.beginPositionEntry(); - long prev = work[0]; - builder.appendLong(prev); - for (int i = 1; i < w; i++) { - if (prev != work[i]) { - prev = work[i]; - builder.appendLong(prev); - } - } - builder.endPositionEntry(); - } - - /** - * Writes a {@link #work} to a {@link LongBlock.Builder}. - */ - private void writeSortedWork(LongBlock.Builder builder, boolean ascending) { - builder.beginPositionEntry(); - for (int i = 0; i < w; i++) { - if (ascending) { - builder.appendLong(work[i]); - } else { - builder.appendLong(work[w - i - 1]); - } - } - builder.endPositionEntry(); - } - /** * Writes an already deduplicated {@link #work} to a hash. */ @@ -607,30 +375,6 @@ private void hashLookupSortedWork(LongHash hash, IntBlock.Builder builder) { builder.endPositionEntry(); } - /** - * Writes a deduplicated {@link #work} to a {@link BatchEncoder.Longs}. - */ - private void encodeUniquedWork(BatchEncoder.Longs encoder) { - for (int i = 0; i < w; i++) { - encoder.encode(work[i]); - } - } - - /** - * Converts {@link #work} from sorted array to a deduplicated array. - */ - private void convertSortedWorkToUnique() { - long prev = work[0]; - int end = w; - w = 1; - for (int i = 1; i < end; i++) { - if (false == valuesEqual(prev, work[i])) { - prev = work[i]; - work[w++] = prev; - } - } - } - private void grow(int size) { work = ArrayUtil.grow(work, size); } From e63b73a29ea7390e60f20a9b28618883ac0bc7bf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Iv=C3=A1n=20Cea=20Fontenla?= Date: Thu, 29 May 2025 15:06:26 +0200 Subject: [PATCH 39/39] Fix missing success=true in constructor --- .../compute/aggregation/blockhash/LongTopNBlockHash.java | 1 + 1 file changed, 1 insertion(+) diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java index 3e6f3a471ba66..58fe427618135 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java @@ -60,6 +60,7 @@ final class LongTopNBlockHash extends BlockHash { try { this.hash = new LongHash(1, blockFactory.bigArrays()); this.topValues = new LongTopNSet(blockFactory.bigArrays(), asc ? SortOrder.ASC : SortOrder.DESC, limit); + success = true; } finally { if (success == false) { close();