io.druid.query

Class QueryToolChest<ResultType,QueryType extends Query<ResultType>>

java.lang.Object

io.druid.query.QueryToolChest<ResultType,QueryType>

Direct Known Subclasses:

DataSourceQueryQueryToolChest, GroupByQueryQueryToolChest, SearchQueryQueryToolChest, SegmentMetadataQueryQueryToolChest, SelectQueryQueryToolChest, TimeBoundaryQueryQueryToolChest, TimeseriesQueryQueryToolChest, TopNQueryQueryToolChest

public abstract class QueryToolChest<ResultType,QueryType extends Query<ResultType>>
extends Object

The broker-side (also used by server in some cases) API for a specific Query type. This API is still undergoing evolution and is only semi-stable, so proprietary Query implementations should be ready for the potential maintenance burden when upgrading versions.

Constructor Summary

Constructors

Constructor and Description
QueryToolChest()

Method Summary

Methods

Modifier and Type	Method and Description
<T extends LogicalSegment> List<T>	filterSegments(QueryType query, List<T> segments) This method is called to allow the query to prune segments that it does not believe need to actually be queried.
<T> CacheStrategy<ResultType,T,QueryType>	getCacheStrategy(QueryType query) Returns a CacheStrategy to be used to load data into the cache and remove it from the cache.
abstract com.fasterxml.jackson.core.type.TypeReference<ResultType>	getResultTypeReference() Returns a TypeReference object that is just passed through to Jackson in order to deserialize the results of this type of query.
abstract com.metamx.emitter.service.ServiceMetricEvent.Builder	makeMetricBuilder(QueryType query) Creates a builder that is used to generate a metric for this specific query type.
com.google.common.base.Function<ResultType,ResultType>	makePostComputeManipulatorFn(QueryType query, MetricManipulationFn fn) Generally speaking this is the exact same thing as makePreComputeManipulatorFn.
abstract com.google.common.base.Function<ResultType,ResultType>	makePreComputeManipulatorFn(QueryType query, MetricManipulationFn fn) Creates a Function that can take in a ResultType and return a new ResultType having applied the MetricManipulatorFn to each of the metrics.
abstract QueryRunner<ResultType>	mergeResults(QueryRunner<ResultType> runner) This method wraps a QueryRunner.
abstract com.metamx.common.guava.Sequence<ResultType>	mergeSequences(com.metamx.common.guava.Sequence<com.metamx.common.guava.Sequence<ResultType>> seqOfSequences) This method doesn't belong here, but it's here for now just to make it work.
abstract com.metamx.common.guava.Sequence<ResultType>	mergeSequencesUnordered(com.metamx.common.guava.Sequence<com.metamx.common.guava.Sequence<ResultType>> seqOfSequences) This method doesn't belong here, but it's here for now just to make it work.
QueryRunner<ResultType>	postMergeQueryDecoration(QueryRunner<ResultType> runner) Wraps a QueryRunner.
QueryRunner<ResultType>	preMergeQueryDecoration(QueryRunner<ResultType> runner) Wraps a QueryRunner.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

QueryToolChest

public QueryToolChest()

Method Detail

mergeResults

public abstract QueryRunner<ResultType> mergeResults(QueryRunner<ResultType> runner)

This method wraps a QueryRunner. The input QueryRunner, by contract, will provide a series of ResultType objects in time order (ascending). This method should return a new QueryRunner that potentially merges the stream of ordered ResultType objects.

Parameters:

runner - A QueryRunner that provides a series of ResultType objects in time order (ascending)

Returns:

a QueryRunner that potentialy merges the stream of ordered ResultType objects

mergeSequences

public abstract com.metamx.common.guava.Sequence<ResultType> mergeSequences(com.metamx.common.guava.Sequence<com.metamx.common.guava.Sequence<ResultType>> seqOfSequences)

This method doesn't belong here, but it's here for now just to make it work. The method needs to take a Sequence of Sequences and return a single Sequence of ResultType objects in time-order (ascending) This method assumes that its input sequences provide values already in sorted order. Even more specifically, it assumes that the individual sequences are also ordered by their first element. In the vast majority of cases, this should just be implemented with: return new OrderedMergeSequence<>(getOrdering(), seqOfSequences);

Parameters:

seqOfSequences - sequence of sequences to be merged

Returns:

the sequence of merged results

mergeSequencesUnordered

public abstract com.metamx.common.guava.Sequence<ResultType> mergeSequencesUnordered(com.metamx.common.guava.Sequence<com.metamx.common.guava.Sequence<ResultType>> seqOfSequences)

