Coverage Report

Created: 2026-06-09 13:42

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/exprs/function/function_string_digest.cpp
Line
Count
Source
1
// Licensed to the Apache Software Foundation (ASF) under one
2
// or more contributor license agreements.  See the NOTICE file
3
// distributed with this work for additional information
4
// regarding copyright ownership.  The ASF licenses this file
5
// to you under the Apache License, Version 2.0 (the
6
// "License"); you may not use this file except in compliance
7
// with the License.  You may obtain a copy of the License at
8
//
9
//   http://www.apache.org/licenses/LICENSE-2.0
10
//
11
// Unless required by applicable law or agreed to in writing,
12
// software distributed under the License is distributed on an
13
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14
// KIND, either express or implied.  See the License for the
15
// specific language governing permissions and limitations
16
// under the License.
17
18
#include <cstddef>
19
#include <cstring>
20
#include <string_view>
21
#include <type_traits>
22
#include <vector>
23
24
#include "common/status.h"
25
#include "core/assert_cast.h"
26
#include "core/block/block.h"
27
#include "core/block/column_numbers.h"
28
#include "core/column/column_string.h"
29
#include "core/column/column_varbinary.h"
30
#include "core/column/column_vector.h"
31
#include "core/data_type/data_type_string.h"
32
#include "core/string_ref.h"
33
#include "exec/common/stringop_substring.h"
34
#include "exprs/function/function.h"
35
#include "exprs/function/simple_function_factory.h"
36
#include "exprs/function_context.h"
37
#include "util/md5.h"
38
#include "util/sha.h"
39
#include "util/sm3.h"
40
41
namespace doris {
42
#include "common/compile_check_avoid_begin.h"
43
44
struct SM3Sum {
45
    static constexpr auto name = "sm3sum";
46
    using ObjectData = SM3Digest;
47
};
48
49
struct MD5Sum {
50
    static constexpr auto name = "md5sum";
51
    using ObjectData = Md5Digest;
52
};
53
54
template <typename Impl>
55
class FunctionStringDigestMulti : public IFunction {
56
public:
57
    static constexpr auto name = Impl::name;
58
373
    static FunctionPtr create() { return std::make_shared<FunctionStringDigestMulti>(); }
_ZN5doris25FunctionStringDigestMultiINS_6SM3SumEE6createEv
Line
Count
Source
58
128
    static FunctionPtr create() { return std::make_shared<FunctionStringDigestMulti>(); }
_ZN5doris25FunctionStringDigestMultiINS_6MD5SumEE6createEv
Line
Count
Source
58
245
    static FunctionPtr create() { return std::make_shared<FunctionStringDigestMulti>(); }
59
0
    String get_name() const override { return name; }
Unexecuted instantiation: _ZNK5doris25FunctionStringDigestMultiINS_6SM3SumEE8get_nameB5cxx11Ev
Unexecuted instantiation: _ZNK5doris25FunctionStringDigestMultiINS_6MD5SumEE8get_nameB5cxx11Ev
60
0
    size_t get_number_of_arguments() const override { return 0; }
Unexecuted instantiation: _ZNK5doris25FunctionStringDigestMultiINS_6SM3SumEE23get_number_of_argumentsEv
Unexecuted instantiation: _ZNK5doris25FunctionStringDigestMultiINS_6MD5SumEE23get_number_of_argumentsEv
61
359
    bool is_variadic() const override { return true; }
_ZNK5doris25FunctionStringDigestMultiINS_6SM3SumEE11is_variadicEv
Line
Count
Source
61
121
    bool is_variadic() const override { return true; }
_ZNK5doris25FunctionStringDigestMultiINS_6MD5SumEE11is_variadicEv
Line
Count
Source
61
238
    bool is_variadic() const override { return true; }
62
63
357
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
64
357
        return std::make_shared<DataTypeString>();
65
357
    }
_ZNK5doris25FunctionStringDigestMultiINS_6SM3SumEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS7_EE
Line
Count
Source
63
120
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
64
120
        return std::make_shared<DataTypeString>();
65
120
    }
_ZNK5doris25FunctionStringDigestMultiINS_6MD5SumEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS7_EE
Line
Count
Source
63
237
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
64
237
        return std::make_shared<DataTypeString>();
65
237
    }
66
67
    Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
