HyperUniquesAggregatorFactory (druid-processing 0.19.0 API)

java.lang.Object
- org.apache.druid.query.aggregation.AggregatorFactory
- - org.apache.druid.query.aggregation.hyperloglog.HyperUniquesAggregatorFactory

All Implemented Interfaces:: Cacheable

public class HyperUniquesAggregatorFactory
extends AggregatorFactory

Constructor Summary

Constructors
Constructor and Description
`HyperUniquesAggregatorFactory(String name, String fieldName)`
`HyperUniquesAggregatorFactory(String name, String fieldName, boolean isInputHyperUnique, boolean round)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`canVectorize(ColumnInspector columnInspector)` Returns whether or not this aggregation class supports vectorization.
`Object`	`combine(Object lhs, Object rhs)` A method that knows how to combine the outputs of `Aggregator.get()` produced via `AggregatorFactory.factorize(org.apache.druid.segment.ColumnSelectorFactory)` or `BufferAggregator.get(java.nio.ByteBuffer, int)` produced via `AggregatorFactory.factorizeBuffered(org.apache.druid.segment.ColumnSelectorFactory)`.
`Object`	`deserialize(Object object)` A method that knows how to "deserialize" the object from whatever form it might have been put into in order to transfer via JSON.
`boolean`	`equals(Object o)`
`static Object`	`estimateCardinality(Object object, boolean round)`
`Aggregator`	`factorize(ColumnSelectorFactory metricFactory)`
`BufferAggregator`	`factorizeBuffered(ColumnSelectorFactory metricFactory)`
`VectorAggregator`	`factorizeVector(VectorColumnSelectorFactory selectorFactory)` Create a VectorAggregator based on the provided column selector factory.
`Object`	`finalizeComputation(Object object)` "Finalizes" the computation of an object.
`byte[]`	`getCacheKey()`
`AggregatorFactory`	`getCombiningFactory()` Returns an AggregatorFactory that can be used to combine the output of aggregators from this factory.
`Comparator`	`getComparator()`
`String`	`getFieldName()`
`boolean`	`getIsInputHyperUnique()`
`int`	`getMaxIntermediateSize()` Returns the maximum size that this aggregator will require in bytes for intermediate storage of results.
`AggregatorFactory`	`getMergingFactory(AggregatorFactory other)` Returns an AggregatorFactory that can be used to combine the output of aggregators from this factory and another factory.
`String`	`getName()`
`List<AggregatorFactory>`	`getRequiredColumns()` Used by `GroupByStrategyV1` when running nested groupBys, to "transfer" values from this aggreagtor to an incremental index that the outer query will run on.
`String`	`getTypeName()` Get the type name of the intermediate type for this aggregator.
`int`	`hashCode()`
`boolean`	`isRound()`
`AggregateCombiner`	`makeAggregateCombiner()` Creates an AggregateCombiner to fold rollup aggregation results from serveral "rows" of different indexes during index merging.
`List<String>`	`requiredFields()` Get a list of fields that aggregators built by this factory will need to read.
`String`	`toString()`

Methods inherited from class org.apache.druid.query.aggregation.AggregatorFactory
getMaxIntermediateSizeWithNulls, makeNullableAggregateCombiner, mergeAggregators, optimizeForSegment

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - HyperUniquesAggregatorFactory
```
public HyperUniquesAggregatorFactory(String name,
                                     String fieldName,
                                     boolean isInputHyperUnique,
                                     boolean round)
```
  - HyperUniquesAggregatorFactory
```
public HyperUniquesAggregatorFactory(String name,
                                     String fieldName)
```
- Method Detail
  - estimateCardinality
```
public static Object estimateCardinality(@Nullable
                                         Object object,
                                         boolean round)
```
  - factorize
```
public Aggregator factorize(ColumnSelectorFactory metricFactory)
```
    Specified by:
    
    factorize in class AggregatorFactory
  - factorizeBuffered
```
public BufferAggregator factorizeBuffered(ColumnSelectorFactory metricFactory)
```
    Specified by:
    
    factorizeBuffered in class AggregatorFactory
  - factorizeVector
```
public VectorAggregator factorizeVector(VectorColumnSelectorFactory selectorFactory)
```
    Description copied from class: AggregatorFactory
    
    Create a VectorAggregator based on the provided column selector factory. Will throw an exception if this aggregation class does not support vectorization: check "canVectorize" first.
    
    Overrides:
    
    factorizeVector in class AggregatorFactory
  - canVectorize
```
public boolean canVectorize(ColumnInspector columnInspector)
```
    Description copied from class: AggregatorFactory
    
    Returns whether or not this aggregation class supports vectorization. The default implementation returns false.
    
    Overrides:
    
    canVectorize in class AggregatorFactory
  - getComparator
```
public Comparator getComparator()
```
    Specified by:
    
    getComparator in class AggregatorFactory
  - combine
```
public Object combine(Object lhs,
                      Object rhs)
