GroupByV2QueryContext::setIntermediateCombineDegree() - Code Metrics - Inspection of "Scrutinizer php8" - level23/druid-client - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#22)

by Teye

created 2021-04-01 11:38 UTC

setIntermediateCombineDegree() A

↳ Parent: GroupByV2QueryContext

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	2
c	1
b	0
f	0
dl	0
loc	5
ccs	3
cts	3
cp	1
rs	10
cc	1
nc	1
nop	1
crap	1

<?php
declare(strict_types=1);

namespace Level23\Druid\Context;

/**
 * GroupBy queries can be executed using two different strategies. The default strategy for a cluster is determined
 * by the "druid.query.groupBy.defaultStrategy" runtime property on the Broker. This can be overridden using
 * "groupByStrategy" in the query context. If neither the context field nor the property is set, the "v2" strategy
 * will be used.
 *
 * "v2", the default, is designed to offer better performance and memory management. This strategy generates
 * per-segment results using a fully off-heap map. Data processes merge the per-segment results using a fully
 * off-heap concurrent facts map combined with an on-heap string dictionary. This may optionally involve spilling
 * to disk. Data processes return sorted results to the Broker, which merges result streams using an N-way merge.
 * The broker materializes the results if necessary (e.g. if the query sorts on columns other than its dimensions).
 * Otherwise, it streams results back as they are merged.
 *
 * "v1", a legacy engine, generates per-segment results on data processes (Historical, realtime, MiddleManager)
 * using a map which is partially on-heap (dimension keys and the map itself) and partially off-heap (the
 * aggregated values). Data processes then merge the per-segment results using Druid's indexing mechanism. This
 * merging is multi-threaded by default, but can optionally be single-threaded. The Broker merges the final result
 * set using Druid's indexing mechanism again. The broker merging is always single-threaded. Because the Broker
 * merges results using the indexing mechanism, it must materialize the full result set before returning any
 * results. On both the data processes and the Broker, the merging index is fully on-heap by default, but it can
 * optionally store aggregated values off-heap.
 *
 * Overrides the value of druid.query.groupBy.defaultStrategy for this query.
 */
class GroupByV2QueryContext extends QueryContext implements ContextInterface
{
    public function __construct(array $properties = [])
    {
        parent::__construct($properties);

        $this->properties['groupByStrategy'] = 'v2';
    }

    /**
     * Overrides the value of druid.query.groupBy.singleThreaded for this query.
     *
     * @param bool $groupByIsSingleThreaded
     *
     * @return $this;
     */
    public function setGroupByIsSingleThreaded(bool $groupByIsSingleThreaded)
    {
        $this->properties['groupByIsSingleThreaded'] = $groupByIsSingleThreaded;

        return $this;
    }

    /**
     * Overrides the value of druid.query.groupBy.bufferGrouperInitialBuckets for this query.
     *
     * @param int $bufferGrouperInitialBuckets
     *
     * @return $this;
     */
    public function setBufferGrouperInitialBuckets(int $bufferGrouperInitialBuckets)
    {
        $this->properties['bufferGrouperInitialBuckets'] = $bufferGrouperInitialBuckets;

        return $this;
    }

    /**
     * Overrides the value of druid.query.groupBy.bufferGrouperMaxLoadFactor for this query.
     *
     * @param int $bufferGrouperMaxLoadFactor
     *
     * @return $this;
     */
    public function setBufferGrouperMaxLoadFactor(int $bufferGrouperMaxLoadFactor)
    {
        $this->properties['bufferGrouperMaxLoadFactor'] = $bufferGrouperMaxLoadFactor;

        return $this;
    }

    /**
     * Overrides the value of druid.query.groupBy.forceHashAggregation
     *
     * @param bool $forceHashAggregation
     *
     * @return $this;
     */
    public function setForceHashAggregation(bool $forceHashAggregation)
    {
        $this->properties['forceHashAggregation'] = $forceHashAggregation;

        return $this;
    }

    /**
     * Overrides the value of druid.query.groupBy.intermediateCombineDegree
     *
     * @param int $intermediateCombineDegree
     *
     * @return $this;
     */
    public function setIntermediateCombineDegree(int $intermediateCombineDegree)
    {
        $this->properties['intermediateCombineDegree'] = $intermediateCombineDegree;

        return $this;
    }

    /**
     * Overrides the value of druid.query.groupBy.numParallelCombineThreads
     *
     * @param int $numParallelCombineThreads
     *
     * @return $this;
     */
    public function setNumParallelCombineThreads(int $numParallelCombineThreads)
    {
        $this->properties['numParallelCombineThreads'] = $numParallelCombineThreads;

        return $this;
    }

