ClickHouse

1
#include <Columns/ColumnNullable.h>
2
#include <Columns/ColumnString.h>
3
#include <Columns/ColumnFixedString.h>
4
#include <Columns/ColumnVector.h>
5
#include <Columns/ColumnsNumber.h>
6
#include <DataTypes/IDataType.h>
7
#include <DataTypes/DataTypesNumber.h>
8
#include <DataTypes/DataTypeNullable.h>
9
#include <Functions/IFunction.h>
10
#include <Functions/FunctionFactory.h>
11
#include <Functions/GregorianDate.h>
12
#include <IO/ReadBufferFromMemory.h>
13

14
namespace DB
15
{
16
    namespace ErrorCodes
17
    {
18
        extern const int ILLEGAL_COLUMN;
19
        extern const int ILLEGAL_TYPE_OF_ARGUMENT;
20
    }
21

22
    template <typename Name, typename ToDataType, bool nullOnErrors>
23
    class ExecutableFunctionToModifiedJulianDay : public IExecutableFunction
24
    {
25
    public:
26
        String getName() const override
27
        {
28
            return Name::name;
29
        }
30

31
        ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
32
        {
33
            const IColumn * col_from = arguments[0].column.get();
34
            const ColumnString * col_from_string = checkAndGetColumn<ColumnString>(col_from);
35
            const ColumnFixedString * col_from_fixed_string = checkAndGetColumn<ColumnFixedString>(col_from);
36

37
            const ColumnString::Chars * chars = nullptr;
38
            const IColumn::Offsets * offsets = nullptr;
39
            size_t fixed_string_size = 0;
40

41
            if (col_from_string)
42
            {
43
                chars = &col_from_string->getChars();
44
                offsets = &col_from_string->getOffsets();
45
            }
46
            else if (col_from_fixed_string)
47
            {
48
                chars = &col_from_fixed_string->getChars();
49
                fixed_string_size = col_from_fixed_string->getN();
50
            }
51
            else
52
            {
53
                 throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of first argument of function {}",
54
                                 col_from->getName(), Name::name);
55
            }
56

57
            using ColVecTo = typename ToDataType::ColumnType;
58
            typename ColVecTo::MutablePtr col_to = ColVecTo::create(input_rows_count);
59
            typename ColVecTo::Container & vec_to = col_to->getData();
60

61
            ColumnUInt8::MutablePtr col_null_map_to;
62
            UInt8 * vec_null_map_to [[maybe_unused]] = nullptr;
63
            if constexpr (nullOnErrors)
64
            {
65
                col_null_map_to = ColumnUInt8::create(input_rows_count);
66
                vec_null_map_to = col_null_map_to->getData().data();
67
            }
68

69
            size_t current_offset = 0;
70
            for (size_t i = 0; i < input_rows_count; ++i)
71
            {
72
                const size_t next_offset = offsets ? (*offsets)[i] : current_offset + fixed_string_size;
73
                const size_t string_size = offsets ? next_offset - current_offset - 1 : fixed_string_size;
74
                ReadBufferFromMemory read_buffer(&(*chars)[current_offset], string_size);
75
                current_offset = next_offset;
76

77
                if constexpr (nullOnErrors)
78
                {
79
                    GregorianDate date;
80

81
                    int64_t res = 0;
82
                    bool success = date.tryInit(read_buffer) && date.tryToModifiedJulianDay(res);
83

84
                    vec_to[i] = static_cast<typename ToDataType::FieldType>(res);
85
                    vec_null_map_to[i] = !success;
86
                }
87
                else
88
                {
89
                    const GregorianDate date(read_buffer);
90
                    vec_to[i] = static_cast<typename ToDataType::FieldType>(date.toModifiedJulianDay());
91
                }
92
            }
93

94
            if constexpr (nullOnErrors)
95
                return ColumnNullable::create(std::move(col_to), std::move(col_null_map_to));
96
            else
97
                return col_to;
98
        }
99

100
        bool useDefaultImplementationForConstants() const override
101
        {
102
            return true;
103
        }
104
    };
