Package org.apache.druid.query.metadata

Class SegmentMetadataQueryQueryToolChest

    • Method Detail

      • mergeResults

        public QueryRunner<SegmentAnalysis> mergeResults​(QueryRunner<SegmentAnalysis> runner)
        Description copied from class: QueryToolChest
        This method wraps a QueryRunner. The input QueryRunner, by contract, will provide a series of ResultType objects in time order (ascending or descending). This method should return a new QueryRunner that merges the stream of ordered ResultType objects.

        A default implementation constructs a ResultMergeQueryRunner which creates a CombiningSequence using the supplied QueryRunner with QueryToolChest.createResultComparator(Query) and QueryToolChest.createMergeFn(Query)} supplied by this toolchest.

        Generally speaking, the logic that exists in makePostComputeManipulatorFn should actually exist in this method. Additionally, if a query supports PostAggregations, this method should take steps to ensure that it computes PostAggregations a minimum number of times. This is most commonly achieved by computing the PostAgg results during merge and also rewriting the query such that it has the minimum number of PostAggs (most often zero).

        Overrides:
        mergeResults in class QueryToolChest<SegmentAnalysis,​SegmentMetadataQuery>
        Parameters:
        runner - A QueryRunner that provides a series of ResultType objects in time order (ascending or descending)
        Returns:
        a QueryRunner that merges the stream of ordered ResultType objects

      • makeMetrics

        public QueryMetrics<Query<?>> makeMetrics​(SegmentMetadataQuery query)
        Description copied from class: QueryToolChest
        Creates a QueryMetrics object that is used to generate metrics for this specific query type. This exists to allow for query-specific dimensions and metrics. That is, the ToolChest is expected to set some meaningful dimensions for metrics given this query type. Examples might be the topN threshold for a TopN query or the number of dimensions included for a groupBy query.

        QueryToolChests for query types in core (druid-processing) and public extensions (belonging to the Druid source tree) should use delegate this method to GenericQueryMetricsFactory.makeMetrics(Query) on an injected instance of GenericQueryMetricsFactory, as long as they don't need to emit custom dimensions and/or metrics.

        If some custom dimensions and/or metrics should be emitted for a query type, a plan described in "Making subinterfaces of QueryMetrics" section in QueryMetrics's class-level Javadocs should be followed.

        One way or another, this method should ensure that QueryMetrics.query(Query) is called with the given query passed on the created QueryMetrics object before returning.

        Specified by:
        makeMetrics in class QueryToolChest<SegmentAnalysis,​SegmentMetadataQuery>
        Parameters:
        query - The query that is being processed
        Returns:
        A QueryMetrics that can be used to make metrics for the provided query

      • makePreComputeManipulatorFn

        public com.google.common.base.Function<SegmentAnalysis,​SegmentAnalysis> makePreComputeManipulatorFn​(SegmentMetadataQuery query,
                                                                                                          MetricManipulationFn fn)
        Description copied from class: QueryToolChest
        Creates a Function that can take in a ResultType and return a new ResultType having applied the MetricManipulatorFn to each of the metrics.

        This function's primary purpose is to help work around some challenges that exist around deserializing results across the wire. Specifically, different aggregators will generate different object types in a result set, if we wanted jackson to be able to deserialize these directly, we'd need to generate a response class for each query that jackson could use to deserialize things. That is not what we do. Instead, we have jackson deserialize Object instances and then use a MetricManipulatorFn to convert from those object instances to the actual object that the aggregator expects. As such, this would be more effectively named "makeObjectDeserializingFn".

        It is safe and acceptable for implementations of this method to first validate that the MetricManipulationFn is MetricManipulatorFns.DESERIALIZING_INSTANCE and throw an exception if it is not. If such an exception is ever thrown, it is indicative of a bug in the caller which should be fixed by not calling this method with anything other than the deserializing manipulator function.

        There are some implementations where this was also tasked with computing PostAggregators, but this is actually not a good place to compute those as this function can be called in a number of cases when PostAggs are not really meaningful to compute. Instead, PostAggs should be computed in the mergeResults call and the mergeResults implementation should take care to ensure that PostAggs are only computed the minimum number of times necessary.

        This function is called very early in the processing pipeline on the Broker.

        Specified by:
        makePreComputeManipulatorFn in class QueryToolChest<SegmentAnalysis,​SegmentMetadataQuery>
        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

      • filterSegments

        public <T extends LogicalSegment> List<T> filterSegments​(SegmentMetadataQuery query,
                                                         List<T> segments)
        Description copied from class: QueryToolChest
        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.
        Overrides:
        filterSegments in class QueryToolChest<SegmentAnalysis,​SegmentMetadataQuery>
        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