68
362
                        uint32_t result, size_t input_rows_count) const override {
69
362
        DCHECK_GE(arguments.size(), 1);
70
71
362
        auto res = ColumnString::create();
72
362
        auto& res_data = res->get_chars();
73
362
        auto& res_offset = res->get_offsets();
74
362
        res_offset.resize(input_rows_count);
75
76
362
        std::vector<ColumnPtr> argument_columns(arguments.size());
77
362
        std::vector<uint8_t> is_const(arguments.size(), 0);
78
1.01k
        for (size_t i = 0; i < arguments.size(); ++i) {
79
651
            std::tie(argument_columns[i], is_const[i]) =
80
651
                    unpack_if_const(block.get_by_position(arguments[i]).column);
81
651
        }
82
83
362
        if (check_and_get_column<ColumnString>(argument_columns[0].get())) {
84
231
            vector_execute<ColumnString>(block, input_rows_count, argument_columns, is_const,
85
231
                                         res_data, res_offset);
86
231
        } else if (check_and_get_column<ColumnVarbinary>(argument_columns[0].get())) {
87
131
            vector_execute<ColumnVarbinary>(block, input_rows_count, argument_columns, is_const,
88
131
                                            res_data, res_offset);
89
131
        } else {
90
0
            return Status::RuntimeError("Illegal column {} of argument of function {}",
91
0
                                        argument_columns[0]->get_name(), get_name());
92
0
        }
93
94
362
        block.replace_by_position(result, std::move(res));
95
362
        return Status::OK();
96
362
    }
_ZNK5doris25FunctionStringDigestMultiINS_6SM3SumEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
68
120
                        uint32_t result, size_t input_rows_count) const override {
69
120
        DCHECK_GE(arguments.size(), 1);
70
71
120
        auto res = ColumnString::create();
72
120
        auto& res_data = res->get_chars();
73
120
        auto& res_offset = res->get_offsets();
74
120
        res_offset.resize(input_rows_count);
75
76
120
        std::vector<ColumnPtr> argument_columns(arguments.size());
77
120
        std::vector<uint8_t> is_const(arguments.size(), 0);
78
353
        for (size_t i = 0; i < arguments.size(); ++i) {
79
233
            std::tie(argument_columns[i], is_const[i]) =
80
233
                    unpack_if_const(block.get_by_position(arguments[i]).column);
81
233
        }
82
83
120
        if (check_and_get_column<ColumnString>(argument_columns[0].get())) {
84
78
            vector_execute<ColumnString>(block, input_rows_count, argument_columns, is_const,
85
78
                                         res_data, res_offset);
86
78
        } else if (check_and_get_column<ColumnVarbinary>(argument_columns[0].get())) {
87
42
            vector_execute<ColumnVarbinary>(block, input_rows_count, argument_columns, is_const,
88
42
                                            res_data, res_offset);
89
42
        } else {
90
0
            return Status::RuntimeError("Illegal column {} of argument of function {}",
91
0
                                        argument_columns[0]->get_name(), get_name());
92
0
        }
93
94
120
        block.replace_by_position(result, std::move(res));
95
120
        return Status::OK();
96
120
    }
_ZNK5doris25FunctionStringDigestMultiINS_6MD5SumEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
68
242
                        uint32_t result, size_t input_rows_count) const override {
69
242
        DCHECK_GE(arguments.size(), 1);
70
71
242
        auto res = ColumnString::create();
72
242
        auto& res_data = res->get_chars();
73
242
        auto& res_offset = res->get_offsets();
74
242
        res_offset.resize(input_rows_count);
75
76
242
        std::vector<ColumnPtr> argument_columns(arguments.size());
77
242
        std::vector<uint8_t> is_const(arguments.size(), 0);
78
660
        for (size_t i = 0; i < arguments.size(); ++i) {
79
418
            std::tie(argument_columns[i], is_const[i]) =
80
418
                    unpack_if_const(block.get_by_position(arguments[i]).column);
81
418
        }
82
83
242
        if (check_and_get_column<ColumnString>(argument_columns[0].get())) {
84
153
            vector_execute<ColumnString>(block, input_rows_count, argument_columns, is_const,
85
153
                                         res_data, res_offset);
86
153
        } else if (check_and_get_column<ColumnVarbinary>(argument_columns[0].get())) {
87
89
            vector_execute<ColumnVarbinary>(block, input_rows_count, argument_columns, is_const,
88
89
                                            res_data, res_offset);
89
89
        } else {
90
0
            return Status::RuntimeError("Illegal column {} of argument of function {}",
91
0
                                        argument_columns[0]->get_name(), get_name());
92
0
        }
93
94
242
        block.replace_by_position(result, std::move(res));
95
242
        return Status::OK();
96
242
    }
97
98
private:
99
    template <typename ColumnType>