```
    Description copied from class: AggregatorFactory
    
    A method that knows how to combine the outputs of Aggregator.get() produced via AggregatorFactory.factorize(org.apache.druid.segment.ColumnSelectorFactory) or BufferAggregator.get(java.nio.ByteBuffer, int) produced via AggregatorFactory.factorizeBuffered(org.apache.druid.segment.ColumnSelectorFactory). Note, even though this method is called "combine", this method's contract *does* allow for mutation of the input objects. Thus, any use of lhs or rhs after calling this method is highly discouraged.
    
    Specified by:
    
    combine in class AggregatorFactory
    
    Parameters:
    
    lhs - The left hand side of the combine
    
    rhs - The right hand side of the combine
    
    Returns:
    
    an object representing the combination of lhs and rhs, this can be a new object or a mutation of the inputs
  - makeAggregateCombiner
```
public AggregateCombiner makeAggregateCombiner()
```
    Description copied from class: AggregatorFactory
    
    Creates an AggregateCombiner to fold rollup aggregation results from serveral "rows" of different indexes during index merging. AggregateCombiner implements the same logic as AggregatorFactory.combine(java.lang.Object, java.lang.Object), with the difference that it uses ColumnValueSelector and it's subinterfaces to get inputs and implements ColumnValueSelector to provide output.
    
    Overrides:
    
    makeAggregateCombiner in class AggregatorFactory
    
    See Also:
    
    AggregateCombiner, IndexMerger
  - getCombiningFactory
```
public AggregatorFactory getCombiningFactory()
```
    Description copied from class: AggregatorFactory
    
    Returns an AggregatorFactory that can be used to combine the output of aggregators from this factory. It is used when we know we have some values that were produced with this aggregator factory, and want to do some additional combining of them. This happens, for example, when merging query results from two different segments, or two different servers. For simple aggregators, the combining factory may be computed by simply creating a new factory that is the same as the current, except with its input column renamed to the same as the output column. For example, this aggregator: {"type": "longSum", "fieldName": "foo", "name": "bar"} Would become: {"type": "longSum", "fieldName": "bar", "name": "bar"} Sometimes, the type or other parameters of the combining aggregator will be different from the original aggregator. For example, the CountAggregatorFactory getCombiningFactory method will return a LongSumAggregatorFactory, because counts are combined by summing. No matter what, `foo.getCombiningFactory()` and `foo.getCombiningFactory().getCombiningFactory()` should return the same result.
    
    Specified by:
    
    getCombiningFactory in class AggregatorFactory
    
    Returns:
    
    a new Factory that can be used for operations on top of data output from the current factory.
  - getMergingFactory
```
public AggregatorFactory getMergingFactory(AggregatorFactory other)
                                    throws AggregatorFactoryNotMergeableException
