Coverage Report

Created: 2026-05-29 11:21

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/exprs/function/function_encryption.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 <algorithm>
19
#include <cstddef>
20
#include <cstdint>
21
#include <memory>
22
#include <string>
23
#include <string_view>
24
#include <utility>
25
#include <vector>
26
27
#include "common/cast_set.h"
28
#include "common/status.h"
29
#include "core/assert_cast.h"
30
#include "core/block/block.h"
31
#include "core/column/column.h"
32
#include "core/column/column_nullable.h"
33
#include "core/column/column_string.h"
34
#include "core/column/column_vector.h"
35
#include "core/data_type/data_type.h"
36
#include "core/data_type/data_type_nullable.h"
37
#include "core/data_type/data_type_string.h"
38
#include "core/string_ref.h"
39
#include "exec/common/stringop_substring.h"
40
#include "exec/common/util.hpp"
41
#include "exprs/function/function.h"
42
#include "exprs/function/simple_function_factory.h"
43
#include "util/encryption_util.h"
44
45
namespace doris {
46
class FunctionContext;
47
} // namespace doris
48
49
namespace doris {
50
51
inline StringCaseUnorderedMap<EncryptionMode> aes_mode_map {
52
        {"AES_128_ECB", EncryptionMode::AES_128_ECB},
53
        {"AES_192_ECB", EncryptionMode::AES_192_ECB},
54
        {"AES_256_ECB", EncryptionMode::AES_256_ECB},
55
        {"AES_128_CBC", EncryptionMode::AES_128_CBC},
56
        {"AES_192_CBC", EncryptionMode::AES_192_CBC},
57
        {"AES_256_CBC", EncryptionMode::AES_256_CBC},
58
        {"AES_128_CFB", EncryptionMode::AES_128_CFB},
59
        {"AES_192_CFB", EncryptionMode::AES_192_CFB},
60
        {"AES_256_CFB", EncryptionMode::AES_256_CFB},
61
        {"AES_128_CFB1", EncryptionMode::AES_128_CFB1},
62
        {"AES_192_CFB1", EncryptionMode::AES_192_CFB1},
63
        {"AES_256_CFB1", EncryptionMode::AES_256_CFB1},
64
        {"AES_128_CFB8", EncryptionMode::AES_128_CFB8},
65
        {"AES_192_CFB8", EncryptionMode::AES_192_CFB8},
66
        {"AES_256_CFB8", EncryptionMode::AES_256_CFB8},
67
        {"AES_128_CFB128", EncryptionMode::AES_128_CFB128},
68
        {"AES_192_CFB128", EncryptionMode::AES_192_CFB128},
69
        {"AES_256_CFB128", EncryptionMode::AES_256_CFB128},
70
        {"AES_128_CTR", EncryptionMode::AES_128_CTR},
71
        {"AES_192_CTR", EncryptionMode::AES_192_CTR},
72
        {"AES_256_CTR", EncryptionMode::AES_256_CTR},
73
        {"AES_128_OFB", EncryptionMode::AES_128_OFB},
74
        {"AES_192_OFB", EncryptionMode::AES_192_OFB},
75
        {"AES_256_OFB", EncryptionMode::AES_256_OFB},
76
        {"AES_128_GCM", EncryptionMode::AES_128_GCM},
77
        {"AES_192_GCM", EncryptionMode::AES_192_GCM},
78
        {"AES_256_GCM", EncryptionMode::AES_256_GCM}};
79
inline StringCaseUnorderedMap<EncryptionMode> sm4_mode_map {
80
        {"SM4_128_ECB", EncryptionMode::SM4_128_ECB},
81
        {"SM4_128_CBC", EncryptionMode::SM4_128_CBC},
82
        {"SM4_128_CFB128", EncryptionMode::SM4_128_CFB128},
83
        {"SM4_128_OFB", EncryptionMode::SM4_128_OFB},
84
        {"SM4_128_CTR", EncryptionMode::SM4_128_CTR}};
85
template <typename Impl, typename FunctionName>
86
class FunctionEncryptionAndDecrypt : public IFunction {
87
public:
88
    static constexpr auto name = FunctionName::name;
89
90
10
    String get_name() const override { return name; }
_ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1EEENS_14SM4EncryptNameEE8get_nameB5cxx11Ev
Line
Count
Source
90
1
    String get_name() const override { return name; }
_ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0EEENS_14SM4DecryptNameEE8get_nameB5cxx11Ev
Line
Count
Source
90
1
    String get_name() const override { return name; }
_ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1EEENS_14AESEncryptNameEE8get_nameB5cxx11Ev
Line
Count
Source
90
1
    String get_name() const override { return name; }
_ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0EEENS_14AESDecryptNameEE8get_nameB5cxx11Ev
Line
Count
Source
90
1
    String get_name() const override { return name; }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1ELb1ELi4EEENS_14SM4EncryptNameEE8get_nameB5cxx11Ev
Line
Count
Source
90
1
    String get_name() const override { return name; }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0ELb1ELi4EEENS_14SM4DecryptNameEE8get_nameB5cxx11Ev
Line
Count
Source
90
1
    String get_name() const override { return name; }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1ELb0ELi4EEENS_14AESEncryptNameEE8get_nameB5cxx11Ev
Line
Count
Source
90
1
    String get_name() const override { return name; }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0ELb0ELi4EEENS_14AESDecryptNameEE8get_nameB5cxx11Ev
Line
Count
Source
90
1
    String get_name() const override { return name; }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE24ELb1ELb0ELi5EEENS_14AESEncryptNameEE8get_nameB5cxx11Ev
Line
Count
Source
90
1
    String get_name() const override { return name; }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE24ELb0ELb0ELi5EEENS_14AESDecryptNameEE8get_nameB5cxx11Ev
Line
Count
Source
90
1
    String get_name() const override { return name; }
91
92
946
    static FunctionPtr create() { return std::make_shared<FunctionEncryptionAndDecrypt>(); }
_ZN5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1EEENS_14SM4EncryptNameEE6createEv
Line
Count
Source
92
9
    static FunctionPtr create() { return std::make_shared<FunctionEncryptionAndDecrypt>(); }
_ZN5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0EEENS_14SM4DecryptNameEE6createEv
Line
Count
Source
92
9
    static FunctionPtr create() { return std::make_shared<FunctionEncryptionAndDecrypt>(); }
_ZN5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1EEENS_14AESEncryptNameEE6createEv
Line
Count
Source
92
59
    static FunctionPtr create() { return std::make_shared<FunctionEncryptionAndDecrypt>(); }
_ZN5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0EEENS_14AESDecryptNameEE6createEv
Line
Count
Source
92
52
    static FunctionPtr create() { return std::make_shared<FunctionEncryptionAndDecrypt>(); }
_ZN5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1ELb1ELi4EEENS_14SM4EncryptNameEE6createEv
Line
Count
Source
92
259
    static FunctionPtr create() { return std::make_shared<FunctionEncryptionAndDecrypt>(); }
_ZN5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0ELb1ELi4EEENS_14SM4DecryptNameEE6createEv
Line
Count
Source
92
230
    static FunctionPtr create() { return std::make_shared<FunctionEncryptionAndDecrypt>(); }
_ZN5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1ELb0ELi4EEENS_14AESEncryptNameEE6createEv
Line
Count
Source
92
160
    static FunctionPtr create() { return std::make_shared<FunctionEncryptionAndDecrypt>(); }
_ZN5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0ELb0ELi4EEENS_14AESDecryptNameEE6createEv
Line
Count
Source
92
142
    static FunctionPtr create() { return std::make_shared<FunctionEncryptionAndDecrypt>(); }
_ZN5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE24ELb1ELb0ELi5EEENS_14AESEncryptNameEE6createEv
Line
Count
Source
92
13
    static FunctionPtr create() { return std::make_shared<FunctionEncryptionAndDecrypt>(); }
_ZN5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE24ELb0ELb0ELi5EEENS_14AESDecryptNameEE6createEv
Line
Count
Source
92
13
    static FunctionPtr create() { return std::make_shared<FunctionEncryptionAndDecrypt>(); }
93
94
856
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
95
856
        return make_nullable(std::make_shared<DataTypeString>());
96
856
    }
Unexecuted instantiation: _ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1EEENS_14SM4EncryptNameEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaISB_EE
Unexecuted instantiation: _ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0EEENS_14SM4DecryptNameEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaISB_EE
_ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1EEENS_14AESEncryptNameEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaISB_EE
Line
Count
Source
94
50
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
95
50
        return make_nullable(std::make_shared<DataTypeString>());
96
50
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0EEENS_14AESDecryptNameEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaISB_EE
Line
Count
Source
94
43
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
95
43
        return make_nullable(std::make_shared<DataTypeString>());
96
43
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1ELb1ELi4EEENS_14SM4EncryptNameEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaISB_EE
Line
Count
Source
94
250
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
95
250
        return make_nullable(std::make_shared<DataTypeString>());
96
250
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0ELb1ELi4EEENS_14SM4DecryptNameEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaISB_EE
Line
Count
Source
94
221
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
95
221
        return make_nullable(std::make_shared<DataTypeString>());
96
221
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1ELb0ELi4EEENS_14AESEncryptNameEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaISB_EE
Line
Count
Source
94
151
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
95
151
        return make_nullable(std::make_shared<DataTypeString>());
96
151
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0ELb0ELi4EEENS_14AESDecryptNameEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaISB_EE
Line
Count
Source
94
133
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
95
133
        return make_nullable(std::make_shared<DataTypeString>());
96
133
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE24ELb1ELb0ELi5EEENS_14AESEncryptNameEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaISB_EE
Line
Count
Source
94
4
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
95
4
        return make_nullable(std::make_shared<DataTypeString>());
96
4
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE24ELb0ELb0ELi5EEENS_14AESDecryptNameEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaISB_EE
Line
Count
Source
94
4
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
95
4
        return make_nullable(std::make_shared<DataTypeString>());
96
4
    }
