ClickHouse源码笔记1:聚合函数的实现

时间 2020-06-03

原文原文链接

因为工做的需求，后续笔者工做须要和开源的OLAP数据库ClickHouse打交道。ClickHouse是Yandex在2016年6月15日开源了一个分析型数据库，以强悍的单机处理能力被称道。
笔者在实际测试ClickHouse和阅读ClickHouse的源码过程之中，对"战斗民族"开发的数据库十分欣赏。ClickHouse不只是一个很好的数据库学习材料，并且同时应用了大量的CPP17的新特性进行开发，也是一个大型的Modern CPP的教导资料。
笔者接下来会陆续将阅读ClickHouse的部分心得体会与经过源码阅读笔记的方式和你们分享，坦白说，这种源码阅读笔记很难写啊。(多一分繁琐，少一分就模糊了~~)
第一篇文章，咱们就从聚合函数的实现开始聊起~~ 上车！git

1.基础知识的梳理

什么是聚合函数？

聚合函数: 顾名思义就是对一组数据执行聚合计算并返回结果的函数。
这类函数在数据库之中很常见，如：count, max, min, sum等等。github

ClickHouse的实现接口

IAggregateFunction接口
在ClickHouse之中，定义了一个统一的聚合函数接口：IAggregateFunction.（在ClickHouse之中，全部的接口类都是以大写的I开头的。) 上文笔者提到的聚合函数，则都是做为抽象类IAggregateFunction的子类实现的。其中该接口最为核心的方法是下面这5个方法：
- add函数：最为核心的调用接口，将对应AggregateDataPtr指针之中数据取出，与列columns中的第row_num的数据进行对应的聚合计算。(这里能够看到ClickHouse是一个纯粹的列式存储数据库，全部的操做都是基于列的数据结构。）
- merge函数：将两个聚合结果进行合并的函数，一般用在并发执行聚合函数的过程之中，须要将对应的聚合结果进行合并。
- serialize函数与deserialize函数：序列化与反序列化的函数，一般用于spill to disk或分布式场景须要保存或传输中间结果的。
- addBatch函数：这是函数也是很是重要的，虽然它仅仅实现了一个for循环调用add函数。它经过这样的方式来减小虚函数的调用次数，而且增长了编译器内联的几率。（虚函数的调用须要一次访存指令，一次查表，最终才能定位到须要调用的函数上，这在传统的火山模型的实现上会带来极大的CPU开销。）

/** Adds a value into aggregation data on which place points to.
     *  columns points to columns containing arguments of aggregation function.
     *  row_num is number of row which should be added.
     *  Additional parameter arena should be used instead of standard memory allocator if the addition requires memory allocation.
     */
    virtual void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena * arena) const = 0;

    /// Merges state (on which place points to) with other state of current aggregation function.
    virtual void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena * arena) const = 0;

    /// Serializes state (to transmit it over the network, for example).
    virtual void serialize(ConstAggregateDataPtr place, WriteBuffer & buf) const = 0;

    /// Deserializes state. This function is called only for empty (just created) states.
    virtual void deserialize(AggregateDataPtr place, ReadBuffer & buf, Arena * arena) const = 0;
    // /** Contains a loop with calls to "add" function. You can collect arguments into array "places"
      *  and do a single call to "addBatch" for devirtualization and inlining.
      */
    virtual void addBatch(size_t batch_size, AggregateDataPtr * places, size_t place_offset, const IColumn ** columns, Arena * arena) const = 0;

抽象类IColumn
上面的接口IAggregateFunction的函数使用到了ClickHouse的核心接口IColumn类，这里也进行简要的介绍。 IColumn 接口表达了全部数据在ClickHouse之中的用内存表达的数据结构，其余带有具体数据类型的如ColumnUInt八、ColumnArray 等, 都实现了对应的列接口，而且在子类之中具象实现了不一样的内存布局。
IColumn的子类实现细节很琐碎，笔者这里就暂时不展开讲了，笔者这里就简单讲讲涉及到聚合函数调用部分的IColumn接口的对应方法：
这里columns是一个二维数组，经过columns[0]能够取到第一列。(这里只有涉及到一列，为何columns是二维数组呢？由于处理array等列的时候，也是经过对应的接口，而array就须要应用二维数组了. )
注意这里有一个强制的类型转换，column已经转换为ColVecType类型了，这是模板派生出IColumn的子类。
而后经过IColumn子类实现的getData方法获取对应row_num行的数据进行add函数调用就完成了一次聚合函数的计算了。