```
    Description copied from class: AggregatorFactory
    
    Returns an AggregatorFactory that can be used to combine the output of aggregators from this factory and another factory. It is used when we have some values produced by this aggregator factory, and some values produced by the "other" aggregator factory, and we want to do some additional combining of them. This happens, for example, when compacting two segments together that both have a metric column with the same name. (Even though the name of the column is the same, the aggregator factory used to create it may be different from segment to segment.) This method may throw AggregatorFactoryNotMergeableException, meaning that "this" and "other" are not compatible and values from one cannot sensibly be combined with values from the other.
    
    Overrides:
    
    getMergingFactory in class AggregatorFactory
    
    Returns:
    
    a new Factory that can be used for merging the output of aggregators from this factory and other.
    
    Throws:
    
    AggregatorFactoryNotMergeableException
    
    See Also:
    
    which is equivalent to {@code foo.getMergingFactory(foo)} (when "this" and "other" are the same instance).
  - getRequiredColumns
```
public List<AggregatorFactory> getRequiredColumns()
```
    Description copied from class: AggregatorFactory
    
    Used by GroupByStrategyV1 when running nested groupBys, to "transfer" values from this aggreagtor to an incremental index that the outer query will run on. This method only exists due to the design of GroupByStrategyV1, and should probably not be used for anything else. If you are here because you are looking for a way to get the input fields required by this aggregator, and thought "getRequiredColumns" sounded right, please use AggregatorFactory.requiredFields() instead.
    
    Specified by:
    
    getRequiredColumns in class AggregatorFactory
    
    Returns:
    
    AggregatorFactories that can be used to "transfer" values from this aggregator into an incremental index
    
    See Also:
    
    a similarly-named method that is perhaps the one you want instead.
  - deserialize
```
public Object deserialize(Object object)
```
    Description copied from class: AggregatorFactory
    
    A method that knows how to "deserialize" the object from whatever form it might have been put into in order to transfer via JSON.
    
    Specified by:
    
    deserialize in class AggregatorFactory
    
    Parameters:
    
    object - the object to deserialize
    
    Returns:
    
    the deserialized object
  - finalizeComputation
```
@Nullable
public Object finalizeComputation(@Nullable
                                            Object object)
```
    Description copied from class: AggregatorFactory
    
    "Finalizes" the computation of an object. Primarily useful for complex types that have a different mergeable intermediate format than their final resultant output.
    
    Specified by:
    
    finalizeComputation in class AggregatorFactory
    
    Parameters:
    
    object - the object to be finalized
    
    Returns:
    
    the finalized value that should be returned for the initial query
  - getName
```
public String getName()
```
    Specified by:
    
    getName in class AggregatorFactory
  - requiredFields
```
public List<String> requiredFields()
```
    Description copied from class: AggregatorFactory
    
    Get a list of fields that aggregators built by this factory will need to read.
    
    Specified by:
    
    requiredFields in class AggregatorFactory
  - getFieldName
```
public String getFieldName()
```
  - getIsInputHyperUnique
```
public boolean getIsInputHyperUnique()
```
  - isRound
```
public boolean isRound()
```
  - getCacheKey
```
public byte[] getCacheKey()
```
  - getTypeName
```
public String getTypeName()
```
    Description copied from class: AggregatorFactory
    Get the type name of the intermediate type for this aggregator. This is the same as the type returned by AggregatorFactory.deserialize(java.lang.Object) and the type accepted by AggregatorFactory.combine(java.lang.Object, java.lang.Object). However, it is *not* necessarily the same type returned by AggregatorFactory.finalizeComputation(java.lang.Object). If the type is complex (i.e. not a simple, numeric ValueType) then there must be a corresponding ComplexMetricSerde which was registered with ComplexMetrics.registerSerde(java.lang.String, org.apache.druid.segment.serde.ComplexMetricSerde) using this type name. If you need a ValueType enum corresponding to this aggregator, a good way to do that is:
```
   Optional.ofNullable(GuavaUtils.getEnumIfPresent(ValueType.class, aggregator.getTypeName()))
           .orElse(ValueType.COMPLEX);
 
```
    Specified by:
    
    getTypeName in class AggregatorFactory
  - getMaxIntermediateSize
```
public int getMaxIntermediateSize()
```
    Description copied from class: AggregatorFactory
    
    Returns the maximum size that this aggregator will require in bytes for intermediate storage of results.
    
    Specified by:
    
    getMaxIntermediateSize in class AggregatorFactory
    
    Returns:
    
    the maximum number of bytes that an aggregator of this type will require for intermediate result storage.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object

Class HyperUniquesAggregatorFactory

Constructor Summary

Method Summary

Methods inherited from class org.apache.druid.query.aggregation.AggregatorFactory

Methods inherited from class java.lang.Object

Constructor Detail

HyperUniquesAggregatorFactory

HyperUniquesAggregatorFactory

Method Detail

estimateCardinality

factorize

factorizeBuffered

factorizeVector

canVectorize

getComparator

combine

makeAggregateCombiner

getCombiningFactory

getMergingFactory

getRequiredColumns

deserialize

finalizeComputation

getName

requiredFields

getFieldName

getIsInputHyperUnique

isRound

getCacheKey

getTypeName

getMaxIntermediateSize

toString

equals

hashCode