100
    void vector_execute(Block& block, size_t input_rows_count,
101
                        const std::vector<ColumnPtr>& argument_columns,
102
                        const std::vector<uint8_t>& is_const, ColumnString::Chars& res_data,
103
362
                        ColumnString::Offsets& res_offset) const {
104
362
        if constexpr (std::is_same_v<Impl, MD5Sum>) {
105
242
            if (argument_columns.size() == 1) {
106
140
                const auto* col = assert_cast<const ColumnType*>(argument_columns[0].get());
107
140
                vector_execute_single_md5(col, input_rows_count, is_const[0], res_data, res_offset);
108
140
                return;
109
140
            }
110
242
        }
111
112
102
        using ObjectData = typename Impl::ObjectData;
113
719
        for (size_t i = 0; i < input_rows_count; ++i) {
114
357
            ObjectData digest;
115
1.08k
            for (size_t j = 0; j < argument_columns.size(); ++j) {
116
723
                const auto* col = assert_cast<const ColumnType*>(argument_columns[j].get());
117
723
                StringRef data_ref = col->get_data_at(is_const[j] ? 0 : i);
118
723
                if (data_ref.size < 1) {
119
180
                    continue;
120
180
                }
121
543
                digest.update(data_ref.data, data_ref.size);
122
543
            }
123
357
            digest.digest();
124
357
            StringOP::push_value_string(std::string_view(digest.hex().c_str(), digest.hex().size()),
125
357
                                        i, res_data, res_offset);
126
357
        }
127
362
    }
_ZNK5doris25FunctionStringDigestMultiINS_6SM3SumEE14vector_executeINS_9ColumnStrIjEEEEvRNS_5BlockEmRKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrISA_EESaISD_EERKS8_IhSaIhEERNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNSM_IjLm4096ESP_Lm16ELm15EEE
Line
Count
Source
103
78
                        ColumnString::Offsets& res_offset) const {
104
        if constexpr (std::is_same_v<Impl, MD5Sum>) {
105
            if (argument_columns.size() == 1) {
106
                const auto* col = assert_cast<const ColumnType*>(argument_columns[0].get());
107
                vector_execute_single_md5(col, input_rows_count, is_const[0], res_data, res_offset);
108
                return;
109
            }
110
        }
111
112
78
        using ObjectData = typename Impl::ObjectData;
113
245
        for (size_t i = 0; i < input_rows_count; ++i) {
114
167
            ObjectData digest;
115
408
            for (size_t j = 0; j < argument_columns.size(); ++j) {
116
241
                const auto* col = assert_cast<const ColumnType*>(argument_columns[j].get());
117
241
                StringRef data_ref = col->get_data_at(is_const[j] ? 0 : i);
118
241
                if (data_ref.size < 1) {
119
34
                    continue;
120
34
                }
121
207
                digest.update(data_ref.data, data_ref.size);
122
207
            }
123
167
            digest.digest();
124
167
            StringOP::push_value_string(std::string_view(digest.hex().c_str(), digest.hex().size()),
125
167
                                        i, res_data, res_offset);
126
167
        }
127
78
    }
_ZNK5doris25FunctionStringDigestMultiINS_6SM3SumEE14vector_executeINS_15ColumnVarbinaryEEEvRNS_5BlockEmRKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS9_EESaISC_EERKS7_IhSaIhEERNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNSL_IjLm4096ESO_Lm16ELm15EEE
Line
Count
Source
103
42
                        ColumnString::Offsets& res_offset) const {
104
        if constexpr (std::is_same_v<Impl, MD5Sum>) {
105
            if (argument_columns.size() == 1) {
106
                const auto* col = assert_cast<const ColumnType*>(argument_columns[0].get());
107
                vector_execute_single_md5(col, input_rows_count, is_const[0], res_data, res_offset);
108
                return;
109
            }
110
        }
111
112
42
        using ObjectData = typename Impl::ObjectData;
113
105
        for (size_t i = 0; i < input_rows_count; ++i) {
114
63
            ObjectData digest;
115
199
            for (size_t j = 0; j < argument_columns.size(); ++j) {
116
136
                const auto* col = assert_cast<const ColumnType*>(argument_columns[j].get());
117
136
                StringRef data_ref = col->get_data_at(is_const[j] ? 0 : i);
118
136
                if (data_ref.size < 1) {
119
34
                    continue;
120
34
                }
121
102
                digest.update(data_ref.data, data_ref.size);
122
102
            }
123
63
            digest.digest();
124
63
            StringOP::push_value_string(std::string_view(digest.hex().c_str(), digest.hex().size()),
125
63
                                        i, res_data, res_offset);
126
63
        }
127
42
    }
_ZNK5doris25FunctionStringDigestMultiINS_6MD5SumEE14vector_executeINS_9ColumnStrIjEEEEvRNS_5BlockEmRKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrISA_EESaISD_EERKS8_IhSaIhEERNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNSM_IjLm4096ESP_Lm16ELm15EEE
Line
Count
Source
103
153
                        ColumnString::Offsets& res_offset) const {
104
153
        if constexpr (std::is_same_v<Impl, MD5Sum>) {
105
153
            if (argument_columns.size() == 1) {
106
105
                const auto* col = assert_cast<const ColumnType*>(argument_columns[0].get());
107
105
                vector_execute_single_md5(col, input_rows_count, is_const[0], res_data, res_offset);
108
105
                return;
109
105
            }
110
153
        }
111
112
48
        using ObjectData = typename Impl::ObjectData;
113
213
        for (size_t i = 0; i < input_rows_count; ++i) {
114
60
            ObjectData digest;
115
226
            for (size_t j = 0; j < argument_columns.size(); ++j) {
116
166
                const auto* col = assert_cast<const ColumnType*>(argument_columns[j].get());
117
166
                StringRef data_ref = col->get_data_at(is_const[j] ? 0 : i);
118
166
                if (data_ref.size < 1) {
119
54
                    continue;
120
54
                }
121
112
                digest.update(data_ref.data, data_ref.size);
122
112
            }
123
60
            digest.digest();
124
60
            StringOP::push_value_string(std::string_view(digest.hex().c_str(), digest.hex().size()),
125
60
                                        i, res_data, res_offset);
126
60
        }
127
153
    }