    /**
     * Sort the results first by dimension values and then by timestamp.
     *
     * @param bool $sortByDimsFirst
     *
     * @return $this;
     */
    public function setSortByDimsFirst(bool $sortByDimsFirst)
    {
        $this->properties['sortByDimsFirst'] = $sortByDimsFirst;

        return $this;
    }

    /**
     * When all fields in the orderBy are part of the grouping key, the Broker will push limit application down to the
     * Historical processes. When the sorting order uses fields that are not in the grouping key, applying this
     * optimization can result in approximate results with unknown accuracy, so this optimization is disabled by
     * default in that case. Enabling this context flag turns on limit push down for limit/orderBy's that contain
     * non-grouping key columns.
     *
     * @param bool $forceLimitPushDown
     *
     * @return $this;
     */
    public function setForceLimitPushDown(bool $forceLimitPushDown)
    {
        $this->properties['forceLimitPushDown'] = $forceLimitPushDown;

        return $this;
    }

    /**
     * Can be used to lower the value of druid.query.groupBy.maxMergingDictionarySize for this query.
     *
     * @param int $maxMergingDictionarySize
     *
     * @return $this;
     */
    public function setMaxMergingDictionarySize(int $maxMergingDictionarySize)
    {
        $this->properties['maxMergingDictionarySize'] = $maxMergingDictionarySize;

        return $this;
    }

    /**
     * Can be used to lower the value of druid.query.groupBy.maxOnDiskStorage for this query.
     *
     * @param int $maxOnDiskStorage
     *
     * @return $this;
     */
    public function setMaxOnDiskStorage(int $maxOnDiskStorage)
    {
        $this->properties['maxOnDiskStorage'] = $maxOnDiskStorage;

        return $this;
    }

    /**
     * If Broker pushes limit down to queryable nodes (historicals, peons) then limit results
     * during segment scan. This context value can be used to override
     * druid.query.groupBy.applyLimitPushDownToSegment.
     *
     * @param bool $applyLimitPushDownToSegment
     */
    public function setApplyLimitPushDownToSegment(bool $applyLimitPushDownToSegment)
    {
        $this->properties['applyLimitPushDownToSegment'] = $applyLimitPushDownToSegment;

        return $this;
    }
}