105

106
    template <typename Name, typename ToDataType, bool nullOnErrors>
107
    class FunctionBaseToModifiedJulianDay : public IFunctionBase
108
    {
109
    public:
110
        explicit FunctionBaseToModifiedJulianDay(DataTypes argument_types_, DataTypePtr return_type_)
111
            : argument_types(std::move(argument_types_))
112
            , return_type(std::move(return_type_)) {}
113

114
        String getName() const override
115
        {
116
            return Name::name;
117
        }
118

119
        const DataTypes & getArgumentTypes() const override
120
        {
121
            return argument_types;
122
        }
123

124
        const DataTypePtr & getResultType() const override
125
        {
126
            return return_type;
127
        }
128

129
        bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; }
130

131
        ExecutableFunctionPtr prepare(const ColumnsWithTypeAndName &) const override
132
        {
133
            return std::make_unique<ExecutableFunctionToModifiedJulianDay<Name, ToDataType, nullOnErrors>>();
134
        }
135

136
        bool isInjective(const ColumnsWithTypeAndName &) const override
137
        {
138
            return true;
139
        }
140

141
        bool hasInformationAboutMonotonicity() const override
142
        {
143
            return true;
144
        }
145

146
        Monotonicity getMonotonicityForRange(const IDataType &, const Field &, const Field &) const override
147
        {
148
            return { .is_monotonic = true, .is_always_monotonic = true, .is_strict = true };
149
        }
150

151
    private:
152
        DataTypes argument_types;
153
        DataTypePtr return_type;
154
    };
155

156
    template <typename Name, typename ToDataType, bool nullOnErrors>
157
    class ToModifiedJulianDayOverloadResolver : public IFunctionOverloadResolver
158
    {
159
    public:
160
        static constexpr auto name = Name::name;
161

162
        static FunctionOverloadResolverPtr create(ContextPtr)
163
        {
164
            return std::make_unique<ToModifiedJulianDayOverloadResolver<Name, ToDataType, nullOnErrors>>();
165
        }
166

167
        String getName() const override
168
        {
169
            return Name::name;
170
        }
171

172
        FunctionBasePtr buildImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & return_type) const override
173
        {
174
            DataTypes argument_types = { arguments[0].type };
175

176
            return std::make_unique<FunctionBaseToModifiedJulianDay<Name, ToDataType, nullOnErrors>>(argument_types, return_type);
177
        }
178

179
        DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
180
        {
181
            if (!isStringOrFixedString(arguments[0]))
182
            {
183
                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "The argument of function {} must be String or FixedString",
184
                    getName());
185
            }
186

187
            DataTypePtr base_type = std::make_shared<ToDataType>();
188
            if constexpr (nullOnErrors)
189
            {
190
                return std::make_shared<DataTypeNullable>(base_type);
191
            }
192
            else
193
            {
194
                return base_type;
195
            }
196
        }
197

198
        size_t getNumberOfArguments() const override
199
        {
200
            return 1;
201
        }
202

203
        bool isInjective(const ColumnsWithTypeAndName &) const override
204
        {
205
            return true;
206
        }
207
    };
208

209
    struct NameToModifiedJulianDay
210
    {
211
        static constexpr auto name = "toModifiedJulianDay";
212
    };
213

214
    struct NameToModifiedJulianDayOrNull
215
    {
216
        static constexpr auto name = "toModifiedJulianDayOrNull";
217
    };
218

219
    REGISTER_FUNCTION(ToModifiedJulianDay)
220
    {
221
        factory.registerFunction<ToModifiedJulianDayOverloadResolver<NameToModifiedJulianDay, DataTypeInt32, false>>();
222
        factory.registerFunction<ToModifiedJulianDayOverloadResolver<NameToModifiedJulianDayOrNull, DataTypeInt32, true>>();
223
    }
224
}
225