97
98
936
    DataTypes get_variadic_argument_types_impl() const override {
99
936
        return Impl::get_variadic_argument_types_impl();
100
936
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1EEENS_14SM4EncryptNameEE32get_variadic_argument_types_implEv
Line
Count
Source
98
8
    DataTypes get_variadic_argument_types_impl() const override {
99
8
        return Impl::get_variadic_argument_types_impl();
100
8
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0EEENS_14SM4DecryptNameEE32get_variadic_argument_types_implEv
Line
Count
Source
98
8
    DataTypes get_variadic_argument_types_impl() const override {
99
8
        return Impl::get_variadic_argument_types_impl();
100
8
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1EEENS_14AESEncryptNameEE32get_variadic_argument_types_implEv
Line
Count
Source
98
58
    DataTypes get_variadic_argument_types_impl() const override {
99
58
        return Impl::get_variadic_argument_types_impl();
100
58
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0EEENS_14AESDecryptNameEE32get_variadic_argument_types_implEv
Line
Count
Source
98
51
    DataTypes get_variadic_argument_types_impl() const override {
99
51
        return Impl::get_variadic_argument_types_impl();
100
51
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1ELb1ELi4EEENS_14SM4EncryptNameEE32get_variadic_argument_types_implEv
Line
Count
Source
98
258
    DataTypes get_variadic_argument_types_impl() const override {
99
258
        return Impl::get_variadic_argument_types_impl();
100
258
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0ELb1ELi4EEENS_14SM4DecryptNameEE32get_variadic_argument_types_implEv
Line
Count
Source
98
229
    DataTypes get_variadic_argument_types_impl() const override {
99
229
        return Impl::get_variadic_argument_types_impl();
100
229
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1ELb0ELi4EEENS_14AESEncryptNameEE32get_variadic_argument_types_implEv
Line
Count
Source
98
159
    DataTypes get_variadic_argument_types_impl() const override {
99
159
        return Impl::get_variadic_argument_types_impl();
100
159
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0ELb0ELi4EEENS_14AESDecryptNameEE32get_variadic_argument_types_implEv
Line
Count
Source
98
141
    DataTypes get_variadic_argument_types_impl() const override {
99
141
        return Impl::get_variadic_argument_types_impl();
100
141
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE24ELb1ELb0ELi5EEENS_14AESEncryptNameEE32get_variadic_argument_types_implEv
Line
Count
Source
98
12
    DataTypes get_variadic_argument_types_impl() const override {
99
12
        return Impl::get_variadic_argument_types_impl();
100
12
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE24ELb0ELb0ELi5EEENS_14AESDecryptNameEE32get_variadic_argument_types_implEv
Line
Count
Source
98
12
    DataTypes get_variadic_argument_types_impl() const override {
99
12
        return Impl::get_variadic_argument_types_impl();
100
12
    }
101
102
856
    size_t get_number_of_arguments() const override {
103
856
        return get_variadic_argument_types_impl().size();
104
856
    }
Unexecuted instantiation: _ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1EEENS_14SM4EncryptNameEE23get_number_of_argumentsEv
Unexecuted instantiation: _ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0EEENS_14SM4DecryptNameEE23get_number_of_argumentsEv
_ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1EEENS_14AESEncryptNameEE23get_number_of_argumentsEv
Line
Count
Source
102
50
    size_t get_number_of_arguments() const override {
103
50
        return get_variadic_argument_types_impl().size();
104
50
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0EEENS_14AESDecryptNameEE23get_number_of_argumentsEv
Line
Count
Source
102
43
    size_t get_number_of_arguments() const override {
103
43
        return get_variadic_argument_types_impl().size();
104
43
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1ELb1ELi4EEENS_14SM4EncryptNameEE23get_number_of_argumentsEv
Line
Count
Source
102
250
    size_t get_number_of_arguments() const override {
103
250
        return get_variadic_argument_types_impl().size();
104
250
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0ELb1ELi4EEENS_14SM4DecryptNameEE23get_number_of_argumentsEv
Line
Count
Source
102
221
    size_t get_number_of_arguments() const override {
103
221
        return get_variadic_argument_types_impl().size();
104
221
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1ELb0ELi4EEENS_14AESEncryptNameEE23get_number_of_argumentsEv
Line
Count
Source
102
151
    size_t get_number_of_arguments() const override {
103
151
        return get_variadic_argument_types_impl().size();
104
151
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0ELb0ELi4EEENS_14AESDecryptNameEE23get_number_of_argumentsEv
Line
Count
Source
102
133
    size_t get_number_of_arguments() const override {
103
133
        return get_variadic_argument_types_impl().size();
104
133
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE24ELb1ELb0ELi5EEENS_14AESEncryptNameEE23get_number_of_argumentsEv
Line
Count
Source
102
4
    size_t get_number_of_arguments() const override {
103
4
        return get_variadic_argument_types_impl().size();
104
4
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE24ELb0ELb0ELi5EEENS_14AESDecryptNameEE23get_number_of_argumentsEv
Line
Count
Source
102
4
    size_t get_number_of_arguments() const override {
103
4
        return get_variadic_argument_types_impl().size();
104
4
    }
105
106
    Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
107
752
                        uint32_t result, size_t input_rows_count) const override {
108
752
        return Impl::execute_impl_inner(context, block, arguments, result, input_rows_count);
109
752
    }
Unexecuted instantiation: _ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1EEENS_14SM4EncryptNameEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Unexecuted instantiation: _ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0EEENS_14SM4DecryptNameEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
_ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1EEENS_14AESEncryptNameEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
107
43
                        uint32_t result, size_t input_rows_count) const override {
108
43
        return Impl::execute_impl_inner(context, block, arguments, result, input_rows_count);
109
43
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0EEENS_14AESDecryptNameEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
107
36
                        uint32_t result, size_t input_rows_count) const override {
108
36
        return Impl::execute_impl_inner(context, block, arguments, result, input_rows_count);
109
36
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1ELb1ELi4EEENS_14SM4EncryptNameEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
107
220
                        uint32_t result, size_t input_rows_count) const override {
108
220
        return Impl::execute_impl_inner(context, block, arguments, result, input_rows_count);
109
220
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0ELb1ELi4EEENS_14SM4DecryptNameEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
107
191
                        uint32_t result, size_t input_rows_count) const override {
108
191
        return Impl::execute_impl_inner(context, block, arguments, result, input_rows_count);
109
191
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1ELb0ELi4EEENS_14AESEncryptNameEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
107
136
                        uint32_t result, size_t input_rows_count) const override {
108
136
        return Impl::execute_impl_inner(context, block, arguments, result, input_rows_count);
109
136
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0ELb0ELi4EEENS_14AESDecryptNameEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
107
118
                        uint32_t result, size_t input_rows_count) const override {
108
118
        return Impl::execute_impl_inner(context, block, arguments, result, input_rows_count);
109
118
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE24ELb1ELb0ELi5EEENS_14AESEncryptNameEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
107
4
                        uint32_t result, size_t input_rows_count) const override {
108
4
        return Impl::execute_impl_inner(context, block, arguments, result, input_rows_count);
109
4
    }
_ZNK5doris28FunctionEncryptionAndDecryptINS_29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE24ELb0ELb0ELi5EEENS_14AESDecryptNameEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
107
4
                        uint32_t result, size_t input_rows_count) const override {
108
4
        return Impl::execute_impl_inner(context, block, arguments, result, input_rows_count);
109
4
    }
110
};
111
112
template <typename Impl, bool is_encrypt>
113
void execute_result_vector(std::vector<const ColumnString::Offsets*>& offsets_list,
114
                           std::vector<const ColumnString::Chars*>& chars_list, size_t i,
115
                           EncryptionMode& encryption_mode, const char* iv_raw, int iv_length,
116
                           ColumnString::Chars& result_data, ColumnString::Offsets& result_offset,
117
726
                           NullMap& null_map, const char* aad, int aad_length) {
118
726
    int src_size = (*offsets_list[0])[i] - (*offsets_list[0])[i - 1];
119
726
    const auto* src_raw =
120
726
            reinterpret_cast<const char*>(&(*chars_list[0])[(*offsets_list[0])[i - 1]]);
121
726
    int key_size = (*offsets_list[1])[i] - (*offsets_list[1])[i - 1];
122
726
    const auto* key_raw =
123
726
            reinterpret_cast<const char*>(&(*chars_list[1])[(*offsets_list[1])[i - 1]]);
124
726
    execute_result<Impl, is_encrypt>(src_raw, src_size, key_raw, key_size, i, encryption_mode,
125
726
                                     iv_raw, iv_length, result_data, result_offset, null_map, aad,
126
726
                                     aad_length);
127
726
}
_ZN5doris21execute_result_vectorINS_11EncryptImplELb1EEEvRSt6vectorIPKNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESaIS9_EERS2_IPKNS3_IhLm4096ES6_Lm16ELm15EEESaISF_EEmRNS_14EncryptionModeEPKciRSD_RS7_SN_SM_i
Line
Count
Source
117
389
                           NullMap& null_map, const char* aad, int aad_length) {
118
389
    int src_size = (*offsets_list[0])[i] - (*offsets_list[0])[i - 1];
119
389
    const auto* src_raw =
120
389
            reinterpret_cast<const char*>(&(*chars_list[0])[(*offsets_list[0])[i - 1]]);
121
389
    int key_size = (*offsets_list[1])[i] - (*offsets_list[1])[i - 1];
122
389
    const auto* key_raw =
123
389
            reinterpret_cast<const char*>(&(*chars_list[1])[(*offsets_list[1])[i - 1]]);
124
389
    execute_result<Impl, is_encrypt>(src_raw, src_size, key_raw, key_size, i, encryption_mode,
125
389
                                     iv_raw, iv_length, result_data, result_offset, null_map, aad,
126
389
                                     aad_length);
127
389
}
_ZN5doris21execute_result_vectorINS_11DecryptImplELb0EEEvRSt6vectorIPKNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESaIS9_EERS2_IPKNS3_IhLm4096ES6_Lm16ELm15EEESaISF_EEmRNS_14EncryptionModeEPKciRSD_RS7_SN_SM_i
Line
Count
Source
117
337
                           NullMap& null_map, const char* aad, int aad_length) {
118
337
    int src_size = (*offsets_list[0])[i] - (*offsets_list[0])[i - 1];
119
337
    const auto* src_raw =
120
337
            reinterpret_cast<const char*>(&(*chars_list[0])[(*offsets_list[0])[i - 1]]);
121
337
    int key_size = (*offsets_list[1])[i] - (*offsets_list[1])[i - 1];
122
337
    const auto* key_raw =
123
337
            reinterpret_cast<const char*>(&(*chars_list[1])[(*offsets_list[1])[i - 1]]);
124
337
    execute_result<Impl, is_encrypt>(src_raw, src_size, key_raw, key_size, i, encryption_mode,
125
337
                                     iv_raw, iv_length, result_data, result_offset, null_map, aad,
126
337
                                     aad_length);
127
337
}
128
129
template <typename Impl, bool is_encrypt>
130
void execute_result_const(const ColumnString::Offsets* offsets_column,
131
                          const ColumnString::Chars* chars_column, StringRef key_arg, size_t i,
132
                          EncryptionMode& encryption_mode, const char* iv_raw, size_t iv_length,
133
                          ColumnString::Chars& result_data, ColumnString::Offsets& result_offset,
134
71
                          NullMap& null_map, const char* aad, size_t aad_length) {
135
71
    int src_size = (*offsets_column)[i] - (*offsets_column)[i - 1];
136
71
    const auto* src_raw = reinterpret_cast<const char*>(&(*chars_column)[(*offsets_column)[i - 1]]);
137
71
    execute_result<Impl, is_encrypt>(src_raw, src_size, key_arg.data, key_arg.size, i,
138
71
                                     encryption_mode, iv_raw, iv_length, result_data, result_offset,
139
71
                                     null_map, aad, aad_length);
140
71
}
_ZN5doris20execute_result_constINS_11EncryptImplELb1EEEvPKNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEEPKNS2_IhLm4096ES5_Lm16ELm15EEENS_9StringRefEmRNS_14EncryptionModeEPKcmRS9_RS6_SH_SG_m
Line
Count
Source
134
39
                          NullMap& null_map, const char* aad, size_t aad_length) {
135
39
    int src_size = (*offsets_column)[i] - (*offsets_column)[i - 1];
136
39
    const auto* src_raw = reinterpret_cast<const char*>(&(*chars_column)[(*offsets_column)[i - 1]]);
137
39
    execute_result<Impl, is_encrypt>(src_raw, src_size, key_arg.data, key_arg.size, i,
138
39
                                     encryption_mode, iv_raw, iv_length, result_data, result_offset,
139
39
                                     null_map, aad, aad_length);
140
39
}
_ZN5doris20execute_result_constINS_11DecryptImplELb0EEEvPKNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEEPKNS2_IhLm4096ES5_Lm16ELm15EEENS_9StringRefEmRNS_14EncryptionModeEPKcmRS9_RS6_SH_SG_m
Line
Count
Source
134
32
                          NullMap& null_map, const char* aad, size_t aad_length) {
135
32
    int src_size = (*offsets_column)[i] - (*offsets_column)[i - 1];
136
32
    const auto* src_raw = reinterpret_cast<const char*>(&(*chars_column)[(*offsets_column)[i - 1]]);
137
32
    execute_result<Impl, is_encrypt>(src_raw, src_size, key_arg.data, key_arg.size, i,
138
32
                                     encryption_mode, iv_raw, iv_length, result_data, result_offset,
139
32
                                     null_map, aad, aad_length);
140
32
}
141
142
template <typename Impl, bool is_encrypt>
143
void execute_result(const char* src_raw, size_t src_size, const char* key_raw, size_t key_size,
144
                    size_t i, EncryptionMode& encryption_mode, const char* iv_raw, size_t iv_length,
145
                    ColumnString::Chars& result_data, ColumnString::Offsets& result_offset,
146
797
                    NullMap& null_map, const char* aad, size_t aad_length) {
147
797
    auto cipher_len = src_size;
148
797
    if constexpr (is_encrypt) {
149
428
        cipher_len += 16;
150
        // for output AEAD tag
151
428
        if (EncryptionUtil::is_gcm_mode(encryption_mode)) {
152
5
            cipher_len += EncryptionUtil::GCM_TAG_SIZE;
153
5
        }
154
428
    }
155
797
    std::unique_ptr<char[]> p;
156
797
    p.reset(new char[cipher_len]);
157
797
    int ret_code = 0;
158
159
797
    ret_code = Impl::execute_impl(encryption_mode, (unsigned char*)src_raw, src_size,
160
797
                                  (unsigned char*)key_raw, key_size, iv_raw, iv_length, true,
161
797
                                  (unsigned char*)p.get(), (unsigned char*)aad, aad_length);
162
163
797
    if (ret_code < 0) {
164
8
        StringOP::push_null_string(i, result_data, result_offset, null_map);
165
789
    } else {
166
789
        StringOP::push_value_string(std::string_view(p.get(), ret_code), i, result_data,
167
789
                                    result_offset);
168
789
    }
169
797
}
_ZN5doris14execute_resultINS_11EncryptImplELb1EEEvPKcmS3_mmRNS_14EncryptionModeES3_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS6_IjLm4096ES9_Lm16ELm15EEESB_S3_m
Line
Count
Source
146
428
                    NullMap& null_map, const char* aad, size_t aad_length) {
147
428
    auto cipher_len = src_size;
148
428
    if constexpr (is_encrypt) {
149
428
        cipher_len += 16;
150
        // for output AEAD tag
151
428
        if (EncryptionUtil::is_gcm_mode(encryption_mode)) {
152
5
            cipher_len += EncryptionUtil::GCM_TAG_SIZE;
153
5
        }
154
428
    }
155
428
    std::unique_ptr<char[]> p;
156
428
    p.reset(new char[cipher_len]);
157
428
    int ret_code = 0;
158
159
428
    ret_code = Impl::execute_impl(encryption_mode, (unsigned char*)src_raw, src_size,
160
428
                                  (unsigned char*)key_raw, key_size, iv_raw, iv_length, true,
161
428
                                  (unsigned char*)p.get(), (unsigned char*)aad, aad_length);
162
163
428
    if (ret_code < 0) {
164
0
        StringOP::push_null_string(i, result_data, result_offset, null_map);
165
428
    } else {
166
428
        StringOP::push_value_string(std::string_view(p.get(), ret_code), i, result_data,
167
428
                                    result_offset);
168
428
    }
169
428
}
_ZN5doris14execute_resultINS_11DecryptImplELb0EEEvPKcmS3_mmRNS_14EncryptionModeES3_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS6_IjLm4096ES9_Lm16ELm15EEESB_S3_m
Line
Count
Source
146
369
                    NullMap& null_map, const char* aad, size_t aad_length) {
147
369
    auto cipher_len = src_size;
148
    if constexpr (is_encrypt) {
149
        cipher_len += 16;
150
        // for output AEAD tag
151
        if (EncryptionUtil::is_gcm_mode(encryption_mode)) {
152
            cipher_len += EncryptionUtil::GCM_TAG_SIZE;
153
        }
154
    }
155
369
    std::unique_ptr<char[]> p;
156
369
    p.reset(new char[cipher_len]);
157
369
    int ret_code = 0;
158
159
369
    ret_code = Impl::execute_impl(encryption_mode, (unsigned char*)src_raw, src_size,
160
369
                                  (unsigned char*)key_raw, key_size, iv_raw, iv_length, true,
161
369
                                  (unsigned char*)p.get(), (unsigned char*)aad, aad_length);
162
163
369
    if (ret_code < 0) {
164
8
        StringOP::push_null_string(i, result_data, result_offset, null_map);
165
361
    } else {
166
361
        StringOP::push_value_string(std::string_view(p.get(), ret_code), i, result_data,
167
361
                                    result_offset);
168
361
    }
169
369
}
170
171
template <typename Impl, EncryptionMode mode, bool is_encrypt>
172
struct EncryptionAndDecryptTwoImpl {
173
125
    static DataTypes get_variadic_argument_types_impl() {
174
125
        return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
175
125
                std::make_shared<DataTypeString>()};
176
125
    }
_ZN5doris27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1EE32get_variadic_argument_types_implEv
Line
Count
Source
173
8
    static DataTypes get_variadic_argument_types_impl() {
174
8
        return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
175
8
                std::make_shared<DataTypeString>()};
176
8
    }
_ZN5doris27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0EE32get_variadic_argument_types_implEv
Line
Count
Source
173
8
    static DataTypes get_variadic_argument_types_impl() {
174
8
        return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
175
8
                std::make_shared<DataTypeString>()};
176
8
    }
_ZN5doris27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1EE32get_variadic_argument_types_implEv
Line
Count
Source
173
58
    static DataTypes get_variadic_argument_types_impl() {
174
58
        return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
175
58
                std::make_shared<DataTypeString>()};
176
58
    }
_ZN5doris27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0EE32get_variadic_argument_types_implEv
Line
Count
Source
173
51
    static DataTypes get_variadic_argument_types_impl() {
174
51
        return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
175
51
                std::make_shared<DataTypeString>()};
176
51
    }
177
178
    static Status execute_impl_inner(FunctionContext* context, Block& block,
179
                                     const ColumnNumbers& arguments, uint32_t result,
180
79
                                     size_t input_rows_count) {
181
79
        auto result_column = ColumnString::create();
182
79
        auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0);
183
79
        DCHECK_EQ(3, arguments.size());
184
79
        const size_t argument_size = 3;
185
79
        bool col_const[argument_size];
186
79
        ColumnPtr argument_columns[argument_size];
187
316
        for (int i = 0; i < argument_size; ++i) {
188
237
            col_const[i] = is_column_const(*block.get_by_position(arguments[i]).column);
189
237
        }
190
79
        argument_columns[0] = col_const[0] ? static_cast<const ColumnConst&>(
191
33
                                                     *block.get_by_position(arguments[0]).column)
192
33
                                                     .convert_to_full_column()
193
79
                                           : block.get_by_position(arguments[0]).column;
194
195
79
        default_preprocess_parameter_columns(argument_columns, col_const, {1, 2}, block, arguments);
196
197
79
        auto& result_data = result_column->get_chars();
198
79
        auto& result_offset = result_column->get_offsets();
199
79
        result_offset.resize(input_rows_count);
200
201
79
        if (col_const[1] && col_const[2]) {
202
11
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
203
11
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
204
11
                         input_rows_count, result_data, result_offset,
205
11
                         result_null_map_column->get_data());
206
68
        } else {
207
68
            std::vector<const ColumnString::Offsets*> offsets_list(argument_size);
208
68
            std::vector<const ColumnString::Chars*> chars_list(argument_size);
209
272
            for (size_t i = 0; i < argument_size; ++i) {
210
204
                const auto* col_str = assert_cast<const ColumnString*>(argument_columns[i].get());
211
204
                offsets_list[i] = &col_str->get_offsets();
212
204
                chars_list[i] = &col_str->get_chars();
213
204
            }
214
68
            vector_vector(offsets_list, chars_list, input_rows_count, result_data, result_offset,
215
68
                          result_null_map_column->get_data());
216
68
        }
217
79
        block.get_by_position(result).column =
218
79
                ColumnNullable::create(std::move(result_column), std::move(result_null_map_column));
219
79
        return Status::OK();
220
79
    }
Unexecuted instantiation: _ZN5doris27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1EE18execute_impl_innerEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Unexecuted instantiation: _ZN5doris27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0EE18execute_impl_innerEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
_ZN5doris27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1EE18execute_impl_innerEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
180
43
                                     size_t input_rows_count) {
181
43
        auto result_column = ColumnString::create();
182
43
        auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0);