_ZNK5doris25FunctionStringDigestMultiINS_6MD5SumEE14vector_executeINS_15ColumnVarbinaryEEEvRNS_5BlockEmRKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS9_EESaISC_EERKS7_IhSaIhEERNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNSL_IjLm4096ESO_Lm16ELm15EEE
Line
Count
Source
103
89
                        ColumnString::Offsets& res_offset) const {
104
89
        if constexpr (std::is_same_v<Impl, MD5Sum>) {
105
89
            if (argument_columns.size() == 1) {
106
35
                const auto* col = assert_cast<const ColumnType*>(argument_columns[0].get());
107
35
                vector_execute_single_md5(col, input_rows_count, is_const[0], res_data, res_offset);
108
35
                return;
109
35
            }
110
89
        }
111
112
54
        using ObjectData = typename Impl::ObjectData;
113
156
        for (size_t i = 0; i < input_rows_count; ++i) {
114
67
            ObjectData digest;
115
247
            for (size_t j = 0; j < argument_columns.size(); ++j) {
116
180
                const auto* col = assert_cast<const ColumnType*>(argument_columns[j].get());
117
180
                StringRef data_ref = col->get_data_at(is_const[j] ? 0 : i);
118
180
                if (data_ref.size < 1) {
119
58
                    continue;
120
58
                }
121
122
                digest.update(data_ref.data, data_ref.size);
122
122
            }
123
67
            digest.digest();
124
67
            StringOP::push_value_string(std::string_view(digest.hex().c_str(), digest.hex().size()),
125
67
                                        i, res_data, res_offset);
126
67
        }
127
89
    }
128
129
    template <typename ColumnType>
130
    void vector_execute_single_md5(const ColumnType* col, size_t input_rows_count, bool is_const,
131
                                   ColumnString::Chars& res_data,
132
140
                                   ColumnString::Offsets& res_offset) const {
133
140
        ColumnString::check_chars_length(input_rows_count * MD5_HEX_LENGTH, input_rows_count);
134
140
        res_data.resize(input_rows_count * MD5_HEX_LENGTH);
135
435
        for (size_t i = 0; i < input_rows_count; ++i) {
136
295
            res_offset[i] = (i + 1) * MD5_HEX_LENGTH;
137
295
        }
138
140
        if (input_rows_count == 0) {
139
0
            return;
140
0
        }
141
142
140
        if (is_const) {
143
0
            StringRef data_ref = col->get_data_at(0);
144
0
            const unsigned char* input = reinterpret_cast<const unsigned char*>(data_ref.data);
145
0
            size_t length = data_ref.size;
146
0
            char digest[MD5_HEX_LENGTH];
147
0
            md5_hex_batch(&input, &length, digest, 1);
148
0
            for (size_t i = 0; i < input_rows_count; ++i) {
149
0
                std::memcpy(res_data.data() + i * MD5_HEX_LENGTH, digest, MD5_HEX_LENGTH);
150
0
            }
151
0
            return;
152
0
        }
153
154
140
        std::vector<const unsigned char*> inputs(input_rows_count);
155
140
        std::vector<size_t> lengths(input_rows_count);
156
435
        for (size_t i = 0; i < input_rows_count; ++i) {
157
295
            StringRef data_ref = col->get_data_at(i);
158
295
            inputs[i] = reinterpret_cast<const unsigned char*>(data_ref.data);
159
295
            lengths[i] = data_ref.size;
160
295
        }
161
140
        md5_hex_batch(inputs.data(), lengths.data(), reinterpret_cast<char*>(res_data.data()),
162
140
                      input_rows_count);
163
140
    }
