org.apache.druid.query.groupby.strategy

Interface GroupByStrategy

All Known Implementing Classes:

GroupByStrategyV1, GroupByStrategyV2

public interface GroupByStrategy

Method Summary

Modifier and Type	Method and Description
Sequence<ResultRow>	applyPostProcessing(Sequence<ResultRow> results, GroupByQuery query) Apply the GroupByQuery "postProcessingFn", which is responsible for HavingSpec and LimitSpec.
default BinaryOperator<ResultRow>	createMergeFn(Query<ResultRow> query) See QueryToolChest.createMergeFn(Query) for details, allows GroupByQueryQueryToolChest to delegate implementation to the strategy
default Comparator<ResultRow>	createResultComparator(Query<ResultRow> queryParam) See QueryToolChest.createResultComparator(Query), allows GroupByQueryQueryToolChest to delegate implementation to the strategy
boolean	doMergeResults(GroupByQuery query) Indicates if this query should undergo "mergeResults" or not.
boolean	isCacheable(boolean willMergeRunners) Indicates if results from this query are cacheable or not.
Sequence<ResultRow>	mergeResults(QueryRunner<ResultRow> baseRunner, GroupByQuery query, ResponseContext responseContext) Runs a provided QueryRunner on a provided GroupByQuery, which is assumed to return rows that are properly sorted (by timestamp and dimensions) but not necessarily fully merged (that is, there may be adjacent rows with the same timestamp and dimensions) and without PostAggregators computed.
QueryRunner<ResultRow>	mergeRunners(com.google.common.util.concurrent.ListeningExecutorService exec, Iterable<QueryRunner<ResultRow>> queryRunners) Merge a variety of single-segment query runners into a combined runner.
GroupByQueryResource	prepareResource(GroupByQuery query) Initializes resources required to run GroupByQueryQueryToolChest.mergeResults(QueryRunner) for a particular query.
Sequence<ResultRow>	process(GroupByQuery query, StorageAdapter storageAdapter) Process a groupBy query on a single StorageAdapter.
Sequence<ResultRow>	processSubqueryResult(GroupByQuery subquery, GroupByQuery query, GroupByQueryResource resource, Sequence<ResultRow> subqueryResult, boolean wasQueryPushedDown) Called by GroupByQueryQueryToolChest.mergeResults(QueryRunner) when it needs to process a subquery.
Sequence<ResultRow>	processSubtotalsSpec(GroupByQuery query, GroupByQueryResource resource, Sequence<ResultRow> queryResult) Called by GroupByQueryQueryToolChest.mergeResults(QueryRunner) when it needs to generate subtotals.
boolean	supportsNestedQueryPushDown() Returns whether this strategy supports pushing down outer queries.

Method Detail

prepareResource

GroupByQueryResource prepareResource(GroupByQuery query)

Initializes resources required to run GroupByQueryQueryToolChest.mergeResults(QueryRunner) for a particular query. That method is also the primary caller of this method. Used by GroupByQueryQueryToolChest.mergeResults(QueryRunner).

Parameters:

query - a groupBy query to be processed

Returns:

broker resource

isCacheable

boolean isCacheable(boolean willMergeRunners)

Indicates if results from this query are cacheable or not. Used by GroupByQueryQueryToolChest.getCacheStrategy(GroupByQuery).

Parameters:

willMergeRunners - indicates that QueryRunnerFactory.mergeRunners(ExecutorService, 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.

Returns:

true if this strategy is cacheable, otherwise false.

doMergeResults

boolean doMergeResults(GroupByQuery query)

Indicates if this query should undergo "mergeResults" or not. Checked by GroupByQueryQueryToolChest.mergeResults(QueryRunner).

mergeResults

Sequence<ResultRow> mergeResults(QueryRunner<ResultRow> baseRunner,
                                 GroupByQuery query,
                                 ResponseContext responseContext)

Runs a provided QueryRunner on a provided GroupByQuery, which is assumed to return rows that are properly sorted (by timestamp and dimensions) but not necessarily fully merged (that is, there may be adjacent rows with the same timestamp and dimensions) and without PostAggregators computed. This method will fully merge the rows, apply PostAggregators, and return the resulting Sequence. The query will be modified before passing it down to the base runner. For example, "having" clauses will be removed and various context parameters will be adjusted. Despite the similar name, this method is much reduced in scope compared to GroupByQueryQueryToolChest.mergeResults(QueryRunner). That method does delegate to this one at some points, but has a truckload of other responsibility, including computing outer query results (if there are subqueries), computing subtotals (like GROUPING SETS), and computing the havingSpec and limitSpec.

Parameters:

baseRunner - base query runner

query - the groupBy query to run inside the base query runner

responseContext - the response context to pass to the base query runner

Returns:

merged result sequence

createMergeFn

@Nullable
default BinaryOperator<ResultRow> createMergeFn(Query<ResultRow> query)

See QueryToolChest.createMergeFn(Query) for details, allows GroupByQueryQueryToolChest to delegate implementation to the strategy

createResultComparator

@Nullable
default Comparator<ResultRow> createResultComparator(Query<ResultRow> queryParam)

See QueryToolChest.createResultComparator(Query), allows GroupByQueryQueryToolChest to delegate implementation to the strategy

applyPostProcessing

Sequence<ResultRow> applyPostProcessing(Sequence<ResultRow> results,
                                        GroupByQuery query)

Apply the GroupByQuery "postProcessingFn", which is responsible for HavingSpec and LimitSpec.

Parameters:

results - sequence of results

query - the groupBy query

Returns:

post-processed results, with HavingSpec and LimitSpec applied

processSubqueryResult

Sequence<ResultRow> processSubqueryResult(GroupByQuery subquery,
                                          GroupByQuery query,
                                          GroupByQueryResource resource,
                                          Sequence<ResultRow> subqueryResult,
                                          boolean wasQueryPushedDown)

Called by GroupByQueryQueryToolChest.mergeResults(QueryRunner) when it needs to process a subquery.

Parameters:

subquery - inner query

query - outer query

resource - resources returned by prepareResource(GroupByQuery)

subqueryResult - result rows from the subquery

wasQueryPushedDown - true if the outer query was pushed down (so we only need to merge the outer query's results, not run it from scratch like a normal outer query)

Returns:

results of the outer query

processSubtotalsSpec

Sequence<ResultRow> processSubtotalsSpec(GroupByQuery query,
                                         GroupByQueryResource resource,
                                         Sequence<ResultRow> queryResult)

Called by GroupByQueryQueryToolChest.mergeResults(QueryRunner) when it needs to generate subtotals.

Parameters:

query - query that has a "subtotalsSpec"

resource - resources returned by prepareResource(GroupByQuery)

queryResult - result rows from the main query

Returns:

results for each list of subtotals in the query, concatenated together

mergeRunners

QueryRunner<ResultRow> mergeRunners(com.google.common.util.concurrent.ListeningExecutorService exec,
                                    Iterable<QueryRunner<ResultRow>> queryRunners)

Merge a variety of single-segment query runners into a combined runner. Used by GroupByQueryRunnerFactory.mergeRunners(ExecutorService, Iterable). In that sense, it is intended to go along with process(GroupByQuery, StorageAdapter) (the runners created by that method will be fed into this method). This method is only called on data servers, like Historicals (not the Broker).

Parameters:

exec - executor service used for parallel execution of the query runners

queryRunners - collection of query runners to merge

Returns:

merged query runner

process

Sequence<ResultRow> process(GroupByQuery query,
                            StorageAdapter storageAdapter)

Process a groupBy query on a single StorageAdapter. This is used by GroupByQueryRunnerFactory.createRunner(org.apache.druid.segment.Segment) to create per-segment QueryRunners. This method is only called on data servers, like Historicals (not the Broker).

Parameters:

query - the groupBy query

storageAdapter - storage adatper for the segment in question

Returns:

result sequence for the storage adapter

supportsNestedQueryPushDown

boolean supportsNestedQueryPushDown()

Returns whether this strategy supports pushing down outer queries. This is used by GroupByQueryQueryToolChest.mergeResults(QueryRunner) when it decides whether or not to push down an outer query from the Broker to data servers, like Historicals. Can be removed when the "v1" groupBy strategy is removed. ("v1" returns false, and "v2" returns true.)