This method doesn't belong here, but it's here for now just to make it work. The method needs to take a Sequence of Sequences and return a single Sequence of ResultType objects in time-order (ascending) This method assumes that its input sequences provide values already in sorted order, but, unlike mergeSequences, it does *not* assume that the individual sequences are also ordered by their first element. In the vast majority if ocases, this hsould just be implemented with: return new MergeSequence<>(getOrdering(), seqOfSequences);

Parameters:

seqOfSequences - sequence of sequences to be merged

Returns:

the sequence of merged results

makeMetricBuilder

public abstract com.metamx.emitter.service.ServiceMetricEvent.Builder makeMetricBuilder(QueryType query)

Creates a builder that is used to generate a metric for this specific query type. This exists to allow for query-specific dimensions on metrics. That is, the ToolChest is expected to set some meaningful dimensions for metrics given this query type. Examples might be the topN threshhold for a TopN query or the number of dimensions included for a groupBy query.

Parameters:

query - The query that is being processed

Returns:

A MetricEvent.Builder that can be used to make metrics for the provided query

makePreComputeManipulatorFn

public abstract com.google.common.base.Function<ResultType,ResultType> makePreComputeManipulatorFn(QueryType query,
                                                                                 MetricManipulationFn fn)

Creates a Function that can take in a ResultType and return a new ResultType having applied the MetricManipulatorFn to each of the metrics. This exists because the QueryToolChest is the only thing that understands the internal serialization format of ResultType, so it's primary responsibility is to "decompose" that structure and apply the given function to all metrics. This function is called very early in the processing pipeline on the Broker.

Parameters:

query - The Query that is currently being processed

fn - The function that should be applied to all metrics in the results

Returns:

A function that will apply the provided fn to all metrics in the input ResultType object

makePostComputeManipulatorFn

public com.google.common.base.Function<ResultType,ResultType> makePostComputeManipulatorFn(QueryType query,
                                                                                  MetricManipulationFn fn)

Generally speaking this is the exact same thing as makePreComputeManipulatorFn. It is leveraged in order to compute PostAggregators on results after they have been completely merged together, which should actually be done in the mergeResults() call instead of here. This should never actually be overridden and it should be removed as quickly as possible.

Parameters:

query - The Query that is currently being processed

fn - The function that should be applied to all metrics in the results

Returns:

A function that will apply the provided fn to all metrics in the input ResultType object

getResultTypeReference

public abstract com.fasterxml.jackson.core.type.TypeReference<ResultType> getResultTypeReference()

Returns a TypeReference object that is just passed through to Jackson in order to deserialize the results of this type of query.

Returns:

A TypeReference to indicate to Jackson what type of data will exist for this query

getCacheStrategy

public <T> CacheStrategy<ResultType,T,QueryType> getCacheStrategy(QueryType query)

Returns a CacheStrategy to be used to load data into the cache and remove it from the cache. This is optional. If it returns null, caching is effectively disabled for the query.

Type Parameters:

T - The type of object that will be stored in the cache

Parameters:

query - The query whose results might be cached

Returns:

A CacheStrategy that can be used to populate and read from the Cache

preMergeQueryDecoration

public QueryRunner<ResultType> preMergeQueryDecoration(QueryRunner<ResultType> runner)

Wraps a QueryRunner. The input QueryRunner is the QueryRunner as it exists *before* being passed to mergeResults(). In fact, the return value of this method is always passed to mergeResults, so it is equivalent to just implement this functionality as extra decoration on the QueryRunner during mergeResults(). In the interests of potentially simplifying these interfaces, the recommendation is to actually not override this method and instead apply anything that might be needed here in the mergeResults() call.

Parameters:

runner - The runner to be wrapped

Returns:

The wrapped runner

postMergeQueryDecoration

public QueryRunner<ResultType> postMergeQueryDecoration(QueryRunner<ResultType> runner)

Wraps a QueryRunner. The input QueryRunner is the QueryRunner as it exists coming out of mergeResults() In fact, the input value of this method is always the return value from mergeResults, so it is equivalent to just implement this functionality as extra decoration on the QueryRunner during mergeResults(). In the interests of potentially simplifying these interfaces, the recommendation is to actually not override this method and instead apply anything that might be needed here in the mergeResults() call.

Parameters:

runner - The runner to be wrapped

Returns:

The wrapped runner

filterSegments

public <T extends LogicalSegment> List<T> filterSegments(QueryType query,
                                                List<T> segments)

This method is called to allow the query to prune segments that it does not believe need to actually be queried. It can use whatever criteria it wants in order to do the pruning, it just needs to return the list of Segments it actually wants to see queried.

Type Parameters:

T - A Generic parameter because Java is cool

Parameters:

query - The query being processed

segments - The list of candidate segments to be queried

Returns:

The list of segments to actually query