183
43
        DCHECK_EQ(3, arguments.size());
184
43
        const size_t argument_size = 3;
185
43
        bool col_const[argument_size];
186
43
        ColumnPtr argument_columns[argument_size];
187
172
        for (int i = 0; i < argument_size; ++i) {
188
129
            col_const[i] = is_column_const(*block.get_by_position(arguments[i]).column);
189
129
        }
190
43
        argument_columns[0] = col_const[0] ? static_cast<const ColumnConst&>(
191
18
                                                     *block.get_by_position(arguments[0]).column)
192
18
                                                     .convert_to_full_column()
193
43
                                           : block.get_by_position(arguments[0]).column;
194
195
43
        default_preprocess_parameter_columns(argument_columns, col_const, {1, 2}, block, arguments);
196
197
43
        auto& result_data = result_column->get_chars();
198
43
        auto& result_offset = result_column->get_offsets();
199
43
        result_offset.resize(input_rows_count);
200
201
43
        if (col_const[1] && col_const[2]) {
202
6
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
203
6
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
204
6
                         input_rows_count, result_data, result_offset,
205
6
                         result_null_map_column->get_data());
206
37
        } else {
207
37
            std::vector<const ColumnString::Offsets*> offsets_list(argument_size);
208
37
            std::vector<const ColumnString::Chars*> chars_list(argument_size);
209
148
            for (size_t i = 0; i < argument_size; ++i) {
210
111
                const auto* col_str = assert_cast<const ColumnString*>(argument_columns[i].get());
211
111
                offsets_list[i] = &col_str->get_offsets();
212
111
                chars_list[i] = &col_str->get_chars();
213
111
            }
214
37
            vector_vector(offsets_list, chars_list, input_rows_count, result_data, result_offset,
215
37
                          result_null_map_column->get_data());
216
37
        }
217
43
        block.get_by_position(result).column =
218
43
                ColumnNullable::create(std::move(result_column), std::move(result_null_map_column));
219
43
        return Status::OK();
220
43
    }
_ZN5doris27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0EE18execute_impl_innerEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
180
36
                                     size_t input_rows_count) {
181
36
        auto result_column = ColumnString::create();
182
36
        auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0);
183
36
        DCHECK_EQ(3, arguments.size());
184
36
        const size_t argument_size = 3;
185
36
        bool col_const[argument_size];
186
36
        ColumnPtr argument_columns[argument_size];
187
144
        for (int i = 0; i < argument_size; ++i) {
188
108
            col_const[i] = is_column_const(*block.get_by_position(arguments[i]).column);
189
108
        }
190
36
        argument_columns[0] = col_const[0] ? static_cast<const ColumnConst&>(
191
15
                                                     *block.get_by_position(arguments[0]).column)
192
15
                                                     .convert_to_full_column()
193
36
                                           : block.get_by_position(arguments[0]).column;
194
195
36
        default_preprocess_parameter_columns(argument_columns, col_const, {1, 2}, block, arguments);
196
197
36
        auto& result_data = result_column->get_chars();
198
36
        auto& result_offset = result_column->get_offsets();
199
36
        result_offset.resize(input_rows_count);
200
201
36
        if (col_const[1] && col_const[2]) {
202
5
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
203
5
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
204
5
                         input_rows_count, result_data, result_offset,
205
5
                         result_null_map_column->get_data());
206
31
        } else {
207
31
            std::vector<const ColumnString::Offsets*> offsets_list(argument_size);
208
31
            std::vector<const ColumnString::Chars*> chars_list(argument_size);
209
124
            for (size_t i = 0; i < argument_size; ++i) {
210
93
                const auto* col_str = assert_cast<const ColumnString*>(argument_columns[i].get());
211
93
                offsets_list[i] = &col_str->get_offsets();
212
93
                chars_list[i] = &col_str->get_chars();
213
93
            }
214
31
            vector_vector(offsets_list, chars_list, input_rows_count, result_data, result_offset,
215
31
                          result_null_map_column->get_data());
216
31
        }
217
36
        block.get_by_position(result).column =
218
36
                ColumnNullable::create(std::move(result_column), std::move(result_null_map_column));
219
36
        return Status::OK();
220
36
    }
221
222
    static void vector_const(const ColumnString* column, StringRef key_arg, StringRef mode_arg,
223
                             size_t input_rows_count, ColumnString::Chars& result_data,
224
11
                             ColumnString::Offsets& result_offset, NullMap& null_map) {
225
11
        EncryptionMode encryption_mode = mode;
226
11
        std::string mode_str(mode_arg.data, mode_arg.size);
227
11
        bool all_insert_null = false;
228
11
        if (mode_arg.size != 0) {
229
11
            if (!aes_mode_map.contains(mode_str)) {
230
0
                all_insert_null = true;
231
11
            } else {
232
11
                encryption_mode = aes_mode_map.at(mode_str);
233
11
            }
234
11
        }
235
11
        const ColumnString::Offsets* offsets_column = &column->get_offsets();
236
11
        const ColumnString::Chars* chars_column = &column->get_chars();
237
22
        for (int i = 0; i < input_rows_count; ++i) {
238
11
            if (all_insert_null || null_map[i]) {
239
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
240
0
                continue;
241
0
            }
242
11
            execute_result_const<Impl, is_encrypt>(offsets_column, chars_column, key_arg, i,
243
11
                                                   encryption_mode, nullptr, 0, result_data,
244
11
                                                   result_offset, null_map, nullptr, 0);
245
11
        }
246
11
    }
Unexecuted instantiation: _ZN5doris27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1EE12vector_constEPKNS_9ColumnStrIjEENS_9StringRefES8_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS9_IjLm4096ESC_Lm16ELm15EEESE_
Unexecuted instantiation: _ZN5doris27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0EE12vector_constEPKNS_9ColumnStrIjEENS_9StringRefES8_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS9_IjLm4096ESC_Lm16ELm15EEESE_
_ZN5doris27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1EE12vector_constEPKNS_9ColumnStrIjEENS_9StringRefES8_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS9_IjLm4096ESC_Lm16ELm15EEESE_
Line
Count
Source
224
6
                             ColumnString::Offsets& result_offset, NullMap& null_map) {
225
6
        EncryptionMode encryption_mode = mode;
226
6
        std::string mode_str(mode_arg.data, mode_arg.size);
227
6
        bool all_insert_null = false;
228
6
        if (mode_arg.size != 0) {
229
6
            if (!aes_mode_map.contains(mode_str)) {
230
0
                all_insert_null = true;
231
6
            } else {
232
6
                encryption_mode = aes_mode_map.at(mode_str);
233
6
            }
234
6
        }
235
6
        const ColumnString::Offsets* offsets_column = &column->get_offsets();
236
6
        const ColumnString::Chars* chars_column = &column->get_chars();
237
12
        for (int i = 0; i < input_rows_count; ++i) {
238
6
            if (all_insert_null || null_map[i]) {
239
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
240
0
                continue;
241
0
            }
242
6
            execute_result_const<Impl, is_encrypt>(offsets_column, chars_column, key_arg, i,
243
6
                                                   encryption_mode, nullptr, 0, result_data,
244
6
                                                   result_offset, null_map, nullptr, 0);
245
6
        }
246
6
    }