_ZNK5doris25FunctionStringDigestMultiINS_6MD5SumEE25vector_execute_single_md5INS_9ColumnStrIjEEEEvPKT_mbRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS9_IjLm4096ESC_Lm16ELm15EEE
Line
Count
Source
132
105
                                   ColumnString::Offsets& res_offset) const {
133
105
        ColumnString::check_chars_length(input_rows_count * MD5_HEX_LENGTH, input_rows_count);
134
105
        res_data.resize(input_rows_count * MD5_HEX_LENGTH);
135
332
        for (size_t i = 0; i < input_rows_count; ++i) {
136
227
            res_offset[i] = (i + 1) * MD5_HEX_LENGTH;
137
227
        }
138
105
        if (input_rows_count == 0) {
139
0
            return;
140
0
        }
141
142
105
        if (is_const) {
143
0
            StringRef data_ref = col->get_data_at(0);
144
0
            const unsigned char* input = reinterpret_cast<const unsigned char*>(data_ref.data);
145
0
            size_t length = data_ref.size;
146
0
            char digest[MD5_HEX_LENGTH];
147
0
            md5_hex_batch(&input, &length, digest, 1);
148
0
            for (size_t i = 0; i < input_rows_count; ++i) {
149
0
                std::memcpy(res_data.data() + i * MD5_HEX_LENGTH, digest, MD5_HEX_LENGTH);
150
0
            }
151
0
            return;
152
0
        }
153
154
105
        std::vector<const unsigned char*> inputs(input_rows_count);
155
105
        std::vector<size_t> lengths(input_rows_count);
156
332
        for (size_t i = 0; i < input_rows_count; ++i) {
157
227
            StringRef data_ref = col->get_data_at(i);
158
227
            inputs[i] = reinterpret_cast<const unsigned char*>(data_ref.data);
159
227
            lengths[i] = data_ref.size;
160
227
        }
161
105
        md5_hex_batch(inputs.data(), lengths.data(), reinterpret_cast<char*>(res_data.data()),
162
105
                      input_rows_count);
163
105
    }
_ZNK5doris25FunctionStringDigestMultiINS_6MD5SumEE25vector_execute_single_md5INS_15ColumnVarbinaryEEEvPKT_mbRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS8_IjLm4096ESB_Lm16ELm15EEE
Line
Count
Source
132
35
                                   ColumnString::Offsets& res_offset) const {
133
35
        ColumnString::check_chars_length(input_rows_count * MD5_HEX_LENGTH, input_rows_count);
134
35
        res_data.resize(input_rows_count * MD5_HEX_LENGTH);
135
103
        for (size_t i = 0; i < input_rows_count; ++i) {
136
68
            res_offset[i] = (i + 1) * MD5_HEX_LENGTH;
137
68
        }
138
35
        if (input_rows_count == 0) {
139
0
            return;
140
0
        }
141
142
35
        if (is_const) {
143
0
            StringRef data_ref = col->get_data_at(0);
144
0
            const unsigned char* input = reinterpret_cast<const unsigned char*>(data_ref.data);
145
0
            size_t length = data_ref.size;
146
0
            char digest[MD5_HEX_LENGTH];
147
0
            md5_hex_batch(&input, &length, digest, 1);
148
0
            for (size_t i = 0; i < input_rows_count; ++i) {
149
0
                std::memcpy(res_data.data() + i * MD5_HEX_LENGTH, digest, MD5_HEX_LENGTH);
150
0
            }
151
0
            return;
152
0
        }
153
154
35
        std::vector<const unsigned char*> inputs(input_rows_count);
155
35
        std::vector<size_t> lengths(input_rows_count);
156
103
        for (size_t i = 0; i < input_rows_count; ++i) {
157
68
            StringRef data_ref = col->get_data_at(i);
158
68
            inputs[i] = reinterpret_cast<const unsigned char*>(data_ref.data);
159
68
            lengths[i] = data_ref.size;
160
68
        }
161
35
        md5_hex_batch(inputs.data(), lengths.data(), reinterpret_cast<char*>(res_data.data()),
162
35
                      input_rows_count);
163
35
    }
164
};
165
166
class FunctionStringDigestSHA1 : public IFunction {
167
public:
168
    static constexpr auto name = "sha1";
169
25
    static FunctionPtr create() { return std::make_shared<FunctionStringDigestSHA1>(); }
170
0
    String get_name() const override { return name; }
171
0
    size_t get_number_of_arguments() const override { return 1; }
172
18
    bool is_variadic() const override { return true; }
173
174
17
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
175
17
        return std::make_shared<DataTypeString>();
176
17
    }
177
178
    Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
179
15
                        uint32_t result, size_t input_rows_count) const override {
180
15
        DCHECK_EQ(arguments.size(), 1);
181
15
        ColumnPtr data_col = block.get_by_position(arguments[0]).column;
182
183
15
        auto res_col = ColumnString::create();
184
15
        auto& res_data = res_col->get_chars();
185
15
        auto& res_offset = res_col->get_offsets();
186
15
        res_offset.resize(input_rows_count);
187
15
        if (const auto* str_col = check_and_get_column<ColumnString>(data_col.get())) {
188
10
            vector_execute(str_col, input_rows_count, res_data, res_offset);
189
10
        } else if (const auto* vb_col = check_and_get_column<ColumnVarbinary>(data_col.get())) {
190
6
            vector_execute(vb_col, input_rows_count, res_data, res_offset);
191
18.4E
        } else {
192
18.4E
            return Status::RuntimeError("Illegal column {} of argument of function {}",
193
18.4E
                                        data_col->get_name(), get_name());
194
18.4E
        }
195
196
16
        block.replace_by_position(result, std::move(res_col));
197
16
        return Status::OK();
198
15
    }
