From f156c615cc2b435d62f77427f422fc7f4ac78973 Mon Sep 17 00:00:00 2001 From: Clint Wylie Date: Fri, 15 Nov 2019 02:14:09 -0800 Subject: [PATCH 1/7] fix sql compatible null handling config work with runtime.properties --- .../druid/benchmark/BoundFilterBenchmark.java | 5 ++++ .../CompressedColumnarIntsBenchmark.java | 5 ++++ ...ressedVSizeColumnarMultiIntsBenchmark.java | 5 ++++ .../benchmark/DataSketchesHllBenchmark.java | 5 ++++ .../DimensionPredicateFilterBenchmark.java | 5 ++++ .../ExpressionAggregationBenchmark.java | 5 ++++ .../ExpressionSelectorBenchmark.java | 5 ++++ .../benchmark/FilterPartitionBenchmark.java | 4 +++ .../FilteredAggregatorBenchmark.java | 5 ++++ .../benchmark/FixedHistogramAddBenchmark.java | 5 ++++ .../benchmark/FixedHistogramBenchmark.java | 5 ++++ .../benchmark/FloatCompressionBenchmark.java | 5 ++++ ...loatCompressionBenchmarkFileGenerator.java | 5 ++++ .../benchmark/GenericIndexedBenchmark.java | 5 ++++ .../GroupByTypeInterfaceBenchmark.java | 5 ++++ .../IncrementalIndexRowTypeBenchmark.java | 5 ++++ .../druid/benchmark/LikeFilterBenchmark.java | 5 ++++ .../benchmark/LongCompressionBenchmark.java | 5 ++++ ...LongCompressionBenchmarkFileGenerator.java | 5 ++++ .../benchmark/TopNTypeInterfaceBenchmark.java | 5 ++++ .../druid/benchmark/VSizeSerdeBenchmark.java | 5 ++++ .../benchmark/datagen/SegmentGenerator.java | 5 ++++ .../IncrementalIndexReadBenchmark.java | 6 ++++ .../indexing/IndexIngestionBenchmark.java | 5 ++++ .../indexing/IndexMergeBenchmark.java | 5 ++++ .../indexing/IndexPersistBenchmark.java | 2 ++ .../StringDimensionIndexerBenchmark.java | 5 ++++ .../CachingClusteredClientBenchmark.java | 7 ++++- .../benchmark/query/GroupByBenchmark.java | 5 ++++ .../benchmark/query/QueryBenchmarkUtil.java | 5 ++++ .../druid/benchmark/query/ScanBenchmark.java | 5 ++++ .../benchmark/query/SearchBenchmark.java | 5 ++++ .../query/SerializingQueryRunner.java | 5 ++++ .../druid/benchmark/query/SqlBenchmark.java | 2 ++ .../benchmark/query/SqlVsNativeBenchmark.java | 5 ++++ .../benchmark/query/TimeseriesBenchmark.java | 5 ++++ .../druid/benchmark/query/TopNBenchmark.java | 5 ++++ .../timecompare/TimeCompareBenchmark.java | 2 ++ .../druid/common/config/NullHandling.java | 17 +++++++---- .../config/NullValueHandlingConfig.java | 3 +- ...fetchableTextFilesFirehoseFactoryTest.java | 2 ++ .../parsers/FlatTextFormatParserTest.java | 3 +- .../druid/math/expr/ApplyFunctionTest.java | 3 +- .../org/apache/druid/math/expr/EvalTest.java | 3 +- .../apache/druid/math/expr/FunctionTest.java | 3 +- .../apache/druid/math/expr/ParserTest.java | 3 +- .../testing/InitializedNullHandlingTest.java | 29 ++++++++++++++++++ .../DistinctCountGroupByQueryTest.java | 3 +- .../DistinctCountTimeseriesQueryTest.java | 3 +- .../DistinctCountTopNQueryTest.java | 3 +- .../materialized-view-selection/pom.xml | 8 ++++- .../MaterializedViewUtilsTest.java | 3 +- .../MomentsSketchAggregatorTest.java | 4 +-- .../moving-average-query/pom.xml | 30 ++++++++++++------- .../MovingAverageIterableTest.java | 3 +- .../movingaverage/MovingAverageQueryTest.java | 3 +- .../TDigestSketchAggregatorTest.java | 4 +-- extensions-contrib/virtual-columns/pom.xml | 7 +++++ .../segment/MapVirtualColumnGroupByTest.java | 3 +- .../segment/MapVirtualColumnTestBase.java | 3 +- .../segment/MapVirtualColumnTopNTest.java | 3 +- .../hll/HllSketchAggregatorTest.java | 3 +- .../bloom/BloomFilterAggregatorTest.java | 3 +- .../bloom/BloomFilterGroupByQueryTest.java | 3 +- .../sql/BloomFilterSqlAggregatorTest.java | 3 +- .../ApproximateHistogramAggregationTest.java | 3 +- .../ApproximateHistogramAggregatorTest.java | 3 +- .../ApproximateHistogramGroupByQueryTest.java | 3 +- ...pproximateHistogramPostAggregatorTest.java | 3 +- .../ApproximateHistogramTopNQueryTest.java | 3 +- .../FixedBucketsHistogramAggregationTest.java | 3 +- ...FixedBucketsHistogramGroupByQueryTest.java | 3 +- .../FixedBucketsHistogramTopNQueryTest.java | 3 +- .../kinesis/KinesisSamplerSpecTest.java | 5 ++++ .../NamespaceLookupExtractorFactoryTest.java | 5 ++++ .../namespace/UriExtractionNamespaceTest.java | 5 ++++ .../cache/JdbcExtractionNamespaceTest.java | 4 +++ extensions-core/lookups-cached-single/pom.xml | 7 +++++ .../server/lookup/LoadingLookupTest.java | 3 +- .../server/lookup/PollingLookupTest.java | 3 +- .../lookup/jdbc/JdbcDataFetcherTest.java | 3 +- .../VarianceAggregatorCollectorTest.java | 3 +- .../variance/VarianceAggregatorTest.java | 3 +- .../variance/VarianceGroupByQueryTest.java | 3 +- .../variance/VarianceTimeseriesQueryTest.java | 3 +- .../variance/VarianceTopNQueryTest.java | 3 +- .../sql/VarianceSqlAggregatorTest.java | 3 +- .../overlord/sampler/FirehoseSamplerTest.java | 11 +++---- .../SeekableStreamIndexTaskTestBase.java | 5 ++++ .../druid/segment/NilColumnValueSelector.java | 12 ++++---- .../collections/bitmap/BitmapBenchmark.java | 5 ++++ .../druid/query/expression/MacroTestBase.java | 3 +- .../metadata/SegmentMetadataQueryTest.java | 5 ++++ .../SegmentMetadataUnionQueryTest.java | 5 ++++ .../org/apache/druid/segment/IndexIOTest.java | 9 ++++-- .../druid/segment/IndexMergerTestBase.java | 4 +-- .../data/GenericIndexedStringWriterTest.java | 3 +- .../segment/data/GenericIndexedTest.java | 3 +- .../segment/data/IncrementalIndexTest.java | 3 +- .../druid/segment/filter/BaseFilterTest.java | 3 +- .../IncrementalIndexAdapterTest.java | 3 +- .../IncrementalIndexMultiValueSpecTest.java | 3 +- .../IncrementalIndexRowCompTest.java | 3 +- .../IncrementalIndexRowSizeTest.java | 3 +- .../IncrementalIndexStorageAdapterTest.java | 3 +- .../incremental/IncrementalIndexTest.java | 4 +-- .../OnheapIncrementalIndexTest.java | 4 +-- .../virtual/ExpressionVirtualColumnTest.java | 3 +- .../segment/virtual/VirtualColumnsTest.java | 3 +- .../sql/calcite/util/CalciteTestBase.java | 2 ++ 110 files changed, 429 insertions(+), 91 deletions(-) create mode 100644 core/src/test/java/org/apache/druid/testing/InitializedNullHandlingTest.java diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/BoundFilterBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/BoundFilterBenchmark.java index 682491789b44..6c0b6d940ed4 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/BoundFilterBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/BoundFilterBenchmark.java @@ -27,6 +27,7 @@ import org.apache.druid.collections.bitmap.MutableBitmap; import org.apache.druid.collections.bitmap.RoaringBitmapFactory; import org.apache.druid.collections.spatial.ImmutableRTree; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.extendedset.intset.ConciseSetUtils; import org.apache.druid.query.filter.BitmapIndexSelector; import org.apache.druid.query.filter.BoundDimFilter; @@ -60,6 +61,10 @@ @Measurement(iterations = 10) public class BoundFilterBenchmark { + static { + NullHandling.initializeForTests(); + } + private static final int START_INT = 1_000_000_000; private static final int END_INT = ConciseSetUtils.MAX_ALLOWED_INTEGER; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/CompressedColumnarIntsBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/CompressedColumnarIntsBenchmark.java index 32dd6f23b7cb..5e283ae55d9c 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/CompressedColumnarIntsBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/CompressedColumnarIntsBenchmark.java @@ -20,6 +20,7 @@ package org.apache.druid.benchmark; import it.unimi.dsi.fastutil.ints.IntArrayList; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.io.Closer; import org.apache.druid.segment.data.ColumnarInts; import org.apache.druid.segment.data.CompressedVSizeColumnarIntsSupplier; @@ -49,6 +50,10 @@ @State(Scope.Benchmark) public class CompressedColumnarIntsBenchmark { + static { + NullHandling.initializeForTests(); + } + private IndexedInts uncompressed; private IndexedInts compressed; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/CompressedVSizeColumnarMultiIntsBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/CompressedVSizeColumnarMultiIntsBenchmark.java index 1c7c350df321..bbf5b537c839 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/CompressedVSizeColumnarMultiIntsBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/CompressedVSizeColumnarMultiIntsBenchmark.java @@ -21,6 +21,7 @@ import com.google.common.base.Function; import com.google.common.collect.Iterables; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.io.Closer; import org.apache.druid.segment.data.ColumnarInts; import org.apache.druid.segment.data.ColumnarMultiInts; @@ -54,6 +55,10 @@ @State(Scope.Benchmark) public class CompressedVSizeColumnarMultiIntsBenchmark { + static { + NullHandling.initializeForTests(); + } + private ColumnarMultiInts uncompressed; private ColumnarMultiInts compressed; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/DataSketchesHllBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/DataSketchesHllBenchmark.java index 3493f559412e..1c0ddae58d0a 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/DataSketchesHllBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/DataSketchesHllBenchmark.java @@ -20,6 +20,7 @@ package org.apache.druid.benchmark; import com.yahoo.sketches.hll.HllSketch; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.query.aggregation.AggregatorFactory; import org.apache.druid.query.aggregation.BufferAggregator; import org.apache.druid.query.aggregation.datasketches.hll.HllSketchMergeAggregatorFactory; @@ -54,6 +55,10 @@ @State(Scope.Benchmark) public class DataSketchesHllBenchmark { + static { + NullHandling.initializeForTests(); + } + private final AggregatorFactory aggregatorFactory = new HllSketchMergeAggregatorFactory( "hll", "hll", diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/DimensionPredicateFilterBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/DimensionPredicateFilterBenchmark.java index 6f7a2bb09b5e..8dd177f1e831 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/DimensionPredicateFilterBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/DimensionPredicateFilterBenchmark.java @@ -28,6 +28,7 @@ import org.apache.druid.collections.bitmap.MutableBitmap; import org.apache.druid.collections.bitmap.RoaringBitmapFactory; import org.apache.druid.collections.spatial.ImmutableRTree; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.query.filter.BitmapIndexSelector; import org.apache.druid.query.filter.DruidDoublePredicate; import org.apache.druid.query.filter.DruidFloatPredicate; @@ -62,6 +63,10 @@ @Measurement(iterations = 10) public class DimensionPredicateFilterBenchmark { + static { + NullHandling.initializeForTests(); + } + private static final int START_INT = 1_000_000_000; private static final DimensionPredicateFilter IS_EVEN = new DimensionPredicateFilter( diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/ExpressionAggregationBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/ExpressionAggregationBenchmark.java index 14c36867e9d9..7d7c8c45f81a 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/ExpressionAggregationBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/ExpressionAggregationBenchmark.java @@ -24,6 +24,7 @@ import org.apache.druid.benchmark.datagen.BenchmarkColumnSchema; import org.apache.druid.benchmark.datagen.BenchmarkSchemaInfo; import org.apache.druid.benchmark.datagen.SegmentGenerator; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.Intervals; import org.apache.druid.java.util.common.granularity.Granularities; import org.apache.druid.java.util.common.guava.Sequence; @@ -71,6 +72,10 @@ @OutputTimeUnit(TimeUnit.MILLISECONDS) public class ExpressionAggregationBenchmark { + static { + NullHandling.initializeForTests(); + } + @Param({"1000000"}) private int rowsPerSegment; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/ExpressionSelectorBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/ExpressionSelectorBenchmark.java index 46be7ff1d571..d3406a469051 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/ExpressionSelectorBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/ExpressionSelectorBenchmark.java @@ -23,6 +23,7 @@ import org.apache.druid.benchmark.datagen.BenchmarkColumnSchema; import org.apache.druid.benchmark.datagen.BenchmarkSchemaInfo; import org.apache.druid.benchmark.datagen.SegmentGenerator; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.Intervals; import org.apache.druid.java.util.common.granularity.Granularities; import org.apache.druid.java.util.common.guava.Sequence; @@ -70,6 +71,10 @@ @OutputTimeUnit(TimeUnit.MILLISECONDS) public class ExpressionSelectorBenchmark { + static { + NullHandling.initializeForTests(); + } + @Param({"1000000"}) private int rowsPerSegment; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/FilterPartitionBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/FilterPartitionBenchmark.java index 0309ac7a5da7..cedf85b00edf 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/FilterPartitionBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/FilterPartitionBenchmark.java @@ -102,6 +102,10 @@ @Measurement(iterations = 25) public class FilterPartitionBenchmark { + static { + NullHandling.initializeForTests(); + } + @Param({"750000"}) private int rowsPerSegment; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/FilteredAggregatorBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/FilteredAggregatorBenchmark.java index a1948221a8e1..ec4256425297 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/FilteredAggregatorBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/FilteredAggregatorBenchmark.java @@ -27,6 +27,7 @@ import org.apache.druid.benchmark.datagen.BenchmarkSchemaInfo; import org.apache.druid.benchmark.datagen.BenchmarkSchemas; import org.apache.druid.benchmark.query.QueryBenchmarkUtil; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; import org.apache.druid.jackson.DefaultObjectMapper; import org.apache.druid.java.util.common.granularity.Granularities; @@ -99,6 +100,10 @@ @Measurement(iterations = 25) public class FilteredAggregatorBenchmark { + static { + NullHandling.initializeForTests(); + } + @Param({"75000"}) private int rowsPerSegment; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/FixedHistogramAddBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/FixedHistogramAddBenchmark.java index 39ef26c46e2e..c5010bbccef0 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/FixedHistogramAddBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/FixedHistogramAddBenchmark.java @@ -20,6 +20,7 @@ package org.apache.druid.benchmark; import org.apache.commons.math3.distribution.NormalDistribution; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.query.aggregation.histogram.FixedBucketsHistogram; import org.openjdk.jmh.annotations.Benchmark; import org.openjdk.jmh.annotations.BenchmarkMode; @@ -46,6 +47,10 @@ @OutputTimeUnit(TimeUnit.MICROSECONDS) public class FixedHistogramAddBenchmark { + static { + NullHandling.initializeForTests(); + } + private static final int LOWER_LIMIT = 0; private static final int UPPER_LIMIT = 100000; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/FixedHistogramBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/FixedHistogramBenchmark.java index 8e0e6de4682d..747b645816d4 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/FixedHistogramBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/FixedHistogramBenchmark.java @@ -19,6 +19,7 @@ package org.apache.druid.benchmark; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.logger.Logger; import org.apache.druid.query.aggregation.histogram.FixedBucketsHistogram; import org.openjdk.jmh.annotations.Benchmark; @@ -46,6 +47,10 @@ @OutputTimeUnit(TimeUnit.MICROSECONDS) public class FixedHistogramBenchmark { + static { + NullHandling.initializeForTests(); + } + private static final Logger log = new Logger(FixedHistogramBenchmark.class); private static final int LOWER_LIMIT = 0; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/FloatCompressionBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/FloatCompressionBenchmark.java index 8ac9941b5828..1663c0eba373 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/FloatCompressionBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/FloatCompressionBenchmark.java @@ -20,6 +20,7 @@ package org.apache.druid.benchmark; import com.google.common.base.Supplier; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.FileUtils; import org.apache.druid.java.util.common.MappedByteBufferHandler; import org.apache.druid.segment.data.ColumnarFloats; @@ -55,6 +56,10 @@ @OutputTimeUnit(TimeUnit.MILLISECONDS) public class FloatCompressionBenchmark { + static { + NullHandling.initializeForTests(); + } + @Param("floatCompress/") private static String dirPath; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/FloatCompressionBenchmarkFileGenerator.java b/benchmarks/src/main/java/org/apache/druid/benchmark/FloatCompressionBenchmarkFileGenerator.java index 03c31a2daa5f..ef3bffc65004 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/FloatCompressionBenchmarkFileGenerator.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/FloatCompressionBenchmarkFileGenerator.java @@ -22,6 +22,7 @@ import com.google.common.collect.ImmutableList; import org.apache.druid.benchmark.datagen.BenchmarkColumnSchema; import org.apache.druid.benchmark.datagen.BenchmarkColumnValueGenerator; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.logger.Logger; import org.apache.druid.segment.column.ValueType; import org.apache.druid.segment.data.ColumnarFloatsSerializer; @@ -44,6 +45,10 @@ public class FloatCompressionBenchmarkFileGenerator { + static { + NullHandling.initializeForTests(); + } + private static final Logger log = new Logger(FloatCompressionBenchmarkFileGenerator.class); public static final int ROW_NUM = 5000000; public static final List COMPRESSIONS = diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/GenericIndexedBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/GenericIndexedBenchmark.java index 27a57f9ca9da..c8ea121d1ddb 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/GenericIndexedBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/GenericIndexedBenchmark.java @@ -21,6 +21,7 @@ import com.google.common.io.Files; import com.google.common.primitives.Ints; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.io.smoosh.FileSmoosher; import org.apache.druid.java.util.common.io.smoosh.SmooshedFileMapper; import org.apache.druid.segment.data.GenericIndexed; @@ -60,6 +61,10 @@ @State(Scope.Benchmark) public class GenericIndexedBenchmark { + static { + NullHandling.initializeForTests(); + } + public static final int ITERATIONS = 10000; static final ObjectStrategy BYTE_ARRAY_STRATEGY = new ObjectStrategy() diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/GroupByTypeInterfaceBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/GroupByTypeInterfaceBenchmark.java index ea50070fce07..06e27787aa97 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/GroupByTypeInterfaceBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/GroupByTypeInterfaceBenchmark.java @@ -33,6 +33,7 @@ import org.apache.druid.collections.DefaultBlockingPool; import org.apache.druid.collections.NonBlockingPool; import org.apache.druid.collections.StupidPool; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; import org.apache.druid.jackson.DefaultObjectMapper; import org.apache.druid.java.util.common.granularity.Granularities; @@ -108,6 +109,10 @@ @Measurement(iterations = 30) public class GroupByTypeInterfaceBenchmark { + static { + NullHandling.initializeForTests(); + } + private static final SegmentId Q_INDEX_SEGMENT_ID = SegmentId.dummy("qIndex"); @Param({"4"}) diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/IncrementalIndexRowTypeBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/IncrementalIndexRowTypeBenchmark.java index 1c0e841285d6..0da6c06c747c 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/IncrementalIndexRowTypeBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/IncrementalIndexRowTypeBenchmark.java @@ -20,6 +20,7 @@ package org.apache.druid.benchmark; import com.google.common.collect.ImmutableMap; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; import org.apache.druid.data.input.MapBasedInputRow; import org.apache.druid.java.util.common.StringUtils; @@ -48,6 +49,10 @@ @State(Scope.Benchmark) public class IncrementalIndexRowTypeBenchmark { + static { + NullHandling.initializeForTests(); + } + private IncrementalIndex incIndex; private IncrementalIndex incFloatIndex; private IncrementalIndex incStrIndex; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/LikeFilterBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/LikeFilterBenchmark.java index ce445ca16ede..83551146eb24 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/LikeFilterBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/LikeFilterBenchmark.java @@ -26,6 +26,7 @@ import org.apache.druid.collections.bitmap.MutableBitmap; import org.apache.druid.collections.bitmap.RoaringBitmapFactory; import org.apache.druid.collections.spatial.ImmutableRTree; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.query.filter.BitmapIndexSelector; import org.apache.druid.query.filter.BoundDimFilter; import org.apache.druid.query.filter.Filter; @@ -62,6 +63,10 @@ @Measurement(iterations = 10) public class LikeFilterBenchmark { + static { + NullHandling.initializeForTests(); + } + private static final int START_INT = 1_000_000; private static final int END_INT = 9_999_999; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/LongCompressionBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/LongCompressionBenchmark.java index f8383bfbf608..7bd057311a4d 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/LongCompressionBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/LongCompressionBenchmark.java @@ -20,6 +20,7 @@ package org.apache.druid.benchmark; import com.google.common.base.Supplier; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.FileUtils; import org.apache.druid.java.util.common.MappedByteBufferHandler; import org.apache.druid.segment.data.ColumnarLongs; @@ -55,6 +56,10 @@ @OutputTimeUnit(TimeUnit.MILLISECONDS) public class LongCompressionBenchmark { + static { + NullHandling.initializeForTests(); + } + @Param("longCompress/") private static String dirPath; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/LongCompressionBenchmarkFileGenerator.java b/benchmarks/src/main/java/org/apache/druid/benchmark/LongCompressionBenchmarkFileGenerator.java index 8495d672ead8..31c39fe040b4 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/LongCompressionBenchmarkFileGenerator.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/LongCompressionBenchmarkFileGenerator.java @@ -22,6 +22,7 @@ import com.google.common.collect.ImmutableList; import org.apache.druid.benchmark.datagen.BenchmarkColumnSchema; import org.apache.druid.benchmark.datagen.BenchmarkColumnValueGenerator; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.logger.Logger; import org.apache.druid.segment.column.ValueType; import org.apache.druid.segment.data.ColumnarLongsSerializer; @@ -44,6 +45,10 @@ public class LongCompressionBenchmarkFileGenerator { + static { + NullHandling.initializeForTests(); + } + private static final Logger log = new Logger(LongCompressionBenchmarkFileGenerator.class); public static final int ROW_NUM = 5000000; public static final List COMPRESSIONS = diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/TopNTypeInterfaceBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/TopNTypeInterfaceBenchmark.java index f24a9f8242d2..7ceb6998de4a 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/TopNTypeInterfaceBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/TopNTypeInterfaceBenchmark.java @@ -26,6 +26,7 @@ import org.apache.druid.benchmark.datagen.BenchmarkSchemas; import org.apache.druid.benchmark.query.QueryBenchmarkUtil; import org.apache.druid.collections.StupidPool; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; import org.apache.druid.jackson.DefaultObjectMapper; import org.apache.druid.java.util.common.granularity.Granularities; @@ -99,6 +100,10 @@ @Measurement(iterations = 25) public class TopNTypeInterfaceBenchmark { + static { + NullHandling.initializeForTests(); + } + private static final SegmentId Q_INDEX_SEGMENT_ID = SegmentId.dummy("qIndex"); @Param({"1"}) diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/VSizeSerdeBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/VSizeSerdeBenchmark.java index e96c36cb75f4..1738046205e1 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/VSizeSerdeBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/VSizeSerdeBenchmark.java @@ -19,6 +19,7 @@ package org.apache.druid.benchmark; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.FileUtils; import org.apache.druid.java.util.common.MappedByteBufferHandler; import org.apache.druid.java.util.common.logger.Logger; @@ -53,6 +54,10 @@ @OutputTimeUnit(TimeUnit.MILLISECONDS) public class VSizeSerdeBenchmark { + static { + NullHandling.initializeForTests(); + } + private static final Logger log = new Logger(VSizeSerdeBenchmark.class); @Param({"500000"}) private int values; 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 74466d07de96..c2dd1400d923 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 @@ -23,6 +23,7 @@ import com.google.common.hash.Hashing; import com.google.common.io.Files; import org.apache.commons.io.FileUtils; +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; @@ -68,6 +69,10 @@ public class SegmentGenerator implements Closeable private static final String CACHE_DIR_PROPERTY = "druid.benchmark.cacheDir"; private static final String CACHE_DIR_ENV_VAR = "DRUID_BENCHMARK_CACHE_DIR"; + static { + NullHandling.initializeForTests(); + } + private final File cacheDir; private final boolean cleanupCacheDir; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IncrementalIndexReadBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IncrementalIndexReadBenchmark.java index 122577dff8c9..f68f99394518 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IncrementalIndexReadBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IncrementalIndexReadBenchmark.java @@ -22,6 +22,7 @@ import org.apache.druid.benchmark.datagen.BenchmarkDataGenerator; import org.apache.druid.benchmark.datagen.BenchmarkSchemaInfo; import org.apache.druid.benchmark.datagen.BenchmarkSchemas; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; import org.apache.druid.java.util.common.granularity.Granularities; import org.apache.druid.java.util.common.guava.Sequence; @@ -83,6 +84,11 @@ public class IncrementalIndexReadBenchmark private static final Logger log = new Logger(IncrementalIndexReadBenchmark.class); private static final int RNG_SEED = 9999; + + static { + NullHandling.initializeForTests(); + } + private IncrementalIndex incIndex; private BenchmarkSchemaInfo schemaInfo; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IndexIngestionBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IndexIngestionBenchmark.java index 907ec9bd3c79..19862f27c948 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IndexIngestionBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IndexIngestionBenchmark.java @@ -22,6 +22,7 @@ import org.apache.druid.benchmark.datagen.BenchmarkDataGenerator; import org.apache.druid.benchmark.datagen.BenchmarkSchemaInfo; import org.apache.druid.benchmark.datagen.BenchmarkSchemas; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; import org.apache.druid.java.util.common.logger.Logger; import org.apache.druid.query.aggregation.hyperloglog.HyperUniquesSerde; @@ -63,6 +64,10 @@ public class IndexIngestionBenchmark private static final Logger log = new Logger(IndexIngestionBenchmark.class); private static final int RNG_SEED = 9999; + static { + NullHandling.initializeForTests(); + } + private IncrementalIndex incIndex; private ArrayList rows; private BenchmarkSchemaInfo schemaInfo; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IndexMergeBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IndexMergeBenchmark.java index da08e0bac8c8..78a642fb80d9 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IndexMergeBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IndexMergeBenchmark.java @@ -26,6 +26,7 @@ import org.apache.druid.benchmark.datagen.BenchmarkDataGenerator; import org.apache.druid.benchmark.datagen.BenchmarkSchemaInfo; import org.apache.druid.benchmark.datagen.BenchmarkSchemas; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; import org.apache.druid.jackson.DefaultObjectMapper; import org.apache.druid.java.util.common.logger.Logger; @@ -84,6 +85,10 @@ public class IndexMergeBenchmark private static final IndexIO INDEX_IO; public static final ObjectMapper JSON_MAPPER; + static { + NullHandling.initializeForTests(); + } + private List indexesToMerge; private BenchmarkSchemaInfo schemaInfo; private File tmpDir; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IndexPersistBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IndexPersistBenchmark.java index 19d109cccdb5..826c4095f2e8 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IndexPersistBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/IndexPersistBenchmark.java @@ -25,6 +25,7 @@ import org.apache.druid.benchmark.datagen.BenchmarkDataGenerator; import org.apache.druid.benchmark.datagen.BenchmarkSchemaInfo; import org.apache.druid.benchmark.datagen.BenchmarkSchemas; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; import org.apache.druid.jackson.DefaultObjectMapper; import org.apache.druid.java.util.common.logger.Logger; @@ -69,6 +70,7 @@ public class IndexPersistBenchmark private static final IndexIO INDEX_IO; static { + NullHandling.initializeForTests(); JSON_MAPPER = new DefaultObjectMapper(); INDEX_IO = new IndexIO( JSON_MAPPER, diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/StringDimensionIndexerBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/StringDimensionIndexerBenchmark.java index eacfc652db8e..52fc85194e7c 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/StringDimensionIndexerBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/indexing/StringDimensionIndexerBenchmark.java @@ -19,6 +19,7 @@ package org.apache.druid.benchmark.indexing; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.impl.DimensionSchema; import org.apache.druid.segment.StringDimensionIndexer; import org.openjdk.jmh.annotations.Benchmark; @@ -42,6 +43,10 @@ @Measurement(iterations = 10) public class StringDimensionIndexerBenchmark { + static { + NullHandling.initializeForTests(); + } + StringDimensionIndexer indexer; int[] exampleArray; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/CachingClusteredClientBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/CachingClusteredClientBenchmark.java index 2e110e220c8a..6fa37a896a72 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/CachingClusteredClientBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/CachingClusteredClientBenchmark.java @@ -47,6 +47,7 @@ import org.apache.druid.collections.DefaultBlockingPool; import org.apache.druid.collections.NonBlockingPool; import org.apache.druid.collections.StupidPool; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.guice.http.DruidHttpClientConfig; import org.apache.druid.jackson.DefaultObjectMapper; import org.apache.druid.java.util.common.concurrent.Execs; @@ -149,10 +150,14 @@ public class CachingClusteredClientBenchmark private static final String DATA_SOURCE = "ds"; public static final ObjectMapper JSON_MAPPER; + + static { + NullHandling.initializeForTests(); + } + @Param({"8", "24"}) private int numServers; - @Param({"0", "1", "4"}) private int parallelism; 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 443ff147dbc6..d493e4c4951d 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 @@ -34,6 +34,7 @@ import org.apache.druid.collections.DefaultBlockingPool; import org.apache.druid.collections.NonBlockingPool; import org.apache.druid.collections.StupidPool; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; import org.apache.druid.jackson.DefaultObjectMapper; import org.apache.druid.java.util.common.concurrent.Execs; @@ -148,6 +149,10 @@ public class GroupByBenchmark private static final IndexIO INDEX_IO; public static final ObjectMapper JSON_MAPPER; + static { + NullHandling.initializeForTests(); + } + private File tmpDir; private IncrementalIndex anIncrementalIndex; private List queryableIndexes; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/QueryBenchmarkUtil.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/QueryBenchmarkUtil.java index 65891248802c..43cf6d20fa64 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/QueryBenchmarkUtil.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/QueryBenchmarkUtil.java @@ -20,6 +20,7 @@ package org.apache.druid.benchmark.query; import com.google.common.util.concurrent.ListenableFuture; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.guava.Sequence; import org.apache.druid.query.BySegmentQueryRunner; import org.apache.druid.query.FinalizeResultsQueryRunner; @@ -36,6 +37,10 @@ public class QueryBenchmarkUtil { + static { + NullHandling.initializeForTests(); + } + public static > QueryRunner makeQueryRunner( QueryRunnerFactory factory, SegmentId segmentId, diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/ScanBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/ScanBenchmark.java index 5afcab6205c8..60b7712f1f27 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/ScanBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/ScanBenchmark.java @@ -27,6 +27,7 @@ import org.apache.druid.benchmark.datagen.BenchmarkDataGenerator; import org.apache.druid.benchmark.datagen.BenchmarkSchemaInfo; import org.apache.druid.benchmark.datagen.BenchmarkSchemas; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; import org.apache.druid.data.input.Row; import org.apache.druid.jackson.DefaultObjectMapper; @@ -125,6 +126,10 @@ public class ScanBenchmark private static final IndexMergerV9 INDEX_MERGER_V9; private static final IndexIO INDEX_IO; + static { + NullHandling.initializeForTests(); + } + private List incIndexes; private List qIndexes; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/SearchBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/SearchBenchmark.java index 59f1fecb8f50..b04f1e1dbb51 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/SearchBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/SearchBenchmark.java @@ -29,6 +29,7 @@ import org.apache.druid.benchmark.datagen.BenchmarkDataGenerator; import org.apache.druid.benchmark.datagen.BenchmarkSchemaInfo; import org.apache.druid.benchmark.datagen.BenchmarkSchemas; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; import org.apache.druid.data.input.Row; import org.apache.druid.jackson.DefaultObjectMapper; @@ -125,6 +126,10 @@ public class SearchBenchmark private static final IndexIO INDEX_IO; public static final ObjectMapper JSON_MAPPER; + static { + NullHandling.initializeForTests(); + } + private List incIndexes; private List qIndexes; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/SerializingQueryRunner.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/SerializingQueryRunner.java index ec5d378aa2cc..cfdd30af391a 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/SerializingQueryRunner.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/SerializingQueryRunner.java @@ -21,6 +21,7 @@ import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.guava.Sequence; import org.apache.druid.java.util.common.guava.Sequences; import org.apache.druid.java.util.common.jackson.JacksonUtils; @@ -30,6 +31,10 @@ public class SerializingQueryRunner implements QueryRunner { + static { + NullHandling.initializeForTests(); + } + private final ObjectMapper smileMapper; private final QueryRunner baseRunner; private final Class clazz; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/SqlBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/SqlBenchmark.java index cbb339e5a087..f51684a221a8 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/SqlBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/SqlBenchmark.java @@ -24,6 +24,7 @@ import org.apache.druid.benchmark.datagen.BenchmarkSchemaInfo; import org.apache.druid.benchmark.datagen.BenchmarkSchemas; import org.apache.druid.benchmark.datagen.SegmentGenerator; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.Pair; import org.apache.druid.java.util.common.granularity.Granularities; import org.apache.druid.java.util.common.guava.Sequence; @@ -75,6 +76,7 @@ public class SqlBenchmark { static { + NullHandling.initializeForTests(); Calcites.setSystemProperties(); } diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/SqlVsNativeBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/SqlVsNativeBenchmark.java index d2787ddd31b2..043405da1de3 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/SqlVsNativeBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/SqlVsNativeBenchmark.java @@ -22,6 +22,7 @@ import org.apache.druid.benchmark.datagen.BenchmarkSchemaInfo; import org.apache.druid.benchmark.datagen.BenchmarkSchemas; import org.apache.druid.benchmark.datagen.SegmentGenerator; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.Intervals; import org.apache.druid.java.util.common.Pair; import org.apache.druid.java.util.common.granularity.Granularities; @@ -80,6 +81,10 @@ public class SqlVsNativeBenchmark private static final Logger log = new Logger(SqlVsNativeBenchmark.class); + static { + NullHandling.initializeForTests(); + } + private SpecificSegmentsQuerySegmentWalker walker; private PlannerFactory plannerFactory; private GroupByQuery groupByQuery; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/TimeseriesBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/TimeseriesBenchmark.java index ba2484a93f52..f8e66536dc44 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/TimeseriesBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/TimeseriesBenchmark.java @@ -25,6 +25,7 @@ import org.apache.druid.benchmark.datagen.BenchmarkDataGenerator; import org.apache.druid.benchmark.datagen.BenchmarkSchemaInfo; import org.apache.druid.benchmark.datagen.BenchmarkSchemas; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; import org.apache.druid.jackson.DefaultObjectMapper; import org.apache.druid.java.util.common.Intervals; @@ -117,6 +118,10 @@ public class TimeseriesBenchmark private static final IndexIO INDEX_IO; public static final ObjectMapper JSON_MAPPER; + static { + NullHandling.initializeForTests(); + } + private List incIndexes; private List qIndexes; private File tmpDir; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/TopNBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/TopNBenchmark.java index 904cdfeb8e8e..df4c22740418 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/TopNBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/TopNBenchmark.java @@ -26,6 +26,7 @@ import org.apache.druid.benchmark.datagen.BenchmarkSchemaInfo; import org.apache.druid.benchmark.datagen.BenchmarkSchemas; import org.apache.druid.collections.StupidPool; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; import org.apache.druid.jackson.DefaultObjectMapper; import org.apache.druid.java.util.common.concurrent.Execs; @@ -117,6 +118,10 @@ public class TopNBenchmark private static final IndexIO INDEX_IO; public static final ObjectMapper JSON_MAPPER; + static { + NullHandling.initializeForTests(); + } + private List incIndexes; private List qIndexes; diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/timecompare/TimeCompareBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/timecompare/TimeCompareBenchmark.java index 83dfe0ab8f33..92805ad46f05 100644 --- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/timecompare/TimeCompareBenchmark.java +++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/timecompare/TimeCompareBenchmark.java @@ -28,6 +28,7 @@ import org.apache.druid.benchmark.datagen.BenchmarkSchemas; import org.apache.druid.benchmark.query.QueryBenchmarkUtil; import org.apache.druid.collections.StupidPool; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.InputRow; import org.apache.druid.jackson.DefaultObjectMapper; import org.apache.druid.java.util.common.Intervals; @@ -119,6 +120,7 @@ public class TimeCompareBenchmark protected static final Map SCRIPT_DOUBLE_SUM = new HashMap<>(); static { + NullHandling.initializeForTests(); SCRIPT_DOUBLE_SUM.put("fnAggregate", "function aggregate(current, a) { return current + a }"); SCRIPT_DOUBLE_SUM.put("fnReset", "function reset() { return 0 }"); SCRIPT_DOUBLE_SUM.put("fnCombine", "function combine(a,b) { return a + b }"); diff --git a/core/src/main/java/org/apache/druid/common/config/NullHandling.java b/core/src/main/java/org/apache/druid/common/config/NullHandling.java index 71ac2bda341c..cabe9734f986 100644 --- a/core/src/main/java/org/apache/druid/common/config/NullHandling.java +++ b/core/src/main/java/org/apache/druid/common/config/NullHandling.java @@ -19,6 +19,7 @@ package org.apache.druid.common.config; +import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Strings; import com.google.inject.Inject; @@ -31,8 +32,6 @@ */ public class NullHandling { - public static final String NULL_HANDLING_CONFIG_STRING = "druid.generic.useDefaultValueForNull"; - /** * use these values to ensure that {@link NullHandling#defaultDoubleValue()}, * {@link NullHandling#defaultFloatValue()} , {@link NullHandling#defaultFloatValue()} @@ -50,9 +49,17 @@ public class NullHandling * It does not take effect in all unit tests since we don't use Guice Injection. */ @Inject - private static NullValueHandlingConfig INSTANCE = new NullValueHandlingConfig( - Boolean.valueOf(System.getProperty(NULL_HANDLING_CONFIG_STRING, "true")) - ); + private static NullValueHandlingConfig INSTANCE; + + /** + * Many unit tests do not setup modules for this value to be injected, this method provides a manual way to initialize + * {@link #INSTANCE} + */ + @VisibleForTesting + public static void initializeForTests() + { + INSTANCE = new NullValueHandlingConfig(null); + } /** * whether nulls should be replaced with default value. diff --git a/core/src/main/java/org/apache/druid/common/config/NullValueHandlingConfig.java b/core/src/main/java/org/apache/druid/common/config/NullValueHandlingConfig.java index b9e0670584f4..ae15d95969c2 100644 --- a/core/src/main/java/org/apache/druid/common/config/NullValueHandlingConfig.java +++ b/core/src/main/java/org/apache/druid/common/config/NullValueHandlingConfig.java @@ -24,6 +24,7 @@ public class NullValueHandlingConfig { + private static final String NULL_HANDLING_CONFIG_STRING = "druid.generic.useDefaultValueForNull"; @JsonProperty("useDefaultValueForNull") private final boolean useDefaultValuesForNull; @@ -32,7 +33,7 @@ public class NullValueHandlingConfig public NullValueHandlingConfig(@JsonProperty("useDefaultValueForNull") Boolean useDefaultValuesForNull) { this.useDefaultValuesForNull = useDefaultValuesForNull == null - ? true + ? Boolean.valueOf(System.getProperty(NULL_HANDLING_CONFIG_STRING, "true")) : useDefaultValuesForNull; } diff --git a/core/src/test/java/org/apache/druid/data/input/impl/prefetch/PrefetchableTextFilesFirehoseFactoryTest.java b/core/src/test/java/org/apache/druid/data/input/impl/prefetch/PrefetchableTextFilesFirehoseFactoryTest.java index 1564daca5350..d3a09a02e0fc 100644 --- a/core/src/test/java/org/apache/druid/data/input/impl/prefetch/PrefetchableTextFilesFirehoseFactoryTest.java +++ b/core/src/test/java/org/apache/druid/data/input/impl/prefetch/PrefetchableTextFilesFirehoseFactoryTest.java @@ -24,6 +24,7 @@ import com.google.common.io.CountingOutputStream; import org.apache.commons.io.FileUtils; import org.apache.commons.io.filefilter.TrueFileFilter; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.FiniteFirehoseFactory; import org.apache.druid.data.input.Firehose; import org.apache.druid.data.input.InputSplit; @@ -94,6 +95,7 @@ public class PrefetchableTextFilesFirehoseFactoryTest @BeforeClass public static void setup() throws IOException { + NullHandling.initializeForTests(); TEST_DIR = tempDir.newFolder(); for (int i = 0; i < 100; i++) { try ( diff --git a/core/src/test/java/org/apache/druid/java/util/common/parsers/FlatTextFormatParserTest.java b/core/src/test/java/org/apache/druid/java/util/common/parsers/FlatTextFormatParserTest.java index 571a0d359b8b..5393da4ab3fa 100644 --- a/core/src/test/java/org/apache/druid/java/util/common/parsers/FlatTextFormatParserTest.java +++ b/core/src/test/java/org/apache/druid/java/util/common/parsers/FlatTextFormatParserTest.java @@ -24,6 +24,7 @@ import org.apache.druid.java.util.common.IAE; import org.apache.druid.java.util.common.StringUtils; import org.apache.druid.java.util.common.parsers.AbstractFlatTextFormatParser.FlatTextFormat; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Rule; import org.junit.Test; @@ -38,7 +39,7 @@ import java.util.stream.Collectors; @RunWith(Parameterized.class) -public class FlatTextFormatParserTest +public class FlatTextFormatParserTest extends InitializedNullHandlingTest { @Parameters(name = "{0}") public static Collection constructorFeeder() diff --git a/core/src/test/java/org/apache/druid/math/expr/ApplyFunctionTest.java b/core/src/test/java/org/apache/druid/math/expr/ApplyFunctionTest.java index 83a1151d0d6c..80d0410eeae1 100644 --- a/core/src/test/java/org/apache/druid/math/expr/ApplyFunctionTest.java +++ b/core/src/test/java/org/apache/druid/math/expr/ApplyFunctionTest.java @@ -21,13 +21,14 @@ import com.google.common.collect.ImmutableMap; import org.apache.druid.common.config.NullHandling; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; -public class ApplyFunctionTest +public class ApplyFunctionTest extends InitializedNullHandlingTest { private Expr.ObjectBinding bindings; diff --git a/core/src/test/java/org/apache/druid/math/expr/EvalTest.java b/core/src/test/java/org/apache/druid/math/expr/EvalTest.java index 70e1a955fc86..732e744fd8fe 100644 --- a/core/src/test/java/org/apache/druid/math/expr/EvalTest.java +++ b/core/src/test/java/org/apache/druid/math/expr/EvalTest.java @@ -21,12 +21,13 @@ import com.google.common.collect.ImmutableMap; import org.apache.druid.common.config.NullHandling; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Test; /** */ -public class EvalTest +public class EvalTest extends InitializedNullHandlingTest { private long evalLong(String x, Expr.ObjectBinding bindings) { diff --git a/core/src/test/java/org/apache/druid/math/expr/FunctionTest.java b/core/src/test/java/org/apache/druid/math/expr/FunctionTest.java index ac110880a08c..5571096ccb4f 100644 --- a/core/src/test/java/org/apache/druid/math/expr/FunctionTest.java +++ b/core/src/test/java/org/apache/druid/math/expr/FunctionTest.java @@ -21,11 +21,12 @@ import com.google.common.collect.ImmutableMap; import org.apache.druid.common.config.NullHandling; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Before; import org.junit.Test; -public class FunctionTest +public class FunctionTest extends InitializedNullHandlingTest { private Expr.ObjectBinding bindings; diff --git a/core/src/test/java/org/apache/druid/math/expr/ParserTest.java b/core/src/test/java/org/apache/druid/math/expr/ParserTest.java index 3ab11606b78c..27a9eb4abde4 100644 --- a/core/src/test/java/org/apache/druid/math/expr/ParserTest.java +++ b/core/src/test/java/org/apache/druid/math/expr/ParserTest.java @@ -22,6 +22,7 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Test; @@ -32,7 +33,7 @@ /** * */ -public class ParserTest +public class ParserTest extends InitializedNullHandlingTest { @Test public void testSimple() diff --git a/core/src/test/java/org/apache/druid/testing/InitializedNullHandlingTest.java b/core/src/test/java/org/apache/druid/testing/InitializedNullHandlingTest.java new file mode 100644 index 000000000000..a4a737b4c751 --- /dev/null +++ b/core/src/test/java/org/apache/druid/testing/InitializedNullHandlingTest.java @@ -0,0 +1,29 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.druid.testing; + +import org.apache.druid.common.config.NullHandling; + +public class InitializedNullHandlingTest +{ + static { + NullHandling.initializeForTests(); + } +} diff --git a/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountGroupByQueryTest.java b/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountGroupByQueryTest.java index 4ea3062c7f68..08c286989f4a 100644 --- a/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountGroupByQueryTest.java +++ b/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountGroupByQueryTest.java @@ -41,6 +41,7 @@ import org.apache.druid.segment.TestHelper; import org.apache.druid.segment.incremental.IncrementalIndex; import org.apache.druid.segment.incremental.IncrementalIndexSchema; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.After; import org.junit.Before; import org.junit.Test; @@ -50,7 +51,7 @@ import java.util.Collections; import java.util.List; -public class DistinctCountGroupByQueryTest +public class DistinctCountGroupByQueryTest extends InitializedNullHandlingTest { private GroupByQueryRunnerFactory factory; private Closer resourceCloser; diff --git a/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTimeseriesQueryTest.java b/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTimeseriesQueryTest.java index bb911e818b9a..2cc0526480bf 100644 --- a/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTimeseriesQueryTest.java +++ b/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTimeseriesQueryTest.java @@ -35,13 +35,14 @@ import org.apache.druid.segment.incremental.IncrementalIndex; import org.apache.druid.segment.incremental.IncrementalIndexSchema; import org.apache.druid.segment.incremental.IncrementalIndexStorageAdapter; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.joda.time.DateTime; import org.junit.Test; import java.util.Collections; import java.util.List; -public class DistinctCountTimeseriesQueryTest +public class DistinctCountTimeseriesQueryTest extends InitializedNullHandlingTest { @Test diff --git a/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTopNQueryTest.java b/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTopNQueryTest.java index 40280bcf2f30..7b14fba07f11 100644 --- a/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTopNQueryTest.java +++ b/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTopNQueryTest.java @@ -37,6 +37,7 @@ import org.apache.druid.segment.incremental.IncrementalIndex; import org.apache.druid.segment.incremental.IncrementalIndexSchema; import org.apache.druid.segment.incremental.IncrementalIndexStorageAdapter; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.joda.time.DateTime; import org.junit.After; import org.junit.Before; @@ -48,7 +49,7 @@ import java.util.List; import java.util.Map; -public class DistinctCountTopNQueryTest +public class DistinctCountTopNQueryTest extends InitializedNullHandlingTest { private CloseableStupidPool pool; diff --git a/extensions-contrib/materialized-view-selection/pom.xml b/extensions-contrib/materialized-view-selection/pom.xml index 4ceeb20d0171..21346f630910 100644 --- a/extensions-contrib/materialized-view-selection/pom.xml +++ b/extensions-contrib/materialized-view-selection/pom.xml @@ -107,7 +107,13 @@ guava provided - + + org.apache.druid + druid-core + ${project.parent.version} + test + test-jar + org.apache.druid druid-processing diff --git a/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/MaterializedViewUtilsTest.java b/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/MaterializedViewUtilsTest.java index c040517c8fe1..fe00a2ce318c 100644 --- a/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/MaterializedViewUtilsTest.java +++ b/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/MaterializedViewUtilsTest.java @@ -27,6 +27,7 @@ import org.apache.druid.query.timeseries.TimeseriesQuery; import org.apache.druid.query.topn.TopNQuery; import org.apache.druid.segment.TestHelper; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.joda.time.Interval; import org.junit.Assert; import org.junit.Test; @@ -34,7 +35,7 @@ import java.util.List; import java.util.Set; -public class MaterializedViewUtilsTest +public class MaterializedViewUtilsTest extends InitializedNullHandlingTest { private static ObjectMapper jsonMapper = TestHelper.makeJsonMapper(); diff --git a/extensions-contrib/momentsketch/src/test/java/org/apache/druid/query/aggregation/momentsketch/aggregator/MomentsSketchAggregatorTest.java b/extensions-contrib/momentsketch/src/test/java/org/apache/druid/query/aggregation/momentsketch/aggregator/MomentsSketchAggregatorTest.java index 0299a0dd42ca..f75de5ed2491 100644 --- a/extensions-contrib/momentsketch/src/test/java/org/apache/druid/query/aggregation/momentsketch/aggregator/MomentsSketchAggregatorTest.java +++ b/extensions-contrib/momentsketch/src/test/java/org/apache/druid/query/aggregation/momentsketch/aggregator/MomentsSketchAggregatorTest.java @@ -31,6 +31,7 @@ import org.apache.druid.query.groupby.GroupByQueryConfig; import org.apache.druid.query.groupby.GroupByQueryRunnerTest; import org.apache.druid.query.groupby.ResultRow; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Rule; import org.junit.Test; @@ -44,9 +45,8 @@ import java.util.List; @RunWith(Parameterized.class) -public class MomentsSketchAggregatorTest +public class MomentsSketchAggregatorTest extends InitializedNullHandlingTest { - private final AggregationTestHelper helper; @Rule diff --git a/extensions-contrib/moving-average-query/pom.xml b/extensions-contrib/moving-average-query/pom.xml index 2f5d935ed9ec..d50c2ec0217b 100644 --- a/extensions-contrib/moving-average-query/pom.xml +++ b/extensions-contrib/moving-average-query/pom.xml @@ -38,17 +38,6 @@ - - junit - junit - test - - - com.fasterxml.jackson.dataformat - jackson-dataformat-yaml - ${jackson.version} - test - org.apache.druid druid-core @@ -108,6 +97,25 @@ provided + + + org.apache.druid + druid-core + ${project.parent.version} + test-jar + test + + + junit + junit + test + + + com.fasterxml.jackson.dataformat + jackson-dataformat-yaml + ${jackson.version} + test + org.hamcrest hamcrest-core diff --git a/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageIterableTest.java b/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageIterableTest.java index f7134c39bee8..42737f708045 100644 --- a/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageIterableTest.java +++ b/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageIterableTest.java @@ -33,6 +33,7 @@ import org.apache.druid.query.movingaverage.averagers.AveragerFactory; import org.apache.druid.query.movingaverage.averagers.ConstantAveragerFactory; import org.apache.druid.query.movingaverage.averagers.LongMeanAveragerFactory; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.hamcrest.CoreMatchers; import org.joda.time.DateTime; import org.joda.time.chrono.ISOChronology; @@ -47,7 +48,7 @@ import java.util.List; import java.util.Map; -public class MovingAverageIterableTest +public class MovingAverageIterableTest extends InitializedNullHandlingTest { private static final DateTime JAN_1 = new DateTime(2017, 1, 1, 0, 0, 0, 0, ISOChronology.getInstanceUTC()); private static final DateTime JAN_2 = new DateTime(2017, 1, 2, 0, 0, 0, 0, ISOChronology.getInstanceUTC()); diff --git a/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageQueryTest.java b/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageQueryTest.java index f9bb0f273158..ca9e4c5ec18b 100644 --- a/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageQueryTest.java +++ b/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageQueryTest.java @@ -67,6 +67,7 @@ import org.apache.druid.query.timeseries.TimeseriesResultValue; import org.apache.druid.server.ClientQuerySegmentWalker; import org.apache.druid.server.initialization.ServerConfig; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.apache.druid.timeline.TimelineLookup; import org.hamcrest.core.IsInstanceOf; import org.joda.time.Interval; @@ -91,7 +92,7 @@ * Base class for implementing MovingAverageQuery tests */ @RunWith(Parameterized.class) -public class MovingAverageQueryTest +public class MovingAverageQueryTest extends InitializedNullHandlingTest { private final ObjectMapper jsonMapper; private final QueryToolChestWarehouse warehouse; diff --git a/extensions-contrib/tdigestsketch/src/test/java/org/apache/druid/query/aggregation/tdigestsketch/TDigestSketchAggregatorTest.java b/extensions-contrib/tdigestsketch/src/test/java/org/apache/druid/query/aggregation/tdigestsketch/TDigestSketchAggregatorTest.java index e531407cdb04..d5577b9bcc2e 100644 --- a/extensions-contrib/tdigestsketch/src/test/java/org/apache/druid/query/aggregation/tdigestsketch/TDigestSketchAggregatorTest.java +++ b/extensions-contrib/tdigestsketch/src/test/java/org/apache/druid/query/aggregation/tdigestsketch/TDigestSketchAggregatorTest.java @@ -28,6 +28,7 @@ import org.apache.druid.query.groupby.GroupByQueryConfig; import org.apache.druid.query.groupby.GroupByQueryRunnerTest; import org.apache.druid.query.groupby.ResultRow; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Rule; import org.junit.Test; @@ -41,9 +42,8 @@ import java.util.List; @RunWith(Parameterized.class) -public class TDigestSketchAggregatorTest +public class TDigestSketchAggregatorTest extends InitializedNullHandlingTest { - private final AggregationTestHelper helper; @Rule diff --git a/extensions-contrib/virtual-columns/pom.xml b/extensions-contrib/virtual-columns/pom.xml index 3f4af75aeb87..0e8d3a14bd89 100644 --- a/extensions-contrib/virtual-columns/pom.xml +++ b/extensions-contrib/virtual-columns/pom.xml @@ -88,6 +88,13 @@ easymock test + + org.apache.druid + druid-core + ${project.parent.version} + test-jar + test + org.apache.druid druid-processing diff --git a/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnGroupByTest.java b/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnGroupByTest.java index 568cfc5aeaf7..d335025239fd 100644 --- a/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnGroupByTest.java +++ b/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnGroupByTest.java @@ -44,6 +44,7 @@ import org.apache.druid.query.groupby.strategy.GroupByStrategyV2; import org.apache.druid.query.spec.MultipleIntervalSegmentSpec; import org.apache.druid.segment.incremental.IncrementalIndex; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.apache.druid.timeline.SegmentId; import org.junit.Assert; import org.junit.Before; @@ -56,7 +57,7 @@ import java.util.List; import java.util.stream.Collectors; -public class MapVirtualColumnGroupByTest +public class MapVirtualColumnGroupByTest extends InitializedNullHandlingTest { @Rule public ExpectedException expectedException = ExpectedException.none(); diff --git a/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTestBase.java b/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTestBase.java index ffc3706f95e5..4d2164d7ec21 100644 --- a/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTestBase.java +++ b/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTestBase.java @@ -27,13 +27,14 @@ import org.apache.druid.java.util.common.DateTimes; import org.apache.druid.segment.incremental.IncrementalIndex; import org.apache.druid.segment.incremental.IncrementalIndexSchema; +import org.apache.druid.testing.InitializedNullHandlingTest; import java.io.IOException; import java.util.Arrays; import java.util.HashMap; import java.util.Map; -public class MapVirtualColumnTestBase +public class MapVirtualColumnTestBase extends InitializedNullHandlingTest { static IncrementalIndex generateIndex() throws IOException { diff --git a/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTopNTest.java b/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTopNTest.java index 38df988e92c2..345698564f35 100644 --- a/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTopNTest.java +++ b/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTopNTest.java @@ -40,6 +40,7 @@ import org.apache.druid.query.topn.TopNQueryRunnerFactory; import org.apache.druid.query.topn.TopNResultValue; import org.apache.druid.segment.incremental.IncrementalIndex; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.apache.druid.timeline.SegmentId; import org.junit.Assert; import org.junit.Before; @@ -52,7 +53,7 @@ import java.util.Collections; import java.util.List; -public class MapVirtualColumnTopNTest +public class MapVirtualColumnTopNTest extends InitializedNullHandlingTest { @Rule public ExpectedException expectedException = ExpectedException.none(); diff --git a/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/hll/HllSketchAggregatorTest.java b/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/hll/HllSketchAggregatorTest.java index e2c55be53552..f6a13060ce4a 100644 --- a/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/hll/HllSketchAggregatorTest.java +++ b/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/hll/HllSketchAggregatorTest.java @@ -28,6 +28,7 @@ import org.apache.druid.query.groupby.GroupByQueryConfig; import org.apache.druid.query.groupby.GroupByQueryRunnerTest; import org.apache.druid.query.groupby.ResultRow; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Rule; import org.junit.Test; @@ -44,7 +45,7 @@ import java.util.Map; @RunWith(Parameterized.class) -public class HllSketchAggregatorTest +public class HllSketchAggregatorTest extends InitializedNullHandlingTest { private static final boolean ROUND = true; diff --git a/extensions-core/druid-bloom-filter/src/test/java/org/apache/druid/query/aggregation/bloom/BloomFilterAggregatorTest.java b/extensions-core/druid-bloom-filter/src/test/java/org/apache/druid/query/aggregation/bloom/BloomFilterAggregatorTest.java index 5fedc8441660..5888b7d13dde 100644 --- a/extensions-core/druid-bloom-filter/src/test/java/org/apache/druid/query/aggregation/bloom/BloomFilterAggregatorTest.java +++ b/extensions-core/druid-bloom-filter/src/test/java/org/apache/druid/query/aggregation/bloom/BloomFilterAggregatorTest.java @@ -44,6 +44,7 @@ import org.apache.druid.segment.DoubleColumnSelector; import org.apache.druid.segment.FloatColumnSelector; import org.apache.druid.segment.LongColumnSelector; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Test; @@ -55,7 +56,7 @@ import java.util.List; import java.util.stream.IntStream; -public class BloomFilterAggregatorTest +public class BloomFilterAggregatorTest extends InitializedNullHandlingTest { private static final String NULLISH = NullHandling.replaceWithDefault() ? "" : null; private static final List VALUES1 = dimensionValues( diff --git a/extensions-core/druid-bloom-filter/src/test/java/org/apache/druid/query/aggregation/bloom/BloomFilterGroupByQueryTest.java b/extensions-core/druid-bloom-filter/src/test/java/org/apache/druid/query/aggregation/bloom/BloomFilterGroupByQueryTest.java index 2a2de448fc0c..8b664ff3464a 100644 --- a/extensions-core/druid-bloom-filter/src/test/java/org/apache/druid/query/aggregation/bloom/BloomFilterGroupByQueryTest.java +++ b/extensions-core/druid-bloom-filter/src/test/java/org/apache/druid/query/aggregation/bloom/BloomFilterGroupByQueryTest.java @@ -36,6 +36,7 @@ import org.apache.druid.query.groupby.ResultRow; import org.apache.druid.query.groupby.strategy.GroupByStrategySelector; import org.apache.druid.segment.TestHelper; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.After; import org.junit.Assert; import org.junit.Rule; @@ -51,7 +52,7 @@ import java.util.List; @RunWith(Parameterized.class) -public class BloomFilterGroupByQueryTest +public class BloomFilterGroupByQueryTest extends InitializedNullHandlingTest { private static final BloomFilterExtensionModule MODULE = new BloomFilterExtensionModule(); diff --git a/extensions-core/druid-bloom-filter/src/test/java/org/apache/druid/query/aggregation/bloom/sql/BloomFilterSqlAggregatorTest.java b/extensions-core/druid-bloom-filter/src/test/java/org/apache/druid/query/aggregation/bloom/sql/BloomFilterSqlAggregatorTest.java index ff068f4289ad..6c63e1943bd3 100644 --- a/extensions-core/druid-bloom-filter/src/test/java/org/apache/druid/query/aggregation/bloom/sql/BloomFilterSqlAggregatorTest.java +++ b/extensions-core/druid-bloom-filter/src/test/java/org/apache/druid/query/aggregation/bloom/sql/BloomFilterSqlAggregatorTest.java @@ -77,6 +77,7 @@ import org.apache.druid.sql.calcite.util.CalciteTests; import org.apache.druid.sql.calcite.util.QueryLogHook; import org.apache.druid.sql.calcite.util.SpecificSegmentsQuerySegmentWalker; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.apache.druid.timeline.DataSegment; import org.apache.druid.timeline.partition.LinearShardSpec; import org.junit.After; @@ -92,7 +93,7 @@ import java.util.Collections; import java.util.List; -public class BloomFilterSqlAggregatorTest +public class BloomFilterSqlAggregatorTest extends InitializedNullHandlingTest { private static final int TEST_NUM_ENTRIES = 1000; private static AuthenticationResult authenticationResult = CalciteTests.REGULAR_USER_AUTH_RESULT; diff --git a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramAggregationTest.java b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramAggregationTest.java index 01cef7d1f7ae..da752a256c95 100644 --- a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramAggregationTest.java +++ b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramAggregationTest.java @@ -29,6 +29,7 @@ import org.apache.druid.query.groupby.GroupByQueryConfig; import org.apache.druid.query.groupby.GroupByQueryRunnerTest; import org.apache.druid.query.groupby.ResultRow; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.After; import org.junit.Assert; import org.junit.Rule; @@ -46,7 +47,7 @@ * */ @RunWith(Parameterized.class) -public class ApproximateHistogramAggregationTest +public class ApproximateHistogramAggregationTest extends InitializedNullHandlingTest { private AggregationTestHelper helper; diff --git a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramAggregatorTest.java b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramAggregatorTest.java index c1caa7e30e36..fd41e150214b 100644 --- a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramAggregatorTest.java +++ b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramAggregatorTest.java @@ -22,12 +22,13 @@ import org.apache.druid.jackson.DefaultObjectMapper; import org.apache.druid.query.aggregation.BufferAggregator; import org.apache.druid.query.aggregation.TestFloatColumnSelector; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Test; import java.nio.ByteBuffer; -public class ApproximateHistogramAggregatorTest +public class ApproximateHistogramAggregatorTest extends InitializedNullHandlingTest { private void aggregateBuffer(TestFloatColumnSelector selector, BufferAggregator agg, ByteBuffer buf, int position) { diff --git a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramGroupByQueryTest.java b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramGroupByQueryTest.java index d25b7ed7227a..3e941d232b56 100644 --- a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramGroupByQueryTest.java +++ b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramGroupByQueryTest.java @@ -37,6 +37,7 @@ import org.apache.druid.query.groupby.orderby.OrderByColumnSpec; import org.apache.druid.query.groupby.strategy.GroupByStrategySelector; import org.apache.druid.segment.TestHelper; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.After; import org.junit.Test; import org.junit.runner.RunWith; @@ -50,7 +51,7 @@ /** */ @RunWith(Parameterized.class) -public class ApproximateHistogramGroupByQueryTest +public class ApproximateHistogramGroupByQueryTest extends InitializedNullHandlingTest { private static final Closer RESOURCE_CLOSER = Closer.create(); diff --git a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramPostAggregatorTest.java b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramPostAggregatorTest.java index bf0eff876c06..045ba03dd7ec 100644 --- a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramPostAggregatorTest.java +++ b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramPostAggregatorTest.java @@ -20,13 +20,14 @@ package org.apache.druid.query.aggregation.histogram; import org.apache.druid.query.aggregation.TestFloatColumnSelector; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Test; import java.util.HashMap; import java.util.Map; -public class ApproximateHistogramPostAggregatorTest +public class ApproximateHistogramPostAggregatorTest extends InitializedNullHandlingTest { static final float[] VALUES = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; diff --git a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramTopNQueryTest.java b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramTopNQueryTest.java index fc07a29f6c89..d61114a06ffd 100644 --- a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramTopNQueryTest.java +++ b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramTopNQueryTest.java @@ -39,6 +39,7 @@ import org.apache.druid.query.topn.TopNQueryRunnerFactory; import org.apache.druid.query.topn.TopNResultValue; import org.apache.druid.segment.TestHelper; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.AfterClass; import org.junit.Test; import org.junit.runner.RunWith; @@ -52,7 +53,7 @@ import java.util.Map; @RunWith(Parameterized.class) -public class ApproximateHistogramTopNQueryTest +public class ApproximateHistogramTopNQueryTest extends InitializedNullHandlingTest { private static final Closer RESOURCE_CLOSER = Closer.create(); diff --git a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/FixedBucketsHistogramAggregationTest.java b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/FixedBucketsHistogramAggregationTest.java index 5fbb694e3938..198d62e4185d 100644 --- a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/FixedBucketsHistogramAggregationTest.java +++ b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/FixedBucketsHistogramAggregationTest.java @@ -29,6 +29,7 @@ import org.apache.druid.query.groupby.GroupByQueryConfig; import org.apache.druid.query.groupby.GroupByQueryRunnerTest; import org.apache.druid.query.groupby.ResultRow; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.After; import org.junit.Assert; import org.junit.Rule; @@ -46,7 +47,7 @@ * */ @RunWith(Parameterized.class) -public class FixedBucketsHistogramAggregationTest +public class FixedBucketsHistogramAggregationTest extends InitializedNullHandlingTest { private AggregationTestHelper helper; diff --git a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/FixedBucketsHistogramGroupByQueryTest.java b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/FixedBucketsHistogramGroupByQueryTest.java index 03301f5f8a64..793dcc3b0beb 100644 --- a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/FixedBucketsHistogramGroupByQueryTest.java +++ b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/FixedBucketsHistogramGroupByQueryTest.java @@ -37,6 +37,7 @@ import org.apache.druid.query.groupby.orderby.OrderByColumnSpec; import org.apache.druid.query.groupby.strategy.GroupByStrategySelector; import org.apache.druid.segment.TestHelper; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.After; import org.junit.Test; import org.junit.runner.RunWith; @@ -50,7 +51,7 @@ /** */ @RunWith(Parameterized.class) -public class FixedBucketsHistogramGroupByQueryTest +public class FixedBucketsHistogramGroupByQueryTest extends InitializedNullHandlingTest { private static final Closer RESOURCE_CLOSER = Closer.create(); diff --git a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/FixedBucketsHistogramTopNQueryTest.java b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/FixedBucketsHistogramTopNQueryTest.java index bab48fbbaed3..b493745f6b00 100644 --- a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/FixedBucketsHistogramTopNQueryTest.java +++ b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/FixedBucketsHistogramTopNQueryTest.java @@ -39,6 +39,7 @@ import org.apache.druid.query.topn.TopNQueryRunnerFactory; import org.apache.druid.query.topn.TopNResultValue; import org.apache.druid.segment.TestHelper; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.AfterClass; import org.junit.Test; import org.junit.runner.RunWith; @@ -52,7 +53,7 @@ import java.util.Map; @RunWith(Parameterized.class) -public class FixedBucketsHistogramTopNQueryTest +public class FixedBucketsHistogramTopNQueryTest extends InitializedNullHandlingTest { private static final Closer RESOURCE_CLOSER = Closer.create(); diff --git a/extensions-core/kinesis-indexing-service/src/test/java/org/apache/druid/indexing/kinesis/KinesisSamplerSpecTest.java b/extensions-core/kinesis-indexing-service/src/test/java/org/apache/druid/indexing/kinesis/KinesisSamplerSpecTest.java index 3cfcd97208ea..d417b2cff3e4 100644 --- a/extensions-core/kinesis-indexing-service/src/test/java/org/apache/druid/indexing/kinesis/KinesisSamplerSpecTest.java +++ b/extensions-core/kinesis-indexing-service/src/test/java/org/apache/druid/indexing/kinesis/KinesisSamplerSpecTest.java @@ -25,6 +25,7 @@ import com.google.common.collect.ImmutableSet; import org.apache.druid.client.cache.MapCache; import org.apache.druid.common.aws.AWSCredentialsConfig; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.Firehose; import org.apache.druid.data.input.impl.DimensionsSpec; import org.apache.druid.data.input.impl.FloatDimensionSchema; @@ -102,6 +103,10 @@ public class KinesisSamplerSpecTest extends EasyMockSupport OBJECT_MAPPER ); + static { + NullHandling.initializeForTests(); + } + private final KinesisRecordSupplier recordSupplier = mock(KinesisRecordSupplier.class); private static List> generateRecords(String stream) diff --git a/extensions-core/lookups-cached-global/src/test/java/org/apache/druid/query/lookup/NamespaceLookupExtractorFactoryTest.java b/extensions-core/lookups-cached-global/src/test/java/org/apache/druid/query/lookup/NamespaceLookupExtractorFactoryTest.java index 6f036757d965..bab8259dbcfc 100644 --- a/extensions-core/lookups-cached-global/src/test/java/org/apache/druid/query/lookup/NamespaceLookupExtractorFactoryTest.java +++ b/extensions-core/lookups-cached-global/src/test/java/org/apache/druid/query/lookup/NamespaceLookupExtractorFactoryTest.java @@ -30,6 +30,7 @@ import com.google.inject.Injector; import com.google.inject.Key; import com.google.inject.Module; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.guice.GuiceInjectors; import org.apache.druid.guice.JsonConfigProvider; import org.apache.druid.guice.annotations.Json; @@ -74,6 +75,10 @@ @PowerMockIgnore({"javax.net.ssl.*", "javax.xml.*", "com.sun.xml.*"}) public class NamespaceLookupExtractorFactoryTest { + static { + NullHandling.initializeForTests(); + } + private final ObjectMapper mapper = new DefaultObjectMapper(); @Rule public TemporaryFolder temporaryFolder = new TemporaryFolder(); diff --git a/extensions-core/lookups-cached-global/src/test/java/org/apache/druid/query/lookup/namespace/UriExtractionNamespaceTest.java b/extensions-core/lookups-cached-global/src/test/java/org/apache/druid/query/lookup/namespace/UriExtractionNamespaceTest.java index a933cdc7af31..d5ac42a068c7 100644 --- a/extensions-core/lookups-cached-global/src/test/java/org/apache/druid/query/lookup/namespace/UriExtractionNamespaceTest.java +++ b/extensions-core/lookups-cached-global/src/test/java/org/apache/druid/query/lookup/namespace/UriExtractionNamespaceTest.java @@ -27,6 +27,7 @@ import com.google.inject.Binder; import com.google.inject.Guice; import com.google.inject.Module; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.guice.GuiceAnnotationIntrospector; import org.apache.druid.guice.GuiceInjectableValues; import org.apache.druid.guice.annotations.Json; @@ -43,6 +44,10 @@ */ public class UriExtractionNamespaceTest { + static { + NullHandling.initializeForTests(); + } + public static ObjectMapper registerTypes( final ObjectMapper mapper ) diff --git a/extensions-core/lookups-cached-global/src/test/java/org/apache/druid/server/lookup/namespace/cache/JdbcExtractionNamespaceTest.java b/extensions-core/lookups-cached-global/src/test/java/org/apache/druid/server/lookup/namespace/cache/JdbcExtractionNamespaceTest.java index 6dfc88df5279..84086b8f6490 100644 --- a/extensions-core/lookups-cached-global/src/test/java/org/apache/druid/server/lookup/namespace/cache/JdbcExtractionNamespaceTest.java +++ b/extensions-core/lookups-cached-global/src/test/java/org/apache/druid/server/lookup/namespace/cache/JdbcExtractionNamespaceTest.java @@ -67,6 +67,10 @@ @RunWith(Parameterized.class) public class JdbcExtractionNamespaceTest { + static { + NullHandling.initializeForTests(); + } + @Rule public final TestDerbyConnector.DerbyConnectorRule derbyConnectorRule = new TestDerbyConnector.DerbyConnectorRule(); private static final Logger log = new Logger(JdbcExtractionNamespaceTest.class); diff --git a/extensions-core/lookups-cached-single/pom.xml b/extensions-core/lookups-cached-single/pom.xml index f3469f5ff5a0..61630a2db9b8 100644 --- a/extensions-core/lookups-cached-single/pom.xml +++ b/extensions-core/lookups-cached-single/pom.xml @@ -103,6 +103,13 @@ junit test + + org.apache.druid + druid-core + ${project.parent.version} + test-jar + test + org.apache.druid druid-server diff --git a/extensions-core/lookups-cached-single/src/test/java/org/apache/druid/server/lookup/LoadingLookupTest.java b/extensions-core/lookups-cached-single/src/test/java/org/apache/druid/server/lookup/LoadingLookupTest.java index 9e451782acb2..93e147dee460 100644 --- a/extensions-core/lookups-cached-single/src/test/java/org/apache/druid/server/lookup/LoadingLookupTest.java +++ b/extensions-core/lookups-cached-single/src/test/java/org/apache/druid/server/lookup/LoadingLookupTest.java @@ -23,6 +23,7 @@ import com.google.common.collect.ImmutableSet; import org.apache.druid.common.config.NullHandling; import org.apache.druid.server.lookup.cache.loading.LoadingCache; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.easymock.EasyMock; import org.junit.Assert; import org.junit.Test; @@ -32,7 +33,7 @@ import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; -public class LoadingLookupTest +public class LoadingLookupTest extends InitializedNullHandlingTest { DataFetcher dataFetcher = EasyMock.createMock(DataFetcher.class); LoadingCache lookupCache = EasyMock.createStrictMock(LoadingCache.class); diff --git a/extensions-core/lookups-cached-single/src/test/java/org/apache/druid/server/lookup/PollingLookupTest.java b/extensions-core/lookups-cached-single/src/test/java/org/apache/druid/server/lookup/PollingLookupTest.java index 9ce0e1c52a73..cb31eb404f05 100644 --- a/extensions-core/lookups-cached-single/src/test/java/org/apache/druid/server/lookup/PollingLookupTest.java +++ b/extensions-core/lookups-cached-single/src/test/java/org/apache/druid/server/lookup/PollingLookupTest.java @@ -30,6 +30,7 @@ import org.apache.druid.server.lookup.cache.polling.OffHeapPollingCache; import org.apache.druid.server.lookup.cache.polling.OnHeapPollingCache; import org.apache.druid.server.lookup.cache.polling.PollingCacheFactory; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.After; import org.junit.Assert; import org.junit.Before; @@ -45,7 +46,7 @@ import java.util.Map; @RunWith(Parameterized.class) -public class PollingLookupTest +public class PollingLookupTest extends InitializedNullHandlingTest { private static final Map FIRST_LOOKUP_MAP = ImmutableMap.of( "foo", "bar", diff --git a/extensions-core/lookups-cached-single/src/test/java/org/apache/druid/server/lookup/jdbc/JdbcDataFetcherTest.java b/extensions-core/lookups-cached-single/src/test/java/org/apache/druid/server/lookup/jdbc/JdbcDataFetcherTest.java index 76187ce1513b..c0199ce9d41f 100644 --- a/extensions-core/lookups-cached-single/src/test/java/org/apache/druid/server/lookup/jdbc/JdbcDataFetcherTest.java +++ b/extensions-core/lookups-cached-single/src/test/java/org/apache/druid/server/lookup/jdbc/JdbcDataFetcherTest.java @@ -26,6 +26,7 @@ import org.apache.druid.metadata.MetadataStorageConnectorConfig; import org.apache.druid.metadata.TestDerbyConnector; import org.apache.druid.server.lookup.DataFetcher; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.After; import org.junit.Assert; import org.junit.Before; @@ -37,7 +38,7 @@ import java.util.Collections; import java.util.Map; -public class JdbcDataFetcherTest +public class JdbcDataFetcherTest extends InitializedNullHandlingTest { @Rule public final TestDerbyConnector.DerbyConnectorRule derbyConnectorRule = new TestDerbyConnector.DerbyConnectorRule(); diff --git a/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceAggregatorCollectorTest.java b/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceAggregatorCollectorTest.java index 1db5388948d1..57ab6ea86d42 100644 --- a/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceAggregatorCollectorTest.java +++ b/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceAggregatorCollectorTest.java @@ -23,6 +23,7 @@ import org.apache.druid.java.util.common.Pair; import org.apache.druid.segment.TestFloatColumnSelector; import org.apache.druid.segment.TestObjectColumnSelector; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Test; @@ -32,7 +33,7 @@ import java.util.Random; import java.util.concurrent.ThreadLocalRandom; -public class VarianceAggregatorCollectorTest +public class VarianceAggregatorCollectorTest extends InitializedNullHandlingTest { private static final float[] MARKET_UPFRONT = new float[]{ 800.0f, 800.0f, 826.0602f, 1564.6177f, 1006.4021f, 869.64374f, 809.04175f, 1458.4027f, 852.4375f, 879.9881f, diff --git a/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceAggregatorTest.java b/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceAggregatorTest.java index bb4bad493f66..33967f2ed03f 100644 --- a/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceAggregatorTest.java +++ b/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceAggregatorTest.java @@ -22,6 +22,7 @@ import org.apache.druid.jackson.DefaultObjectMapper; import org.apache.druid.query.aggregation.TestFloatColumnSelector; import org.apache.druid.segment.ColumnSelectorFactory; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.easymock.EasyMock; import org.junit.Assert; import org.junit.Before; @@ -31,7 +32,7 @@ /** */ -public class VarianceAggregatorTest +public class VarianceAggregatorTest extends InitializedNullHandlingTest { private VarianceAggregatorFactory aggFactory; private ColumnSelectorFactory colSelectorFactory; diff --git a/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceGroupByQueryTest.java b/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceGroupByQueryTest.java index e2e1d60edea0..9a04aee18b82 100644 --- a/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceGroupByQueryTest.java +++ b/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceGroupByQueryTest.java @@ -38,6 +38,7 @@ import org.apache.druid.query.groupby.orderby.DefaultLimitSpec; import org.apache.druid.query.groupby.orderby.OrderByColumnSpec; import org.apache.druid.segment.TestHelper; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.joda.time.Period; import org.junit.Test; import org.junit.runner.RunWith; @@ -52,7 +53,7 @@ * */ @RunWith(Parameterized.class) -public class VarianceGroupByQueryTest +public class VarianceGroupByQueryTest extends InitializedNullHandlingTest { private final GroupByQueryConfig config; private final QueryRunner runner; diff --git a/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceTimeseriesQueryTest.java b/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceTimeseriesQueryTest.java index 82ebc34e4ef2..9c52961f7c64 100644 --- a/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceTimeseriesQueryTest.java +++ b/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceTimeseriesQueryTest.java @@ -30,6 +30,7 @@ import org.apache.druid.query.timeseries.TimeseriesQueryRunnerTest; import org.apache.druid.query.timeseries.TimeseriesResultValue; import org.apache.druid.segment.TestHelper; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; @@ -40,7 +41,7 @@ import java.util.stream.StreamSupport; @RunWith(Parameterized.class) -public class VarianceTimeseriesQueryTest +public class VarianceTimeseriesQueryTest extends InitializedNullHandlingTest { @Parameterized.Parameters(name = "{0}:descending={1}") public static Iterable constructorFeeder() diff --git a/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceTopNQueryTest.java b/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceTopNQueryTest.java index 72cf6758b24d..8003ad1c3949 100644 --- a/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceTopNQueryTest.java +++ b/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceTopNQueryTest.java @@ -37,6 +37,7 @@ import org.apache.druid.query.topn.TopNQueryRunnerTest; import org.apache.druid.query.topn.TopNResultValue; import org.apache.druid.segment.TestHelper; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; @@ -47,7 +48,7 @@ import java.util.Map; @RunWith(Parameterized.class) -public class VarianceTopNQueryTest +public class VarianceTopNQueryTest extends InitializedNullHandlingTest { @Parameterized.Parameters(name = "{0}") public static Iterable constructorFeeder() diff --git a/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/sql/VarianceSqlAggregatorTest.java b/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/sql/VarianceSqlAggregatorTest.java index 8046f44c1279..a061f476f993 100644 --- a/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/sql/VarianceSqlAggregatorTest.java +++ b/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/sql/VarianceSqlAggregatorTest.java @@ -63,6 +63,7 @@ import org.apache.druid.sql.calcite.util.CalciteTests; import org.apache.druid.sql.calcite.util.QueryLogHook; import org.apache.druid.sql.calcite.util.SpecificSegmentsQuerySegmentWalker; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.apache.druid.timeline.DataSegment; import org.apache.druid.timeline.partition.LinearShardSpec; import org.junit.After; @@ -77,7 +78,7 @@ import java.io.IOException; import java.util.List; -public class VarianceSqlAggregatorTest +public class VarianceSqlAggregatorTest extends InitializedNullHandlingTest { private static AuthenticationResult authenticationResult = CalciteTests.REGULAR_USER_AUTH_RESULT; private static final String DATA_SOURCE = "numfoo"; diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/FirehoseSamplerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/FirehoseSamplerTest.java index 06ab5dc1b58e..8e6ceb43cd5a 100644 --- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/FirehoseSamplerTest.java +++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/FirehoseSamplerTest.java @@ -49,6 +49,7 @@ import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec; import org.apache.druid.segment.transform.ExpressionTransform; import org.apache.druid.segment.transform.TransformSpec; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Before; import org.junit.Rule; @@ -64,7 +65,7 @@ import java.util.stream.Collectors; @RunWith(Parameterized.class) -public class FirehoseSamplerTest +public class FirehoseSamplerTest extends InitializedNullHandlingTest { private enum ParserType { @@ -72,10 +73,6 @@ private enum ParserType } private static final ObjectMapper OBJECT_MAPPER = TestHelper.makeJsonMapper(); - private static final boolean USE_DEFAULT_VALUE_FOR_NULL = Boolean.valueOf(System.getProperty( - NullHandling.NULL_HANDLING_CONFIG_STRING, - "true" - )); private static final List MAP_ROWS = ImmutableList.of( ImmutableMap.of("t", "2019-04-22T12:00", "dim1", "foo", "met1", "1"), @@ -814,7 +811,7 @@ private ParseSpec getParseSpec(TimestampSpec timestampSpec, DimensionsSpec dimen private String getUnparseableTimestampString() { return ParserType.STR_CSV.equals(parserType) - ? (USE_DEFAULT_VALUE_FOR_NULL + ? (NullHandling.replaceWithDefault() ? "Unparseable timestamp found! Event: {t=bad_timestamp, dim1=foo, dim2=null, met1=6}" : "Unparseable timestamp found! Event: {t=bad_timestamp, dim1=foo, dim2=, met1=6}") : "Unparseable timestamp found! Event: {t=bad_timestamp, dim1=foo, met1=6}"; @@ -822,7 +819,7 @@ private String getUnparseableTimestampString() private List removeEmptyColumns(List rows) { - return USE_DEFAULT_VALUE_FOR_NULL + return NullHandling.replaceWithDefault() ? rows : rows.stream().map(x -> x.withParsed(removeEmptyValues(x.getParsed()))).collect(Collectors.toList()); } diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java b/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java index b8c2715b1384..b13c0b4129e5 100644 --- a/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java +++ b/indexing-service/src/test/java/org/apache/druid/indexing/seekablestream/SeekableStreamIndexTaskTestBase.java @@ -29,6 +29,7 @@ import com.google.common.io.Files; import com.google.common.util.concurrent.ListenableFuture; import com.google.common.util.concurrent.ListeningExecutorService; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.impl.DimensionsSpec; import org.apache.druid.data.input.impl.FloatDimensionSchema; import org.apache.druid.data.input.impl.JSONParseSpec; @@ -133,6 +134,10 @@ public class SeekableStreamIndexTaskTestBase extends EasyMockSupport protected static final Logger LOG = new Logger(SeekableStreamIndexTaskTestBase.class); protected static ListeningExecutorService taskExec; + static { + NullHandling.initializeForTests(); + } + protected final List runningTasks = new ArrayList<>(); protected final LockGranularity lockGranularity; protected File directory; diff --git a/processing/src/main/java/org/apache/druid/segment/NilColumnValueSelector.java b/processing/src/main/java/org/apache/druid/segment/NilColumnValueSelector.java index ef74477536c7..98d6ee645920 100644 --- a/processing/src/main/java/org/apache/druid/segment/NilColumnValueSelector.java +++ b/processing/src/main/java/org/apache/druid/segment/NilColumnValueSelector.java @@ -45,8 +45,8 @@ private NilColumnValueSelector() } /** - * always returns 0, if {@link NullHandling#NULL_HANDLING_CONFIG_STRING} is set to true, - * or always throws an exception, if {@link NullHandling#NULL_HANDLING_CONFIG_STRING} is + * always returns 0, if {@link NullHandling#replaceWithDefault} is set to true, + * or always throws an exception, if {@link NullHandling#replaceWithDefault} is * set to false. */ @Override @@ -56,8 +56,8 @@ public double getDouble() } /** - * always returns 0.0f, if {@link NullHandling#NULL_HANDLING_CONFIG_STRING} is set to true, - * or always throws an exception, if {@link NullHandling#NULL_HANDLING_CONFIG_STRING} is + * always returns 0.0f, if {@link NullHandling#replaceWithDefault} is set to true, + * or always throws an exception, if {@link NullHandling#replaceWithDefault} is * set to false. */ @Override @@ -67,8 +67,8 @@ public float getFloat() } /** - * always returns 0L, if {@link NullHandling#NULL_HANDLING_CONFIG_STRING} is set to true, - * or always throws an exception, if {@link NullHandling#NULL_HANDLING_CONFIG_STRING} is + * always returns 0L, if {@link NullHandling#replaceWithDefault} is set to true, + * or always throws an exception, if {@link NullHandling#replaceWithDefault} is * set to false. */ @Override diff --git a/processing/src/test/java/org/apache/druid/collections/bitmap/BitmapBenchmark.java b/processing/src/test/java/org/apache/druid/collections/bitmap/BitmapBenchmark.java index b12158bdbc16..a0689b8979e7 100644 --- a/processing/src/test/java/org/apache/druid/collections/bitmap/BitmapBenchmark.java +++ b/processing/src/test/java/org/apache/druid/collections/bitmap/BitmapBenchmark.java @@ -22,6 +22,7 @@ import com.carrotsearch.junitbenchmarks.BenchmarkOptions; import com.carrotsearch.junitbenchmarks.BenchmarkRule; import com.carrotsearch.junitbenchmarks.Clock; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.extendedset.intset.ImmutableConciseSet; import org.junit.Assert; import org.junit.Rule; @@ -66,6 +67,10 @@ public class BitmapBenchmark @Rule public TestRule benchmarkRun = new BenchmarkRule(); + static { + NullHandling.initializeForTests(); + } + protected static ImmutableConciseSet makeOffheapConcise(ImmutableConciseSet concise) { final byte[] bytes = concise.toBytes(); diff --git a/processing/src/test/java/org/apache/druid/query/expression/MacroTestBase.java b/processing/src/test/java/org/apache/druid/query/expression/MacroTestBase.java index 2c203abe5942..38e607c2b8f4 100644 --- a/processing/src/test/java/org/apache/druid/query/expression/MacroTestBase.java +++ b/processing/src/test/java/org/apache/druid/query/expression/MacroTestBase.java @@ -19,10 +19,11 @@ package org.apache.druid.query.expression; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Rule; import org.junit.rules.ExpectedException; -public abstract class MacroTestBase +public abstract class MacroTestBase extends InitializedNullHandlingTest { @Rule public ExpectedException expectedException = ExpectedException.none(); diff --git a/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryTest.java b/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryTest.java index ed6d19970ea8..715e3c8b89e4 100644 --- a/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryTest.java +++ b/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryTest.java @@ -24,6 +24,7 @@ import com.google.common.collect.ImmutableMap; import com.google.common.collect.Iterables; import com.google.common.collect.Lists; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.impl.TimestampSpec; import org.apache.druid.jackson.DefaultObjectMapper; import org.apache.druid.java.util.common.Intervals; @@ -73,6 +74,10 @@ @RunWith(Parameterized.class) public class SegmentMetadataQueryTest { + static { + NullHandling.initializeForTests(); + } + private static final SegmentMetadataQueryRunnerFactory FACTORY = new SegmentMetadataQueryRunnerFactory( new SegmentMetadataQueryQueryToolChest(new SegmentMetadataQueryConfig()), QueryRunnerTestHelper.NOOP_QUERYWATCHER diff --git a/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataUnionQueryTest.java b/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataUnionQueryTest.java index ca5100baaea9..76812023d11b 100644 --- a/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataUnionQueryTest.java +++ b/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataUnionQueryTest.java @@ -21,6 +21,7 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.java.util.common.Intervals; import org.apache.druid.query.Druids; import org.apache.druid.query.QueryPlus; @@ -46,6 +47,10 @@ @RunWith(Parameterized.class) public class SegmentMetadataUnionQueryTest { + static { + NullHandling.initializeForTests(); + } + private static final QueryRunnerFactory FACTORY = new SegmentMetadataQueryRunnerFactory( new SegmentMetadataQueryQueryToolChest(new SegmentMetadataQueryConfig()), QueryRunnerTestHelper.NOOP_QUERYWATCHER diff --git a/processing/src/test/java/org/apache/druid/segment/IndexIOTest.java b/processing/src/test/java/org/apache/druid/segment/IndexIOTest.java index 59305147c664..2fb6bc39eaa4 100644 --- a/processing/src/test/java/org/apache/druid/segment/IndexIOTest.java +++ b/processing/src/test/java/org/apache/druid/segment/IndexIOTest.java @@ -26,6 +26,7 @@ import com.google.common.collect.Iterables; import com.google.common.collect.Lists; import com.google.common.collect.Maps; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.MapBasedInputRow; import org.apache.druid.data.input.impl.DimensionsSpec; import org.apache.druid.java.util.common.Intervals; @@ -39,6 +40,7 @@ import org.apache.druid.segment.incremental.IncrementalIndexAdapter; import org.apache.druid.segment.incremental.IncrementalIndexSchema; import org.apache.druid.segment.incremental.IndexSizeExceededException; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.joda.time.Interval; import org.junit.Assert; import org.junit.Before; @@ -61,7 +63,7 @@ * This is mostly a test of the validator */ @RunWith(Parameterized.class) -public class IndexIOTest +public class IndexIOTest extends InitializedNullHandlingTest { private static Interval DEFAULT_INTERVAL = Intervals.of("1970-01-01/2000-01-01"); private static final IndexSpec INDEX_SPEC = IndexMergerTestBase.makeIndexSpec( @@ -71,6 +73,10 @@ public class IndexIOTest CompressionFactory.LongEncodingStrategy.LONGS ); + static { + NullHandling.initializeForTests(); + } + private static List filterByBitset(List list, BitSet bitSet) { final ArrayList outList = new ArrayList<>(bitSet.cardinality()); @@ -85,7 +91,6 @@ private static List filterByBitset(List list, BitSet bitSet) @Parameterized.Parameters(name = "{0}, {1}") public static Iterable constructionFeeder() { - final Map map = ImmutableMap.of(); final Map map00 = ImmutableMap.of( diff --git a/processing/src/test/java/org/apache/druid/segment/IndexMergerTestBase.java b/processing/src/test/java/org/apache/druid/segment/IndexMergerTestBase.java index d19af352d408..1783f433b1b5 100644 --- a/processing/src/test/java/org/apache/druid/segment/IndexMergerTestBase.java +++ b/processing/src/test/java/org/apache/druid/segment/IndexMergerTestBase.java @@ -59,6 +59,7 @@ import org.apache.druid.segment.incremental.IncrementalIndexAdapter; import org.apache.druid.segment.incremental.IncrementalIndexSchema; import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.joda.time.Interval; import org.junit.Assert; import org.junit.Rule; @@ -81,9 +82,8 @@ import java.util.Map; import java.util.stream.Collectors; -public class IndexMergerTestBase +public class IndexMergerTestBase extends InitializedNullHandlingTest { - @Rule public final TemporaryFolder temporaryFolder = new TemporaryFolder(); diff --git a/processing/src/test/java/org/apache/druid/segment/data/GenericIndexedStringWriterTest.java b/processing/src/test/java/org/apache/druid/segment/data/GenericIndexedStringWriterTest.java index 16961e2d5375..5b4a2d95d8e9 100644 --- a/processing/src/test/java/org/apache/druid/segment/data/GenericIndexedStringWriterTest.java +++ b/processing/src/test/java/org/apache/druid/segment/data/GenericIndexedStringWriterTest.java @@ -20,6 +20,7 @@ package org.apache.druid.segment.data; import org.apache.druid.segment.writeout.OnHeapMemorySegmentWriteOutMedium; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Test; @@ -29,7 +30,7 @@ import java.util.List; import java.util.concurrent.ThreadLocalRandom; -public class GenericIndexedStringWriterTest +public class GenericIndexedStringWriterTest extends InitializedNullHandlingTest { @Test public void testRandomAccess() throws IOException diff --git a/processing/src/test/java/org/apache/druid/segment/data/GenericIndexedTest.java b/processing/src/test/java/org/apache/druid/segment/data/GenericIndexedTest.java index 651b8b5b57ee..52e5087f0f37 100644 --- a/processing/src/test/java/org/apache/druid/segment/data/GenericIndexedTest.java +++ b/processing/src/test/java/org/apache/druid/segment/data/GenericIndexedTest.java @@ -19,6 +19,7 @@ package org.apache.druid.segment.data; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Test; @@ -32,7 +33,7 @@ /** */ -public class GenericIndexedTest +public class GenericIndexedTest extends InitializedNullHandlingTest { @Test(expected = UnsupportedOperationException.class) public void testNotSortedNoIndexOf() diff --git a/processing/src/test/java/org/apache/druid/segment/data/IncrementalIndexTest.java b/processing/src/test/java/org/apache/druid/segment/data/IncrementalIndexTest.java index b254811094b0..11d5bdc67774 100644 --- a/processing/src/test/java/org/apache/druid/segment/data/IncrementalIndexTest.java +++ b/processing/src/test/java/org/apache/druid/segment/data/IncrementalIndexTest.java @@ -66,6 +66,7 @@ import org.apache.druid.segment.incremental.IncrementalIndex.Builder; import org.apache.druid.segment.incremental.IncrementalIndexSchema; import org.apache.druid.segment.incremental.IndexSizeExceededException; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.joda.time.Interval; import org.junit.AfterClass; import org.junit.Assert; @@ -92,7 +93,7 @@ /** */ @RunWith(Parameterized.class) -public class IncrementalIndexTest +public class IncrementalIndexTest extends InitializedNullHandlingTest { interface IndexCreator { diff --git a/processing/src/test/java/org/apache/druid/segment/filter/BaseFilterTest.java b/processing/src/test/java/org/apache/druid/segment/filter/BaseFilterTest.java index db4863ad7952..cdfe8644b1ef 100644 --- a/processing/src/test/java/org/apache/druid/segment/filter/BaseFilterTest.java +++ b/processing/src/test/java/org/apache/druid/segment/filter/BaseFilterTest.java @@ -70,6 +70,7 @@ import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory; import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory; import org.apache.druid.segment.writeout.TmpFileSegmentWriteOutMediumFactory; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Before; import org.junit.Rule; @@ -87,7 +88,7 @@ import java.util.Map; import java.util.Set; -public abstract class BaseFilterTest +public abstract class BaseFilterTest extends InitializedNullHandlingTest { static final VirtualColumns VIRTUAL_COLUMNS = VirtualColumns.create( ImmutableList.of( diff --git a/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexAdapterTest.java b/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexAdapterTest.java index 11182c7140f9..32a26a521c0a 100644 --- a/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexAdapterTest.java +++ b/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexAdapterTest.java @@ -29,6 +29,7 @@ import org.apache.druid.segment.data.CompressionStrategy; import org.apache.druid.segment.data.ConciseBitmapSerdeFactory; import org.apache.druid.segment.data.IncrementalIndexTest; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Test; @@ -36,7 +37,7 @@ import java.util.List; import java.util.function.Function; -public class IncrementalIndexAdapterTest +public class IncrementalIndexAdapterTest extends InitializedNullHandlingTest { private static final IndexSpec INDEX_SPEC = new IndexSpec( new ConciseBitmapSerdeFactory(), diff --git a/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexMultiValueSpecTest.java b/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexMultiValueSpecTest.java index a80c9103b42d..dfd386f3e92e 100644 --- a/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexMultiValueSpecTest.java +++ b/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexMultiValueSpecTest.java @@ -29,6 +29,7 @@ import org.apache.druid.java.util.common.granularity.Granularities; import org.apache.druid.query.aggregation.AggregatorFactory; import org.apache.druid.segment.VirtualColumns; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Test; @@ -38,7 +39,7 @@ /** */ -public class IncrementalIndexMultiValueSpecTest +public class IncrementalIndexMultiValueSpecTest extends InitializedNullHandlingTest { @Test public void test() throws IndexSizeExceededException diff --git a/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexRowCompTest.java b/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexRowCompTest.java index a062aa3a99c5..94e17c645e53 100644 --- a/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexRowCompTest.java +++ b/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexRowCompTest.java @@ -22,6 +22,7 @@ import com.google.common.collect.Lists; import org.apache.druid.data.input.MapBasedInputRow; import org.apache.druid.query.aggregation.CountAggregatorFactory; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Test; @@ -32,7 +33,7 @@ /** */ -public class IncrementalIndexRowCompTest +public class IncrementalIndexRowCompTest extends InitializedNullHandlingTest { @Test public void testBasic() diff --git a/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexRowSizeTest.java b/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexRowSizeTest.java index 0e5283bc7bd0..afcdfd492277 100644 --- a/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexRowSizeTest.java +++ b/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexRowSizeTest.java @@ -22,6 +22,7 @@ import com.google.common.collect.Lists; import org.apache.druid.data.input.MapBasedInputRow; import org.apache.druid.query.aggregation.CountAggregatorFactory; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Test; @@ -31,7 +32,7 @@ /** */ -public class IncrementalIndexRowSizeTest +public class IncrementalIndexRowSizeTest extends InitializedNullHandlingTest { @Test public void testIncrementalIndexRowSizeBasic() diff --git a/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexStorageAdapterTest.java b/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexStorageAdapterTest.java index 2015690dde87..3f3f79d0c03a 100644 --- a/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexStorageAdapterTest.java +++ b/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexStorageAdapterTest.java @@ -64,6 +64,7 @@ import org.apache.druid.segment.data.IndexedInts; import org.apache.druid.segment.filter.Filters; import org.apache.druid.segment.filter.SelectorFilter; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.joda.time.DateTime; import org.joda.time.Interval; import org.junit.Assert; @@ -83,7 +84,7 @@ /** */ @RunWith(Parameterized.class) -public class IncrementalIndexStorageAdapterTest +public class IncrementalIndexStorageAdapterTest extends InitializedNullHandlingTest { interface IndexCreator { diff --git a/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexTest.java b/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexTest.java index 3dfd3210d408..91863ff54344 100644 --- a/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexTest.java +++ b/processing/src/test/java/org/apache/druid/segment/incremental/IncrementalIndexTest.java @@ -38,6 +38,7 @@ import org.apache.druid.query.aggregation.FilteredAggregatorFactory; import org.apache.druid.query.filter.SelectorDimFilter; import org.apache.druid.segment.CloserRule; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.After; import org.junit.Assert; import org.junit.Rule; @@ -56,9 +57,8 @@ /** */ @RunWith(Parameterized.class) -public class IncrementalIndexTest +public class IncrementalIndexTest extends InitializedNullHandlingTest { - interface IndexCreator { IncrementalIndex createIndex(); diff --git a/processing/src/test/java/org/apache/druid/segment/incremental/OnheapIncrementalIndexTest.java b/processing/src/test/java/org/apache/druid/segment/incremental/OnheapIncrementalIndexTest.java index c5977a07f3c0..d475a5779f43 100644 --- a/processing/src/test/java/org/apache/druid/segment/incremental/OnheapIncrementalIndexTest.java +++ b/processing/src/test/java/org/apache/druid/segment/incremental/OnheapIncrementalIndexTest.java @@ -30,6 +30,7 @@ import org.apache.druid.query.aggregation.LongMaxAggregatorFactory; import org.apache.druid.query.aggregation.LongSumAggregatorFactory; import org.apache.druid.query.expression.TestExprMacroTable; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.easymock.EasyMock; import org.junit.Assert; import org.junit.Test; @@ -39,9 +40,8 @@ import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.atomic.AtomicInteger; -public class OnheapIncrementalIndexTest +public class OnheapIncrementalIndexTest extends InitializedNullHandlingTest { - private static final int MAX_ROWS = 100000; @Test diff --git a/processing/src/test/java/org/apache/druid/segment/virtual/ExpressionVirtualColumnTest.java b/processing/src/test/java/org/apache/druid/segment/virtual/ExpressionVirtualColumnTest.java index d53dd3fcbe28..4675852da2b1 100644 --- a/processing/src/test/java/org/apache/druid/segment/virtual/ExpressionVirtualColumnTest.java +++ b/processing/src/test/java/org/apache/druid/segment/virtual/ExpressionVirtualColumnTest.java @@ -43,12 +43,13 @@ import org.apache.druid.segment.ColumnValueSelector; import org.apache.druid.segment.DimensionSelector; import org.apache.druid.segment.column.ValueType; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Test; import java.util.Arrays; -public class ExpressionVirtualColumnTest +public class ExpressionVirtualColumnTest extends InitializedNullHandlingTest { private static final InputRow ROW0 = new MapBasedInputRow( DateTimes.of("2000-01-01T00:00:00").getMillis(), diff --git a/processing/src/test/java/org/apache/druid/segment/virtual/VirtualColumnsTest.java b/processing/src/test/java/org/apache/druid/segment/virtual/VirtualColumnsTest.java index 2b42c0350e72..b1a9eeeab14d 100644 --- a/processing/src/test/java/org/apache/druid/segment/virtual/VirtualColumnsTest.java +++ b/processing/src/test/java/org/apache/druid/segment/virtual/VirtualColumnsTest.java @@ -49,6 +49,7 @@ import org.apache.druid.segment.column.ValueType; import org.apache.druid.segment.data.IndexedInts; import org.apache.druid.segment.data.ZeroIndexedInts; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.junit.Assert; import org.junit.Rule; import org.junit.Test; @@ -58,7 +59,7 @@ import java.util.Arrays; import java.util.List; -public class VirtualColumnsTest +public class VirtualColumnsTest extends InitializedNullHandlingTest { @Rule public ExpectedException expectedException = ExpectedException.none(); diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/CalciteTestBase.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/CalciteTestBase.java index bb6225c3362a..8c99ee52ee37 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/util/CalciteTestBase.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/CalciteTestBase.java @@ -19,6 +19,7 @@ package org.apache.druid.sql.calcite.util; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.sql.calcite.planner.Calcites; import org.junit.BeforeClass; @@ -28,5 +29,6 @@ public abstract class CalciteTestBase public static void setupCalciteProperties() { Calcites.setSystemProperties(); + NullHandling.initializeForTests(); } } From 5eb9f63016e675a112882e27450d05f053ce6c0c Mon Sep 17 00:00:00 2001 From: Clint Wylie Date: Sun, 17 Nov 2019 22:09:17 -0800 Subject: [PATCH 2/7] fix npe --- .../movingaverage/PostAveragerAggregatorCalculatorTest.java | 3 ++- .../org/apache/druid/indexing/kafka/KafkaSamplerSpecTest.java | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/PostAveragerAggregatorCalculatorTest.java b/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/PostAveragerAggregatorCalculatorTest.java index 542408c75de5..f12d9b2b6e14 100644 --- a/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/PostAveragerAggregatorCalculatorTest.java +++ b/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/PostAveragerAggregatorCalculatorTest.java @@ -28,6 +28,7 @@ import org.apache.druid.query.aggregation.post.FieldAccessPostAggregator; import org.apache.druid.query.movingaverage.averagers.DoubleMeanAveragerFactory; import org.apache.druid.query.spec.MultipleIntervalSegmentSpec; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.joda.time.DateTime; import org.joda.time.Interval; import org.joda.time.chrono.ISOChronology; @@ -40,7 +41,7 @@ import java.util.HashMap; import java.util.Map; -public class PostAveragerAggregatorCalculatorTest +public class PostAveragerAggregatorCalculatorTest extends InitializedNullHandlingTest { private PostAveragerAggregatorCalculator pac; private Map event; diff --git a/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/KafkaSamplerSpecTest.java b/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/KafkaSamplerSpecTest.java index 5ede763b8d62..f2c02b0fe301 100644 --- a/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/KafkaSamplerSpecTest.java +++ b/extensions-core/kafka-indexing-service/src/test/java/org/apache/druid/indexing/kafka/KafkaSamplerSpecTest.java @@ -47,6 +47,7 @@ import org.apache.druid.segment.TestHelper; import org.apache.druid.segment.indexing.DataSchema; import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec; +import org.apache.druid.testing.InitializedNullHandlingTest; import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerRecord; import org.junit.AfterClass; @@ -60,7 +61,7 @@ import java.util.List; import java.util.Map; -public class KafkaSamplerSpecTest +public class KafkaSamplerSpecTest extends InitializedNullHandlingTest { private static final ObjectMapper OBJECT_MAPPER = TestHelper.makeJsonMapper(); private static final String TOPIC = "sampling"; From 3000d7aa80db3c75d09d293bcc4ca4a307143697 Mon Sep 17 00:00:00 2001 From: Clint Wylie Date: Mon, 18 Nov 2019 00:27:07 -0800 Subject: [PATCH 3/7] fix tests --- .../druid/query/movingaverage/MovingAverageIterableTest.java | 5 +++-- .../movingaverage/PostAveragerAggregatorCalculatorTest.java | 5 +++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageIterableTest.java b/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageIterableTest.java index 42737f708045..589b03d6d20e 100644 --- a/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageIterableTest.java +++ b/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/MovingAverageIterableTest.java @@ -19,6 +19,7 @@ package org.apache.druid.query.movingaverage; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.MapBasedRow; import org.apache.druid.data.input.Row; import org.apache.druid.java.util.common.guava.Sequence; @@ -613,7 +614,7 @@ public void testMissingDaysAtBegining() public void testMissingDaysInMiddle() { System.setProperty("druid.generic.useDefaultValueForNull", "true"); - + NullHandling.initializeForTests(); Map event1 = new HashMap<>(); Map event2 = new HashMap<>(); @@ -733,7 +734,7 @@ public void testWithFilteredAggregation() public void testMissingDaysAtEnd() { System.setProperty("druid.generic.useDefaultValueForNull", "true"); - + NullHandling.initializeForTests(); Map event1 = new HashMap<>(); Map event2 = new HashMap<>(); diff --git a/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/PostAveragerAggregatorCalculatorTest.java b/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/PostAveragerAggregatorCalculatorTest.java index f12d9b2b6e14..280cedd1088c 100644 --- a/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/PostAveragerAggregatorCalculatorTest.java +++ b/extensions-contrib/moving-average-query/src/test/java/org/apache/druid/query/movingaverage/PostAveragerAggregatorCalculatorTest.java @@ -19,6 +19,7 @@ package org.apache.druid.query.movingaverage; +import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.MapBasedRow; import org.apache.druid.data.input.Row; import org.apache.druid.java.util.common.granularity.Granularities; @@ -28,7 +29,6 @@ import org.apache.druid.query.aggregation.post.FieldAccessPostAggregator; import org.apache.druid.query.movingaverage.averagers.DoubleMeanAveragerFactory; import org.apache.druid.query.spec.MultipleIntervalSegmentSpec; -import org.apache.druid.testing.InitializedNullHandlingTest; import org.joda.time.DateTime; import org.joda.time.Interval; import org.joda.time.chrono.ISOChronology; @@ -41,7 +41,7 @@ import java.util.HashMap; import java.util.Map; -public class PostAveragerAggregatorCalculatorTest extends InitializedNullHandlingTest +public class PostAveragerAggregatorCalculatorTest { private PostAveragerAggregatorCalculator pac; private Map event; @@ -51,6 +51,7 @@ public class PostAveragerAggregatorCalculatorTest extends InitializedNullHandlin public void setup() { System.setProperty("druid.generic.useDefaultValueForNull", "true"); + NullHandling.initializeForTests(); MovingAverageQuery query = new MovingAverageQuery( new TableDataSource("d"), new MultipleIntervalSegmentSpec(Collections.singletonList(new Interval( From 1eccc538f97ee462eec567f665a1bc83aae53044 Mon Sep 17 00:00:00 2001 From: Clint Wylie Date: Tue, 19 Nov 2019 15:34:55 -0800 Subject: [PATCH 4/7] add friendly error --- .../java/org/apache/druid/common/config/NullHandling.java | 3 +++ .../org/apache/druid/server/lookup/jdbc/JdbcDataFetcher.java | 4 ++++ 2 files changed, 7 insertions(+) diff --git a/core/src/main/java/org/apache/druid/common/config/NullHandling.java b/core/src/main/java/org/apache/druid/common/config/NullHandling.java index cabe9734f986..a68ab43f8af8 100644 --- a/core/src/main/java/org/apache/druid/common/config/NullHandling.java +++ b/core/src/main/java/org/apache/druid/common/config/NullHandling.java @@ -66,6 +66,9 @@ public static void initializeForTests() */ public static boolean replaceWithDefault() { + if (INSTANCE == null) { + throw new IllegalStateException("NullHandling module not initialized"); + } return INSTANCE.isUseDefaultValuesForNull(); } diff --git a/extensions-core/lookups-cached-single/src/main/java/org/apache/druid/server/lookup/jdbc/JdbcDataFetcher.java b/extensions-core/lookups-cached-single/src/main/java/org/apache/druid/server/lookup/jdbc/JdbcDataFetcher.java index 191a3f585e5a..6336de583c30 100644 --- a/extensions-core/lookups-cached-single/src/main/java/org/apache/druid/server/lookup/jdbc/JdbcDataFetcher.java +++ b/extensions-core/lookups-cached-single/src/main/java/org/apache/druid/server/lookup/jdbc/JdbcDataFetcher.java @@ -43,6 +43,10 @@ public class JdbcDataFetcher implements DataFetcher { + static { + NullHandling.initializeForTests(); + } + private static final Logger LOGGER = new Logger(JdbcDataFetcher.class); private static final int DEFAULT_STREAMING_FETCH_SIZE = 1000; From baf922620c394dd35d1d1c54e2329c462ccb50b9 Mon Sep 17 00:00:00 2001 From: Clint Wylie Date: Tue, 19 Nov 2019 15:37:17 -0800 Subject: [PATCH 5/7] comment, and friendlier still --- .../main/java/org/apache/druid/common/config/NullHandling.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/core/src/main/java/org/apache/druid/common/config/NullHandling.java b/core/src/main/java/org/apache/druid/common/config/NullHandling.java index a68ab43f8af8..794d8bfcb1c0 100644 --- a/core/src/main/java/org/apache/druid/common/config/NullHandling.java +++ b/core/src/main/java/org/apache/druid/common/config/NullHandling.java @@ -66,8 +66,9 @@ public static void initializeForTests() */ public static boolean replaceWithDefault() { + // this should only be null in a unit test context, in production this will be injected by the null handling module if (INSTANCE == null) { - throw new IllegalStateException("NullHandling module not initialized"); + throw new IllegalStateException("NullHandling module not initialized, call NullHandling.initializeForTests()"); } return INSTANCE.isUseDefaultValuesForNull(); } From 8f1599d4de13e599c2dce3b5ad097d502a38a31c Mon Sep 17 00:00:00 2001 From: Clint Wylie Date: Tue, 19 Nov 2019 19:43:41 -0800 Subject: [PATCH 6/7] fix compile --- .../main/java/org/apache/druid/common/config/NullHandling.java | 1 - .../druid/indexing/overlord/sampler/FirehoseSamplerTest.java | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/core/src/main/java/org/apache/druid/common/config/NullHandling.java b/core/src/main/java/org/apache/druid/common/config/NullHandling.java index 794d8bfcb1c0..f5c46e6de64a 100644 --- a/core/src/main/java/org/apache/druid/common/config/NullHandling.java +++ b/core/src/main/java/org/apache/druid/common/config/NullHandling.java @@ -122,5 +122,4 @@ public static boolean isNullOrEquivalent(@Nullable String value) { return replaceWithDefault() ? Strings.isNullOrEmpty(value) : value == null; } - } diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/FirehoseSamplerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/FirehoseSamplerTest.java index e0986a307994..eca902b77e4b 100644 --- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/FirehoseSamplerTest.java +++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/FirehoseSamplerTest.java @@ -1215,7 +1215,7 @@ private Map removeEmptyValues(Map data) private Map replaceNullValues(Map data) { return ParserType.STR_CSV.equals(parserType) - ? USE_DEFAULT_VALUE_FOR_NULL + ? NullHandling.replaceWithDefault() ? data : data.entrySet() .stream() From dc51d4f8420df4fffd91b7f11bad5598022680c0 Mon Sep 17 00:00:00 2001 From: Clint Wylie Date: Wed, 20 Nov 2019 02:06:05 -0800 Subject: [PATCH 7/7] fix from merges --- .../overlord/sampler/FirehoseSamplerTest.java | 180 ++++++++---------- 1 file changed, 78 insertions(+), 102 deletions(-) diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/FirehoseSamplerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/FirehoseSamplerTest.java index bc3048a7940c..3ff3b4f2ef4c 100644 --- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/FirehoseSamplerTest.java +++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/FirehoseSamplerTest.java @@ -24,7 +24,6 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import org.apache.druid.client.cache.MapCache; -import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.FirehoseFactory; import org.apache.druid.data.input.impl.DelimitedParseSpec; import org.apache.druid.data.input.impl.DimensionsSpec; @@ -248,7 +247,7 @@ public void testCSVColumnAllNull() Assert.assertEquals(new SamplerResponseRow( str_csv_rows.get(1).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 0L); @@ -257,13 +256,13 @@ public void testCSVColumnAllNull() put("LastName", "G"); put("Gender", "Male"); } - }), + }, null, null ), data.get(0)); Assert.assertEquals(new SamplerResponseRow( str_csv_rows.get(2).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 0L); @@ -272,13 +271,13 @@ public void testCSVColumnAllNull() put("LastName", "Bryant"); put("Gender", "Male"); } - }), + }, null, null ), data.get(1)); Assert.assertEquals(new SamplerResponseRow( str_csv_rows.get(3).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 0L); @@ -287,13 +286,13 @@ public void testCSVColumnAllNull() put("LastName", " Krystal"); put("Gender", "Female"); } - }), + }, null, null ), data.get(2)); Assert.assertEquals(new SamplerResponseRow( str_csv_rows.get(4).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 0L); @@ -302,7 +301,7 @@ public void testCSVColumnAllNull() put("LastName", "Jackson"); put("Gender", "Male"); } - }), + }, null, null ), data.get(3)); @@ -326,7 +325,7 @@ public void testMissingValueTimestampSpec() Assert.assertEquals(new SamplerResponseRow( getTestRows().get(0).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 0L); @@ -335,13 +334,13 @@ public void testMissingValueTimestampSpec() put("dim1", "foo"); put("met1", "1"); } - }), + }, null, null ), data.get(0)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(1).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 0L); @@ -350,13 +349,13 @@ public void testMissingValueTimestampSpec() put("dim1", "foo"); put("met1", "2"); } - }), + }, null, null ), data.get(1)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(2).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 0L); @@ -365,13 +364,13 @@ public void testMissingValueTimestampSpec() put("dim1", "foo"); put("met1", "3"); } - }), + }, null, null ), data.get(2)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(3).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 0L); @@ -380,13 +379,13 @@ public void testMissingValueTimestampSpec() put("dim1", "foo2"); put("met1", "4"); } - }), + }, null, null ), data.get(3)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(4).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 0L); @@ -395,13 +394,13 @@ public void testMissingValueTimestampSpec() put("dim1", "foo"); put("met1", "5"); } - }), + }, null, null ), data.get(4)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(5).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 0L); @@ -410,7 +409,7 @@ public void testMissingValueTimestampSpec() put("dim1", "foo"); put("met1", "6"); } - }), + }, null, null ), data.get(5)); @@ -434,7 +433,7 @@ public void testWithTimestampSpec() Assert.assertEquals(new SamplerResponseRow( getTestRows().get(0).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -442,13 +441,13 @@ public void testWithTimestampSpec() put("dim1", "foo"); put("met1", "1"); } - }), + }, null, null ), data.get(0)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(1).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -456,13 +455,13 @@ public void testWithTimestampSpec() put("dim1", "foo"); put("met1", "2"); } - }), + }, null, null ), data.get(1)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(2).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934460000L); @@ -470,13 +469,13 @@ public void testWithTimestampSpec() put("dim1", "foo"); put("met1", "3"); } - }), + }, null, null ), data.get(2)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(3).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -484,13 +483,13 @@ public void testWithTimestampSpec() put("dim1", "foo2"); put("met1", "4"); } - }), + }, null, null ), data.get(3)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(4).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -498,7 +497,7 @@ public void testWithTimestampSpec() put("dim1", "foo"); put("met1", "5"); } - }), + }, null, null ), data.get(4)); @@ -534,66 +533,66 @@ public void testWithDimensionSpec() Assert.assertEquals(new SamplerResponseRow( getTestRows().get(0).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); put("dim1", "foo"); put("met1", "1"); } - }), + }, null, null ), data.get(0)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(1).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); put("dim1", "foo"); put("met1", "2"); } - }), + }, null, null ), data.get(1)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(2).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934460000L); put("dim1", "foo"); put("met1", "3"); } - }), + }, null, null ), data.get(2)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(3).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); put("dim1", "foo2"); put("met1", "4"); } - }), + }, null, null ), data.get(3)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(4).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); put("dim1", "foo"); put("met1", "5"); } - }), + }, null, null ), data.get(4)); @@ -632,7 +631,7 @@ public void testWithNoRollup() Assert.assertEquals(new SamplerResponseRow( getTestRows().get(0).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -640,13 +639,13 @@ public void testWithNoRollup() put("dim1", "foo"); put("met1", 1L); } - }), + }, null, null ), data.get(0)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(1).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -654,13 +653,13 @@ public void testWithNoRollup() put("dim1", "foo"); put("met1", 2L); } - }), + }, null, null ), data.get(1)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(2).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -668,13 +667,13 @@ public void testWithNoRollup() put("dim1", "foo"); put("met1", 3L); } - }), + }, null, null ), data.get(2)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(3).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -682,13 +681,13 @@ public void testWithNoRollup() put("dim1", "foo2"); put("met1", 4L); } - }), + }, null, null ), data.get(3)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(4).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -696,7 +695,7 @@ public void testWithNoRollup() put("dim1", "foo"); put("met1", 5L); } - }), + }, null, null ), data.get(4)); @@ -735,7 +734,7 @@ public void testWithRollup() Assert.assertEquals(new SamplerResponseRow( getTestRows().get(0).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -743,13 +742,13 @@ public void testWithRollup() put("dim1", "foo"); put("met1", 6L); } - }), + }, null, null ), data.get(0)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(3).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -757,13 +756,13 @@ public void testWithRollup() put("dim1", "foo2"); put("met1", 4L); } - }), + }, null, null ), data.get(1)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(4).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -771,7 +770,7 @@ public void testWithRollup() put("dim1", "foo"); put("met1", 5L); } - }), + }, null, null ), data.get(2)); @@ -813,27 +812,27 @@ public void testWithMoreRollup() Assert.assertEquals(new SamplerResponseRow( getTestRows().get(0).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); put("dim1", "foo"); put("met1", 11L); } - }), + }, null, null ), data.get(0)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(3).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); put("dim1", "foo2"); put("met1", 4L); } - }), + }, null, null ), data.get(1)); @@ -880,27 +879,27 @@ public void testWithMoreRollupCacheReplay() Assert.assertEquals(new SamplerResponseRow( getTestRows().get(0).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); put("dim1", "foo"); put("met1", 11L); } - }), + }, null, null ), data.get(0)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(3).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); put("dim1", "foo2"); put("met1", 4L); } - }), + }, null, null ), data.get(1)); @@ -947,7 +946,7 @@ public void testWithTransformsAutoDimensions() Assert.assertEquals(new SamplerResponseRow( getTestRows().get(0).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -955,13 +954,13 @@ public void testWithTransformsAutoDimensions() put("dim1", "foo"); put("met1", 6L); } - }), + }, null, null ), data.get(0)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(3).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -969,13 +968,13 @@ public void testWithTransformsAutoDimensions() put("dim1", "foo2"); put("met1", 4L); } - }), + }, null, null ), data.get(1)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(4).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -983,7 +982,7 @@ public void testWithTransformsAutoDimensions() put("dim1", "foo"); put("met1", 5L); } - }), + }, null, null ), data.get(2)); @@ -1036,27 +1035,27 @@ public void testWithTransformsDimensionsSpec() Assert.assertEquals(new SamplerResponseRow( getTestRows().get(0).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); put("dim1PlusBar", "foobar"); put("met1", 11L); } - }), + }, null, null ), data.get(0)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(3).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); put("dim1PlusBar", "foo2bar"); put("met1", 4L); } - }), + }, null, null ), data.get(1)); @@ -1099,7 +1098,7 @@ public void testWithFilter() Assert.assertEquals(new SamplerResponseRow( getTestRows().get(0).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -1107,13 +1106,13 @@ public void testWithFilter() put("dim1", "foo"); put("met1", 6L); } - }), + }, null, null ), data.get(0)); Assert.assertEquals(new SamplerResponseRow( getTestRows().get(4).toString(), - replaceNullValues(new HashMap() + new HashMap() { { put("__time", 1555934400000L); @@ -1121,7 +1120,7 @@ public void testWithFilter() put("dim1", "foo"); put("met1", 5L); } - }), + }, null, null ), data.get(1)); @@ -1191,14 +1190,6 @@ private String getUnparseableTimestampString() : "Unparseable timestamp found! Event: {t=bad_timestamp, dim1=foo, met1=6}"; } - private List removeEmptyColumns(List rows) - { - return NullHandling.replaceWithDefault() - ? rows - : rows.stream().map(x -> x.withParsed(removeEmptyValues(x.getParsed()))).collect(Collectors.toList()); - } - - @Nullable private Map removeEmptyValues(Map data) { @@ -1208,19 +1199,4 @@ private Map removeEmptyValues(Map data) .filter(x -> !(x.getValue() instanceof String) || !((String) x.getValue()).isEmpty()) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); } - - @Nullable - private Map replaceNullValues(Map data) - { - return ParserType.STR_CSV.equals(parserType) - ? NullHandling.replaceWithDefault() - ? data - : data.entrySet() - .stream() - .collect(Collectors.toMap( - Map.Entry::getKey, - e -> e.getValue() == null ? "" : e.getValue() - )) - : data; - } }