_ZN5doris27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0EE12vector_constEPKNS_9ColumnStrIjEENS_9StringRefES8_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS9_IjLm4096ESC_Lm16ELm15EEESE_
Line
Count
Source
224
5
                             ColumnString::Offsets& result_offset, NullMap& null_map) {
225
5
        EncryptionMode encryption_mode = mode;
226
5
        std::string mode_str(mode_arg.data, mode_arg.size);
227
5
        bool all_insert_null = false;
228
5
        if (mode_arg.size != 0) {
229
5
            if (!aes_mode_map.contains(mode_str)) {
230
0
                all_insert_null = true;
231
5
            } else {
232
5
                encryption_mode = aes_mode_map.at(mode_str);
233
5
            }
234
5
        }
235
5
        const ColumnString::Offsets* offsets_column = &column->get_offsets();
236
5
        const ColumnString::Chars* chars_column = &column->get_chars();
237
10
        for (int i = 0; i < input_rows_count; ++i) {
238
5
            if (all_insert_null || null_map[i]) {
239
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
240
0
                continue;
241
0
            }
242
5
            execute_result_const<Impl, is_encrypt>(offsets_column, chars_column, key_arg, i,
243
5
                                                   encryption_mode, nullptr, 0, result_data,
244
5
                                                   result_offset, null_map, nullptr, 0);
245
5
        }
246
5
    }
247
248
    static void vector_vector(std::vector<const ColumnString::Offsets*>& offsets_list,
249
                              std::vector<const ColumnString::Chars*>& chars_list,
250
                              size_t input_rows_count, ColumnString::Chars& result_data,
251
68
                              ColumnString::Offsets& result_offset, NullMap& null_map) {
252
147
        for (int i = 0; i < input_rows_count; ++i) {
253
79
            if (null_map[i]) {
254
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
255
0
                continue;
256
0
            }
257
79
            EncryptionMode encryption_mode = mode;
258
79
            int mode_size = (*offsets_list[2])[i] - (*offsets_list[2])[i - 1];
259
79
            const auto* mode_raw =
260
79
                    reinterpret_cast<const char*>(&(*chars_list[2])[(*offsets_list[2])[i - 1]]);
261
79
            if (mode_size != 0) {
262
79
                std::string mode_str(mode_raw, mode_size);
263
79
                if (aes_mode_map.count(mode_str) == 0) {
264
0
                    StringOP::push_null_string(i, result_data, result_offset, null_map);
265
0
                    continue;
266
0
                }
267
79
                encryption_mode = aes_mode_map.at(mode_str);
268
79
            }
269
79
            execute_result_vector<Impl, is_encrypt>(offsets_list, chars_list, i, encryption_mode,
270
79
                                                    nullptr, 0, result_data, result_offset,
271
79
                                                    null_map, nullptr, 0);
272
79
        }
273
68
    }
Unexecuted instantiation: _ZN5doris27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1EE13vector_vectorERSt6vectorIPKNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESaISB_EERS4_IPKNS5_IhLm4096ES8_Lm16ELm15EEESaISH_EEmRSF_RS9_SL_
Unexecuted instantiation: _ZN5doris27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0EE13vector_vectorERSt6vectorIPKNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESaISB_EERS4_IPKNS5_IhLm4096ES8_Lm16ELm15EEESaISH_EEmRSF_RS9_SL_
_ZN5doris27EncryptionAndDecryptTwoImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1EE13vector_vectorERSt6vectorIPKNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESaISB_EERS4_IPKNS5_IhLm4096ES8_Lm16ELm15EEESaISH_EEmRSF_RS9_SL_
Line
Count
Source
251
37
                              ColumnString::Offsets& result_offset, NullMap& null_map) {
252
80
        for (int i = 0; i < input_rows_count; ++i) {
253
43
            if (null_map[i]) {
254
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
255
0
                continue;
256
0
            }
257
43
            EncryptionMode encryption_mode = mode;
258
43
            int mode_size = (*offsets_list[2])[i] - (*offsets_list[2])[i - 1];
259
43
            const auto* mode_raw =
260
43
                    reinterpret_cast<const char*>(&(*chars_list[2])[(*offsets_list[2])[i - 1]]);
261
43
            if (mode_size != 0) {
262
43
                std::string mode_str(mode_raw, mode_size);
263
43
                if (aes_mode_map.count(mode_str) == 0) {
264
0
                    StringOP::push_null_string(i, result_data, result_offset, null_map);
265
0
                    continue;
266
0
                }
267
43
                encryption_mode = aes_mode_map.at(mode_str);
268
43
            }
269
43
            execute_result_vector<Impl, is_encrypt>(offsets_list, chars_list, i, encryption_mode,
270
43
                                                    nullptr, 0, result_data, result_offset,
271
43
                                                    null_map, nullptr, 0);
272
43
        }
273
37
    }
_ZN5doris27EncryptionAndDecryptTwoImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0EE13vector_vectorERSt6vectorIPKNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESaISB_EERS4_IPKNS5_IhLm4096ES8_Lm16ELm15EEESaISH_EEmRSF_RS9_SL_
Line
Count
Source
251
31
                              ColumnString::Offsets& result_offset, NullMap& null_map) {
252
67
        for (int i = 0; i < input_rows_count; ++i) {
253
36
            if (null_map[i]) {
254
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
255
0
                continue;
256
0
            }
257
36
            EncryptionMode encryption_mode = mode;
258
36
            int mode_size = (*offsets_list[2])[i] - (*offsets_list[2])[i - 1];
259
36
            const auto* mode_raw =
260
36
                    reinterpret_cast<const char*>(&(*chars_list[2])[(*offsets_list[2])[i - 1]]);
261
36
            if (mode_size != 0) {
262
36
                std::string mode_str(mode_raw, mode_size);
263
36
                if (aes_mode_map.count(mode_str) == 0) {
264
0
                    StringOP::push_null_string(i, result_data, result_offset, null_map);
265
0
                    continue;
266
0
                }
267
36
                encryption_mode = aes_mode_map.at(mode_str);
268
36
            }
269
36
            execute_result_vector<Impl, is_encrypt>(offsets_list, chars_list, i, encryption_mode,
270
36
                                                    nullptr, 0, result_data, result_offset,
271
36
                                                    null_map, nullptr, 0);
272
36
        }
273
31
    }
274
};
275
276
template <typename Impl, EncryptionMode mode, bool is_encrypt, bool is_sm_mode, int arg_num = 4>
277
struct EncryptionAndDecryptMultiImpl {
278
811
    static DataTypes get_variadic_argument_types_impl() {
279
811
        if constexpr (arg_num == 5) {
280
24
            return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
281
24
                    std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
282
24
                    std::make_shared<DataTypeString>()};
283
787
        } else {
284
787
            return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
285
787
                    std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>()};
286
787
        }
287
811
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1ELb1ELi4EE32get_variadic_argument_types_implEv
Line
Count
Source
278
258
    static DataTypes get_variadic_argument_types_impl() {
279
        if constexpr (arg_num == 5) {
280
            return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
281
                    std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
282
                    std::make_shared<DataTypeString>()};
283
258
        } else {
284
258
            return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
285
258
                    std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>()};
286
258
        }
287
258
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0ELb1ELi4EE32get_variadic_argument_types_implEv
Line
Count
Source
278
229
    static DataTypes get_variadic_argument_types_impl() {
279
        if constexpr (arg_num == 5) {
280
            return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
281
                    std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
282
                    std::make_shared<DataTypeString>()};
283
229
        } else {
284
229
            return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
285
229
                    std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>()};
286
229
        }
287
229
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1ELb0ELi4EE32get_variadic_argument_types_implEv
Line
Count
Source
278
159
    static DataTypes get_variadic_argument_types_impl() {
279
        if constexpr (arg_num == 5) {
280
            return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
281
                    std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
282
                    std::make_shared<DataTypeString>()};
283
159
        } else {
284
159
            return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
285
159
                    std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>()};
286
159
        }
287
159
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0ELb0ELi4EE32get_variadic_argument_types_implEv
Line
Count
Source
278
141
    static DataTypes get_variadic_argument_types_impl() {
279
        if constexpr (arg_num == 5) {
280
            return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
281
                    std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
282
                    std::make_shared<DataTypeString>()};
283
141
        } else {
284
141
            return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
285
141
                    std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>()};
286
141
        }
287
141
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE24ELb1ELb0ELi5EE32get_variadic_argument_types_implEv
Line
Count
Source
278
12
    static DataTypes get_variadic_argument_types_impl() {
279
12
        if constexpr (arg_num == 5) {
280
12
            return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
281
12
                    std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
282
12
                    std::make_shared<DataTypeString>()};
283
        } else {
284
            return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
285
                    std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>()};
286
        }
287
12
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE24ELb0ELb0ELi5EE32get_variadic_argument_types_implEv
Line
Count
Source
278
12
    static DataTypes get_variadic_argument_types_impl() {
279
12
        if constexpr (arg_num == 5) {
280
12
            return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
281
12
                    std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
282
12
                    std::make_shared<DataTypeString>()};
283
        } else {
284
            return {std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(),
285
                    std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>()};
286
        }
287
12
    }
288
289
    static Status execute_impl_inner(FunctionContext* context, Block& block,
290
                                     const ColumnNumbers& arguments, uint32_t result,
291
673
                                     size_t input_rows_count) {
292
673
        auto result_column = ColumnString::create();
293
673
        auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0);
294
673
        DCHECK_EQ(arguments.size(), arg_num);
295
673
        const size_t argument_size = arg_num;
296
673
        bool col_const[argument_size];
297
673
        ColumnPtr argument_columns[argument_size];
298
3.37k
        for (int i = 0; i < argument_size; ++i) {
299
2.70k
            col_const[i] = is_column_const(*block.get_by_position(arguments[i]).column);
300
2.70k
        }
301
673
        argument_columns[0] = col_const[0] ? static_cast<const ColumnConst&>(
302
255
                                                     *block.get_by_position(arguments[0]).column)
303
255
                                                     .convert_to_full_column()
304
673
                                           : block.get_by_position(arguments[0]).column;
305
306
673
        if constexpr (arg_num == 5) {
307
8
            default_preprocess_parameter_columns(argument_columns, col_const, {1, 2, 3, 4}, block,
308
8
                                                 arguments);
309
665
        } else {
310
665
            default_preprocess_parameter_columns(argument_columns, col_const, {1, 2, 3}, block,
311
665
                                                 arguments);
312
665
        }
313
314
673
        auto& result_data = result_column->get_chars();
315
673
        auto& result_offset = result_column->get_offsets();
316
673
        result_offset.resize(input_rows_count);
317
318
673
        if ((arg_num == 5) && col_const[1] && col_const[2] && col_const[3] && col_const[4]) {
319
2
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
320
2
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
321
2
                         argument_columns[3]->get_data_at(0), input_rows_count, result_data,
322
2
                         result_offset, result_null_map_column->get_data(),
323
2
                         argument_columns[4]->get_data_at(0));
324
671
        } else if ((arg_num == 4) && col_const[1] && col_const[2] && col_const[3]) {
325
59
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
326
59
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
327
59
                         argument_columns[3]->get_data_at(0), input_rows_count, result_data,
328
59
                         result_offset, result_null_map_column->get_data(), StringRef());
329
612
        } else {
330
612
            std::vector<const ColumnString::Offsets*> offsets_list(argument_size);
331
612
            std::vector<const ColumnString::Chars*> chars_list(argument_size);
332
3.06k
            for (size_t i = 0; i < argument_size; ++i) {
333
2.45k
                const auto* col_str = assert_cast<const ColumnString*>(argument_columns[i].get());
334
2.45k
                offsets_list[i] = &col_str->get_offsets();
335
2.45k
                chars_list[i] = &col_str->get_chars();
336
2.45k
            }
337
612
            vector_vector(offsets_list, chars_list, input_rows_count, result_data, result_offset,
338
612
                          result_null_map_column->get_data());
339
612
        }
340
673
        block.get_by_position(result).column =
341
673
                ColumnNullable::create(std::move(result_column), std::move(result_null_map_column));
342
673
        return Status::OK();