199
200
private:
201
    template <typename ColumnType>
202
    void vector_execute(const ColumnType* col, size_t input_rows_count,
203
16
                        ColumnString::Chars& res_data, ColumnString::Offsets& res_offset) const {
204
16
        SHA1Digest digest;
205
49
        for (size_t i = 0; i < input_rows_count; ++i) {
206
33
            StringRef data_ref = col->get_data_at(i);
207
33
            digest.reset(data_ref.data, data_ref.size);
208
33
            std::string_view ans = digest.digest();
209
210
33
            StringOP::push_value_string(ans, i, res_data, res_offset);
211
33
        }
212
16
    }
_ZNK5doris24FunctionStringDigestSHA114vector_executeINS_9ColumnStrIjEEEEvPKT_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS7_IjLm4096ESA_Lm16ELm15EEE
Line
Count
Source
203
10
                        ColumnString::Chars& res_data, ColumnString::Offsets& res_offset) const {
204
10
        SHA1Digest digest;
205
29
        for (size_t i = 0; i < input_rows_count; ++i) {
206
19
            StringRef data_ref = col->get_data_at(i);
207
19
            digest.reset(data_ref.data, data_ref.size);
208
19
            std::string_view ans = digest.digest();
209
210
19
            StringOP::push_value_string(ans, i, res_data, res_offset);
211
19
        }
212
10
    }
_ZNK5doris24FunctionStringDigestSHA114vector_executeINS_15ColumnVarbinaryEEEvPKT_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS6_IjLm4096ES9_Lm16ELm15EEE
Line
Count
Source
203
6
                        ColumnString::Chars& res_data, ColumnString::Offsets& res_offset) const {
204
6
        SHA1Digest digest;
205
20
        for (size_t i = 0; i < input_rows_count; ++i) {
206
14
            StringRef data_ref = col->get_data_at(i);
207
14
            digest.reset(data_ref.data, data_ref.size);
208
14
            std::string_view ans = digest.digest();
209
210
14
            StringOP::push_value_string(ans, i, res_data, res_offset);
211
14
        }
212
6
    }
213
};
214
215
class FunctionStringDigestSHA2 : public IFunction {
216
public:
217
    static constexpr auto name = "sha2";
218
21
    static FunctionPtr create() { return std::make_shared<FunctionStringDigestSHA2>(); }
219
0
    String get_name() const override { return name; }
220
0
    size_t get_number_of_arguments() const override { return 2; }
221
14
    bool is_variadic() const override { return true; }
222
223
13
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
224
13
        return std::make_shared<DataTypeString>();
225
13
    }
226
227
    Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
228
14
                        uint32_t result, size_t input_rows_count) const override {
229
14
        DCHECK(!is_column_const(*block.get_by_position(arguments[0]).column));
230
231
14
        ColumnPtr data_col = block.get_by_position(arguments[0]).column;
232
233
14
        [[maybe_unused]] const auto& [right_column, right_const] =
234
14
                unpack_if_const(block.get_by_position(arguments[1]).column);
235
14
        auto digest_length = assert_cast<const ColumnInt32*>(right_column.get())->get_data()[0];
236
237
14
        auto res_col = ColumnString::create();
238
14
        auto& res_data = res_col->get_chars();
239
14
        auto& res_offset = res_col->get_offsets();
240
14
        res_offset.resize(input_rows_count);
241
242
14
        if (digest_length == 224) {
243
3
            execute_base<SHA224Digest>(data_col, input_rows_count, res_data, res_offset);
244
11
        } else if (digest_length == 256) {
245
4
            execute_base<SHA256Digest>(data_col, input_rows_count, res_data, res_offset);
246
7
        } else if (digest_length == 384) {
247
3
            execute_base<SHA384Digest>(data_col, input_rows_count, res_data, res_offset);
248
4
        } else if (digest_length == 512) {
249
4
            execute_base<SHA512Digest>(data_col, input_rows_count, res_data, res_offset);
250
4
        } else {
251
0
            return Status::InvalidArgument(
252
0
                    "sha2's digest length only support 224/256/384/512 but meet {}", digest_length);
253
0
        }
254
255
14
        block.replace_by_position(result, std::move(res_col));
256
14
        return Status::OK();
257
14
    }
258
259
private:
260
    template <typename T>
