mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-10-19 06:50:50 +00:00
115 lines
3.2 KiB
C++
115 lines
3.2 KiB
C++
#pragma once
|
|
|
|
#include <DataTypes/DataTypesNumber.h>
|
|
#include <Columns/ColumnsNumber.h>
|
|
#include <Common/assert_cast.h>
|
|
#include <AggregateFunctions/IAggregateFunction.h>
|
|
|
|
|
|
namespace DB
|
|
{
|
|
|
|
namespace ErrorCodes
|
|
{
|
|
extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
|
|
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
|
|
}
|
|
|
|
/** Not an aggregate function, but an adapter of aggregate functions,
|
|
* which any aggregate function `agg(x)` makes an aggregate function of the form `aggIf(x, cond)`.
|
|
* The adapted aggregate function takes two arguments - a value and a condition,
|
|
* and calculates the nested aggregate function for the values when the condition is satisfied.
|
|
* For example, avgIf(x, cond) calculates the average x if `cond`.
|
|
*/
|
|
class AggregateFunctionIf final : public IAggregateFunctionHelper<AggregateFunctionIf>
|
|
{
|
|
private:
|
|
AggregateFunctionPtr nested_func;
|
|
size_t num_arguments;
|
|
|
|
public:
|
|
AggregateFunctionIf(AggregateFunctionPtr nested, const DataTypes & types)
|
|
: IAggregateFunctionHelper<AggregateFunctionIf>(types, nested->getParameters())
|
|
, nested_func(nested), num_arguments(types.size())
|
|
{
|
|
if (num_arguments == 0)
|
|
throw Exception("Aggregate function " + getName() + " require at least one argument", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
|
|
|
|
if (!isUInt8(types.back()))
|
|
throw Exception("Last argument for aggregate function " + getName() + " must be UInt8", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
|
|
}
|
|
|
|
String getName() const override
|
|
{
|
|
return nested_func->getName() + "If";
|
|
}
|
|
|
|
DataTypePtr getReturnType() const override
|
|
{
|
|
return nested_func->getReturnType();
|
|
}
|
|
|
|
void create(AggregateDataPtr place) const override
|
|
{
|
|
nested_func->create(place);
|
|
}
|
|
|
|
void destroy(AggregateDataPtr place) const noexcept override
|
|
{
|
|
nested_func->destroy(place);
|
|
}
|
|
|
|
bool hasTrivialDestructor() const override
|
|
{
|
|
return nested_func->hasTrivialDestructor();
|
|
}
|
|
|
|
size_t sizeOfData() const override
|
|
{
|
|
return nested_func->sizeOfData();
|
|
}
|
|
|
|
size_t alignOfData() const override
|
|
{
|
|
return nested_func->alignOfData();
|
|
}
|
|
|
|
void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena * arena) const override
|
|
{
|
|
if (assert_cast<const ColumnUInt8 &>(*columns[num_arguments - 1]).getData()[row_num])
|
|
nested_func->add(place, columns, row_num, arena);
|
|
}
|
|
|
|
void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena * arena) const override
|
|
{
|
|
nested_func->merge(place, rhs, arena);
|
|
}
|
|
|
|
void serialize(ConstAggregateDataPtr place, WriteBuffer & buf) const override
|
|
{
|
|
nested_func->serialize(place, buf);
|
|
}
|
|
|
|
void deserialize(AggregateDataPtr place, ReadBuffer & buf, Arena * arena) const override
|
|
{
|
|
nested_func->deserialize(place, buf, arena);
|
|
}
|
|
|
|
void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
|
|
{
|
|
nested_func->insertResultInto(place, to);
|
|
}
|
|
|
|
bool allocatesMemoryInArena() const override
|
|
{
|
|
return nested_func->allocatesMemoryInArena();
|
|
}
|
|
|
|
bool isState() const override
|
|
{
|
|
return nested_func->isState();
|
|
}
|
|
};
|
|
|
|
}
|