1		<?php
2		declare(strict_types=1);
3
4		namespace Level23\Druid\Context;
5
6		/**
7		* GroupBy queries can be executed using two different strategies. The default strategy for a cluster is determined
8		* by the "druid.query.groupBy.defaultStrategy" runtime property on the Broker. This can be overridden using
9		* "groupByStrategy" in the query context. If neither the context field nor the property is set, the "v2" strategy
10		* will be used.
11		*
12		* "v2", the default, is designed to offer better performance and memory management. This strategy generates
13		* per-segment results using a fully off-heap map. Data processes merge the per-segment results using a fully
14		* off-heap concurrent facts map combined with an on-heap string dictionary. This may optionally involve spilling
15		* to disk. Data processes return sorted results to the Broker, which merges result streams using an N-way merge.
16		* The broker materializes the results if necessary (e.g. if the query sorts on columns other than its dimensions).
17		* Otherwise, it streams results back as they are merged.
18		*
19		* "v1", a legacy engine, generates per-segment results on data processes (Historical, realtime, MiddleManager)
20		* using a map which is partially on-heap (dimension keys and the map itself) and partially off-heap (the
21		* aggregated values). Data processes then merge the per-segment results using Druid's indexing mechanism. This
22		* merging is multi-threaded by default, but can optionally be single-threaded. The Broker merges the final result
23		* set using Druid's indexing mechanism again. The broker merging is always single-threaded. Because the Broker
24		* merges results using the indexing mechanism, it must materialize the full result set before returning any
25		* results. On both the data processes and the Broker, the merging index is fully on-heap by default, but it can
26		* optionally store aggregated values off-heap.
27		*
28		* Overrides the value of druid.query.groupBy.defaultStrategy for this query.
29		*/
30		class GroupByV2QueryContext extends QueryContext implements ContextInterface
31		{
32	9	public function __construct(array $properties = [])
33		{
34	9	parent::__construct($properties);
35
36	8	$this->properties['groupByStrategy'] = 'v2';
37	8	}
38
39		/**
40		* Overrides the value of druid.query.groupBy.singleThreaded for this query.
41		*
42		* @param bool $groupByIsSingleThreaded
43		*
44		* @return $this;
45		*/
46	1	public function setGroupByIsSingleThreaded(bool $groupByIsSingleThreaded)
47		{
48	1	$this->properties['groupByIsSingleThreaded'] = $groupByIsSingleThreaded;
49
50	1	return $this;
51		}
52
53		/**
54		* Overrides the value of druid.query.groupBy.bufferGrouperInitialBuckets for this query.
55		*
56		* @param int $bufferGrouperInitialBuckets
57		*
58		* @return $this;
59		*/
60	1	public function setBufferGrouperInitialBuckets(int $bufferGrouperInitialBuckets)
61		{
62	1	$this->properties['bufferGrouperInitialBuckets'] = $bufferGrouperInitialBuckets;
63
64	1	return $this;
65		}
66
67		/**
68		* Overrides the value of druid.query.groupBy.bufferGrouperMaxLoadFactor for this query.
69		*
70		* @param int $bufferGrouperMaxLoadFactor
71		*
72		* @return $this;
73		*/
74	1	public function setBufferGrouperMaxLoadFactor(int $bufferGrouperMaxLoadFactor)
75		{
76	1	$this->properties['bufferGrouperMaxLoadFactor'] = $bufferGrouperMaxLoadFactor;
77
78	1	return $this;
79		}
80
81		/**
82		* Overrides the value of druid.query.groupBy.forceHashAggregation
83		*
84		* @param bool $forceHashAggregation
85		*
86		* @return $this;
87		*/
88	1	public function setForceHashAggregation(bool $forceHashAggregation)
89		{
90	1	$this->properties['forceHashAggregation'] = $forceHashAggregation;
91
92	1	return $this;
93		}
94
95		/**
96		* Overrides the value of druid.query.groupBy.intermediateCombineDegree
97		*
98		* @param int $intermediateCombineDegree
99		*
100		* @return $this;
101		*/
102	1	public function setIntermediateCombineDegree(int $intermediateCombineDegree)
103		{
104	1	$this->properties['intermediateCombineDegree'] = $intermediateCombineDegree;
105
106	1	return $this;
107		}
108
109		/**
110		* Overrides the value of druid.query.groupBy.numParallelCombineThreads
111		*
112		* @param int $numParallelCombineThreads
113		*
114		* @return $this;
115		*/
116	1	public function setNumParallelCombineThreads(int $numParallelCombineThreads)
117		{
118	1	$this->properties['numParallelCombineThreads'] = $numParallelCombineThreads;
119
120	1	return $this;
121		}
122
123		/**
124		* Sort the results first by dimension values and then by timestamp.
125		*
126		* @param bool $sortByDimsFirst
127		*
128		* @return $this;
129		*/
130	1	public function setSortByDimsFirst(bool $sortByDimsFirst)
131		{
132	1	$this->properties['sortByDimsFirst'] = $sortByDimsFirst;
133
134	1	return $this;
135		}
136
137		/**
138		* When all fields in the orderBy are part of the grouping key, the Broker will push limit application down to the
139		* Historical processes. When the sorting order uses fields that are not in the grouping key, applying this
140		* optimization can result in approximate results with unknown accuracy, so this optimization is disabled by
141		* default in that case. Enabling this context flag turns on limit push down for limit/orderBy's that contain
142		* non-grouping key columns.
143		*
144		* @param bool $forceLimitPushDown
145		*
146		* @return $this;
147		*/
148	1	public function setForceLimitPushDown(bool $forceLimitPushDown)
149		{
150	1	$this->properties['forceLimitPushDown'] = $forceLimitPushDown;
151
152	1	return $this;
153		}
154
155		/**
156		* Can be used to lower the value of druid.query.groupBy.maxMergingDictionarySize for this query.
157		*
158		* @param int $maxMergingDictionarySize
159		*
160		* @return $this;
161		*/
162	1	public function setMaxMergingDictionarySize(int $maxMergingDictionarySize)
163		{
164	1	$this->properties['maxMergingDictionarySize'] = $maxMergingDictionarySize;
165
166	1	return $this;
167		}
168
169		/**
170		* Can be used to lower the value of druid.query.groupBy.maxOnDiskStorage for this query.
171		*
172		* @param int $maxOnDiskStorage
173		*
174		* @return $this;
175		*/
176	3	public function setMaxOnDiskStorage(int $maxOnDiskStorage)
177		{
178	3	$this->properties['maxOnDiskStorage'] = $maxOnDiskStorage;
179
180	3	return $this;
181		}
182
183		/**
184		* If Broker pushes limit down to queryable nodes (historicals, peons) then limit results
185		* during segment scan. This context value can be used to override
186		* druid.query.groupBy.applyLimitPushDownToSegment.
187		*
188		* @param bool $applyLimitPushDownToSegment
189		*/
190	1	public function setApplyLimitPushDownToSegment(bool $applyLimitPushDownToSegment)
191		{
192	1	$this->properties['applyLimitPushDownToSegment'] = $applyLimitPushDownToSegment;
193
194	1	return $this;
195		}
196		}

level23 / druid-client

Pull Request — master (#22)

setIntermediateCombineDegree() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like