261
    void execute_base(ColumnPtr data_col, int input_rows_count, ColumnString::Chars& res_data,
262
14
                      ColumnString::Offsets& res_offset) const {
263
14
        if (const auto* str_col = check_and_get_column<ColumnString>(data_col.get())) {
264
14
            vector_execute<T>(str_col, input_rows_count, res_data, res_offset);
265
14
        } else if (const auto* vb_col = check_and_get_column<ColumnVarbinary>(data_col.get())) {
266
0
            vector_execute<T>(vb_col, input_rows_count, res_data, res_offset);
267
0
        } else {
268
0
            throw Exception(ErrorCode::RUNTIME_ERROR,
269
0
                            "Illegal column {} of argument of function {}", data_col->get_name(),
270
0
                            get_name());
271
0
        }
272
14
    }
_ZNK5doris24FunctionStringDigestSHA212execute_baseINS_12SHA224DigestEEEvNS_3COWINS_7IColumnEE13immutable_ptrIS4_EEiRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS8_IjLm4096ESB_Lm16ELm15EEE
Line
Count
Source
262
3
                      ColumnString::Offsets& res_offset) const {
263
3
        if (const auto* str_col = check_and_get_column<ColumnString>(data_col.get())) {
264
3
            vector_execute<T>(str_col, input_rows_count, res_data, res_offset);
265
3
        } else if (const auto* vb_col = check_and_get_column<ColumnVarbinary>(data_col.get())) {
266
0
            vector_execute<T>(vb_col, input_rows_count, res_data, res_offset);
267
0
        } else {
268
0
            throw Exception(ErrorCode::RUNTIME_ERROR,
269
0
                            "Illegal column {} of argument of function {}", data_col->get_name(),
270
0
                            get_name());
271
0
        }
272
3
    }
_ZNK5doris24FunctionStringDigestSHA212execute_baseINS_12SHA256DigestEEEvNS_3COWINS_7IColumnEE13immutable_ptrIS4_EEiRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS8_IjLm4096ESB_Lm16ELm15EEE
Line
Count
Source
262
4
                      ColumnString::Offsets& res_offset) const {
263
4
        if (const auto* str_col = check_and_get_column<ColumnString>(data_col.get())) {
264
4
            vector_execute<T>(str_col, input_rows_count, res_data, res_offset);
265
4
        } else if (const auto* vb_col = check_and_get_column<ColumnVarbinary>(data_col.get())) {
266
0
            vector_execute<T>(vb_col, input_rows_count, res_data, res_offset);
267
0
        } else {
268
0
            throw Exception(ErrorCode::RUNTIME_ERROR,
269
0
                            "Illegal column {} of argument of function {}", data_col->get_name(),
270
0
                            get_name());
271
0
        }
272
4
    }
_ZNK5doris24FunctionStringDigestSHA212execute_baseINS_12SHA384DigestEEEvNS_3COWINS_7IColumnEE13immutable_ptrIS4_EEiRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS8_IjLm4096ESB_Lm16ELm15EEE
Line
Count
Source
262
3
                      ColumnString::Offsets& res_offset) const {
263
3
        if (const auto* str_col = check_and_get_column<ColumnString>(data_col.get())) {
264
3
            vector_execute<T>(str_col, input_rows_count, res_data, res_offset);
265
3
        } else if (const auto* vb_col = check_and_get_column<ColumnVarbinary>(data_col.get())) {
266
0
            vector_execute<T>(vb_col, input_rows_count, res_data, res_offset);
267
0
        } else {
268
0
            throw Exception(ErrorCode::RUNTIME_ERROR,
269
0
                            "Illegal column {} of argument of function {}", data_col->get_name(),
270
0
                            get_name());
271
0
        }
272
3
    }
_ZNK5doris24FunctionStringDigestSHA212execute_baseINS_12SHA512DigestEEEvNS_3COWINS_7IColumnEE13immutable_ptrIS4_EEiRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS8_IjLm4096ESB_Lm16ELm15EEE
Line
Count
Source
262
4
                      ColumnString::Offsets& res_offset) const {
263
4
        if (const auto* str_col = check_and_get_column<ColumnString>(data_col.get())) {
264
4
            vector_execute<T>(str_col, input_rows_count, res_data, res_offset);
265
4
        } else if (const auto* vb_col = check_and_get_column<ColumnVarbinary>(data_col.get())) {
266
0
            vector_execute<T>(vb_col, input_rows_count, res_data, res_offset);
267
0
        } else {
268
0
            throw Exception(ErrorCode::RUNTIME_ERROR,
269
0
                            "Illegal column {} of argument of function {}", data_col->get_name(),
270
0
                            get_name());
271
0
        }
272
4
    }
273
274
    template <typename DigestType, typename ColumnType>
275
    void vector_execute(const ColumnType* col, size_t input_rows_count,
276
14
                        ColumnString::Chars& res_data, ColumnString::Offsets& res_offset) const {
277
14
        DigestType digest;
278
62
        for (size_t i = 0; i < input_rows_count; ++i) {
279
48
            StringRef data_ref = col->get_data_at(i);
280
48
            digest.reset(data_ref.data, data_ref.size);
281
48
            std::string_view ans = digest.digest();
282
283
48
            StringOP::push_value_string(ans, i, res_data, res_offset);
284
48
        }
285
14
    }
