From 8a121b030658f7d148c363ea0c2a0d7be4d11f66 Mon Sep 17 00:00:00 2001 From: Clint Wylie Date: Tue, 19 Nov 2019 01:10:52 -0800 Subject: [PATCH 1/5] benchmark schema with null column values --- .../datagen/BenchmarkColumnSchema.java | 22 +++++++++++ .../BenchmarkColumnValueGenerator.java | 7 ++++ .../datagen/BenchmarkSchemaInfo.java | 13 +++++++ .../benchmark/datagen/BenchmarkSchemas.java | 28 ++++++++++++++ .../benchmark/datagen/SegmentGenerator.java | 27 +------------ .../benchmark/query/GroupByBenchmark.java | 38 ++++++++++++++++++- 6 files changed, 109 insertions(+), 26 deletions(-) diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkColumnSchema.java b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkColumnSchema.java index 549140e62bd4..8636941dd28d 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkColumnSchema.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkColumnSchema.java @@ -19,6 +19,12 @@ package org.apache.druid.benchmark.datagen; +import org.apache.druid.data.input.impl.DimensionSchema; +import org.apache.druid.data.input.impl.DoubleDimensionSchema; +import org.apache.druid.data.input.impl.FloatDimensionSchema; +import org.apache.druid.data.input.impl.LongDimensionSchema; +import org.apache.druid.data.input.impl.StringDimensionSchema; +import org.apache.druid.java.util.common.IAE; import org.apache.druid.segment.column.ValueType; import java.util.List; @@ -144,6 +150,22 @@ public BenchmarkColumnValueGenerator makeGenerator(long seed) return new BenchmarkColumnValueGenerator(this, seed); } + public DimensionSchema getDimensionSchema() + { + switch (type) { + case LONG: + return new LongDimensionSchema(name); + case FLOAT: + return new FloatDimensionSchema(name); + case DOUBLE: + return new DoubleDimensionSchema(name); + case STRING: + return new StringDimensionSchema(name); + default: + throw new IAE("unable to make dimension schema for %s", type); + } + } + public String getName() { return name; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkColumnValueGenerator.java b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkColumnValueGenerator.java index e94a9703598a..5fe89d8a9fb5 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkColumnValueGenerator.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkColumnValueGenerator.java @@ -116,6 +116,13 @@ private Object convertType(Object input, ValueType type) ret = Long.parseLong(input.toString()); } break; + case DOUBLE: + if (input instanceof Number) { + ret = ((Number) input).doubleValue(); + } else { + ret = Double.parseDouble(input.toString()); + } + break; case FLOAT: if (input instanceof Number) { ret = ((Number) input).floatValue(); diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemaInfo.java b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemaInfo.java index 7a2720931e8d..f8c1b60dd373 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemaInfo.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemaInfo.java @@ -19,10 +19,13 @@ package org.apache.druid.benchmark.datagen; +import org.apache.druid.data.input.impl.DimensionSchema; +import org.apache.druid.data.input.impl.DimensionsSpec; import org.apache.druid.query.aggregation.AggregatorFactory; import org.joda.time.Interval; import java.util.List; +import java.util.stream.Collectors; public class BenchmarkSchemaInfo { @@ -49,6 +52,16 @@ public List getColumnSchemas() return columnSchemas; } + public DimensionsSpec getDimensionsSpec() + { + List specs = getColumnSchemas().stream() + .filter(x -> !x.isMetric()) + .map(BenchmarkColumnSchema::getDimensionSchema) + .collect(Collectors.toList()); + + return new DimensionsSpec(specs); + } + public List getAggs() { return aggs; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java index 69a9d901a1e7..edc71b17c5f9 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java @@ -225,4 +225,32 @@ public class BenchmarkSchemas ); SCHEMA_MAP.put("rollo", rolloSchema); } + + static { // simple schema with null valued rows, no aggs on numeric columns + List simpleNullsSchemaColumns = ImmutableList.of( + // dims + BenchmarkColumnSchema.makeZipf("stringZipf", ValueType.STRING, false, 1, 0.5, 1, 101, 1.5), + BenchmarkColumnSchema.makeDiscreteUniform("stringUniform", ValueType.STRING, false, 1, 0.25, 1, 100000), + BenchmarkColumnSchema.makeSequential("stringSequentialHalfNull", ValueType.STRING, false, 1, 0.5, 0, 1000), + + // metrics + BenchmarkColumnSchema.makeSequential("longSequential", ValueType.LONG, false, 1, 0.5, 0, 10000), + BenchmarkColumnSchema.makeDiscreteUniform("longUniform", ValueType.LONG, false, 1, 0.25, 0, 500), + BenchmarkColumnSchema.makeZipf("doubleZipf", ValueType.DOUBLE, false, 1, 0.25, 0, 1000, 2.0) + ); + + List simpleNullsSchemaIngestAggs = new ArrayList<>(); + simpleNullsSchemaIngestAggs.add(new CountAggregatorFactory("rows")); + + Interval simpleNullsSchemaDataInterval = Intervals.of("2000-01-01/P1D"); + + BenchmarkSchemaInfo basicSchema = new BenchmarkSchemaInfo( + simpleNullsSchemaColumns, + simpleNullsSchemaIngestAggs, + simpleNullsSchemaDataInterval, + false + ); + + SCHEMA_MAP.put("simple-nulls", basicSchema); + } } diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/SegmentGenerator.java b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/SegmentGenerator.java index e1dea3142492..94b53cc5e4f2 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/SegmentGenerator.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/SegmentGenerator.java @@ -19,7 +19,6 @@ package org.apache.druid.benchmark.datagen; -import com.google.common.collect.ImmutableList; import com.google.common.hash.Hashing; import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; @@ -71,7 +70,7 @@ public class SegmentGenerator implements Closeable static { NullHandling.initializeForTests(); } - + private final File cacheDir; private final boolean cleanupCacheDir; @@ -145,30 +144,8 @@ public QueryableIndex generate( numRows ); - final List dimensions = new ArrayList<>(); - for (BenchmarkColumnSchema columnSchema : schemaInfo.getColumnSchemas()) { - if (schemaInfo.getAggs().stream().noneMatch(agg -> agg.getName().equals(columnSchema.getName()))) { - switch (columnSchema.getType()) { - case STRING: - dimensions.add(new StringDimensionSchema(columnSchema.getName())); - break; - case LONG: - dimensions.add(new LongDimensionSchema(columnSchema.getName())); - break; - case DOUBLE: - dimensions.add(new DoubleDimensionSchema(columnSchema.getName())); - break; - case FLOAT: - dimensions.add(new FloatDimensionSchema(columnSchema.getName())); - break; - default: - throw new ISE("Unhandleable type[%s]", columnSchema.getType()); - } - } - } - final IncrementalIndexSchema indexSchema = new IncrementalIndexSchema.Builder() - .withDimensionsSpec(new DimensionsSpec(dimensions, ImmutableList.of(), ImmutableList.of())) + .withDimensionsSpec(schemaInfo.getDimensionsSpec()) .withMetrics(schemaInfo.getAggsArray()) .withRollup(schemaInfo.isWithRollup()) .withQueryGranularity(granularity) diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/GroupByBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/GroupByBenchmark.java index 8aca844c8b22..09e809f661ea 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/GroupByBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/GroupByBenchmark.java @@ -19,6 +19,7 @@ package org.apache.druid.benchmark.query; +import com.fasterxml.jackson.databind.InjectableValues; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.dataformat.smile.SmileFactory; import com.google.common.base.Supplier; @@ -41,6 +42,7 @@ import org.apache.druid.java.util.common.granularity.Granularity; import org.apache.druid.java.util.common.guava.Sequence; import org.apache.druid.java.util.common.logger.Logger; +import org.apache.druid.math.expr.ExprMacroTable; import org.apache.druid.offheap.OffheapBufferGenerator; import org.apache.druid.query.DruidProcessingConfig; import org.apache.druid.query.FinalizeResultsQueryRunner; @@ -58,6 +60,7 @@ import org.apache.druid.query.aggregation.hyperloglog.HyperUniquesSerde; import org.apache.druid.query.context.ResponseContext; import org.apache.druid.query.dimension.DefaultDimensionSpec; +import org.apache.druid.query.expression.TestExprMacroTable; import org.apache.druid.query.filter.BoundDimFilter; import org.apache.druid.query.groupby.GroupByQuery; import org.apache.druid.query.groupby.GroupByQueryConfig; @@ -166,7 +169,11 @@ public class GroupByBenchmark static { JSON_MAPPER = new DefaultObjectMapper(); INDEX_IO = new IndexIO( - JSON_MAPPER, + JSON_MAPPER.setInjectableValues( + new InjectableValues.Std() + .addValue(ExprMacroTable.class.getName(), TestExprMacroTable.INSTANCE) + .addValue(ObjectMapper.class.getName(), JSON_MAPPER) + ), new ColumnConfig() { @Override @@ -391,6 +398,34 @@ private void setupQueries() simpleFloatQueries.put("A", queryA); } SCHEMA_QUERY_MAP.put("simpleFloat", simpleFloatQueries); + + // simple one column schema, for testing performance difference between querying on numeric values as Strings and + // directly as longs + Map nullQueries = new LinkedHashMap<>(); + BenchmarkSchemaInfo nullSchema = BenchmarkSchemas.SCHEMA_MAP.get("simple-nulls"); + + { // simple-null + QuerySegmentSpec intervalSpec = new MultipleIntervalSegmentSpec(Collections.singletonList(nullSchema.getDataInterval())); + List queryAggs = new ArrayList<>(); + queryAggs.add(new DoubleSumAggregatorFactory( + "doubleSum", + "doubleZipf" + )); + GroupByQuery queryA = GroupByQuery + .builder() + .setDataSource("blah") + .setQuerySegmentSpec(intervalSpec) + .setDimensions(new DefaultDimensionSpec("stringZipf", "stringZipf", ValueType.STRING)) + .setAggregatorSpecs( + queryAggs + ) + .setGranularity(Granularity.fromString(queryGranularity)) + .setContext(ImmutableMap.of("vectorize", vectorize)) + .build(); + + nullQueries.put("A", queryA); + } + SCHEMA_QUERY_MAP.put("simple-nulls", nullQueries); } @Setup(Level.Trial) @@ -549,6 +584,7 @@ private IncrementalIndex makeIncIndex(boolean withRollup) return new IncrementalIndex.Builder() .setIndexSchema( new IncrementalIndexSchema.Builder() + .withDimensionsSpec(schemaInfo.getDimensionsSpec()) .withMetrics(schemaInfo.getAggsArray()) .withRollup(withRollup) .build() From 64d81e4dc9a5168b9305763373af6e4f3b0cbc6a Mon Sep 17 00:00:00 2001 From: Clint Wylie Date: Fri, 13 Dec 2019 16:28:40 -0800 Subject: [PATCH 2/5] oops --- .../apache/druid/benchmark/datagen/SegmentGenerator.java | 6 ------ 1 file changed, 6 deletions(-) diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/SegmentGenerator.java b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/SegmentGenerator.java index 94b53cc5e4f2..95a42d5ffd88 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/SegmentGenerator.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/SegmentGenerator.java @@ -22,12 +22,6 @@ import com.google.common.hash.Hashing; import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; -import org.apache.druid.data.input.impl.DimensionSchema; -import org.apache.druid.data.input.impl.DimensionsSpec; -import org.apache.druid.data.input.impl.DoubleDimensionSchema; -import org.apache.druid.data.input.impl.FloatDimensionSchema; -import org.apache.druid.data.input.impl.LongDimensionSchema; -import org.apache.druid.data.input.impl.StringDimensionSchema; import org.apache.druid.java.util.common.FileUtils; import org.apache.druid.java.util.common.ISE; import org.apache.druid.java.util.common.StringUtils; From 9e97972328f262cec3bee3ff33afdf79fbd06de9 Mon Sep 17 00:00:00 2001 From: Clint Wylie Date: Tue, 17 Dec 2019 18:22:58 -0800 Subject: [PATCH 3/5] adjustments --- .../apache/druid/benchmark/datagen/BenchmarkSchemas.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java index edc71b17c5f9..07caad87cf64 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java @@ -233,7 +233,7 @@ public class BenchmarkSchemas BenchmarkColumnSchema.makeDiscreteUniform("stringUniform", ValueType.STRING, false, 1, 0.25, 1, 100000), BenchmarkColumnSchema.makeSequential("stringSequentialHalfNull", ValueType.STRING, false, 1, 0.5, 0, 1000), - // metrics + // numeric dims with nulls BenchmarkColumnSchema.makeSequential("longSequential", ValueType.LONG, false, 1, 0.5, 0, 10000), BenchmarkColumnSchema.makeDiscreteUniform("longUniform", ValueType.LONG, false, 1, 0.25, 0, 500), BenchmarkColumnSchema.makeZipf("doubleZipf", ValueType.DOUBLE, false, 1, 0.25, 0, 1000, 2.0) @@ -244,13 +244,13 @@ public class BenchmarkSchemas Interval simpleNullsSchemaDataInterval = Intervals.of("2000-01-01/P1D"); - BenchmarkSchemaInfo basicSchema = new BenchmarkSchemaInfo( + BenchmarkSchemaInfo simpleNullsSchema = new BenchmarkSchemaInfo( simpleNullsSchemaColumns, simpleNullsSchemaIngestAggs, simpleNullsSchemaDataInterval, false ); - SCHEMA_MAP.put("simple-nulls", basicSchema); + SCHEMA_MAP.put("numeric-nulls", simpleNullsSchema); } } From 45170c19ab4c1c4e646293f64803046c1a124121 Mon Sep 17 00:00:00 2001 From: Clint Wylie Date: Tue, 17 Dec 2019 20:58:25 -0800 Subject: [PATCH 4/5] rename again, different null percentage so rows more variety --- .../apache/druid/benchmark/datagen/BenchmarkSchemas.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java index 07caad87cf64..b9c357c6e4a6 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java @@ -230,13 +230,13 @@ public class BenchmarkSchemas List simpleNullsSchemaColumns = ImmutableList.of( // dims BenchmarkColumnSchema.makeZipf("stringZipf", ValueType.STRING, false, 1, 0.5, 1, 101, 1.5), - BenchmarkColumnSchema.makeDiscreteUniform("stringUniform", ValueType.STRING, false, 1, 0.25, 1, 100000), + BenchmarkColumnSchema.makeDiscreteUniform("stringUniform", ValueType.STRING, false, 1, 0.3, 1, 100000), BenchmarkColumnSchema.makeSequential("stringSequentialHalfNull", ValueType.STRING, false, 1, 0.5, 0, 1000), // numeric dims with nulls - BenchmarkColumnSchema.makeSequential("longSequential", ValueType.LONG, false, 1, 0.5, 0, 10000), + BenchmarkColumnSchema.makeSequential("longSequential", ValueType.LONG, false, 1, 0.45, 0, 10000), BenchmarkColumnSchema.makeDiscreteUniform("longUniform", ValueType.LONG, false, 1, 0.25, 0, 500), - BenchmarkColumnSchema.makeZipf("doubleZipf", ValueType.DOUBLE, false, 1, 0.25, 0, 1000, 2.0) + BenchmarkColumnSchema.makeZipf("doubleZipf", ValueType.DOUBLE, false, 1, 0.1, 0, 1000, 2.0) ); List simpleNullsSchemaIngestAggs = new ArrayList<>(); @@ -251,6 +251,6 @@ public class BenchmarkSchemas false ); - SCHEMA_MAP.put("numeric-nulls", simpleNullsSchema); + SCHEMA_MAP.put("nulls", simpleNullsSchema); } } From 85d364452f2f0e57c17c254d19fd7e8f525fa139 Mon Sep 17 00:00:00 2001 From: Clint Wylie Date: Wed, 18 Dec 2019 14:34:52 -0800 Subject: [PATCH 5/5] more schema --- .../benchmark/datagen/BenchmarkSchemas.java | 61 ++++++++++++++++--- .../benchmark/query/GroupByBenchmark.java | 4 +- 2 files changed, 53 insertions(+), 12 deletions(-) diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java index b9c357c6e4a6..142843753fdc 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/BenchmarkSchemas.java @@ -227,30 +227,71 @@ public class BenchmarkSchemas } static { // simple schema with null valued rows, no aggs on numeric columns - List simpleNullsSchemaColumns = ImmutableList.of( - // dims - BenchmarkColumnSchema.makeZipf("stringZipf", ValueType.STRING, false, 1, 0.5, 1, 101, 1.5), + List nullsSchemaColumns = ImmutableList.of( + // string dims with nulls + BenchmarkColumnSchema.makeZipf("stringZipf", ValueType.STRING, false, 1, 0.8, 1, 101, 1.5), BenchmarkColumnSchema.makeDiscreteUniform("stringUniform", ValueType.STRING, false, 1, 0.3, 1, 100000), - BenchmarkColumnSchema.makeSequential("stringSequentialHalfNull", ValueType.STRING, false, 1, 0.5, 0, 1000), + BenchmarkColumnSchema.makeSequential("stringSequential", ValueType.STRING, false, 1, 0.5, 0, 1000), // numeric dims with nulls BenchmarkColumnSchema.makeSequential("longSequential", ValueType.LONG, false, 1, 0.45, 0, 10000), BenchmarkColumnSchema.makeDiscreteUniform("longUniform", ValueType.LONG, false, 1, 0.25, 0, 500), - BenchmarkColumnSchema.makeZipf("doubleZipf", ValueType.DOUBLE, false, 1, 0.1, 0, 1000, 2.0) + BenchmarkColumnSchema.makeZipf("doubleZipf", ValueType.DOUBLE, false, 1, 0.1, 0, 1000, 2.0), + BenchmarkColumnSchema.makeZipf("floatZipf", ValueType.FLOAT, false, 1, 0.1, 0, 1000, 2.0) + ); + + List simpleNullsSchemaIngestAggs = new ArrayList<>(); + simpleNullsSchemaIngestAggs.add(new CountAggregatorFactory("rows")); + + Interval nullsSchemaDataInterval = Intervals.of("2000-01-01/P1D"); + + BenchmarkSchemaInfo nullsSchema = new BenchmarkSchemaInfo( + nullsSchemaColumns, + simpleNullsSchemaIngestAggs, + nullsSchemaDataInterval, + false + ); + + SCHEMA_MAP.put("nulls", nullsSchema); + } + + static { // simple schema with null valued rows, no aggs on numeric columns + List nullsSchemaColumns = ImmutableList.of( + // string dims + BenchmarkColumnSchema.makeZipf("stringZipf", ValueType.STRING, false, 1, null, 1, 101, 1.5), + BenchmarkColumnSchema.makeDiscreteUniform("stringUniform", ValueType.STRING, false, 1, null, 1, 100000), + BenchmarkColumnSchema.makeSequential("stringSequential", ValueType.STRING, false, 1, null, 0, 1000), + + // numeric dims + BenchmarkColumnSchema.makeSequential("longSequential", ValueType.LONG, false, 1, null, 0, 10000), + BenchmarkColumnSchema.makeDiscreteUniform("longUniform", ValueType.LONG, false, 1, null, 0, 500), + BenchmarkColumnSchema.makeZipf("doubleZipf", ValueType.DOUBLE, false, 1, null, 0, 1000, 2.0), + BenchmarkColumnSchema.makeZipf("floatZipf", ValueType.FLOAT, false, 1, null, 0, 1000, 2.0), + + // string dims with nulls + BenchmarkColumnSchema.makeZipf("stringZipfWithNulls", ValueType.STRING, false, 1, 0.8, 1, 101, 1.5), + BenchmarkColumnSchema.makeDiscreteUniform("stringUniformWithNulls", ValueType.STRING, false, 1, 0.3, 1, 100000), + BenchmarkColumnSchema.makeSequential("stringSequentialWithNulls", ValueType.STRING, false, 1, 0.5, 0, 1000), + + // numeric dims with nulls + BenchmarkColumnSchema.makeSequential("longSequentialWithNulls", ValueType.LONG, false, 1, 0.45, 0, 10000), + BenchmarkColumnSchema.makeDiscreteUniform("longUniformWithNulls", ValueType.LONG, false, 1, 0.25, 0, 500), + BenchmarkColumnSchema.makeZipf("doubleZipfWithNulls", ValueType.DOUBLE, false, 1, 0.1, 0, 1000, 2.0), + BenchmarkColumnSchema.makeZipf("floatZipfWithNulls", ValueType.FLOAT, false, 1, 0.1, 0, 1000, 2.0) ); List simpleNullsSchemaIngestAggs = new ArrayList<>(); simpleNullsSchemaIngestAggs.add(new CountAggregatorFactory("rows")); - Interval simpleNullsSchemaDataInterval = Intervals.of("2000-01-01/P1D"); + Interval nullsSchemaDataInterval = Intervals.of("2000-01-01/P1D"); - BenchmarkSchemaInfo simpleNullsSchema = new BenchmarkSchemaInfo( - simpleNullsSchemaColumns, + BenchmarkSchemaInfo nullsSchema = new BenchmarkSchemaInfo( + nullsSchemaColumns, simpleNullsSchemaIngestAggs, - simpleNullsSchemaDataInterval, + nullsSchemaDataInterval, false ); - SCHEMA_MAP.put("nulls", simpleNullsSchema); + SCHEMA_MAP.put("nulls-and-non-nulls", nullsSchema); } } diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/GroupByBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/GroupByBenchmark.java index 09e809f661ea..8cff9e5f1f2a 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/GroupByBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/GroupByBenchmark.java @@ -402,7 +402,7 @@ private void setupQueries() // simple one column schema, for testing performance difference between querying on numeric values as Strings and // directly as longs Map nullQueries = new LinkedHashMap<>(); - BenchmarkSchemaInfo nullSchema = BenchmarkSchemas.SCHEMA_MAP.get("simple-nulls"); + BenchmarkSchemaInfo nullSchema = BenchmarkSchemas.SCHEMA_MAP.get("nulls"); { // simple-null QuerySegmentSpec intervalSpec = new MultipleIntervalSegmentSpec(Collections.singletonList(nullSchema.getDataInterval())); @@ -425,7 +425,7 @@ private void setupQueries() nullQueries.put("A", queryA); } - SCHEMA_QUERY_MAP.put("simple-nulls", nullQueries); + SCHEMA_QUERY_MAP.put("nulls", nullQueries); } @Setup(Level.Trial)