ClickHouse

1
#include <DataTypes/DataTypesNumber.h>
2
#include <Columns/ColumnsNumber.h>
3
#include <Functions/FunctionFactory.h>
4
#include <Functions/FunctionHelpers.h>
5
#include <Functions/IFunction.h>
6

7

8
namespace DB
9
{
10

11
namespace
12
{
13

14
/** byteSize() - get the value size in number of bytes for accounting purposes.
15
  */
16
class FunctionByteSize : public IFunction
17
{
18
public:
19
    static constexpr auto name = "byteSize";
20
    static FunctionPtr create(ContextPtr)
21
    {
22
        return std::make_shared<FunctionByteSize>();
23
    }
24

25
    String getName() const override { return name; }
26
    bool useDefaultImplementationForNulls() const override { return false; }
27
    bool useDefaultImplementationForNothing() const override { return false; }
28
    bool useDefaultImplementationForLowCardinalityColumns() const override { return false; }
29
    bool useDefaultImplementationForSparseColumns() const override { return false; }
30
    bool isVariadic() const override { return true; }
31
    bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; }
32
    size_t getNumberOfArguments() const override { return 0; }
33

34
    DataTypePtr getReturnTypeImpl(const DataTypes & /*arguments*/) const override
35
    {
36
        return std::make_shared<DataTypeUInt64>();
37
    }
38

39
    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
40
    {
41
        size_t num_args = arguments.size();
42

43
        /// If the resulting size is constant, return constant column.
44

45
        bool all_constant = true;
46
        UInt64 constant_size = 0;
47
        for (size_t arg_num = 0; arg_num < num_args; ++arg_num)
48
        {
49
            if (arguments[arg_num].type->isValueUnambiguouslyRepresentedInFixedSizeContiguousMemoryRegion())
50
            {
51
                constant_size += arguments[arg_num].type->getSizeOfValueInMemory();
52
            }
53
            else
54
            {
55
                all_constant = false;
56
                break;
57
            }
58
        }
59

60
        if (all_constant)
61
            return result_type->createColumnConst(input_rows_count, constant_size);
62

63
        auto result_col = ColumnUInt64::create(input_rows_count);
64
        auto & vec_res = result_col->getData();
65
        for (size_t arg_num = 0; arg_num < num_args; ++arg_num)
66
        {
67
            const IColumn * column = arguments[arg_num].column.get();
68

69
            if (arg_num == 0)
70
                for (size_t row_num = 0; row_num < input_rows_count; ++row_num)
71
                    vec_res[row_num] = column->byteSizeAt(row_num);
72
            else
73
                for (size_t row_num = 0; row_num < input_rows_count; ++row_num)
74
                    vec_res[row_num] += column->byteSizeAt(row_num);
75
        }
76

77
        return result_col;
78
    }
79
};
80

81
}
82

83
REGISTER_FUNCTION(ByteSize)
84
{
85
    factory.registerFunction<FunctionByteSize>();
86
}
87

88
}
89