_ZNK5doris24FunctionStringDigestSHA214vector_executeINS_12SHA224DigestENS_9ColumnStrIjEEEEvPKT0_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS8_IjLm4096ESB_Lm16ELm15EEE
Line
Count
Source
276
3
                        ColumnString::Chars& res_data, ColumnString::Offsets& res_offset) const {
277
3
        DigestType digest;
278
14
        for (size_t i = 0; i < input_rows_count; ++i) {
279
11
            StringRef data_ref = col->get_data_at(i);
280
11
            digest.reset(data_ref.data, data_ref.size);
281
11
            std::string_view ans = digest.digest();
282
283
11
            StringOP::push_value_string(ans, i, res_data, res_offset);
284
11
        }
285
3
    }
Unexecuted instantiation: _ZNK5doris24FunctionStringDigestSHA214vector_executeINS_12SHA224DigestENS_15ColumnVarbinaryEEEvPKT0_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS7_IjLm4096ESA_Lm16ELm15EEE
_ZNK5doris24FunctionStringDigestSHA214vector_executeINS_12SHA256DigestENS_9ColumnStrIjEEEEvPKT0_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS8_IjLm4096ESB_Lm16ELm15EEE
Line
Count
Source
276
4
                        ColumnString::Chars& res_data, ColumnString::Offsets& res_offset) const {
277
4
        DigestType digest;
278
17
        for (size_t i = 0; i < input_rows_count; ++i) {
279
13
            StringRef data_ref = col->get_data_at(i);
280
13
            digest.reset(data_ref.data, data_ref.size);
281
13
            std::string_view ans = digest.digest();
282
283
13
            StringOP::push_value_string(ans, i, res_data, res_offset);
284
13
        }
285
4
    }
Unexecuted instantiation: _ZNK5doris24FunctionStringDigestSHA214vector_executeINS_12SHA256DigestENS_15ColumnVarbinaryEEEvPKT0_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS7_IjLm4096ESA_Lm16ELm15EEE
_ZNK5doris24FunctionStringDigestSHA214vector_executeINS_12SHA384DigestENS_9ColumnStrIjEEEEvPKT0_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS8_IjLm4096ESB_Lm16ELm15EEE
Line
Count
Source
276
3
                        ColumnString::Chars& res_data, ColumnString::Offsets& res_offset) const {
277
3
        DigestType digest;
278
14
        for (size_t i = 0; i < input_rows_count; ++i) {
279
11
            StringRef data_ref = col->get_data_at(i);
280
11
            digest.reset(data_ref.data, data_ref.size);
281
11
            std::string_view ans = digest.digest();
282
283
11
            StringOP::push_value_string(ans, i, res_data, res_offset);
284
11
        }
285
3
    }
Unexecuted instantiation: _ZNK5doris24FunctionStringDigestSHA214vector_executeINS_12SHA384DigestENS_15ColumnVarbinaryEEEvPKT0_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS7_IjLm4096ESA_Lm16ELm15EEE
_ZNK5doris24FunctionStringDigestSHA214vector_executeINS_12SHA512DigestENS_9ColumnStrIjEEEEvPKT0_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS8_IjLm4096ESB_Lm16ELm15EEE
Line
Count
Source
276
4
                        ColumnString::Chars& res_data, ColumnString::Offsets& res_offset) const {
277
4
        DigestType digest;
278
17
        for (size_t i = 0; i < input_rows_count; ++i) {
279
13
            StringRef data_ref = col->get_data_at(i);
280
13
            digest.reset(data_ref.data, data_ref.size);
281
13
            std::string_view ans = digest.digest();
282
283
13
            StringOP::push_value_string(ans, i, res_data, res_offset);
284
13
        }
285
4
    }
Unexecuted instantiation: _ZNK5doris24FunctionStringDigestSHA214vector_executeINS_12SHA512DigestENS_15ColumnVarbinaryEEEvPKT0_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS7_IjLm4096ESA_Lm16ELm15EEE
286
};
287
288
7
void register_function_string_digest(SimpleFunctionFactory& factory) {
289
7
    factory.register_function<FunctionStringDigestMulti<SM3Sum>>();
290
7
    factory.register_function<FunctionStringDigestMulti<MD5Sum>>();
291
7
    factory.register_function<FunctionStringDigestSHA1>();
292
7
    factory.register_function<FunctionStringDigestSHA2>();
293
294
7
    factory.register_alias(FunctionStringDigestMulti<MD5Sum>::name, "md5");
295
7
    factory.register_alias(FunctionStringDigestMulti<SM3Sum>::name, "sm3");
296
7
    factory.register_alias(FunctionStringDigestSHA1::name, "sha");
297
7
}
298
299
#include "common/compile_check_avoid_end.h"
300
} // namespace doris