343
673
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1ELb1ELi4EE18execute_impl_innerEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
291
220
                                     size_t input_rows_count) {
292
220
        auto result_column = ColumnString::create();
293
220
        auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0);
294
220
        DCHECK_EQ(arguments.size(), arg_num);
295
220
        const size_t argument_size = arg_num;
296
220
        bool col_const[argument_size];
297
220
        ColumnPtr argument_columns[argument_size];
298
1.10k
        for (int i = 0; i < argument_size; ++i) {
299
880
            col_const[i] = is_column_const(*block.get_by_position(arguments[i]).column);
300
880
        }
301
220
        argument_columns[0] = col_const[0] ? static_cast<const ColumnConst&>(
302
94
                                                     *block.get_by_position(arguments[0]).column)
303
94
                                                     .convert_to_full_column()
304
220
                                           : block.get_by_position(arguments[0]).column;
305
306
        if constexpr (arg_num == 5) {
307
            default_preprocess_parameter_columns(argument_columns, col_const, {1, 2, 3, 4}, block,
308
                                                 arguments);
309
220
        } else {
310
220
            default_preprocess_parameter_columns(argument_columns, col_const, {1, 2, 3}, block,
311
220
                                                 arguments);
312
220
        }
313
314
220
        auto& result_data = result_column->get_chars();
315
220
        auto& result_offset = result_column->get_offsets();
316
220
        result_offset.resize(input_rows_count);
317
318
220
        if ((arg_num == 5) && col_const[1] && col_const[2] && col_const[3] && col_const[4]) {
319
0
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
320
0
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
321
0
                         argument_columns[3]->get_data_at(0), input_rows_count, result_data,
322
0
                         result_offset, result_null_map_column->get_data(),
323
0
                         argument_columns[4]->get_data_at(0));
324
220
        } else if ((arg_num == 4) && col_const[1] && col_const[2] && col_const[3]) {
325
20
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
326
20
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
327
20
                         argument_columns[3]->get_data_at(0), input_rows_count, result_data,
328
20
                         result_offset, result_null_map_column->get_data(), StringRef());
329
200
        } else {
330
200
            std::vector<const ColumnString::Offsets*> offsets_list(argument_size);
331
200
            std::vector<const ColumnString::Chars*> chars_list(argument_size);
332
1.00k
            for (size_t i = 0; i < argument_size; ++i) {
333
800
                const auto* col_str = assert_cast<const ColumnString*>(argument_columns[i].get());
334
800
                offsets_list[i] = &col_str->get_offsets();
335
800
                chars_list[i] = &col_str->get_chars();
336
800
            }
337
200
            vector_vector(offsets_list, chars_list, input_rows_count, result_data, result_offset,
338
200
                          result_null_map_column->get_data());
339
200
        }
340
220
        block.get_by_position(result).column =
341
220
                ColumnNullable::create(std::move(result_column), std::move(result_null_map_column));
342
220
        return Status::OK();
343
220
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0ELb1ELi4EE18execute_impl_innerEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
291
191
                                     size_t input_rows_count) {
292
191
        auto result_column = ColumnString::create();
293
191
        auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0);
294
191
        DCHECK_EQ(arguments.size(), arg_num);
295
191
        const size_t argument_size = arg_num;
296
191
        bool col_const[argument_size];
297
191
        ColumnPtr argument_columns[argument_size];
298
955
        for (int i = 0; i < argument_size; ++i) {
299
764
            col_const[i] = is_column_const(*block.get_by_position(arguments[i]).column);
300
764
        }
301
191
        argument_columns[0] = col_const[0] ? static_cast<const ColumnConst&>(
302
72
                                                     *block.get_by_position(arguments[0]).column)
303
72
                                                     .convert_to_full_column()
304
191
                                           : block.get_by_position(arguments[0]).column;
305
306
        if constexpr (arg_num == 5) {
307
            default_preprocess_parameter_columns(argument_columns, col_const, {1, 2, 3, 4}, block,
308
                                                 arguments);
309
191
        } else {
310
191
            default_preprocess_parameter_columns(argument_columns, col_const, {1, 2, 3}, block,
311
191
                                                 arguments);
312
191
        }
313
314
191
        auto& result_data = result_column->get_chars();
315
191
        auto& result_offset = result_column->get_offsets();
316
191
        result_offset.resize(input_rows_count);
317
318
191
        if ((arg_num == 5) && col_const[1] && col_const[2] && col_const[3] && col_const[4]) {
319
0
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
320
0
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
321
0
                         argument_columns[3]->get_data_at(0), input_rows_count, result_data,
322
0
                         result_offset, result_null_map_column->get_data(),
323
0
                         argument_columns[4]->get_data_at(0));
324
191
        } else if ((arg_num == 4) && col_const[1] && col_const[2] && col_const[3]) {
325
17
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
326
17
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
327
17
                         argument_columns[3]->get_data_at(0), input_rows_count, result_data,
328
17
                         result_offset, result_null_map_column->get_data(), StringRef());
329
174
        } else {
330
174
            std::vector<const ColumnString::Offsets*> offsets_list(argument_size);
331
174
            std::vector<const ColumnString::Chars*> chars_list(argument_size);
332
870
            for (size_t i = 0; i < argument_size; ++i) {
333
696
                const auto* col_str = assert_cast<const ColumnString*>(argument_columns[i].get());
334
696
                offsets_list[i] = &col_str->get_offsets();
335
696
                chars_list[i] = &col_str->get_chars();
336
696
            }
337
174
            vector_vector(offsets_list, chars_list, input_rows_count, result_data, result_offset,
338
174
                          result_null_map_column->get_data());
339
174
        }
340
191
        block.get_by_position(result).column =
341
191
                ColumnNullable::create(std::move(result_column), std::move(result_null_map_column));
342
191
        return Status::OK();
343
191
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1ELb0ELi4EE18execute_impl_innerEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
291
136
                                     size_t input_rows_count) {
292
136
        auto result_column = ColumnString::create();
293
136
        auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0);
294
136
        DCHECK_EQ(arguments.size(), arg_num);
295
136
        const size_t argument_size = arg_num;
296
136
        bool col_const[argument_size];
297
136
        ColumnPtr argument_columns[argument_size];
298
680
        for (int i = 0; i < argument_size; ++i) {
299
544
            col_const[i] = is_column_const(*block.get_by_position(arguments[i]).column);
300
544
        }
301
136
        argument_columns[0] = col_const[0] ? static_cast<const ColumnConst&>(
302
52
                                                     *block.get_by_position(arguments[0]).column)
303
52
                                                     .convert_to_full_column()
304
136
                                           : block.get_by_position(arguments[0]).column;
305
306
        if constexpr (arg_num == 5) {
307
            default_preprocess_parameter_columns(argument_columns, col_const, {1, 2, 3, 4}, block,
308
                                                 arguments);
309
136
        } else {
310
136
            default_preprocess_parameter_columns(argument_columns, col_const, {1, 2, 3}, block,
311
136
                                                 arguments);
312
136
        }
313
314
136
        auto& result_data = result_column->get_chars();
315
136
        auto& result_offset = result_column->get_offsets();
316
136
        result_offset.resize(input_rows_count);
317
318
136
        if ((arg_num == 5) && col_const[1] && col_const[2] && col_const[3] && col_const[4]) {
319
0
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
320
0
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
321
0
                         argument_columns[3]->get_data_at(0), input_rows_count, result_data,
322
0
                         result_offset, result_null_map_column->get_data(),
323
0
                         argument_columns[4]->get_data_at(0));
324
136
        } else if ((arg_num == 4) && col_const[1] && col_const[2] && col_const[3]) {
325
12
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
326
12
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
327
12
                         argument_columns[3]->get_data_at(0), input_rows_count, result_data,
328
12
                         result_offset, result_null_map_column->get_data(), StringRef());
329
124
        } else {
330
124
            std::vector<const ColumnString::Offsets*> offsets_list(argument_size);
331
124
            std::vector<const ColumnString::Chars*> chars_list(argument_size);
332
620
            for (size_t i = 0; i < argument_size; ++i) {
333
496
                const auto* col_str = assert_cast<const ColumnString*>(argument_columns[i].get());
334
496
                offsets_list[i] = &col_str->get_offsets();
335
496
                chars_list[i] = &col_str->get_chars();
336
496
            }
337
124
            vector_vector(offsets_list, chars_list, input_rows_count, result_data, result_offset,
338
124
                          result_null_map_column->get_data());
339
124
        }
340
136
        block.get_by_position(result).column =
341
136
                ColumnNullable::create(std::move(result_column), std::move(result_null_map_column));
342
136
        return Status::OK();
343
136
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0ELb0ELi4EE18execute_impl_innerEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
291
118
                                     size_t input_rows_count) {
292
118
        auto result_column = ColumnString::create();
293
118
        auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0);
294
118
        DCHECK_EQ(arguments.size(), arg_num);
295
118
        const size_t argument_size = arg_num;
296
118
        bool col_const[argument_size];
297
118
        ColumnPtr argument_columns[argument_size];
298
590
        for (int i = 0; i < argument_size; ++i) {
299
472
            col_const[i] = is_column_const(*block.get_by_position(arguments[i]).column);
300
472
        }
301
118
        argument_columns[0] = col_const[0] ? static_cast<const ColumnConst&>(
302
37
                                                     *block.get_by_position(arguments[0]).column)
303
37
                                                     .convert_to_full_column()
304
118
                                           : block.get_by_position(arguments[0]).column;
305
306
        if constexpr (arg_num == 5) {
307
            default_preprocess_parameter_columns(argument_columns, col_const, {1, 2, 3, 4}, block,
308
                                                 arguments);
309
118
        } else {
310
118
            default_preprocess_parameter_columns(argument_columns, col_const, {1, 2, 3}, block,
311
118
                                                 arguments);
312
118
        }
313
314
118
        auto& result_data = result_column->get_chars();
315
118
        auto& result_offset = result_column->get_offsets();
316
118
        result_offset.resize(input_rows_count);
317
318
118
        if ((arg_num == 5) && col_const[1] && col_const[2] && col_const[3] && col_const[4]) {
319
0
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
320
0
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
321
0
                         argument_columns[3]->get_data_at(0), input_rows_count, result_data,
322
0
                         result_offset, result_null_map_column->get_data(),
323
0
                         argument_columns[4]->get_data_at(0));
324
118
        } else if ((arg_num == 4) && col_const[1] && col_const[2] && col_const[3]) {
325
10
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
326
10
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
327
10
                         argument_columns[3]->get_data_at(0), input_rows_count, result_data,
328
10
                         result_offset, result_null_map_column->get_data(), StringRef());
329
108
        } else {
330
108
            std::vector<const ColumnString::Offsets*> offsets_list(argument_size);
331
108
            std::vector<const ColumnString::Chars*> chars_list(argument_size);
332
540
            for (size_t i = 0; i < argument_size; ++i) {
333
432
                const auto* col_str = assert_cast<const ColumnString*>(argument_columns[i].get());
334
432
                offsets_list[i] = &col_str->get_offsets();
335
432
                chars_list[i] = &col_str->get_chars();
336
432
            }
337
108
            vector_vector(offsets_list, chars_list, input_rows_count, result_data, result_offset,
338
108
                          result_null_map_column->get_data());
339
108
        }
340
118
        block.get_by_position(result).column =
341
118
                ColumnNullable::create(std::move(result_column), std::move(result_null_map_column));
342
118
        return Status::OK();
343
118
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE24ELb1ELb0ELi5EE18execute_impl_innerEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
291
4
                                     size_t input_rows_count) {
292
4
        auto result_column = ColumnString::create();
293
4
        auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0);
294
4
        DCHECK_EQ(arguments.size(), arg_num);
295
4
        const size_t argument_size = arg_num;
296
4
        bool col_const[argument_size];
297
4
        ColumnPtr argument_columns[argument_size];
298
24
        for (int i = 0; i < argument_size; ++i) {
299
20
            col_const[i] = is_column_const(*block.get_by_position(arguments[i]).column);
300
20
        }
301
4
        argument_columns[0] = col_const[0] ? static_cast<const ColumnConst&>(
302
0
                                                     *block.get_by_position(arguments[0]).column)
303
0
                                                     .convert_to_full_column()
304
4
                                           : block.get_by_position(arguments[0]).column;
305
306
4
        if constexpr (arg_num == 5) {
307
4
            default_preprocess_parameter_columns(argument_columns, col_const, {1, 2, 3, 4}, block,
308
4
                                                 arguments);
309
        } else {
310
            default_preprocess_parameter_columns(argument_columns, col_const, {1, 2, 3}, block,
311
                                                 arguments);
312
        }
313
314
4
        auto& result_data = result_column->get_chars();
315
4
        auto& result_offset = result_column->get_offsets();