void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena *) const override
    {
        const auto & column = static_cast<const ColVecType &>(*columns[0]);
        this->data(place).add(column.getData()[row_num]);
    }

IAggregateFunctionHelper接口
这个接口是上面提到 IAggregateFunction的辅助子类接口，它很巧妙的经过模板的类型派生，将虚函数的调用转换为函数指针的调用，这个在实际聚合函数的实现过程之中可以大大提升计算的效率。
函数addFree就实现了我上述所说的过程，可是它是一个private的函数，因此一般咱们都是经过getAddressOfAddFunction获取对应的函数地址。这在聚合查询的过程之中可以提升20%左右的执行效率。

template <typename Derived>
class IAggregateFunctionHelper : public IAggregateFunction
{
private:
    static void addFree(const IAggregateFunction * that, AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena * arena)
    {
        static_cast<const Derived &>(*that).add(place, columns, row_num, arena);
    }

public:
    IAggregateFunctionHelper(const DataTypes & argument_types_, const Array & parameters_)
        : IAggregateFunction(argument_types_, parameters_) {}

    AddFunc getAddressOfAddFunction() const override { return &addFree; }

AggregateFunctionFactory类
顾名思义，这个是一个生成聚合函数的工厂类。它的逻辑很简单，全部ClickHouse之中所相关的聚合函数都是经过这个工厂类注册而且获取，而后进行调用的。

class AggregateFunctionFactory final : private boost::noncopyable, public IFactoryWithAliases<AggregateFunctionCreator>
{
public:

    static AggregateFunctionFactory & instance();

    /// Register a function by its name.
    /// No locking, you must register all functions before usage of get.
    void registerFunction(
        const String & name,
        Creator creator,
        CaseSensitiveness case_sensitiveness = CaseSensitive);

    /// Throws an exception if not found.
    AggregateFunctionPtr get(
        const String & name,
        const DataTypes & argument_types,
        const Array & parameters = {},
        int recursion_level = 0) const;

2.聚合函数的注册流程

有了上述的背景知识，咱们接下来举个栗子。来看看一个聚合函数的实现细节，以及它是如何被使用的。算法

AggregateFunctionSum

笔者这里选取了一个很简单的聚合算子Sum，咱们来看看它实现的代码细节。
这里咱们能够看到AggregateFunctionSum是个final类，没法被继承了。而它继承了上面提到的IAggregateFunctionHelp类的子类IAggregateFunctionDataHelper类。数据库

这里咱们就重点看，这个类override了getName方法，返回了对应的名字sum。而且实现了咱们上文提到的四个核心的方法。数组

add
merge
seriable
deserialize

template <typename T, typename TResult, typename Data>
class AggregateFunctionSum final : public IAggregateFunctionDataHelper<Data, AggregateFunctionSum<T, TResult, Data>>
{
public:
    using ResultDataType = std::conditional_t<IsDecimalNumber<T>, DataTypeDecimal<TResult>, DataTypeNumber<TResult>>;
    using ColVecType = std::conditional_t<IsDecimalNumber<T>, ColumnDecimal<T>, ColumnVector<T>>;
    using ColVecResult = std::conditional_t<IsDecimalNumber<T>, ColumnDecimal<TResult>, ColumnVector<TResult>>;

    String getName() const override { return "sum"; }

    AggregateFunctionSum(const DataTypes & argument_types_)
        : IAggregateFunctionDataHelper<Data, AggregateFunctionSum<T, TResult, Data>>(argument_types_, {})
        , scale(0)
    {}

    AggregateFunctionSum(const IDataType & data_type, const DataTypes & argument_types_)
        : IAggregateFunctionDataHelper<Data, AggregateFunctionSum<T, TResult, Data>>(argument_types_, {})
        , scale(getDecimalScale(data_type))
    {}

    DataTypePtr getReturnType() const override
    {
        if constexpr (IsDecimalNumber<T>)
            return std::make_shared<ResultDataType>(ResultDataType::maxPrecision(), scale);
        else
            return std::make_shared<ResultDataType>();
    }

    void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena *) const override
    {
        const auto & column = static_cast<const ColVecType &>(*columns[0]);
        this->data(place).add(column.getData()[row_num]);
    }

    void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena *) const override
    {
        this->data(place).merge(this->data(rhs));
    }

