Skip to content

Commit 6d2bf92

Browse files
limotovalimotova
committed
add aggregate metric double block to some tests
1 parent 8bbddc4 commit 6d2bf92

File tree

17 files changed

+511
-41
lines changed

17 files changed

+511
-41
lines changed

‎x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AggregateMetricDoubleArrayBlock.java‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,7 @@
1515

1616
import java.io.IOException;
1717
import java.util.List;
18+
import java.util.stream.Collectors;
1819
import java.util.stream.Stream;
1920

2021
public final class AggregateMetricDoubleArrayBlock extends AbstractNonThreadSafeRefCounted implements AggregateMetricDoubleBlock {
@@ -289,4 +290,13 @@ public Block getMetricBlock(int index) {
289290
}
290291
throw new UnsupportedOperationException("Received an index (" + index + ") outside of range for AggregateMetricDoubleBlock.");
291292
}
293+
294+
@Override
295+
public String toString() {
296+
String valuesString = Stream.of(AggregateMetricDoubleBlockBuilder.Metric.values())
297+
.map(metric -> metric.getLabel() + "=" + getMetricBlock(metric.getIndex()))
298+
.collect(Collectors.joining(", ", "[", "]"));
299+
300+
return getClass().getSimpleName() + valuesString;
301+
}
292302
}

‎x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AggregateMetricDoubleBlockBuilder.java‎

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -58,6 +58,11 @@ protected int elementSize() {
5858
throw new UnsupportedOperationException("Not available on aggregate_metric_double");
5959
}
6060