316
4
        result_offset.resize(input_rows_count);
317
318
4
        if ((arg_num == 5) && col_const[1] && col_const[2] && col_const[3] && col_const[4]) {
319
1
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
320
1
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
321
1
                         argument_columns[3]->get_data_at(0), input_rows_count, result_data,
322
1
                         result_offset, result_null_map_column->get_data(),
323
1
                         argument_columns[4]->get_data_at(0));
324
3
        } else if ((arg_num == 4) && col_const[1] && col_const[2] && col_const[3]) {
325
0
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
326
0
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
327
0
                         argument_columns[3]->get_data_at(0), input_rows_count, result_data,
328
0
                         result_offset, result_null_map_column->get_data(), StringRef());
329
3
        } else {
330
3
            std::vector<const ColumnString::Offsets*> offsets_list(argument_size);
331
3
            std::vector<const ColumnString::Chars*> chars_list(argument_size);
332
18
            for (size_t i = 0; i < argument_size; ++i) {
333
15
                const auto* col_str = assert_cast<const ColumnString*>(argument_columns[i].get());
334
15
                offsets_list[i] = &col_str->get_offsets();
335
15
                chars_list[i] = &col_str->get_chars();
336
15
            }
337
3
            vector_vector(offsets_list, chars_list, input_rows_count, result_data, result_offset,
338
3
                          result_null_map_column->get_data());
339
3
        }
340
4
        block.get_by_position(result).column =
341
4
                ColumnNullable::create(std::move(result_column), std::move(result_null_map_column));
342
4
        return Status::OK();
343
4
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE24ELb0ELb0ELi5EE18execute_impl_innerEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
291
4
                                     size_t input_rows_count) {
292
4
        auto result_column = ColumnString::create();
293
4
        auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0);
294
4
        DCHECK_EQ(arguments.size(), arg_num);
295
4
        const size_t argument_size = arg_num;
296
4
        bool col_const[argument_size];
297
4
        ColumnPtr argument_columns[argument_size];
298
24
        for (int i = 0; i < argument_size; ++i) {
299
20
            col_const[i] = is_column_const(*block.get_by_position(arguments[i]).column);
300
20
        }
301
4
        argument_columns[0] = col_const[0] ? static_cast<const ColumnConst&>(
302
0
                                                     *block.get_by_position(arguments[0]).column)
303
0
                                                     .convert_to_full_column()
304
4
                                           : block.get_by_position(arguments[0]).column;
305
306
4
        if constexpr (arg_num == 5) {
307
4
            default_preprocess_parameter_columns(argument_columns, col_const, {1, 2, 3, 4}, block,
308
4
                                                 arguments);
309
        } else {
310
            default_preprocess_parameter_columns(argument_columns, col_const, {1, 2, 3}, block,
311
                                                 arguments);
312
        }
313
314
4
        auto& result_data = result_column->get_chars();
315
4
        auto& result_offset = result_column->get_offsets();
316
4
        result_offset.resize(input_rows_count);
317
318
4
        if ((arg_num == 5) && col_const[1] && col_const[2] && col_const[3] && col_const[4]) {
319
1
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
320
1
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
321
1
                         argument_columns[3]->get_data_at(0), input_rows_count, result_data,
322
1
                         result_offset, result_null_map_column->get_data(),
323
1
                         argument_columns[4]->get_data_at(0));
324
3
        } else if ((arg_num == 4) && col_const[1] && col_const[2] && col_const[3]) {
325
0
            vector_const(assert_cast<const ColumnString*>(argument_columns[0].get()),
326
0
                         argument_columns[1]->get_data_at(0), argument_columns[2]->get_data_at(0),
327
0
                         argument_columns[3]->get_data_at(0), input_rows_count, result_data,
328
0
                         result_offset, result_null_map_column->get_data(), StringRef());
329
3
        } else {
330
3
            std::vector<const ColumnString::Offsets*> offsets_list(argument_size);
331
3
            std::vector<const ColumnString::Chars*> chars_list(argument_size);
332
18
            for (size_t i = 0; i < argument_size; ++i) {
333
15
                const auto* col_str = assert_cast<const ColumnString*>(argument_columns[i].get());
334
15
                offsets_list[i] = &col_str->get_offsets();
335
15
                chars_list[i] = &col_str->get_chars();
336
15
            }
337
3
            vector_vector(offsets_list, chars_list, input_rows_count, result_data, result_offset,
338
3
                          result_null_map_column->get_data());
339
3
        }
340
4
        block.get_by_position(result).column =
341
4
                ColumnNullable::create(std::move(result_column), std::move(result_null_map_column));
342
4
        return Status::OK();
343
4
    }
344
345
    static void vector_const(const ColumnString* column, StringRef key_arg, StringRef iv_arg,
346
                             StringRef mode_arg, size_t input_rows_count,
347
                             ColumnString::Chars& result_data, ColumnString::Offsets& result_offset,
348
61
                             NullMap& null_map, StringRef aad_arg) {
349
61
        EncryptionMode encryption_mode = mode;
350
61
        bool all_insert_null = false;
351
61
        if (mode_arg.size != 0) {
352
61
            std::string mode_str(mode_arg.data, mode_arg.size);
353
61
            if constexpr (is_sm_mode) {
354
37
                if (sm4_mode_map.count(mode_str) == 0) {
355
1
                    all_insert_null = true;
356
36
                } else {
357
36
                    encryption_mode = sm4_mode_map.at(mode_str);
358
36
                }
359
37
            } else {
360
24
                if (aes_mode_map.count(mode_str) == 0) {
361
0
                    all_insert_null = true;
362
24
                } else {
363
24
                    encryption_mode = aes_mode_map.at(mode_str);
364
24
                }
365
24
            }
366
61
        }
367
368
61
        const ColumnString::Offsets* offsets_column = &column->get_offsets();
369
61
        const ColumnString::Chars* chars_column = &column->get_chars();
370
122
        for (int i = 0; i < input_rows_count; ++i) {
371
61
            if (all_insert_null || null_map[i]) {
372
1
                StringOP::push_null_string(i, result_data, result_offset, null_map);
373
1
                continue;
374
1
            }
375
60
            execute_result_const<Impl, is_encrypt>(
376
60
                    offsets_column, chars_column, key_arg, i, encryption_mode, iv_arg.data,
377
60
                    iv_arg.size, result_data, result_offset, null_map, aad_arg.data, aad_arg.size);
378
60
        }
379
61
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1ELb1ELi4EE12vector_constEPKNS_9ColumnStrIjEENS_9StringRefES8_S8_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS9_IjLm4096ESC_Lm16ELm15EEESE_S8_
Line
Count
Source
348
20
                             NullMap& null_map, StringRef aad_arg) {
349
20
        EncryptionMode encryption_mode = mode;
350
20
        bool all_insert_null = false;
351
20
        if (mode_arg.size != 0) {
352
20
            std::string mode_str(mode_arg.data, mode_arg.size);
353
20
            if constexpr (is_sm_mode) {
354
20
                if (sm4_mode_map.count(mode_str) == 0) {
355
0
                    all_insert_null = true;
356
20
                } else {
357
20
                    encryption_mode = sm4_mode_map.at(mode_str);
358
20
                }
359
            } else {
360
                if (aes_mode_map.count(mode_str) == 0) {
361
                    all_insert_null = true;
362
                } else {
363
                    encryption_mode = aes_mode_map.at(mode_str);
364
                }
365
            }
366
20
        }
367
368
20
        const ColumnString::Offsets* offsets_column = &column->get_offsets();
369
20
        const ColumnString::Chars* chars_column = &column->get_chars();
370
40
        for (int i = 0; i < input_rows_count; ++i) {
371
20
            if (all_insert_null || null_map[i]) {
372
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
373
0
                continue;
374
0
            }
375
20
            execute_result_const<Impl, is_encrypt>(
376
20
                    offsets_column, chars_column, key_arg, i, encryption_mode, iv_arg.data,
377
20
                    iv_arg.size, result_data, result_offset, null_map, aad_arg.data, aad_arg.size);
378
20
        }
379
20
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0ELb1ELi4EE12vector_constEPKNS_9ColumnStrIjEENS_9StringRefES8_S8_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS9_IjLm4096ESC_Lm16ELm15EEESE_S8_
Line
Count
Source
348
17
                             NullMap& null_map, StringRef aad_arg) {
349
17
        EncryptionMode encryption_mode = mode;
350
17
        bool all_insert_null = false;
351
17
        if (mode_arg.size != 0) {
352
17
            std::string mode_str(mode_arg.data, mode_arg.size);
353
17
            if constexpr (is_sm_mode) {
354
17
                if (sm4_mode_map.count(mode_str) == 0) {
355
1
                    all_insert_null = true;
356
16
                } else {
357
16
                    encryption_mode = sm4_mode_map.at(mode_str);
358
16
                }
359
            } else {
360
                if (aes_mode_map.count(mode_str) == 0) {
361
                    all_insert_null = true;
362
                } else {
363
                    encryption_mode = aes_mode_map.at(mode_str);
364
                }
365
            }
366
17
        }
367
368
17
        const ColumnString::Offsets* offsets_column = &column->get_offsets();
369
17
        const ColumnString::Chars* chars_column = &column->get_chars();
370
34
        for (int i = 0; i < input_rows_count; ++i) {
371
17
            if (all_insert_null || null_map[i]) {
372
1
                StringOP::push_null_string(i, result_data, result_offset, null_map);
373
1
                continue;
374
1
            }
375
16
            execute_result_const<Impl, is_encrypt>(
376
16
                    offsets_column, chars_column, key_arg, i, encryption_mode, iv_arg.data,
377
16
                    iv_arg.size, result_data, result_offset, null_map, aad_arg.data, aad_arg.size);
378
16
        }
379
17
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1ELb0ELi4EE12vector_constEPKNS_9ColumnStrIjEENS_9StringRefES8_S8_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS9_IjLm4096ESC_Lm16ELm15EEESE_S8_
Line
Count
Source
348
12
                             NullMap& null_map, StringRef aad_arg) {
349
12
        EncryptionMode encryption_mode = mode;
350
12
        bool all_insert_null = false;
351
12
        if (mode_arg.size != 0) {
352
12
            std::string mode_str(mode_arg.data, mode_arg.size);
353
            if constexpr (is_sm_mode) {
354
                if (sm4_mode_map.count(mode_str) == 0) {
355
                    all_insert_null = true;
356
                } else {
357
                    encryption_mode = sm4_mode_map.at(mode_str);
358
                }
359
12
            } else {
360
12
                if (aes_mode_map.count(mode_str) == 0) {
361
0
                    all_insert_null = true;
362
12
                } else {
363
12
                    encryption_mode = aes_mode_map.at(mode_str);
364
12
                }
365
12
            }
366
12
        }
367
368
12
        const ColumnString::Offsets* offsets_column = &column->get_offsets();
369
12
        const ColumnString::Chars* chars_column = &column->get_chars();
370
24
        for (int i = 0; i < input_rows_count; ++i) {
371
12
            if (all_insert_null || null_map[i]) {
372
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
373
0
                continue;
374
0
            }
375
12
            execute_result_const<Impl, is_encrypt>(
376
12
                    offsets_column, chars_column, key_arg, i, encryption_mode, iv_arg.data,
377
12
                    iv_arg.size, result_data, result_offset, null_map, aad_arg.data, aad_arg.size);
378
12
        }
379
12
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0ELb0ELi4EE12vector_constEPKNS_9ColumnStrIjEENS_9StringRefES8_S8_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS9_IjLm4096ESC_Lm16ELm15EEESE_S8_
Line
Count
Source
348
10
                             NullMap& null_map, StringRef aad_arg) {
349
10
        EncryptionMode encryption_mode = mode;
350
10
        bool all_insert_null = false;
351
10
        if (mode_arg.size != 0) {
352
10
            std::string mode_str(mode_arg.data, mode_arg.size);
353
            if constexpr (is_sm_mode) {
354
                if (sm4_mode_map.count(mode_str) == 0) {
355
                    all_insert_null = true;
356
                } else {
357
                    encryption_mode = sm4_mode_map.at(mode_str);
358
                }
359
10
            } else {
360
10
                if (aes_mode_map.count(mode_str) == 0) {
361
0
                    all_insert_null = true;
362
10
                } else {
363
10
                    encryption_mode = aes_mode_map.at(mode_str);
364
10
                }
365
10
            }
366
10
        }
367
368
10
        const ColumnString::Offsets* offsets_column = &column->get_offsets();
369
10
        const ColumnString::Chars* chars_column = &column->get_chars();
370
20
        for (int i = 0; i < input_rows_count; ++i) {
371
10
            if (all_insert_null || null_map[i]) {
372
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
373
0
                continue;
374
0
            }
375
10
            execute_result_const<Impl, is_encrypt>(
376
10
                    offsets_column, chars_column, key_arg, i, encryption_mode, iv_arg.data,
377
10
                    iv_arg.size, result_data, result_offset, null_map, aad_arg.data, aad_arg.size);
378
10
        }
379
10
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE24ELb1ELb0ELi5EE12vector_constEPKNS_9ColumnStrIjEENS_9StringRefES8_S8_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS9_IjLm4096ESC_Lm16ELm15EEESE_S8_
Line
Count
Source
348
1
                             NullMap& null_map, StringRef aad_arg) {
349
1
        EncryptionMode encryption_mode = mode;
350
1
        bool all_insert_null = false;
351
1
        if (mode_arg.size != 0) {
352
1
            std::string mode_str(mode_arg.data, mode_arg.size);
353
            if constexpr (is_sm_mode) {
354
                if (sm4_mode_map.count(mode_str) == 0) {
355
                    all_insert_null = true;
356
                } else {
357
                    encryption_mode = sm4_mode_map.at(mode_str);
358
                }
359
1
            } else {
360
1
                if (aes_mode_map.count(mode_str) == 0) {
361
0
                    all_insert_null = true;
362
1
                } else {
363
1
                    encryption_mode = aes_mode_map.at(mode_str);
364
1
                }
365
1
            }
366
1
        }
367
368
1
        const ColumnString::Offsets* offsets_column = &column->get_offsets();
369
1
        const ColumnString::Chars* chars_column = &column->get_chars();
370
2
        for (int i = 0; i < input_rows_count; ++i) {
371
1
            if (all_insert_null || null_map[i]) {
372
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
373
0
                continue;
374
0
            }
375
1
            execute_result_const<Impl, is_encrypt>(
376
1
                    offsets_column, chars_column, key_arg, i, encryption_mode, iv_arg.data,
377
1
                    iv_arg.size, result_data, result_offset, null_map, aad_arg.data, aad_arg.size);
378
1
        }
379
1
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE24ELb0ELb0ELi5EE12vector_constEPKNS_9ColumnStrIjEENS_9StringRefES8_S8_mRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERNS9_IjLm4096ESC_Lm16ELm15EEESE_S8_
Line
Count
Source
348
1
                             NullMap& null_map, StringRef aad_arg) {
349
1
        EncryptionMode encryption_mode = mode;
350
1
        bool all_insert_null = false;
351
1
        if (mode_arg.size != 0) {
352
1
            std::string mode_str(mode_arg.data, mode_arg.size);
353
            if constexpr (is_sm_mode) {
354
                if (sm4_mode_map.count(mode_str) == 0) {
355
                    all_insert_null = true;
356
                } else {
357
                    encryption_mode = sm4_mode_map.at(mode_str);
358
                }
359
1
            } else {
360
1
                if (aes_mode_map.count(mode_str) == 0) {
361
0
                    all_insert_null = true;
362
1
                } else {
363
1
                    encryption_mode = aes_mode_map.at(mode_str);
364
1
                }
365
1
            }
366
1
        }
367
368
1
        const ColumnString::Offsets* offsets_column = &column->get_offsets();
369
1
        const ColumnString::Chars* chars_column = &column->get_chars();
370
2
        for (int i = 0; i < input_rows_count; ++i) {
371
1
            if (all_insert_null || null_map[i]) {
372
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
373
0
                continue;
374
0
            }
375
1
            execute_result_const<Impl, is_encrypt>(
376
1
                    offsets_column, chars_column, key_arg, i, encryption_mode, iv_arg.data,
377
1
                    iv_arg.size, result_data, result_offset, null_map, aad_arg.data, aad_arg.size);
378
1
        }
379
1
    }
