From cf381d56121be85bed44d275349d9ad9796ac2b6 Mon Sep 17 00:00:00 2001 From: "huangqixiang.871" Date: Sat, 14 Aug 2021 09:55:59 +0800 Subject: [PATCH 1/4] enable result-level cache for GroupByStrategyV2 on broker --- docs/configuration/index.md | 2 +- .../org/apache/druid/query/CacheStrategy.java | 3 +- .../groupby/GroupByQueryQueryToolChest.java | 4 +- .../groupby/strategy/GroupByStrategy.java | 3 +- .../groupby/strategy/GroupByStrategyV1.java | 2 +- .../groupby/strategy/GroupByStrategyV2.java | 6 +- .../SegmentMetadataQueryQueryToolChest.java | 2 +- .../search/SearchQueryQueryToolChest.java | 2 +- .../TimeBoundaryQueryQueryToolChest.java | 2 +- .../TimeseriesQueryQueryToolChest.java | 2 +- .../query/topn/TopNQueryQueryToolChest.java | 2 +- .../GroupByQueryQueryToolChestTest.java | 75 +++++++++++++++++++ .../org/apache/druid/client/CacheUtil.java | 14 ++-- .../apache/druid/client/CacheUtilTest.java | 26 ++++--- 14 files changed, 117 insertions(+), 28 deletions(-) diff --git a/docs/configuration/index.md b/docs/configuration/index.md index 251f5c4c511f..30b863c83620 100644 --- a/docs/configuration/index.md +++ b/docs/configuration/index.md @@ -1783,7 +1783,7 @@ You can optionally only configure caching to be enabled on the Broker by setting See [cache configuration](#cache-configuration) for how to configure cache settings. -> Note: Even if cache is enabled, for [groupBy v2](../querying/groupbyquery.md#strategies) queries, both of non-result level cache and result level cache do not work on Brokers. +> Note: Even if cache is enabled, for [groupBy v2](../querying/groupbyquery.md#strategies) queries, segment level cache do not work on Brokers. > See [Differences between v1 and v2](../querying/groupbyquery.md#differences-between-v1-and-v2) and [Query caching](../querying/caching.md) for more information. #### Segment Discovery diff --git a/processing/src/main/java/org/apache/druid/query/CacheStrategy.java b/processing/src/main/java/org/apache/druid/query/CacheStrategy.java index bd21034186ca..92487b2898fa 100644 --- a/processing/src/main/java/org/apache/druid/query/CacheStrategy.java +++ b/processing/src/main/java/org/apache/druid/query/CacheStrategy.java @@ -43,10 +43,11 @@ public interface CacheStrategy> * @param query the query to be cached * @param willMergeRunners indicates that {@link QueryRunnerFactory#mergeRunners(QueryProcessingPool, Iterable)} will be * called on the cached by-segment results + * @param bySegment segment level or result level cache * * @return true if the query is cacheable, otherwise false. */ - boolean isCacheable(QueryType query, boolean willMergeRunners); + boolean isCacheable(QueryType query, boolean willMergeRunners, boolean bySegment); /** * Computes the per-segment cache key for the given query. Because this is a per-segment cache key, it should only diff --git a/processing/src/main/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChest.java b/processing/src/main/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChest.java index 28c265854785..903ae0a17734 100644 --- a/processing/src/main/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChest.java +++ b/processing/src/main/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChest.java @@ -505,9 +505,9 @@ public CacheStrategy getCacheStrategy(final Gro private final List dims = query.getDimensions(); @Override - public boolean isCacheable(GroupByQuery query, boolean willMergeRunners) + public boolean isCacheable(GroupByQuery query, boolean willMergeRunners, boolean bySegment) { - return strategySelector.strategize(query).isCacheable(willMergeRunners); + return strategySelector.strategize(query).isCacheable(willMergeRunners, bySegment); } @Override diff --git a/processing/src/main/java/org/apache/druid/query/groupby/strategy/GroupByStrategy.java b/processing/src/main/java/org/apache/druid/query/groupby/strategy/GroupByStrategy.java index df48c968724f..a3e12b6f1671 100644 --- a/processing/src/main/java/org/apache/druid/query/groupby/strategy/GroupByStrategy.java +++ b/processing/src/main/java/org/apache/druid/query/groupby/strategy/GroupByStrategy.java @@ -59,10 +59,11 @@ public interface GroupByStrategy * @param willMergeRunners indicates that {@link QueryRunnerFactory#mergeRunners(QueryProcessingPool, Iterable)} will be * called on the cached by-segment results. Can be used to distinguish if we are running on * a broker or data node. + * @param bySegment segment level or result level cache * * @return true if this strategy is cacheable, otherwise false. */ - boolean isCacheable(boolean willMergeRunners); + boolean isCacheable(boolean willMergeRunners, boolean bySegment); /** * Indicates if this query should undergo "mergeResults" or not. Checked by diff --git a/processing/src/main/java/org/apache/druid/query/groupby/strategy/GroupByStrategyV1.java b/processing/src/main/java/org/apache/druid/query/groupby/strategy/GroupByStrategyV1.java index 72eafed7c930..8fddbd10cb74 100644 --- a/processing/src/main/java/org/apache/druid/query/groupby/strategy/GroupByStrategyV1.java +++ b/processing/src/main/java/org/apache/druid/query/groupby/strategy/GroupByStrategyV1.java @@ -86,7 +86,7 @@ public GroupByQueryResource prepareResource(GroupByQuery query) } @Override - public boolean isCacheable(boolean willMergeRunners) + public boolean isCacheable(boolean willMergeRunners, boolean bySegment) { return true; } diff --git a/processing/src/main/java/org/apache/druid/query/groupby/strategy/GroupByStrategyV2.java b/processing/src/main/java/org/apache/druid/query/groupby/strategy/GroupByStrategyV2.java index 2caf25169517..bce6e957a3bd 100644 --- a/processing/src/main/java/org/apache/druid/query/groupby/strategy/GroupByStrategyV2.java +++ b/processing/src/main/java/org/apache/druid/query/groupby/strategy/GroupByStrategyV2.java @@ -172,9 +172,11 @@ private static int countRequiredMergeBufferNumWithoutSubtotal(Query query, int f } @Override - public boolean isCacheable(boolean willMergeRunners) + public boolean isCacheable(boolean willMergeRunners, boolean bySegment) { - return willMergeRunners; + //disable segment-level cache on borker, + //see PR https://github.com/apache/druid/issues/3820 + return willMergeRunners || !bySegment; } @Override diff --git a/processing/src/main/java/org/apache/druid/query/metadata/SegmentMetadataQueryQueryToolChest.java b/processing/src/main/java/org/apache/druid/query/metadata/SegmentMetadataQueryQueryToolChest.java index a40bd69ee55c..d2c550879eac 100644 --- a/processing/src/main/java/org/apache/druid/query/metadata/SegmentMetadataQueryQueryToolChest.java +++ b/processing/src/main/java/org/apache/druid/query/metadata/SegmentMetadataQueryQueryToolChest.java @@ -186,7 +186,7 @@ public CacheStrategy get return new CacheStrategy() { @Override - public boolean isCacheable(SegmentMetadataQuery query, boolean willMergeRunners) + public boolean isCacheable(SegmentMetadataQuery query, boolean willMergeRunners, boolean bySegment) { return true; } diff --git a/processing/src/main/java/org/apache/druid/query/search/SearchQueryQueryToolChest.java b/processing/src/main/java/org/apache/druid/query/search/SearchQueryQueryToolChest.java index 4f0563317d9e..e9596224959a 100644 --- a/processing/src/main/java/org/apache/druid/query/search/SearchQueryQueryToolChest.java +++ b/processing/src/main/java/org/apache/druid/query/search/SearchQueryQueryToolChest.java @@ -139,7 +139,7 @@ public CacheStrategy, Object, SearchQuery> getCacheStr : Collections.emptyList(); @Override - public boolean isCacheable(SearchQuery query, boolean willMergeRunners) + public boolean isCacheable(SearchQuery query, boolean willMergeRunners, boolean bySegment) { return true; } diff --git a/processing/src/main/java/org/apache/druid/query/timeboundary/TimeBoundaryQueryQueryToolChest.java b/processing/src/main/java/org/apache/druid/query/timeboundary/TimeBoundaryQueryQueryToolChest.java index d6a402fcc83b..ddfd8799370d 100644 --- a/processing/src/main/java/org/apache/druid/query/timeboundary/TimeBoundaryQueryQueryToolChest.java +++ b/processing/src/main/java/org/apache/druid/query/timeboundary/TimeBoundaryQueryQueryToolChest.java @@ -164,7 +164,7 @@ public CacheStrategy, Object, TimeBoundaryQuery> return new CacheStrategy, Object, TimeBoundaryQuery>() { @Override - public boolean isCacheable(TimeBoundaryQuery query, boolean willMergeRunners) + public boolean isCacheable(TimeBoundaryQuery query, boolean willMergeRunners, boolean bySegment) { return true; } diff --git a/processing/src/main/java/org/apache/druid/query/timeseries/TimeseriesQueryQueryToolChest.java b/processing/src/main/java/org/apache/druid/query/timeseries/TimeseriesQueryQueryToolChest.java index d811914b89d1..7cd10ae8f883 100644 --- a/processing/src/main/java/org/apache/druid/query/timeseries/TimeseriesQueryQueryToolChest.java +++ b/processing/src/main/java/org/apache/druid/query/timeseries/TimeseriesQueryQueryToolChest.java @@ -267,7 +267,7 @@ public CacheStrategy, Object, TimeseriesQuery> get private final List aggs = query.getAggregatorSpecs(); @Override - public boolean isCacheable(TimeseriesQuery query, boolean willMergeRunners) + public boolean isCacheable(TimeseriesQuery query, boolean willMergeRunners, boolean bySegment) { return true; } diff --git a/processing/src/main/java/org/apache/druid/query/topn/TopNQueryQueryToolChest.java b/processing/src/main/java/org/apache/druid/query/topn/TopNQueryQueryToolChest.java index 2401d9790e12..15974a239248 100644 --- a/processing/src/main/java/org/apache/druid/query/topn/TopNQueryQueryToolChest.java +++ b/processing/src/main/java/org/apache/druid/query/topn/TopNQueryQueryToolChest.java @@ -282,7 +282,7 @@ public CacheStrategy, Object, TopNQuery> getCacheStrateg ); @Override - public boolean isCacheable(TopNQuery query, boolean willMergeRunners) + public boolean isCacheable(TopNQuery query, boolean willMergeRunners, boolean bySegment) { return true; } diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChestTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChestTest.java index eaf85fc44ea8..e1ff0b2d4d84 100644 --- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChestTest.java +++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChestTest.java @@ -20,10 +20,16 @@ package org.apache.druid.query.groupby; import com.fasterxml.jackson.databind.ObjectMapper; +import com.google.common.base.Supplier; +import com.google.common.base.Suppliers; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.Lists; +import org.apache.druid.collections.BlockingPool; +import org.apache.druid.collections.DefaultBlockingPool; +import org.apache.druid.collections.NonBlockingPool; import org.apache.druid.collections.SerializablePair; +import org.apache.druid.collections.StupidPool; import org.apache.druid.common.config.NullHandling; import org.apache.druid.data.input.Row; import org.apache.druid.java.util.common.DateTimes; @@ -31,6 +37,7 @@ import org.apache.druid.java.util.common.granularity.Granularities; import org.apache.druid.java.util.common.guava.Sequences; import org.apache.druid.query.CacheStrategy; +import org.apache.druid.query.DruidProcessingConfig; import org.apache.druid.query.Druids; import org.apache.druid.query.QueryDataSource; import org.apache.druid.query.QueryRunnerTestHelper; @@ -62,6 +69,9 @@ import org.apache.druid.query.groupby.having.OrHavingSpec; import org.apache.druid.query.groupby.orderby.DefaultLimitSpec; import org.apache.druid.query.groupby.orderby.OrderByColumnSpec; +import org.apache.druid.query.groupby.strategy.GroupByStrategySelector; +import org.apache.druid.query.groupby.strategy.GroupByStrategyV1; +import org.apache.druid.query.groupby.strategy.GroupByStrategyV2; import org.apache.druid.query.ordering.StringComparators; import org.apache.druid.segment.TestHelper; import org.apache.druid.segment.column.RowSignature; @@ -73,6 +83,7 @@ import org.junit.Test; import java.io.IOException; +import java.nio.ByteBuffer; import java.util.Arrays; import java.util.Collections; import java.util.List; @@ -1032,4 +1043,68 @@ private static ResultRow makeRow(final GroupByQuery query, final String timestam { return GroupByQueryRunnerTestHelper.createExpectedRow(query, timestamp, vals); } + + @Test + public void testIsQueryCacheableOnGroupByStrategyV2() + { + final GroupByQuery query = new GroupByQuery.Builder() + .setDataSource(QueryRunnerTestHelper.DATA_SOURCE) + .setGranularity(Granularities.DAY) + .setDimensions(new DefaultDimensionSpec("col", "dim")) + .setInterval(QueryRunnerTestHelper.FULL_ON_INTERVAL_SPEC) + .setAggregatorSpecs(QueryRunnerTestHelper.COMMON_DOUBLE_AGGREGATORS) + .build(); + final DruidProcessingConfig processingConfig = new DruidProcessingConfig() + { + @Override + public String getFormatString() + { + return "processing-%s"; + } + }; + final GroupByQueryConfig queryConfig = new GroupByQueryConfig(); + final Supplier queryConfigSupplier = Suppliers.ofInstance(queryConfig); + final Supplier bufferSupplier = + () -> ByteBuffer.allocateDirect(processingConfig.intermediateComputeSizeBytes()); + + final NonBlockingPool bufferPool = new StupidPool<>( + "GroupByQueryEngine-bufferPool", + bufferSupplier + ); + final BlockingPool mergeBufferPool = new DefaultBlockingPool<>( + bufferSupplier, + processingConfig.getNumMergeBuffers() + ); + final GroupByStrategySelector strategySelector = new GroupByStrategySelector( + queryConfigSupplier, + new GroupByStrategyV1( + queryConfigSupplier, + new GroupByQueryEngine(queryConfigSupplier, bufferPool), + QueryRunnerTestHelper.NOOP_QUERYWATCHER, + bufferPool + ), + new GroupByStrategyV2( + processingConfig, + queryConfigSupplier, + bufferPool, + mergeBufferPool, + GroupByQueryRunnerTest.DEFAULT_MAPPER, + QueryRunnerTestHelper.NOOP_QUERYWATCHER + ) + ); + final GroupByQueryQueryToolChest queryToolChest = new GroupByQueryQueryToolChest(strategySelector); + CacheStrategy cacheStrategy = queryToolChest.getCacheStrategy(query); + Assert.assertTrue( + "result level cache on broker server for GroupByStrategyV2 should be enabled", + cacheStrategy.isCacheable(query, false, false) + ); + Assert.assertFalse( + "segment level cache on broker server for GroupByStrategyV2 should be disabled", + cacheStrategy.isCacheable(query, false, true) + ); + Assert.assertTrue( + "segment level cache on data server for GroupByStrategyV2 should be enabled", + cacheStrategy.isCacheable(query, true, true) + ); + } } diff --git a/server/src/main/java/org/apache/druid/client/CacheUtil.java b/server/src/main/java/org/apache/druid/client/CacheUtil.java index 88d713c19aba..76597b959d28 100644 --- a/server/src/main/java/org/apache/druid/client/CacheUtil.java +++ b/server/src/main/java/org/apache/druid/client/CacheUtil.java @@ -108,7 +108,7 @@ public static boolean isUseSegmentCache( ServerType serverType ) { - return isQueryCacheable(query, cacheStrategy, cacheConfig, serverType) + return isQueryCacheable(query, cacheStrategy, cacheConfig, serverType, true) && QueryContexts.isUseCache(query) && cacheConfig.isUseCache(); } @@ -128,7 +128,7 @@ public static boolean isPopulateSegmentCache( ServerType serverType ) { - return isQueryCacheable(query, cacheStrategy, cacheConfig, serverType) + return isQueryCacheable(query, cacheStrategy, cacheConfig, serverType, true) && QueryContexts.isPopulateCache(query) && cacheConfig.isPopulateCache(); } @@ -148,7 +148,7 @@ public static boolean isUseResultCache( ServerType serverType ) { - return isQueryCacheable(query, cacheStrategy, cacheConfig, serverType) + return isQueryCacheable(query, cacheStrategy, cacheConfig, serverType, false) && QueryContexts.isUseResultLevelCache(query) && cacheConfig.isUseResultLevelCache(); } @@ -168,7 +168,7 @@ public static boolean isPopulateResultCache( ServerType serverType ) { - return isQueryCacheable(query, cacheStrategy, cacheConfig, serverType) + return isQueryCacheable(query, cacheStrategy, cacheConfig, serverType, false) && QueryContexts.isPopulateResultLevelCache(query) && cacheConfig.isPopulateResultLevelCache(); } @@ -181,16 +181,18 @@ public static boolean isPopulateResultCache( * @param cacheStrategy result of {@link QueryToolChest#getCacheStrategy} on this query * @param cacheConfig current active cache config * @param serverType BROKER or DATA + * @param bySegment segement level or result-level cache */ static boolean isQueryCacheable( final Query query, @Nullable final CacheStrategy> cacheStrategy, final CacheConfig cacheConfig, - final ServerType serverType + final ServerType serverType, + final boolean bySegment ) { return cacheStrategy != null - && cacheStrategy.isCacheable(query, serverType.willMergeRunners()) + && cacheStrategy.isCacheable(query, serverType.willMergeRunners(), bySegment) && cacheConfig.isQueryCacheable(query) && query.getDataSource().isCacheable(serverType == ServerType.BROKER); } diff --git a/server/src/test/java/org/apache/druid/client/CacheUtilTest.java b/server/src/test/java/org/apache/druid/client/CacheUtilTest.java index dc155398ab0b..9d886765ddce 100644 --- a/server/src/test/java/org/apache/druid/client/CacheUtilTest.java +++ b/server/src/test/java/org/apache/druid/client/CacheUtilTest.java @@ -54,7 +54,8 @@ public void test_isQueryCacheable_cacheableOnBroker() timeseriesQuery, new DummyCacheStrategy<>(true, true), makeCacheConfig(ImmutableMap.of()), - CacheUtil.ServerType.BROKER + CacheUtil.ServerType.BROKER, + false ) ); } @@ -67,7 +68,8 @@ public void test_isQueryCacheable_cacheableOnDataServer() timeseriesQuery, new DummyCacheStrategy<>(true, true), makeCacheConfig(ImmutableMap.of()), - CacheUtil.ServerType.DATA + CacheUtil.ServerType.DATA, + true ) ); } @@ -80,7 +82,8 @@ public void test_isQueryCacheable_unCacheableOnBroker() timeseriesQuery, new DummyCacheStrategy<>(false, true), makeCacheConfig(ImmutableMap.of()), - CacheUtil.ServerType.BROKER + CacheUtil.ServerType.BROKER, + false ) ); } @@ -93,7 +96,8 @@ public void test_isQueryCacheable_unCacheableOnDataServer() timeseriesQuery, new DummyCacheStrategy<>(true, false), makeCacheConfig(ImmutableMap.of()), - CacheUtil.ServerType.DATA + CacheUtil.ServerType.DATA, + true ) ); } @@ -106,7 +110,8 @@ public void test_isQueryCacheable_unCacheableType() timeseriesQuery, new DummyCacheStrategy<>(true, false), makeCacheConfig(ImmutableMap.of("unCacheable", ImmutableList.of("timeseries"))), - CacheUtil.ServerType.BROKER + CacheUtil.ServerType.BROKER, + false ) ); } @@ -119,7 +124,8 @@ public void test_isQueryCacheable_unCacheableDataSourceOnBroker() timeseriesQuery.withDataSource(new GlobalTableDataSource("global")), new DummyCacheStrategy<>(true, true), makeCacheConfig(ImmutableMap.of()), - CacheUtil.ServerType.BROKER + CacheUtil.ServerType.BROKER, + false ) ); } @@ -132,7 +138,8 @@ public void test_isQueryCacheable_unCacheableDataSourceOnDataServer() timeseriesQuery.withDataSource(new LookupDataSource("lookyloo")), new DummyCacheStrategy<>(true, true), makeCacheConfig(ImmutableMap.of()), - CacheUtil.ServerType.DATA + CacheUtil.ServerType.DATA, + true ) ); } @@ -145,7 +152,8 @@ public void test_isQueryCacheable_nullCacheStrategy() timeseriesQuery, null, makeCacheConfig(ImmutableMap.of()), - CacheUtil.ServerType.BROKER + CacheUtil.ServerType.BROKER, + false ) ); } @@ -168,7 +176,7 @@ public DummyCacheStrategy(boolean cacheableOnBrokers, boolean cacheableOnDataSer } @Override - public boolean isCacheable(QueryType query, boolean willMergeRunners) + public boolean isCacheable(QueryType query, boolean willMergeRunners, boolean bySegment) { return willMergeRunners ? cacheableOnDataServers : cacheableOnBrokers; } From fb75a3a2fdd5c23301e8d6618367b6a0dbd8a005 Mon Sep 17 00:00:00 2001 From: "huangqixiang.871" Date: Tue, 11 Jul 2023 11:27:50 +0800 Subject: [PATCH 2/4] retain the original method for backward incompatibility. --- .../org/apache/druid/query/CacheStrategy.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/processing/src/main/java/org/apache/druid/query/CacheStrategy.java b/processing/src/main/java/org/apache/druid/query/CacheStrategy.java index 92487b2898fa..61b48b48de07 100644 --- a/processing/src/main/java/org/apache/druid/query/CacheStrategy.java +++ b/processing/src/main/java/org/apache/druid/query/CacheStrategy.java @@ -36,6 +36,23 @@ @ExtensionPoint public interface CacheStrategy> { + /** + * This method is deprecated and retained for backward incompatibility. + * Returns whether the given query is cacheable or not. + * The {@code willMergeRunners} parameter can be used for distinguishing the caller is a broker or a data node. + * + * @param ignoredQuery the query to be cached + * @param ignoredWillMergeRunners indicates that {@link QueryRunnerFactory#mergeRunners(QueryProcessingPool, Iterable)} will be + * called on the cached by-segment results + * + * @return true if the query is cacheable, otherwise false. + */ + @Deprecated + default boolean isCacheable(QueryType ignoredQuery, boolean ignoredWillMergeRunners) + { + return false; + } + /** * Returns whether the given query is cacheable or not. * The {@code willMergeRunners} parameter can be used for distinguishing the caller is a broker or a data node. From cc16291a7c41a4d5a8560e119ed5f7ad218bb7fe Mon Sep 17 00:00:00 2001 From: "huangqixiang.871" Date: Tue, 11 Jul 2023 11:58:21 +0800 Subject: [PATCH 3/4] fix conflict --- .../query/groupby/GroupByQueryQueryToolChestTest.java | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChestTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChestTest.java index d67075155ecd..2e877f61cfa3 100644 --- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChestTest.java +++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChestTest.java @@ -20,6 +20,7 @@ package org.apache.druid.query.groupby; import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.dataformat.smile.SmileFactory; import com.google.common.base.Supplier; import com.google.common.base.Suppliers; import com.google.common.collect.ImmutableList; @@ -1184,15 +1185,15 @@ public String getFormatString() new GroupByStrategyV1( queryConfigSupplier, new GroupByQueryEngine(queryConfigSupplier, bufferPool), - QueryRunnerTestHelper.NOOP_QUERYWATCHER, - bufferPool + QueryRunnerTestHelper.NOOP_QUERYWATCHER ), new GroupByStrategyV2( processingConfig, queryConfigSupplier, bufferPool, mergeBufferPool, - GroupByQueryRunnerTest.DEFAULT_MAPPER, + TestHelper.makeJsonMapper(), + new ObjectMapper(new SmileFactory()), QueryRunnerTestHelper.NOOP_QUERYWATCHER ) ); From 9bfb04c387a824a4ac489e2c2104ed7a91bbd58b Mon Sep 17 00:00:00 2001 From: "huangqixiang.871" Date: Tue, 11 Jul 2023 21:48:00 +0800 Subject: [PATCH 4/4] add default impl --- .../src/main/java/org/apache/druid/query/CacheStrategy.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/processing/src/main/java/org/apache/druid/query/CacheStrategy.java b/processing/src/main/java/org/apache/druid/query/CacheStrategy.java index 61b48b48de07..d883e7555e97 100644 --- a/processing/src/main/java/org/apache/druid/query/CacheStrategy.java +++ b/processing/src/main/java/org/apache/druid/query/CacheStrategy.java @@ -64,7 +64,10 @@ default boolean isCacheable(QueryType ignoredQuery, boolean ignoredWillMergeRunn * * @return true if the query is cacheable, otherwise false. */ - boolean isCacheable(QueryType query, boolean willMergeRunners, boolean bySegment); + default boolean isCacheable(QueryType query, boolean willMergeRunners, boolean bySegment) + { + return isCacheable(query, willMergeRunners); + } /** * Computes the per-segment cache key for the given query. Because this is a per-segment cache key, it should only