61+
@Override
62+
public long estimatedBytes() {
63+
return minBuilder.estimatedBytes() + maxBuilder.estimatedBytes() + sumBuilder.estimatedBytes() + countBuilder.estimatedBytes();
64+
}
65+
6166
@Override
6267
public AggregateMetricDoubleBlockBuilder copyFrom(Block b, int beginInclusive, int endExclusive) {
6368
Block minBlock;
@@ -83,6 +88,35 @@ public AggregateMetricDoubleBlockBuilder copyFrom(Block b, int beginInclusive, i
8388
return this;
8489
}
8590

91+
public AggregateMetricDoubleBlockBuilder copyFrom(AggregateMetricDoubleBlock block, int position) {
92+
if (block.isNull(position)) {
93+
appendNull();
94+
return this;
95+
}
96+
97+
if (block.minBlock().isNull(position)) {
98+
min().appendNull();
99+
} else {
100+
min().appendDouble(block.minBlock().getDouble(position));
101+
}
102+
if (block.maxBlock().isNull(position)) {
103+
max().appendNull();
104+
} else {
105+
max().appendDouble(block.maxBlock().getDouble(position));
106+
}
107+
if (block.sumBlock().isNull(position)) {
108+
sum().appendNull();
109+
} else {
110+
sum().appendDouble(block.sumBlock().getDouble(position));
111+
}
112+
if (block.countBlock().isNull(position)) {
113+
count().appendNull();
114+
} else {
115+
count().appendInt(block.countBlock().getInt(position));
116+
}
117+
return this;
118+
}
119+
86120
@Override
87121
public AggregateMetricDoubleBlockBuilder appendNull() {
88122
minBuilder.appendNull();

‎x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/BlockFactory.java‎

Lines changed: 35 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -441,30 +441,46 @@ public final AggregateMetricDoubleBlock newConstantAggregateMetricDoubleBlock(
441441
int positions
442442
) {
443443
try (AggregateMetricDoubleBlockBuilder builder = newAggregateMetricDoubleBlockBuilder(positions)) {
444-
if (value.min() != null) {
445-
builder.min().appendDouble(value.min());
446-
} else {
447-
builder.min().appendNull();
448-
}
449-
if (value.max() != null) {
450-
builder.max().appendDouble(value.max());
451-
} else {
452-
builder.max().appendNull();
453-
}
454-
if (value.sum() != null) {
455-
builder.sum().appendDouble(value.sum());
456-
} else {
457-
builder.sum().appendNull();
458-
}
459-
if (value.count() != null) {
460-
builder.count().appendInt(value.count());
461-
} else {
462-
builder.count().appendNull();
444+
for (int i = 0; i < positions; i++) {
445+
if (value.min() != null) {
446+
builder.min().appendDouble(value.min());
447+
} else {
448+
builder.min().appendNull();
449+
}
450+
if (value.max() != null) {
451+
builder.max().appendDouble(value.max());
452+
} else {
453+
builder.max().appendNull();
454+
}
455+
if (value.sum() != null) {
456+
builder.sum().appendDouble(value.sum());
457+
} else {
458+
builder.sum().appendNull();
459+
}
460+
if (value.count() != null) {
461+
builder.count().appendInt(value.count());
462+
} else {
463+
builder.count().appendNull();
464+
}
463465
}
464466
return builder.build();
465467
}
466468
}
467469

470+
public final AggregateMetricDoubleBlock newAggregateMetricDoubleBlock(
471+
double[] minValues,
472+
double[] maxValues,
473+
double[] sumValues,
474+
int[] countValues,
475+
int positions
476+
) {
477+
DoubleBlock min = newDoubleArrayVector(minValues, positions).asBlock();
478+
DoubleBlock max = newDoubleArrayVector(maxValues, positions).asBlock();
479+
DoubleBlock sum = newDoubleArrayVector(sumValues, positions).asBlock();
480+
IntBlock count = newIntArrayVector(countValues, positions).asBlock();
481+
return new AggregateMetricDoubleArrayBlock(min, max, sum, count);
482+
}
483+
468484
/**
469485
* Returns the maximum number of bytes that a Block should be backed by a primitive array before switching to using BigArrays.
470486
*/

‎x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/AggregateMetricDoubleBlockEqualityTests.java‎

Lines changed: 213 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -17,8 +17,6 @@ public class AggregateMetricDoubleBlockEqualityTests extends ComputeTestCase {
1717

1818
static final BlockFactory blockFactory = TestBlockFactory.getNonBreakingInstance();
1919

20-
// TODO: Add additional tests
21-
2220
public void testEmptyBlock() {
2321
// all these "empty" blocks should be equivalent
2422
var partialMetricBuilder = blockFactory.newAggregateMetricDoubleBlockBuilder(0);
@@ -54,6 +52,199 @@ public void testEmptyBlock() {
5452
Releasables.close(blocks);
5553
}
5654

55+
public void testBlockEquality() {
56+
// all these blocks should be equivalent
57+
{
58+
// regular blocks
59+
AggregateMetricDoubleBlockBuilder builder1 = blockFactory.newAggregateMetricDoubleBlockBuilder(3);
60+
appendValues(builder1, 1.23, 68392.1, 99999.1, 5);
61+
appendValues(builder1, 582.1, 10942, 209301.4, 25);
62+
appendValues(builder1, 8952.564, 30921.23, 18592950.14, 1000);
63+
AggregateMetricDoubleBlockBuilder builder2 = blockFactory.newAggregateMetricDoubleBlockBuilder(6);
64+
appendValues(builder2, 1.23, 68392.1, 99999.1, 5);
65+
appendValues(builder2, 1.23, 68392.1, 99999.1, 10);
66+
appendValues(builder2, 582.1, 10942, 209301.4, 25);
67+
appendValues(builder2, 999.1, 10942, 209301.4, 50);
68+
appendValues(builder2, 10000.564, 30921.23, 18592950.14, 2000);
69+
appendValues(builder2, 8952.564, 30921.23, 18592950.14, 1000);
70+
AggregateMetricDoubleBlockBuilder builder3 = blockFactory.newAggregateMetricDoubleBlockBuilder(5);
71+
builder3.appendNull();
72+
builder3.appendNull();
73+
appendValues(builder3, 1.23, 68392.1, 99999.1, 5);
74+
appendValues(builder3, 582.1, 10942, 209301.4, 25);
75+
appendValues(builder3, 8952.564, 30921.23, 18592950.14, 1000);
76+
builder3.appendNull();
77+
78+
List<AggregateMetricDoubleBlock> blocks = List.of(
79+
builder1.build(),
80+
builder2.build().filter(0, 2, 5),
81+
builder3.build().filter(2, 3, 4)
82+
);
83+
assertAllEquals(blocks);
84+
}
85+
{
86+
// constant-like blocks
87+
AggregateMetricDoubleBlockBuilder builder1 = blockFactory.newAggregateMetricDoubleBlockBuilder(2);
88+
appendValues(builder1, 12.3, 987.6, 4821.3, 6);
89+
appendValues(builder1, 12.3, 987.6, 4821.3, 6);
90+
AggregateMetricDoubleBlockBuilder builder2 = blockFactory.newAggregateMetricDoubleBlockBuilder(3);
91+
appendValues(builder2, 12.3, 987.6, 4821.3, 6);
92+
appendValues(builder2, 95.2, 10852.2, 20000.5, 5);
93+
appendValues(builder2, 12.3, 987.6, 4821.3, 6);
94+
appendValues(builder2, 1.1, 2.2, 3.3, 2);
95+
DoubleBlock min1 = blockFactory.newDoubleBlockBuilder(4).appendDouble(12.3).appendDouble(12.3).build();
96+
DoubleBlock max1 = blockFactory.newDoubleBlockBuilder(4).appendDouble(987.6).appendDouble(987.6).build();
97+
DoubleBlock sum1 = blockFactory.newDoubleBlockBuilder(4).appendDouble(4821.3).appendDouble(4821.3).build();
98+
IntBlock count1 = blockFactory.newIntBlockBuilder(4).appendInt(6).appendInt(6).build();
99+
CompositeBlock compositeBlock1 = new CompositeBlock(new Block[] { min1, max1, sum1, count1 });
100+
DoubleBlock min2 = blockFactory.newDoubleBlockBuilder(4)
101+
.appendDouble(591.1)
102+
.appendDouble(11.1)
103+
.appendDouble(12.3)
104+
.appendDouble(12.3)
105+
.build();
106+
DoubleBlock max2 = blockFactory.newDoubleBlockBuilder(4)
107+
.appendDouble(198441.1)
108+
.appendDouble(89235982.1)
109+
.appendDouble(987.6)
110+
.appendDouble(987.6)
111+
.build();
112+
DoubleBlock sum2 = blockFactory.newDoubleBlockBuilder(4)
113+
.appendDouble(13498198.2)
114+
.appendDouble(4901245982.1)
115+
.appendDouble(4821.3)
116+
.appendDouble(4821.3)
117+
.build();
118+
IntBlock count2 = blockFactory.newIntBlockBuilder(4).appendInt(100).appendInt(200).appendInt(6).appendInt(6).build();
119+
CompositeBlock compositeBlock2 = new CompositeBlock(new Block[] { min2, max2, sum2, count2 });
120+
121+
List<AggregateMetricDoubleBlock> moreBlocks = List.of(
122+
builder1.build(),
123+
builder2.build().filter(0, 2),
124+
AggregateMetricDoubleArrayBlock.fromCompositeBlock(compositeBlock1),
125+
AggregateMetricDoubleArrayBlock.fromCompositeBlock(compositeBlock2).filter(2, 3),
126+
blockFactory.newConstantAggregateMetricDoubleBlock(
127+
new AggregateMetricDoubleBlockBuilder.AggregateMetricDoubleLiteral(12.3, 987.6, 4821.3, 6),
128+
4
129+
).filter(1, 3),
130+
blockFactory.newConstantAggregateMetricDoubleBlock(
131+
new AggregateMetricDoubleBlockBuilder.AggregateMetricDoubleLiteral(12.3, 987.6, 4821.3, 6),
132+
2
133+
)
134+
);
135+
assertAllEquals(moreBlocks);
136+
}
137+
{
138+
// blocks with partial submetrics appended in different orders (column vs row)
139+
AggregateMetricDoubleBlockBuilder builder1 = blockFactory.newAggregateMetricDoubleBlockBuilder(3);
140+
builder1.min().appendDouble(1.23).appendDouble(582.1).appendNull();
141+
builder1.max().appendDouble(68392.1).appendNull();
142+
builder1.max().appendDouble(30921.23);
143+
builder1.sum().appendNull();
144+
builder1.sum().appendDouble(99999.1).appendNull();
145+
builder1.count().appendNull().appendNull();
146+
builder1.count().appendInt(1000);
147+
148+
AggregateMetricDoubleBlockBuilder builder2 = blockFactory.newAggregateMetricDoubleBlockBuilder(6);
149+
builder2.appendNull();
150+
builder2.appendNull();
151+
builder2.min().appendDouble(1.23);
152+
builder2.max().appendDouble(68392.1);
153+
builder2.sum().appendNull();
154+
builder2.count().appendNull();
155+
builder2.min().appendDouble(582.1);
156+
builder2.max().appendNull();
157+
builder2.sum().appendDouble(99999.1);
158+
builder2.count().appendNull();
159+
builder2.appendNull();
160+
builder2.min().appendNull();
161+
builder2.max().appendDouble(30921.23);
162+
builder2.sum().appendNull();
163+
builder2.count().appendInt(1000);
164+
165+
List<AggregateMetricDoubleBlock> evenMoreBlocks = List.of(builder1.build(), builder2.build().filter(2, 3, 5));
166+
assertAllEquals(evenMoreBlocks);
167+
}
168+
}
169+
170+
public void testBlockInequality() {
171+
// all these blocks should NOT be equivalent
172+
AggregateMetricDoubleBlockBuilder builder1 = blockFactory.newAggregateMetricDoubleBlockBuilder(3);
173+
appendValues(builder1, 1.1, 6.1, 7.2, 2);
174+
builder1.appendNull();
175+
appendValues(builder1, 1.3, 6.3, 11.9, 3);
176+
// same values as builder1, in a different order
177+
AggregateMetricDoubleBlockBuilder builder2 = blockFactory.newAggregateMetricDoubleBlockBuilder(3);
178+
appendValues(builder2, 1.3, 6.3, 11.9, 3);
179+
builder2.appendNull();
180+
appendValues(builder2, 1.1, 6.1, 7.2, 2);
181+
// first 2/3 values match builder1, last 2/3 values match builder2
182+
AggregateMetricDoubleBlockBuilder builder3 = blockFactory.newAggregateMetricDoubleBlockBuilder(3);
183+
appendValues(builder3, 1.1, 6.1, 7.2, 2);
184+
builder3.appendNull();
185+
appendValues(builder3, 1.1, 6.1, 7.2, 2);
186+
// matches the first 2 values of builder1
187+
AggregateMetricDoubleBlockBuilder builder4 = blockFactory.newAggregateMetricDoubleBlockBuilder(2);
188+
appendValues(builder4, 1.1, 6.1, 7.2, 2);
189+
builder4.appendNull();
190+
// like builder1 without null value
191+
AggregateMetricDoubleBlockBuilder builder5 = blockFactory.newAggregateMetricDoubleBlockBuilder(2);
192+
appendValues(builder5, 1.1, 6.1, 7.2, 2);
193+
appendValues(builder5, 1.3, 6.3, 11.9, 3);
194+
// like builder1 but first value's sum is null
195+
AggregateMetricDoubleBlockBuilder builder6 = blockFactory.newAggregateMetricDoubleBlockBuilder(3);
196+
builder6.min().appendDouble(1.1);
197+
builder6.max().appendDouble(6.1);
198+
builder6.sum().appendNull();
199+
builder6.count().appendInt(2);
200+
builder6.appendNull();
201+
appendValues(builder6, 1.3, 6.3, 11.9, 3);
202+
// like builder6 but max and sum are swapped
203+
AggregateMetricDoubleBlockBuilder builder7 = blockFactory.newAggregateMetricDoubleBlockBuilder(3);
204+
builder7.min().appendDouble(1.1);
205+
builder7.max().appendNull();
206+
builder7.sum().appendDouble(6.1);
207+
builder7.count().appendInt(2);
208+
builder7.appendNull();
209+
appendValues(builder7, 1.3, 6.3, 11.9, 3);
210+
211+
List<AggregateMetricDoubleBlock> notEqualBlocks = List.of(
212+
builder1.build(),
213+
builder2.build(),
214+
builder3.build(),
215+
builder4.build(),
216+
builder5.build(),
217+
builder6.build(),
218+
builder7.build(),
219+
blockFactory.newConstantAggregateMetricDoubleBlock(
220+
new AggregateMetricDoubleBlockBuilder.AggregateMetricDoubleLiteral(1.1, 6.1, 7.2, 2),
221+
1
222+
),
223+
blockFactory.newConstantAggregateMetricDoubleBlock(
224+
new AggregateMetricDoubleBlockBuilder.AggregateMetricDoubleLiteral(1.1, 6.1, 7.2, 2),
225+
3
226+
)
227+
);
228+
assertAllNotEquals(notEqualBlocks);
229+
}
230+
231+
public void testSimpleBlockWithSingleNull() {
232+
AggregateMetricDoubleBlockBuilder builder1 = blockFactory.newAggregateMetricDoubleBlockBuilder(3);
233+
appendValues(builder1, 1.1, 6.1, 7.2, 2);
234+
builder1.appendNull();
235+
appendValues(builder1, 1.3, 6.3, 11.9, 3);
236+
AggregateMetricDoubleBlockBuilder builder2 = blockFactory.newAggregateMetricDoubleBlockBuilder(3);
237+
appendValues(builder2, 1.1, 6.1, 7.2, 2);
238+
builder2.appendNull();
239+
appendValues(builder2, 1.3, 6.3, 11.9, 3);
240+
241+
List<AggregateMetricDoubleBlock> blocks = List.of(builder1.build(), builder2.build());
242+
243+
assertEquals(3, blocks.get(0).getPositionCount());
244+
assertTrue(blocks.get(0).isNull(1));
245+
assertAllEquals(blocks);
246+
}
247+
57248
public void testSimpleBlockWithManyNulls() {
58249
int positions = randomIntBetween(1, 256);
59250
boolean grow = randomBoolean();
@@ -86,4 +277,24 @@ static void assertAllEquals(List<?> objs) {
86277
}
87278
}
88279
}
280+
281+
static void assertAllNotEquals(List<?> objs) {
282+
for (Object obj1 : objs) {
283+
for (Object obj2 : objs) {
284+
if (obj1 == obj2) {
285+
continue; // skip self
286+
}
287+
assertNotEquals(obj1, obj2);
288+
assertNotEquals(obj2, obj1);
289+
assertNotEquals(obj1.hashCode(), obj2.hashCode());
290+
}
291+
}
292+
}
293+
294+
static void appendValues(AggregateMetricDoubleBlockBuilder builder, double min, double max, double sum, int count) {
295+
builder.min().appendDouble(min);
296+
builder.max().appendDouble(max);
297+
builder.sum().appendDouble(sum);
298+
builder.count().appendInt(count);
299+
}
89300
}

‎x-pack/plugin/esql/compute/src/test/java/org/elasticsearch/compute/data/BasicBlockTests.java‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -99,6 +99,7 @@ void testEmpty(BlockFactory bf) {
9999
assertZeroPositionsAndRelease(bf.newBooleanBlockBuilder(0).build());
100100
assertZeroPositionsAndRelease(bf.newBooleanArrayVector(new boolean[] {}, 0));
101101
assertZeroPositionsAndRelease(bf.newBooleanVectorBuilder(0).build());
102+
assertZeroPositionsAndRelease(bf.newAggregateMetricDoubleBlockBuilder(0).build());
102103
}
103104

104105
public void testSmallSingleValueDenseGrowthInt() {
@@ -168,6 +169,17 @@ public void testSmallSingleValueDenseGrowthBoolean() {
168169
}
169170
}
170171

172+
public void testSmallSingleValueDenseGrowthAggregateMetricDouble() {
173+
for (int initialSize : List.of(0, 1, 2, 3, 4, 5)) {
174+
try (var blockBuilder = blockFactory.newBooleanBlockBuilder(initialSize)) {
175+
IntStream.range(0, 10).forEach(i -> blockBuilder.appendBoolean(i % 3 == 0));
176+
BooleanBlock block = blockBuilder.build();
177+
assertSingleValueDenseBlock(block);
178+
block.close();
179+
}
180+
}
181+
}
182+
171183
static void assertSingleValueDenseBlock(Block initialBlock) {
172184
final int positionCount = initialBlock.getPositionCount();
173185
int depth = randomIntBetween(1, 5);

0 commit comments

Comments
 (0)