380
381
    static void vector_vector(std::vector<const ColumnString::Offsets*>& offsets_list,
382
                              std::vector<const ColumnString::Chars*>& chars_list,
383
                              size_t input_rows_count, ColumnString::Chars& result_data,
384
612
                              ColumnString::Offsets& result_offset, NullMap& null_map) {
385
1.25k
        for (int i = 0; i < input_rows_count; ++i) {
386
647
            if (null_map[i]) {
387
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
388
0
                continue;
389
0
            }
390
391
647
            EncryptionMode encryption_mode = mode;
392
647
            int mode_size = (*offsets_list[3])[i] - (*offsets_list[3])[i - 1];
393
647
            int iv_size = (*offsets_list[2])[i] - (*offsets_list[2])[i - 1];
394
647
            const auto* mode_raw =
395
647
                    reinterpret_cast<const char*>(&(*chars_list[3])[(*offsets_list[3])[i - 1]]);
396
647
            const auto* iv_raw =
397
647
                    reinterpret_cast<const char*>(&(*chars_list[2])[(*offsets_list[2])[i - 1]]);
398
647
            if (mode_size != 0) {
399
647
                std::string mode_str(mode_raw, mode_size);
400
647
                if constexpr (is_sm_mode) {
401
396
                    if (sm4_mode_map.count(mode_str) == 0) {
402
0
                        StringOP::push_null_string(i, result_data, result_offset, null_map);
403
0
                        continue;
404
0
                    }
405
396
                    encryption_mode = sm4_mode_map.at(mode_str);
406
396
                } else {
407
251
                    if (aes_mode_map.count(mode_str) == 0) {
408
0
                        StringOP::push_null_string(i, result_data, result_offset, null_map);
409
0
                        continue;
410
0
                    }
411
251
                    encryption_mode = aes_mode_map.at(mode_str);
412
251
                }
413
647
            }
414
415
0
            int aad_size = 0;
416
647
            const char* aad = nullptr;
417
647
            if constexpr (arg_num == 5) {
418
8
                aad_size = (*offsets_list[4])[i] - (*offsets_list[4])[i - 1];
419
8
                aad = reinterpret_cast<const char*>(&(*chars_list[4])[(*offsets_list[4])[i - 1]]);
420
8
            }
421
422
647
            execute_result_vector<Impl, is_encrypt>(offsets_list, chars_list, i, encryption_mode,
423
647
                                                    iv_raw, iv_size, result_data, result_offset,
424
647
                                                    null_map, aad, aad_size);
425
647
        }
426
612
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE27ELb1ELb1ELi4EE13vector_vectorERSt6vectorIPKNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESaISB_EERS4_IPKNS5_IhLm4096ES8_Lm16ELm15EEESaISH_EEmRSF_RS9_SL_
Line
Count
Source
384
200
                              ColumnString::Offsets& result_offset, NullMap& null_map) {
385
412
        for (int i = 0; i < input_rows_count; ++i) {
386
212
            if (null_map[i]) {
387
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
388
0
                continue;
389
0
            }
390
391
212
            EncryptionMode encryption_mode = mode;
392
212
            int mode_size = (*offsets_list[3])[i] - (*offsets_list[3])[i - 1];
393
212
            int iv_size = (*offsets_list[2])[i] - (*offsets_list[2])[i - 1];
394
212
            const auto* mode_raw =
395
212
                    reinterpret_cast<const char*>(&(*chars_list[3])[(*offsets_list[3])[i - 1]]);
396
212
            const auto* iv_raw =
397
212
                    reinterpret_cast<const char*>(&(*chars_list[2])[(*offsets_list[2])[i - 1]]);
398
212
            if (mode_size != 0) {
399
212
                std::string mode_str(mode_raw, mode_size);
400
212
                if constexpr (is_sm_mode) {
401
212
                    if (sm4_mode_map.count(mode_str) == 0) {
402
0
                        StringOP::push_null_string(i, result_data, result_offset, null_map);
403
0
                        continue;
404
0
                    }
405
212
                    encryption_mode = sm4_mode_map.at(mode_str);
406
                } else {
407
                    if (aes_mode_map.count(mode_str) == 0) {
408
                        StringOP::push_null_string(i, result_data, result_offset, null_map);
409
                        continue;
410
                    }
411
                    encryption_mode = aes_mode_map.at(mode_str);
412
                }
413
212
            }
414
415
0
            int aad_size = 0;
416
212
            const char* aad = nullptr;
417
            if constexpr (arg_num == 5) {
418
                aad_size = (*offsets_list[4])[i] - (*offsets_list[4])[i - 1];
419
                aad = reinterpret_cast<const char*>(&(*chars_list[4])[(*offsets_list[4])[i - 1]]);
420
            }
421
422
212
            execute_result_vector<Impl, is_encrypt>(offsets_list, chars_list, i, encryption_mode,
423
212
                                                    iv_raw, iv_size, result_data, result_offset,
424
212
                                                    null_map, aad, aad_size);
425
212
        }
426
200
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE27ELb0ELb1ELi4EE13vector_vectorERSt6vectorIPKNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESaISB_EERS4_IPKNS5_IhLm4096ES8_Lm16ELm15EEESaISH_EEmRSF_RS9_SL_
Line
Count
Source
384
174
                              ColumnString::Offsets& result_offset, NullMap& null_map) {
385
358
        for (int i = 0; i < input_rows_count; ++i) {
386
184
            if (null_map[i]) {
387
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
388
0
                continue;
389
0
            }
390
391
184
            EncryptionMode encryption_mode = mode;
392
184
            int mode_size = (*offsets_list[3])[i] - (*offsets_list[3])[i - 1];
393
184
            int iv_size = (*offsets_list[2])[i] - (*offsets_list[2])[i - 1];
394
184
            const auto* mode_raw =
395
184
                    reinterpret_cast<const char*>(&(*chars_list[3])[(*offsets_list[3])[i - 1]]);
396
184
            const auto* iv_raw =
397
184
                    reinterpret_cast<const char*>(&(*chars_list[2])[(*offsets_list[2])[i - 1]]);
398
184
            if (mode_size != 0) {
399
184
                std::string mode_str(mode_raw, mode_size);
400
184
                if constexpr (is_sm_mode) {
401
184
                    if (sm4_mode_map.count(mode_str) == 0) {
402
0
                        StringOP::push_null_string(i, result_data, result_offset, null_map);
403
0
                        continue;
404
0
                    }
405
184
                    encryption_mode = sm4_mode_map.at(mode_str);
406
                } else {
407
                    if (aes_mode_map.count(mode_str) == 0) {
408
                        StringOP::push_null_string(i, result_data, result_offset, null_map);
409
                        continue;
410
                    }
411
                    encryption_mode = aes_mode_map.at(mode_str);
412
                }
413
184
            }
414
415
0
            int aad_size = 0;
416
184
            const char* aad = nullptr;
417
            if constexpr (arg_num == 5) {
418
                aad_size = (*offsets_list[4])[i] - (*offsets_list[4])[i - 1];
419
                aad = reinterpret_cast<const char*>(&(*chars_list[4])[(*offsets_list[4])[i - 1]]);
420
            }
421
422
184
            execute_result_vector<Impl, is_encrypt>(offsets_list, chars_list, i, encryption_mode,
423
184
                                                    iv_raw, iv_size, result_data, result_offset,
424
184
                                                    null_map, aad, aad_size);
425
184
        }
426
174
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE0ELb1ELb0ELi4EE13vector_vectorERSt6vectorIPKNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESaISB_EERS4_IPKNS5_IhLm4096ES8_Lm16ELm15EEESaISH_EEmRSF_RS9_SL_
Line
Count
Source
384
124
                              ColumnString::Offsets& result_offset, NullMap& null_map) {
385
254
        for (int i = 0; i < input_rows_count; ++i) {
386
130
            if (null_map[i]) {
387
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
388
0
                continue;
389
0
            }
390
391
130
            EncryptionMode encryption_mode = mode;
392
130
            int mode_size = (*offsets_list[3])[i] - (*offsets_list[3])[i - 1];
393
130
            int iv_size = (*offsets_list[2])[i] - (*offsets_list[2])[i - 1];
394
130
            const auto* mode_raw =
395
130
                    reinterpret_cast<const char*>(&(*chars_list[3])[(*offsets_list[3])[i - 1]]);
396
130
            const auto* iv_raw =
397
130
                    reinterpret_cast<const char*>(&(*chars_list[2])[(*offsets_list[2])[i - 1]]);
398
130
            if (mode_size != 0) {
399
130
                std::string mode_str(mode_raw, mode_size);
400
                if constexpr (is_sm_mode) {
401
                    if (sm4_mode_map.count(mode_str) == 0) {
402
                        StringOP::push_null_string(i, result_data, result_offset, null_map);
403
                        continue;
404
                    }
405
                    encryption_mode = sm4_mode_map.at(mode_str);
406
130
                } else {
407
130
                    if (aes_mode_map.count(mode_str) == 0) {
408
0
                        StringOP::push_null_string(i, result_data, result_offset, null_map);
409
0
                        continue;
410
0
                    }
411
130
                    encryption_mode = aes_mode_map.at(mode_str);
412
130
                }
413
130
            }
414
415
0
            int aad_size = 0;
416
130
            const char* aad = nullptr;
417
            if constexpr (arg_num == 5) {
418
                aad_size = (*offsets_list[4])[i] - (*offsets_list[4])[i - 1];
419
                aad = reinterpret_cast<const char*>(&(*chars_list[4])[(*offsets_list[4])[i - 1]]);
420
            }
421
422
130
            execute_result_vector<Impl, is_encrypt>(offsets_list, chars_list, i, encryption_mode,
423
130
                                                    iv_raw, iv_size, result_data, result_offset,
424
130
                                                    null_map, aad, aad_size);
425
130
        }
426
124
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE0ELb0ELb0ELi4EE13vector_vectorERSt6vectorIPKNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESaISB_EERS4_IPKNS5_IhLm4096ES8_Lm16ELm15EEESaISH_EEmRSF_RS9_SL_
Line
Count
Source
384
108
                              ColumnString::Offsets& result_offset, NullMap& null_map) {
385
221
        for (int i = 0; i < input_rows_count; ++i) {
386
113
            if (null_map[i]) {
387
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
388
0
                continue;
389
0
            }
390
391
113
            EncryptionMode encryption_mode = mode;
392
113
            int mode_size = (*offsets_list[3])[i] - (*offsets_list[3])[i - 1];
393
113
            int iv_size = (*offsets_list[2])[i] - (*offsets_list[2])[i - 1];
394
113
            const auto* mode_raw =
395
113
                    reinterpret_cast<const char*>(&(*chars_list[3])[(*offsets_list[3])[i - 1]]);
396
113
            const auto* iv_raw =
397
113
                    reinterpret_cast<const char*>(&(*chars_list[2])[(*offsets_list[2])[i - 1]]);
398
113
            if (mode_size != 0) {
399
113
                std::string mode_str(mode_raw, mode_size);
400
                if constexpr (is_sm_mode) {
401
                    if (sm4_mode_map.count(mode_str) == 0) {
402
                        StringOP::push_null_string(i, result_data, result_offset, null_map);
403
                        continue;
404
                    }
405
                    encryption_mode = sm4_mode_map.at(mode_str);
406
113
                } else {
407
113
                    if (aes_mode_map.count(mode_str) == 0) {
408
0
                        StringOP::push_null_string(i, result_data, result_offset, null_map);
409
0
                        continue;
410
0
                    }
411
113
                    encryption_mode = aes_mode_map.at(mode_str);
412
113
                }
413
113
            }
414
415
0
            int aad_size = 0;
416
113
            const char* aad = nullptr;
417
            if constexpr (arg_num == 5) {
418
                aad_size = (*offsets_list[4])[i] - (*offsets_list[4])[i - 1];
419
                aad = reinterpret_cast<const char*>(&(*chars_list[4])[(*offsets_list[4])[i - 1]]);
420
            }
421
422
113
            execute_result_vector<Impl, is_encrypt>(offsets_list, chars_list, i, encryption_mode,
423
113
                                                    iv_raw, iv_size, result_data, result_offset,
424
113
                                                    null_map, aad, aad_size);
425
113
        }
426
108
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11EncryptImplELNS_14EncryptionModeE24ELb1ELb0ELi5EE13vector_vectorERSt6vectorIPKNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESaISB_EERS4_IPKNS5_IhLm4096ES8_Lm16ELm15EEESaISH_EEmRSF_RS9_SL_
Line
Count
Source
384
3
                              ColumnString::Offsets& result_offset, NullMap& null_map) {
385
7
        for (int i = 0; i < input_rows_count; ++i) {
386
4
            if (null_map[i]) {
387
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
388
0
                continue;
389
0
            }
390
391
4
            EncryptionMode encryption_mode = mode;
392
4
            int mode_size = (*offsets_list[3])[i] - (*offsets_list[3])[i - 1];
393
4
            int iv_size = (*offsets_list[2])[i] - (*offsets_list[2])[i - 1];
394
4
            const auto* mode_raw =
395
4
                    reinterpret_cast<const char*>(&(*chars_list[3])[(*offsets_list[3])[i - 1]]);
396
4
            const auto* iv_raw =
397
4
                    reinterpret_cast<const char*>(&(*chars_list[2])[(*offsets_list[2])[i - 1]]);
398
4
            if (mode_size != 0) {
399
4
                std::string mode_str(mode_raw, mode_size);
400
                if constexpr (is_sm_mode) {
401
                    if (sm4_mode_map.count(mode_str) == 0) {
402
                        StringOP::push_null_string(i, result_data, result_offset, null_map);
403
                        continue;
404
                    }
405
                    encryption_mode = sm4_mode_map.at(mode_str);
406
4
                } else {
407
4
                    if (aes_mode_map.count(mode_str) == 0) {
408
0
                        StringOP::push_null_string(i, result_data, result_offset, null_map);
409
0
                        continue;
410
0
                    }
411
4
                    encryption_mode = aes_mode_map.at(mode_str);
412
4
                }
413
4
            }
414
415
0
            int aad_size = 0;
416
4
            const char* aad = nullptr;
417
4
            if constexpr (arg_num == 5) {
418
4
                aad_size = (*offsets_list[4])[i] - (*offsets_list[4])[i - 1];
419
4
                aad = reinterpret_cast<const char*>(&(*chars_list[4])[(*offsets_list[4])[i - 1]]);
420
4
            }
421
422
4
            execute_result_vector<Impl, is_encrypt>(offsets_list, chars_list, i, encryption_mode,
423
4
                                                    iv_raw, iv_size, result_data, result_offset,
424
4
                                                    null_map, aad, aad_size);
425
4
        }
426
3
    }
