ClickHouse

1
#include "AggregateFunctionArray.h"
2
#include "AggregateFunctionCombinatorFactory.h"
3

4
#include <Common/typeid_cast.h>
5

6
namespace DB
7
{
8
struct Settings;
9

10
namespace ErrorCodes
11
{
12
    extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
13
    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
14
}
15

16
namespace
17
{
18

19
class AggregateFunctionCombinatorArray final : public IAggregateFunctionCombinator
20
{
21
public:
22
    String getName() const override { return "Array"; }
23

24
    bool supportsNesting() const override { return true; }
25

26
    DataTypes transformArguments(const DataTypes & arguments) const override
27
    {
28
        if (arguments.empty())
29
            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "-Array aggregate functions require at least one argument");
30

31
        DataTypes nested_arguments;
32
        for (const auto & type : arguments)
33
        {
34
            if (const DataTypeArray * array = typeid_cast<const DataTypeArray *>(type.get()))
35
                nested_arguments.push_back(array->getNestedType());
36
            else
37
                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument"
38
                                " for aggregate function with {} suffix. Must be array.", type->getName(), getName());
39
        }
40

41
        return nested_arguments;
42
    }
43

44
    AggregateFunctionPtr transformAggregateFunction(
45
        const AggregateFunctionPtr & nested_function,
46
        const AggregateFunctionProperties &,
47
        const DataTypes & arguments,
48
        const Array & params) const override
49
    {
50
        return std::make_shared<AggregateFunctionArray>(nested_function, arguments, params);
51
    }
52
};
53

54
}
55

56
void registerAggregateFunctionCombinatorArray(AggregateFunctionCombinatorFactory & factory)
57
{
58
    factory.registerCombinator(std::make_shared<AggregateFunctionCombinatorArray>());
59
}
60

61
}
62