    void serialize(ConstAggregateDataPtr place, WriteBuffer & buf) const override
    {
        this->data(place).write(buf);
    }

    void deserialize(AggregateDataPtr place, ReadBuffer & buf, Arena *) const override
    {
        this->data(place).read(buf);
    }

    void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
    {
        auto & column = static_cast<ColVecResult &>(to);
        column.getData().push_back(this->data(place).get());
    }

private:
    UInt32 scale;
};

接下来，ClickHouse实现了两种聚合计算：AggregateFunctionSumData和AggregateFunctionSumKahanData。后者是用Kahan算法避免float类型精度损失的，咱们能够暂时不细看。直接看SumData的实现。这是个模板类，以前咱们讲到AggregateFunction的函数就是经过AggregateDataPtr指针来获取AggregateFunctionSumData的地址，来调用add实现聚合算子的。咱们能够看到AggregateFunctionSumData实现了前文提到的add, merge, write,read四大方法，正好和接口一一对应上了。数据结构

template <typename T>
struct AggregateFunctionSumData
{
    T sum{};

    void add(T value)
    {
        sum += value;
    }

    void merge(const AggregateFunctionSumData & rhs)
    {
        sum += rhs.sum;
    }

    void write(WriteBuffer & buf) const
    {
        writeBinary(sum, buf);
    }

    void read(ReadBuffer & buf)
    {
        readBinary(sum, buf);
    }

    T get() const
    {
        return sum;
    }
};

ClickHouse在Server启动时。main函数之中会调用registerAggregateFunction的初始化函数注册全部的聚合函数。
而后调用到下面的函数：并发

void registerAggregateFunctionSum(AggregateFunctionFactory & factory)
{
    factory.registerFunction("sum", createAggregateFunctionSum<AggregateFunctionSumSimple>, AggregateFunctionFactory::CaseInsensitive);
    factory.registerFunction("sumWithOverflow", createAggregateFunctionSum<AggregateFunctionSumWithOverflow>);
    factory.registerFunction("sumKahan", createAggregateFunctionSum<AggregateFunctionSumKahan>);
}

这里又调用了 factory.registerFunction("sum", createAggregateFunctionSum<AggregateFunctionSumSimple>, AggregateFunctionFactory::CaseInsensitive);来进行上述咱们看到的聚合函数的注册。这里有一点很恶心的模板代码，笔者这里简化了一下，把注册的部分函数拉出来：分布式

createAggregateFunctionSum(const std::string & name, const DataTypes & argument_types, const Array & parameters)
{
    AggregateFunctionPtr res;
    DataTypePtr data_type = argument_types[0];
    if (isDecimal(data_type))
        res.reset(createWithDecimalType<Function>(*data_type, *data_type, argument_types));
    else
        res.reset(createWithNumericType<Function>(*data_type, argument_types));
    return res;

这里的Function模板就是上面的AggregateFunctionSumSimple, 而它又是下面的模板类型：ide

template <typename T> using AggregateFunctionSumSimple = typename SumSimple<T>::Function;

template <typename T>
struct SumSimple
{
    /// @note It uses slow Decimal128 (cause we need such a variant). sumWithOverflow is faster for Decimal32/64
    using ResultType = std::conditional_t<IsDecimalNumber<T>, Decimal128, NearestFieldType<T>>;
    using AggregateDataType = AggregateFunctionSumData<ResultType>;
    using Function = AggregateFunctionSum<T, ResultType, AggregateDataType>;
};

不知道读者被绕晕了没，最终绕回来仍是new出来这个AggregateFunctionSum<T, ResultType, AggregateDataType>
也就是完成了这个求和算子的注册，后续咱们get出来就能够愉快的调用啦。（这里这部分的模板变化比较复杂，若是看不明白能够回到源码梳理一下~~~）函数

3. 小结

好了，关于聚合函数的基础信息，和它是如何实现而且经过工厂方法注册获取的流程算是搞明白了。
关于其余的聚合算子，也是大同小异的方式。笔者就再也不赘述了，感兴趣的能够回到源码之中继续一探究竟。讲完了聚合函数的实现，下一篇笔者就要继续给探究聚合函数究竟在ClickHouse之中是如何和列存结合使用，并实现向量化的~~。
笔者是一个ClickHouse的初学者，对ClickHouse有兴趣的同窗，也欢迎和笔者多多指教，交流。

4. 参考资料

官方文档
 ClickHouse源代码