_ZN5doris29EncryptionAndDecryptMultiImplINS_11DecryptImplELNS_14EncryptionModeE24ELb0ELb0ELi5EE13vector_vectorERSt6vectorIPKNS_8PODArrayIjLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESaISB_EERS4_IPKNS5_IhLm4096ES8_Lm16ELm15EEESaISH_EEmRSF_RS9_SL_
Line
Count
Source
384
3
                              ColumnString::Offsets& result_offset, NullMap& null_map) {
385
7
        for (int i = 0; i < input_rows_count; ++i) {
386
4
            if (null_map[i]) {
387
0
                StringOP::push_null_string(i, result_data, result_offset, null_map);
388
0
                continue;
389
0
            }
390
391
4
            EncryptionMode encryption_mode = mode;
392
4
            int mode_size = (*offsets_list[3])[i] - (*offsets_list[3])[i - 1];
393
4
            int iv_size = (*offsets_list[2])[i] - (*offsets_list[2])[i - 1];
394
4
            const auto* mode_raw =
395
4
                    reinterpret_cast<const char*>(&(*chars_list[3])[(*offsets_list[3])[i - 1]]);
396
4
            const auto* iv_raw =
397
4
                    reinterpret_cast<const char*>(&(*chars_list[2])[(*offsets_list[2])[i - 1]]);
398
4
            if (mode_size != 0) {
399
4
                std::string mode_str(mode_raw, mode_size);
400
                if constexpr (is_sm_mode) {
401
                    if (sm4_mode_map.count(mode_str) == 0) {
402
                        StringOP::push_null_string(i, result_data, result_offset, null_map);
403
                        continue;
404
                    }
405
                    encryption_mode = sm4_mode_map.at(mode_str);
406
4
                } else {
407
4
                    if (aes_mode_map.count(mode_str) == 0) {
408
0
                        StringOP::push_null_string(i, result_data, result_offset, null_map);
409
0
                        continue;
410
0
                    }
411
4
                    encryption_mode = aes_mode_map.at(mode_str);
412
4
                }
413
4
            }
414
415
0
            int aad_size = 0;
416
4
            const char* aad = nullptr;
417
4
            if constexpr (arg_num == 5) {
418
4
                aad_size = (*offsets_list[4])[i] - (*offsets_list[4])[i - 1];
419
4
                aad = reinterpret_cast<const char*>(&(*chars_list[4])[(*offsets_list[4])[i - 1]]);
420
4
            }
421
422
4
            execute_result_vector<Impl, is_encrypt>(offsets_list, chars_list, i, encryption_mode,
423
4
                                                    iv_raw, iv_size, result_data, result_offset,
424
4
                                                    null_map, aad, aad_size);
425
4
        }
426
3
    }
427
};
428
429
struct EncryptImpl {
430
    static int execute_impl(EncryptionMode mode, const unsigned char* source, size_t source_length,
431
                            const unsigned char* key, size_t key_length, const char* iv,
432
                            size_t iv_length, bool padding, unsigned char* encrypt,
433
428
                            const unsigned char* aad, size_t aad_length) {
434
        // now the openssl only support int, so here we need to cast size_t to uint32_t
435
428
        return EncryptionUtil::encrypt(mode, source, cast_set<uint32_t>(source_length), key,
436
428
                                       cast_set<uint32_t>(key_length), iv, cast_set<int>(iv_length),
437
428
                                       true, encrypt, aad, cast_set<uint32_t>(aad_length));
438
428
    }
439
};
440
441
struct DecryptImpl {
442
    static int execute_impl(EncryptionMode mode, const unsigned char* source, size_t source_length,
443
                            const unsigned char* key, size_t key_length, const char* iv,
444
                            size_t iv_length, bool padding, unsigned char* encrypt,
445
369
                            const unsigned char* aad, size_t aad_length) {
446
369
        return EncryptionUtil::decrypt(mode, source, cast_set<uint32_t>(source_length), key,
447
369
                                       cast_set<uint32_t>(key_length), iv, cast_set<int>(iv_length),
448
369
                                       true, encrypt, aad, cast_set<uint32_t>(aad_length));
449
369
    }
450
};
451
452
struct SM4EncryptName {
453
    static constexpr auto name = "sm4_encrypt";
454
};
455
456
struct SM4DecryptName {
457
    static constexpr auto name = "sm4_decrypt";
458
};
459
460
struct AESEncryptName {
461
    static constexpr auto name = "aes_encrypt";
462
};
463
464
struct AESDecryptName {
465
    static constexpr auto name = "aes_decrypt";
466
};
467
468
8
void register_function_encryption(SimpleFunctionFactory& factory) {
469
8
    factory.register_function<FunctionEncryptionAndDecrypt<
470
8
            EncryptionAndDecryptTwoImpl<EncryptImpl, EncryptionMode::SM4_128_ECB, true>,
471
8
            SM4EncryptName>>();
472
8
    factory.register_function<FunctionEncryptionAndDecrypt<
473
8
            EncryptionAndDecryptTwoImpl<DecryptImpl, EncryptionMode::SM4_128_ECB, false>,
474
8
            SM4DecryptName>>();
475
8
    factory.register_function<FunctionEncryptionAndDecrypt<
476
8
            EncryptionAndDecryptTwoImpl<EncryptImpl, EncryptionMode::AES_128_ECB, true>,
477
8
            AESEncryptName>>();
478
8
    factory.register_function<FunctionEncryptionAndDecrypt<
479
8
            EncryptionAndDecryptTwoImpl<DecryptImpl, EncryptionMode::AES_128_ECB, false>,
480
8
            AESDecryptName>>();
481
482
8
    factory.register_function<FunctionEncryptionAndDecrypt<
483
8
            EncryptionAndDecryptMultiImpl<EncryptImpl, EncryptionMode::SM4_128_ECB, true, true>,
484
8
            SM4EncryptName>>();
485
8
    factory.register_function<FunctionEncryptionAndDecrypt<
486
8
            EncryptionAndDecryptMultiImpl<DecryptImpl, EncryptionMode::SM4_128_ECB, false, true>,
487
8
            SM4DecryptName>>();
488
8
    factory.register_function<FunctionEncryptionAndDecrypt<
489
8
            EncryptionAndDecryptMultiImpl<EncryptImpl, EncryptionMode::AES_128_ECB, true, false>,
490
8
            AESEncryptName>>();
491
8
    factory.register_function<FunctionEncryptionAndDecrypt<
492
8
            EncryptionAndDecryptMultiImpl<DecryptImpl, EncryptionMode::AES_128_ECB, false, false>,
493
8
            AESDecryptName>>();
494
495
8
    factory.register_function<FunctionEncryptionAndDecrypt<
496
8
            EncryptionAndDecryptMultiImpl<EncryptImpl, EncryptionMode::AES_128_GCM, true, false, 5>,
497
8
            AESEncryptName>>();
498
8
    factory.register_function<FunctionEncryptionAndDecrypt<
499
8
            EncryptionAndDecryptMultiImpl<DecryptImpl, EncryptionMode::AES_128_GCM, false, false,
500
8
                                          5>,
501
8
            AESDecryptName>>();
502
8
}
503
504
} // namespace doris