Coverage Report

Created: 2026-03-16 08:03

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/storage/delete/delete_handler.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 "storage/delete/delete_handler.h"
19
20
#include <gen_cpp/PaloInternalService_types.h>
21
#include <gen_cpp/olap_file.pb.h>
22
#include <thrift/protocol/TDebugProtocol.h>
23
24
#include <string>
25
#include <vector>
26
27
#include "common/config.h"
28
#include "common/logging.h"
29
#include "common/status.h"
30
#include "exprs/function/cast/cast_parameters.h"
31
#include "exprs/function/cast/cast_to_boolean.h"
32
#include "exprs/function/cast/cast_to_date_or_datetime_impl.hpp"
33
#include "exprs/function/cast/cast_to_datetimev2_impl.hpp"
34
#include "exprs/function/cast/cast_to_datev2_impl.hpp"
35
#include "exprs/function/cast/cast_to_decimal.h"
36
#include "exprs/function/cast/cast_to_float.h"
37
#include "exprs/function/cast/cast_to_int.h"
38
#include "exprs/function/cast/cast_to_ip.h"
39
#include "storage/olap_common.h"
40
#include "storage/predicate/block_column_predicate.h"
41
#include "storage/predicate/predicate_creator.h"
42
#include "storage/tablet/tablet_schema.h"
43
#include "storage/utils.h"
44
#include "util/debug_points.h"
45
46
using apache::thrift::ThriftDebugString;
47
using std::vector;
48
using std::string;
49
50
using ::google::protobuf::RepeatedPtrField;
51
52
namespace doris {
53
54
template <PrimitiveType PType>
55
Status convert(const DataTypePtr& data_type, const std::string& str, Arena& arena,
56
8.86k
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
2.91k
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
2.91k
        CastParameters parameters;
60
2.91k
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
2
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
2
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
2
                    str);
64
2
        }
65
2.90k
        return Status::OK();
66
2.91k
    }
67
0
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
0
        CastParameters parameters;
69
0
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
0
                    str);
73
0
        }
74
0
        return Status::OK();
75
0
    }
76
17
    if constexpr (PType == TYPE_DATE) {
77
17
        CastParameters parameters;
78
17
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
17
                                                      parameters)) {
80
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
0
                    str);
83
0
        }
84
17
        return Status::OK();
85
17
    }
86
17
    if constexpr (PType == TYPE_DATETIME) {
87
17
        CastParameters parameters;
88
17
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
17
                                                     parameters)) {
90
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
0
                    str);
93
0
        }
94
17
        return Status::OK();
95
17
    }
96
111
    if constexpr (PType == TYPE_DATEV2) {
97
111
        CastParameters parameters;
98
111
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
0
                    str);
102
0
        }
103
111
        return Status::OK();
104
111
    }
105
129
    if constexpr (PType == TYPE_DATETIMEV2) {
106
129
        CastParameters parameters;
107
129
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
129
                                           data_type->get_scale(), parameters)) {
109
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
0
                    str);
112
0
        }
113
129
        return Status::OK();
114
129
    }
115
4.92k
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
4.92k
        CastParameters parameters;
117
4.92k
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
4.92k
                                           data_type->get_scale())) {
119
5
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
5
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
5
                    str);
122
5
        }
123
4.91k
        return Status::OK();
124
4.92k
    }
125
250
    if constexpr (PType == TYPE_CHAR) {
126
250
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
250
        res = {str.data(), str.size()};
128
250
        if (target > str.size()) {
129
244
            char* buffer = arena.alloc(target);
130
244
            memset(buffer, 0, target);
131
244
            memcpy(buffer, str.data(), str.size());
132
244
            res = {buffer, target};
133
244
        }
134
250
        return Status::OK();
135
250
    }
136
414
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
414
        char* buffer = arena.alloc(str.size());
138
414
        memcpy(buffer, str.data(), str.size());
139
414
        res = {buffer, str.size()};
140
414
        return Status::OK();
141
414
    }
142
9
    if constexpr (PType == TYPE_BOOLEAN) {
143
9
        CastParameters parameters;
144
9
        UInt8 tmp;
145
9
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
0
                    str);
149
0
        }
150
9
        res = tmp != 0;
151
9
        return Status::OK();
152
9
    }
153
7
    if constexpr (PType == TYPE_IPV4) {
154
7
        CastParameters parameters;
155
7
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
0
                    str);
159
0
        }
160
7
        return Status::OK();
161
7
    }
162
21
    if constexpr (PType == TYPE_IPV6) {
163
21
        CastParameters parameters;
164
21
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
0
                    str);
168
0
        }
169
21
        return Status::OK();
170
21
    }
171
24
    if constexpr (PType == TYPE_DECIMALV2) {
172
24
        CastParameters parameters;
173
24
        Decimal128V2 tmp;
174
24
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
24
                                        data_type->get_scale(), parameters)) {
176
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
0
                    str);
179
0
        }
180
24
        res = DecimalV2Value(tmp.value);
181
24
        return Status::OK();
182
37
    } else if constexpr (is_decimal(PType)) {
183
37
        CastParameters parameters;
184
37
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
37
                                        data_type->get_scale(), parameters)) {
186
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
0
                    str);
189
0
        }
190
37
        return Status::OK();
191
37
    }
192
0
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
8.86k
            "unsupported data type in delete handler. type={}",
194
8.86k
            type_to_string(data_type->get_primitive_type()));
195
8.86k
}
_ZN5doris7convertILNS_13PrimitiveTypeE3EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
45
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
45
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
45
        CastParameters parameters;
60
45
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
2
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
2
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
2
                    str);
64
2
        }
65
43
        return Status::OK();
66
45
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
45
    } else if constexpr (is_decimal(PType)) {
183
45
        CastParameters parameters;
184
45
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
45
                                        data_type->get_scale(), parameters)) {
186
45
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
45
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
45
                    str);
189
45
        }
190
45
        return Status::OK();
191
45
    }
192
45
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
45
            "unsupported data type in delete handler. type={}",
194
45
            type_to_string(data_type->get_primitive_type()));
195
45
}
_ZN5doris7convertILNS_13PrimitiveTypeE4EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
18
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
18
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
18
        CastParameters parameters;
60
18
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
0
                    str);
64
0
        }
65
18
        return Status::OK();
66
18
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
18
    } else if constexpr (is_decimal(PType)) {
183
18
        CastParameters parameters;
184
18
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
18
                                        data_type->get_scale(), parameters)) {
186
18
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
18
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
18
                    str);
189
18
        }
190
18
        return Status::OK();
191
18
    }
192
18
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
18
            "unsupported data type in delete handler. type={}",
194
18
            type_to_string(data_type->get_primitive_type()));
195
18
}
_ZN5doris7convertILNS_13PrimitiveTypeE5EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
2.24k
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
2.24k
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
2.24k
        CastParameters parameters;
60
2.24k
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
0
                    str);
64
0
        }
65
2.24k
        return Status::OK();
66
2.24k
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
2.24k
    } else if constexpr (is_decimal(PType)) {
183
2.24k
        CastParameters parameters;
184
2.24k
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
2.24k
                                        data_type->get_scale(), parameters)) {
186
2.24k
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
2.24k
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
2.24k
                    str);
189
2.24k
        }
190
2.24k
        return Status::OK();
191
2.24k
    }
192
2.24k
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
2.24k
            "unsupported data type in delete handler. type={}",
194
2.24k
            type_to_string(data_type->get_primitive_type()));
195
2.24k
}
_ZN5doris7convertILNS_13PrimitiveTypeE6EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
167
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
167
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
167
        CastParameters parameters;
60
167
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
0
                    str);
64
0
        }
65
167
        return Status::OK();
66
167
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
167
    } else if constexpr (is_decimal(PType)) {
183
167
        CastParameters parameters;
184
167
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
167
                                        data_type->get_scale(), parameters)) {
186
167
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
167
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
167
                    str);
189
167
        }
190
167
        return Status::OK();
191
167
    }
192
167
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
167
            "unsupported data type in delete handler. type={}",
194
167
            type_to_string(data_type->get_primitive_type()));
195
167
}
_ZN5doris7convertILNS_13PrimitiveTypeE7EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
439
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
439
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
439
        CastParameters parameters;
60
439
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
0
                    str);
64
0
        }
65
439
        return Status::OK();
66
439
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
439
    } else if constexpr (is_decimal(PType)) {
183
439
        CastParameters parameters;
184
439
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
439
                                        data_type->get_scale(), parameters)) {
186
439
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
439
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
439
                    str);
189
439
        }
190
439
        return Status::OK();
191
439
    }
192
439
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
439
            "unsupported data type in delete handler. type={}",
194
439
            type_to_string(data_type->get_primitive_type()));
195
439
}
Unexecuted instantiation: _ZN5doris7convertILNS_13PrimitiveTypeE8EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Unexecuted instantiation: _ZN5doris7convertILNS_13PrimitiveTypeE9EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
_ZN5doris7convertILNS_13PrimitiveTypeE11EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
17
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
        CastParameters parameters;
60
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
                    str);
64
        }
65
        return Status::OK();
66
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
17
    if constexpr (PType == TYPE_DATE) {
77
17
        CastParameters parameters;
78
17
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
17
                                                      parameters)) {
80
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
0
                    str);
83
0
        }
84
17
        return Status::OK();
85
17
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
17
    } else if constexpr (is_decimal(PType)) {
183
17
        CastParameters parameters;
184
17
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
17
                                        data_type->get_scale(), parameters)) {
186
17
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
17
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
17
                    str);
189
17
        }
190
17
        return Status::OK();
191
17
    }
192
17
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
17
            "unsupported data type in delete handler. type={}",
194
17
            type_to_string(data_type->get_primitive_type()));
195
17
}
_ZN5doris7convertILNS_13PrimitiveTypeE12EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
17
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
        CastParameters parameters;
60
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
                    str);
64
        }
65
        return Status::OK();
66
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
17
    if constexpr (PType == TYPE_DATETIME) {
87
17
        CastParameters parameters;
88
17
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
17
                                                     parameters)) {
90
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
0
                    str);
93
0
        }
94
17
        return Status::OK();
95
17
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
17
    } else if constexpr (is_decimal(PType)) {
183
17
        CastParameters parameters;
184
17
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
17
                                        data_type->get_scale(), parameters)) {
186
17
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
17
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
17
                    str);
189
17
        }
190
17
        return Status::OK();
191
17
    }
192
17
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
17
            "unsupported data type in delete handler. type={}",
194
17
            type_to_string(data_type->get_primitive_type()));
195
17
}
_ZN5doris7convertILNS_13PrimitiveTypeE25EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
111
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
        CastParameters parameters;
60
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
                    str);
64
        }
65
        return Status::OK();
66
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
111
    if constexpr (PType == TYPE_DATEV2) {
97
111
        CastParameters parameters;
98
111
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
0
                    str);
102
0
        }
103
111
        return Status::OK();
104
111
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
111
    } else if constexpr (is_decimal(PType)) {
183
111
        CastParameters parameters;
184
111
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
111
                                        data_type->get_scale(), parameters)) {
186
111
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
111
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
111
                    str);
189
111
        }
190
111
        return Status::OK();
191
111
    }
192
111
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
111
            "unsupported data type in delete handler. type={}",
194
111
            type_to_string(data_type->get_primitive_type()));
195
111
}
_ZN5doris7convertILNS_13PrimitiveTypeE26EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
129
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
        CastParameters parameters;
60
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
                    str);
64
        }
65
        return Status::OK();
66
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
129
    if constexpr (PType == TYPE_DATETIMEV2) {
106
129
        CastParameters parameters;
107
129
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
129
                                           data_type->get_scale(), parameters)) {
109
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
0
                    str);
112
0
        }
113
129
        return Status::OK();
114
129
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
129
    } else if constexpr (is_decimal(PType)) {
183
129
        CastParameters parameters;
184
129
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
129
                                        data_type->get_scale(), parameters)) {
186
129
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
129
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
129
                    str);
189
129
        }
190
129
        return Status::OK();
191
129
    }
192
129
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
129
            "unsupported data type in delete handler. type={}",
194
129
            type_to_string(data_type->get_primitive_type()));
195
129
}
_ZN5doris7convertILNS_13PrimitiveTypeE42EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
4.92k
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
        CastParameters parameters;
60
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
                    str);
64
        }
65
        return Status::OK();
66
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
4.92k
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
4.92k
        CastParameters parameters;
117
4.92k
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
4.92k
                                           data_type->get_scale())) {
119
5
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
5
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
5
                    str);
122
5
        }
123
4.91k
        return Status::OK();
124
4.92k
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
4.92k
    } else if constexpr (is_decimal(PType)) {
183
4.92k
        CastParameters parameters;
184
4.92k
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
4.92k
                                        data_type->get_scale(), parameters)) {
186
4.92k
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
4.92k
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
4.92k
                    str);
189
4.92k
        }
190
4.92k
        return Status::OK();
191
4.92k
    }
192
4.92k
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
4.92k
            "unsupported data type in delete handler. type={}",
194
4.92k
            type_to_string(data_type->get_primitive_type()));
195
4.92k
}
_ZN5doris7convertILNS_13PrimitiveTypeE2EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
9
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
        CastParameters parameters;
60
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
                    str);
64
        }
65
        return Status::OK();
66
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
9
    if constexpr (PType == TYPE_BOOLEAN) {
143
9
        CastParameters parameters;
144
9
        UInt8 tmp;
145
9
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
0
                    str);
149
0
        }
150
9
        res = tmp != 0;
151
9
        return Status::OK();
152
9
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
9
    } else if constexpr (is_decimal(PType)) {
183
9
        CastParameters parameters;
184
9
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
9
                                        data_type->get_scale(), parameters)) {
186
9
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
9
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
9
                    str);
189
9
        }
190
9
        return Status::OK();
191
9
    }
192
9
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
9
            "unsupported data type in delete handler. type={}",
194
9
            type_to_string(data_type->get_primitive_type()));
195
9
}
_ZN5doris7convertILNS_13PrimitiveTypeE36EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
7
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
        CastParameters parameters;
60
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
                    str);
64
        }
65
        return Status::OK();
66
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
7
    if constexpr (PType == TYPE_IPV4) {
154
7
        CastParameters parameters;
155
7
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
0
                    str);
159
0
        }
160
7
        return Status::OK();
161
7
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
7
    } else if constexpr (is_decimal(PType)) {
183
7
        CastParameters parameters;
184
7
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
7
                                        data_type->get_scale(), parameters)) {
186
7
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
7
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
7
                    str);
189
7
        }
190
7
        return Status::OK();
191
7
    }
192
7
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
7
            "unsupported data type in delete handler. type={}",
194
7
            type_to_string(data_type->get_primitive_type()));
195
7
}
_ZN5doris7convertILNS_13PrimitiveTypeE37EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
21
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
        CastParameters parameters;
60
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
                    str);
64
        }
65
        return Status::OK();
66
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
21
    if constexpr (PType == TYPE_IPV6) {
163
21
        CastParameters parameters;
164
21
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
0
                    str);
168
0
        }
169
21
        return Status::OK();
170
21
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
21
    } else if constexpr (is_decimal(PType)) {
183
21
        CastParameters parameters;
184
21
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
21
                                        data_type->get_scale(), parameters)) {
186
21
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
21
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
21
                    str);
189
21
        }
190
21
        return Status::OK();
191
21
    }
192
21
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
21
            "unsupported data type in delete handler. type={}",
194
21
            type_to_string(data_type->get_primitive_type()));
195
21
}
_ZN5doris7convertILNS_13PrimitiveTypeE20EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
24
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
        CastParameters parameters;
60
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
                    str);
64
        }
65
        return Status::OK();
66
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
24
    if constexpr (PType == TYPE_DECIMALV2) {
172
24
        CastParameters parameters;
173
24
        Decimal128V2 tmp;
174
24
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
24
                                        data_type->get_scale(), parameters)) {
176
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
0
                    str);
179
0
        }
180
24
        res = DecimalV2Value(tmp.value);
181
24
        return Status::OK();
182
    } else if constexpr (is_decimal(PType)) {
183
        CastParameters parameters;
184
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
                                        data_type->get_scale(), parameters)) {
186
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
                    str);
189
        }
190
        return Status::OK();
191
    }
192
0
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
24
            "unsupported data type in delete handler. type={}",
194
24
            type_to_string(data_type->get_primitive_type()));
195
24
}
_ZN5doris7convertILNS_13PrimitiveTypeE28EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
12
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
        CastParameters parameters;
60
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
                    str);
64
        }
65
        return Status::OK();
66
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
12
    } else if constexpr (is_decimal(PType)) {
183
12
        CastParameters parameters;
184
12
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
12
                                        data_type->get_scale(), parameters)) {
186
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
0
                    str);
189
0
        }
190
12
        return Status::OK();
191
12
    }
192
0
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
12
            "unsupported data type in delete handler. type={}",
194
12
            type_to_string(data_type->get_primitive_type()));
195
12
}
_ZN5doris7convertILNS_13PrimitiveTypeE29EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
24
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
        CastParameters parameters;
60
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
                    str);
64
        }
65
        return Status::OK();
66
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
24
    } else if constexpr (is_decimal(PType)) {
183
24
        CastParameters parameters;
184
24
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
24
                                        data_type->get_scale(), parameters)) {
186
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
0
                    str);
189
0
        }
190
24
        return Status::OK();
191
24
    }
192
0
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
24
            "unsupported data type in delete handler. type={}",
194
24
            type_to_string(data_type->get_primitive_type()));
195
24
}
Unexecuted instantiation: _ZN5doris7convertILNS_13PrimitiveTypeE30EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
_ZN5doris7convertILNS_13PrimitiveTypeE35EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
1
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
        CastParameters parameters;
60
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
                    str);
64
        }
65
        return Status::OK();
66
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
1
    } else if constexpr (is_decimal(PType)) {
183
1
        CastParameters parameters;
184
1
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
1
                                        data_type->get_scale(), parameters)) {
186
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
0
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
0
                    str);
189
0
        }
190
1
        return Status::OK();
191
1
    }
192
0
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
1
            "unsupported data type in delete handler. type={}",
194
1
            type_to_string(data_type->get_primitive_type()));
195
1
}
_ZN5doris7convertILNS_13PrimitiveTypeE15EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
250
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
        CastParameters parameters;
60
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
                    str);
64
        }
65
        return Status::OK();
66
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
250
    if constexpr (PType == TYPE_CHAR) {
126
250
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
250
        res = {str.data(), str.size()};
128
250
        if (target > str.size()) {
129
244
            char* buffer = arena.alloc(target);
130
244
            memset(buffer, 0, target);
131
244
            memcpy(buffer, str.data(), str.size());
132
244
            res = {buffer, target};
133
244
        }
134
250
        return Status::OK();
135
250
    }
136
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
        char* buffer = arena.alloc(str.size());
138
        memcpy(buffer, str.data(), str.size());
139
        res = {buffer, str.size()};
140
        return Status::OK();
141
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
250
    } else if constexpr (is_decimal(PType)) {
183
250
        CastParameters parameters;
184
250
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
250
                                        data_type->get_scale(), parameters)) {
186
250
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
250
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
250
                    str);
189
250
        }
190
250
        return Status::OK();
191
250
    }
192
250
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
250
            "unsupported data type in delete handler. type={}",
194
250
            type_to_string(data_type->get_primitive_type()));
195
250
}
_ZN5doris7convertILNS_13PrimitiveTypeE10EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
408
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
        CastParameters parameters;
60
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
                    str);
64
        }
65
        return Status::OK();
66
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
408
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
408
        char* buffer = arena.alloc(str.size());
138
408
        memcpy(buffer, str.data(), str.size());
139
408
        res = {buffer, str.size()};
140
408
        return Status::OK();
141
408
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
408
    } else if constexpr (is_decimal(PType)) {
183
408
        CastParameters parameters;
184
408
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
408
                                        data_type->get_scale(), parameters)) {
186
408
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
408
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
408
                    str);
189
408
        }
190
408
        return Status::OK();
191
408
    }
192
408
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
408
            "unsupported data type in delete handler. type={}",
194
408
            type_to_string(data_type->get_primitive_type()));
195
408
}
_ZN5doris7convertILNS_13PrimitiveTypeE23EEENS_6StatusERKSt10shared_ptrIKNS_9IDataTypeEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS_5ArenaERNS_19PrimitiveTypeTraitsIXT_EE7CppTypeE
Line
Count
Source
56
6
               typename PrimitiveTypeTraits<PType>::CppType& res) {
57
    if constexpr (PType == TYPE_TINYINT || PType == TYPE_SMALLINT || PType == TYPE_INT ||
58
                  PType == TYPE_BIGINT || PType == TYPE_LARGEINT) {
59
        CastParameters parameters;
60
        if (!CastToInt::from_string<false>({str.data(), str.size()}, res, parameters)) {
61
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
62
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
63
                    str);
64
        }
65
        return Status::OK();
66
    }
67
    if constexpr (PType == TYPE_FLOAT || PType == TYPE_DOUBLE) {
68
        CastParameters parameters;
69
        if (!CastToFloat::from_string({str.data(), str.size()}, res, parameters)) {
70
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
71
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
72
                    str);
73
        }
74
        return Status::OK();
75
    }
76
    if constexpr (PType == TYPE_DATE) {
77
        CastParameters parameters;
78
        if (!CastToDateOrDatetime::from_string<false>({str.data(), str.size()}, res, nullptr,
79
                                                      parameters)) {
80
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
81
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
82
                    str);
83
        }
84
        return Status::OK();
85
    }
86
    if constexpr (PType == TYPE_DATETIME) {
87
        CastParameters parameters;
88
        if (!CastToDateOrDatetime::from_string<true>({str.data(), str.size()}, res, nullptr,
89
                                                     parameters)) {
90
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
91
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
92
                    str);
93
        }
94
        return Status::OK();
95
    }
96
    if constexpr (PType == TYPE_DATEV2) {
97
        CastParameters parameters;
98
        if (!CastToDateV2::from_string({str.data(), str.size()}, res, nullptr, parameters)) {
99
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
100
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
101
                    str);
102
        }
103
        return Status::OK();
104
    }
105
    if constexpr (PType == TYPE_DATETIMEV2) {
106
        CastParameters parameters;
107
        if (!CastToDatetimeV2::from_string({str.data(), str.size()}, res, nullptr,
108
                                           data_type->get_scale(), parameters)) {
109
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
110
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
111
                    str);
112
        }
113
        return Status::OK();
114
    }
115
    if constexpr (PType == TYPE_TIMESTAMPTZ) {
116
        CastParameters parameters;
117
        if (!CastToTimstampTz::from_string({str.data(), str.size()}, res, parameters, nullptr,
118
                                           data_type->get_scale())) {
119
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
120
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
121
                    str);
122
        }
123
        return Status::OK();
124
    }
125
    if constexpr (PType == TYPE_CHAR) {
126
        size_t target = assert_cast<const DataTypeString*>(remove_nullable(data_type).get())->len();
127
        res = {str.data(), str.size()};
128
        if (target > str.size()) {
129
            char* buffer = arena.alloc(target);
130
            memset(buffer, 0, target);
131
            memcpy(buffer, str.data(), str.size());
132
            res = {buffer, target};
133
        }
134
        return Status::OK();
135
    }
136
6
    if constexpr (PType == TYPE_STRING || PType == TYPE_VARCHAR) {
137
6
        char* buffer = arena.alloc(str.size());
138
6
        memcpy(buffer, str.data(), str.size());
139
6
        res = {buffer, str.size()};
140
6
        return Status::OK();
141
6
    }
142
    if constexpr (PType == TYPE_BOOLEAN) {
143
        CastParameters parameters;
144
        UInt8 tmp;
145
        if (!CastToBool::from_string({str.data(), str.size()}, tmp, parameters)) {
146
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
147
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
148
                    str);
149
        }
150
        res = tmp != 0;
151
        return Status::OK();
152
    }
153
    if constexpr (PType == TYPE_IPV4) {
154
        CastParameters parameters;
155
        if (!CastToIPv4::from_string({str.data(), str.size()}, res, parameters)) {
156
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
157
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
158
                    str);
159
        }
160
        return Status::OK();
161
    }
162
    if constexpr (PType == TYPE_IPV6) {
163
        CastParameters parameters;
164
        if (!CastToIPv6::from_string({str.data(), str.size()}, res, parameters)) {
165
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
166
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
167
                    str);
168
        }
169
        return Status::OK();
170
    }
171
    if constexpr (PType == TYPE_DECIMALV2) {
172
        CastParameters parameters;
173
        Decimal128V2 tmp;
174
        if (!CastToDecimal::from_string({str.data(), str.size()}, tmp, data_type->get_precision(),
175
                                        data_type->get_scale(), parameters)) {
176
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
177
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
178
                    str);
179
        }
180
        res = DecimalV2Value(tmp.value);
181
        return Status::OK();
182
6
    } else if constexpr (is_decimal(PType)) {
183
6
        CastParameters parameters;
184
6
        if (!CastToDecimal::from_string({str.data(), str.size()}, res, data_type->get_precision(),
185
6
                                        data_type->get_scale(), parameters)) {
186
6
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
187
6
                    "invalid {} string. str={}", type_to_string(data_type->get_primitive_type()),
188
6
                    str);
189
6
        }
190
6
        return Status::OK();
191
6
    }
192
6
    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
193
6
            "unsupported data type in delete handler. type={}",
194
6
            type_to_string(data_type->get_primitive_type()));
195
6
}
196
197
#define CONVERT_CASE(PType)                                            \
198
503
    case PType: {                                                      \
199
503
        set = build_set<PType>();                                      \
200
1.50k
        for (const auto& s : str) {                                    \
201
1.50k
            typename PrimitiveTypeTraits<PType>::CppType tmp;          \
202
1.50k
            RETURN_IF_ERROR(convert<PType>(data_type, s, arena, tmp)); \
203
1.50k
            set->insert(reinterpret_cast<const void*>(&tmp));          \
204
1.50k
        }                                                              \
205
503
        return Status::OK();                                           \
206
503
    }
207
Status convert(const DataTypePtr& data_type, const std::list<std::string>& str, Arena& arena,
208
505
               std::shared_ptr<HybridSetBase>& set) {
209
505
    switch (data_type->get_primitive_type()) {
210
3
        CONVERT_CASE(TYPE_TINYINT);
211
3
        CONVERT_CASE(TYPE_SMALLINT);
212
95
        CONVERT_CASE(TYPE_INT);
213
8
        CONVERT_CASE(TYPE_BIGINT);
214
0
        CONVERT_CASE(TYPE_LARGEINT);
215
0
        CONVERT_CASE(TYPE_FLOAT);
216
0
        CONVERT_CASE(TYPE_DOUBLE);
217
0
        CONVERT_CASE(TYPE_DATE);
218
0
        CONVERT_CASE(TYPE_DATETIME);
219
3
        CONVERT_CASE(TYPE_DATEV2);
220
3
        CONVERT_CASE(TYPE_DATETIMEV2);
221
130
        CONVERT_CASE(TYPE_TIMESTAMPTZ);
222
0
        CONVERT_CASE(TYPE_BOOLEAN);
223
0
        CONVERT_CASE(TYPE_IPV4);
224
0
        CONVERT_CASE(TYPE_IPV6);
225
6
        CONVERT_CASE(TYPE_DECIMALV2);
226
0
        CONVERT_CASE(TYPE_DECIMAL32);
227
3
        CONVERT_CASE(TYPE_DECIMAL64);
228
0
        CONVERT_CASE(TYPE_DECIMAL128I);
229
0
        CONVERT_CASE(TYPE_DECIMAL256);
230
124
        CONVERT_CASE(TYPE_CHAR);
231
122
        CONVERT_CASE(TYPE_VARCHAR);
232
3
        CONVERT_CASE(TYPE_STRING);
233
0
    default:
234
0
        return Status::Error<ErrorCode::INVALID_ARGUMENT>(
235
0
                "unsupported data type in delete handler. type={}",
236
0
                type_to_string(data_type->get_primitive_type()));
237
505
    }
238
0
    return Status::OK();
239
505
}
240
#undef CONVERT_CASE
241
242
#define CONVERT_CASE(PType)                                                                       \
243
7.36k
    case PType: {                                                                                 \
244
7.36k
        typename PrimitiveTypeTraits<PType>::CppType tmp;                                         \
245
7.36k
        RETURN_IF_ERROR(convert<PType>(type, res.value_str.front(), arena, tmp));                 \
246
7.36k
        v = Field::create_field<PType>(tmp);                                                      \
247
7.36k
        switch (res.condition_op) {                                                               \
248
3.59k
        case PredicateType::EQ:                                                                   \
249
3.59k
            predicate = create_comparison_predicate<PredicateType::EQ>(index, col_name, type, v,  \
250
3.59k
                                                                       true);                     \
251
3.59k
            return Status::OK();                                                                  \
252
1.03k
        case PredicateType::NE:                                                                   \
253
1.03k
            predicate = create_comparison_predicate<PredicateType::NE>(index, col_name, type, v,  \
254
1.03k
                                                                       true);                     \
255
1.03k
            return Status::OK();                                                                  \
256
730
        case PredicateType::GT:                                                                   \
257
730
            predicate = create_comparison_predicate<PredicateType::GT>(index, col_name, type, v,  \
258
730
                                                                       true);                     \
259
730
            return Status::OK();                                                                  \
260
435
        case PredicateType::GE:                                                                   \
261
435
            predicate = create_comparison_predicate<PredicateType::GE>(index, col_name, type, v,  \
262
435
                                                                       true);                     \
263
435
            return Status::OK();                                                                  \
264
857
        case PredicateType::LT:                                                                   \
265
857
            predicate = create_comparison_predicate<PredicateType::LT>(index, col_name, type, v,  \
266
857
                                                                       true);                     \
267
857
            return Status::OK();                                                                  \
268
704
        case PredicateType::LE:                                                                   \
269
704
            predicate = create_comparison_predicate<PredicateType::LE>(index, col_name, type, v,  \
270
704
                                                                       true);                     \
271
704
            return Status::OK();                                                                  \
272
0
        default:                                                                                  \
273
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(                                    \
274
0
                    "invalid condition operator. operator={}", type_to_op_str(res.condition_op)); \
275
7.36k
        }                                                                                         \
276
7.36k
    }
277
Status parse_to_predicate(const uint32_t index, const std::string col_name, const DataTypePtr& type,
278
                          DeleteHandler::ConditionParseResult& res, Arena& arena,
279
9.45k
                          std::shared_ptr<ColumnPredicate>& predicate) {
280
9.45k
    DCHECK_EQ(res.value_str.size(), 1);
281
9.45k
    if (res.condition_op == PredicateType::IS_NULL ||
282
9.45k
        res.condition_op == PredicateType::IS_NOT_NULL) {
283
587
        predicate = NullPredicate::create_shared(index, col_name,
284
587
                                                 res.condition_op == PredicateType::IS_NOT_NULL,
285
587
                                                 type->get_primitive_type());
286
587
        return Status::OK();
287
587
    }
288
8.86k
    Field v;
289
8.86k
    switch (type->get_primitive_type()) {
290
64
        CONVERT_CASE(TYPE_TINYINT);
291
24
        CONVERT_CASE(TYPE_SMALLINT);
292
3.87k
        CONVERT_CASE(TYPE_INT);
293
292
        CONVERT_CASE(TYPE_BIGINT);
294
876
        CONVERT_CASE(TYPE_LARGEINT);
295
0
        CONVERT_CASE(TYPE_FLOAT);
296
0
        CONVERT_CASE(TYPE_DOUBLE);
297
34
        CONVERT_CASE(TYPE_DATE);
298
34
        CONVERT_CASE(TYPE_DATETIME);
299
210
        CONVERT_CASE(TYPE_DATEV2);
300
246
        CONVERT_CASE(TYPE_DATETIMEV2);
301
8.93k
        CONVERT_CASE(TYPE_TIMESTAMPTZ);
302
18
        CONVERT_CASE(TYPE_BOOLEAN);
303
14
        CONVERT_CASE(TYPE_IPV4);
304
42
        CONVERT_CASE(TYPE_IPV6);
305
0
        CONVERT_CASE(TYPE_DECIMALV2);
306
24
        CONVERT_CASE(TYPE_DECIMAL32);
307
36
        CONVERT_CASE(TYPE_DECIMAL64);
308
0
        CONVERT_CASE(TYPE_DECIMAL128I);
309
2
        CONVERT_CASE(TYPE_DECIMAL256);
310
12
    case TYPE_CHAR:
311
1.26k
    case TYPE_VARCHAR:
312
1.48k
    case TYPE_STRING: {
313
1.48k
        v = Field::create_field<TYPE_STRING>(res.value_str.front());
314
1.48k
        switch (res.condition_op) {
315
1.44k
        case PredicateType::EQ:
316
1.44k
            predicate =
317
1.44k
                    create_comparison_predicate<PredicateType::EQ>(index, col_name, type, v, true);
318
1.44k
            return Status::OK();
319
9
        case PredicateType::NE:
320
9
            predicate =
321
9
                    create_comparison_predicate<PredicateType::NE>(index, col_name, type, v, true);
322
9
            return Status::OK();
323
0
        case PredicateType::GT:
324
0
            predicate =
325
0
                    create_comparison_predicate<PredicateType::GT>(index, col_name, type, v, true);
326
0
            return Status::OK();
327
9
        case PredicateType::GE:
328
9
            predicate =
329
9
                    create_comparison_predicate<PredicateType::GE>(index, col_name, type, v, true);
330
9
            return Status::OK();
331
21
        case PredicateType::LT:
332
21
            predicate =
333
21
                    create_comparison_predicate<PredicateType::LT>(index, col_name, type, v, true);
334
21
            return Status::OK();
335
9
        case PredicateType::LE:
336
9
            predicate =
337
9
                    create_comparison_predicate<PredicateType::LE>(index, col_name, type, v, true);
338
9
            return Status::OK();
339
0
        default:
340
0
            return Status::Error<ErrorCode::INVALID_ARGUMENT>(
341
0
                    "invalid condition operator. operator={}", type_to_op_str(res.condition_op));
342
1.48k
        }
343
0
        break;
344
1.48k
    }
345
0
    default:
346
0
        return Status::Error<ErrorCode::INVALID_ARGUMENT>(
347
0
                "unsupported data type in delete handler. type={}",
348
0
                type_to_string(type->get_primitive_type()));
349
8.86k
    }
350
0
    return Status::OK();
351
8.86k
#undef CONVERT_CASE
352
8.86k
}
353
354
Status parse_to_in_predicate(const uint32_t index, const std::string& col_name,
355
                             const DataTypePtr& type, DeleteHandler::ConditionParseResult& res,
356
503
                             Arena& arena, std::shared_ptr<ColumnPredicate>& predicate) {
357
503
    DCHECK_GT(res.value_str.size(), 1);
358
503
    switch (res.condition_op) {
359
432
    case PredicateType::IN_LIST: {
360
432
        std::shared_ptr<HybridSetBase> set;
361
432
        RETURN_IF_ERROR(convert(type, res.value_str, arena, set));
362
432
        predicate =
363
432
                create_in_list_predicate<PredicateType::IN_LIST>(index, col_name, type, set, true);
364
432
        break;
365
432
    }
366
71
    case PredicateType::NOT_IN_LIST: {
367
71
        std::shared_ptr<HybridSetBase> set;
368
71
        RETURN_IF_ERROR(convert(type, res.value_str, arena, set));
369
71
        predicate = create_in_list_predicate<PredicateType::NOT_IN_LIST>(index, col_name, type, set,
370
71
                                                                         true);
371
71
        break;
372
71
    }
373
0
    default:
374
0
        return Status::Error<ErrorCode::INVALID_ARGUMENT>("invalid condition operator. operator={}",
375
0
                                                          type_to_op_str(res.condition_op));
376
503
    }
377
505
    return Status::OK();
378
503
}
379
380
// construct sub condition from TCondition
381
3.20k
std::string construct_sub_predicate(const TCondition& condition) {
382
3.20k
    string op = condition.condition_op;
383
3.20k
    if (op == "<") {
384
313
        op += "<";
385
2.88k
    } else if (op == ">") {
386
232
        op += ">";
387
232
    }
388
3.20k
    string condition_str;
389
3.20k
    if ("IS" == op) {
390
        // ATTN: tricky! Surround IS with spaces to make it "special"
391
410
        condition_str = condition.column_name + " IS " + condition.condition_values[0];
392
2.79k
    } else { // multi-elements IN expr has been processed with InPredicatePB
393
2.79k
        if (op == "*=") {
394
2
            op = "=";
395
2.78k
        } else if (op == "!*=") {
396
2
            op = "!=";
397
2
        }
398
2.79k
        condition_str = condition.column_name + op + "'" + condition.condition_values[0] + "'";
399
2.79k
    }
400
3.20k
    return condition_str;
401
3.20k
}
402
403
// make operators from FE adaptive to BE
404
3.19k
std::string trans_op(const std::string& opt) {
405
3.19k
    std::string op = string(opt);
406
3.19k
    if (op == "<") {
407
314
        op += "<";
408
2.88k
    } else if (op == ">") {
409
234
        op += ">";
410
234
    }
411
3.19k
    if ("IS" != op) {
412
2.79k
        if (op == "*=") {
413
2
            op = "=";
414
2.79k
        } else if (op == "!*=") {
415
2
            op = "!=";
416
2
        }
417
2.79k
    }
418
3.19k
    return op;
419
3.19k
}
420
421
Status DeleteHandler::generate_delete_predicate(const TabletSchema& schema,
422
                                                const std::vector<TCondition>& conditions,
423
3.31k
                                                DeletePredicatePB* del_pred) {
424
3.31k
    DBUG_EXECUTE_IF("DeleteHandler::generate_delete_predicate.inject_failure", {
425
3.31k
        return Status::Error<false>(dp->param<int>("error_code"),
426
3.31k
                                    dp->param<std::string>("error_msg"));
427
3.31k
    })
428
3.31k
    if (conditions.empty()) {
429
1
        return Status::Error<ErrorCode::INVALID_ARGUMENT>(
430
1
                "invalid parameters for store_cond. condition_size={}", conditions.size());
431
1
    }
432
433
    // Check whether the delete condition meets the requirements
434
3.43k
    for (const TCondition& condition : conditions) {
435
3.43k
        RETURN_IF_ERROR(check_condition_valid(schema, condition));
436
3.43k
    }
437
438
    // Store delete condition
439
3.40k
    for (const TCondition& condition : conditions) {
440
3.40k
        if (condition.condition_values.size() > 1) {
441
195
            InPredicatePB* in_pred = del_pred->add_in_predicates();
442
195
            if (condition.__isset.column_unique_id) {
443
191
                in_pred->set_column_unique_id(condition.column_unique_id);
444
191
            }
445
195
            in_pred->set_column_name(condition.column_name);
446
195
            bool is_not_in = condition.condition_op == "!*=";
447
195
            in_pred->set_is_not_in(is_not_in);
448
620
            for (const auto& condition_value : condition.condition_values) {
449
620
                in_pred->add_values(condition_value);
450
620
            }
451
452
195
            LOG(INFO) << "store one sub-delete condition. condition name=" << in_pred->column_name()
453
195
                      << "condition size=" << in_pred->values().size();
454
3.20k
        } else {
455
            // write sub predicate v1 for compactbility
456
3.20k
            std::string condition_str = construct_sub_predicate(condition);
457
3.20k
            VLOG_NOTICE << __PRETTY_FUNCTION__ << " condition_str: " << condition_str;
458
3.20k
            del_pred->add_sub_predicates(condition_str);
459
3.20k
            DeleteSubPredicatePB* sub_predicate = del_pred->add_sub_predicates_v2();
460
3.20k
            if (condition.__isset.column_unique_id) {
461
                // only light schema change capable table set this field
462
3.10k
                sub_predicate->set_column_unique_id(condition.column_unique_id);
463
3.10k
            } else {
464
102
                try {
465
102
                    [[maybe_unused]] auto parsed_cond = parse_condition(condition_str);
466
102
                } catch (const Exception& e) {
467
0
                    return Status::Error<ErrorCode::INVALID_ARGUMENT>(
468
0
                            "failed to parse condition_str, condition={}, error={}",
469
0
                            ThriftDebugString(condition), e.to_string());
470
0
                }
471
102
            }
472
473
3.20k
            sub_predicate->set_column_name(condition.column_name);
474
3.20k
            sub_predicate->set_op(trans_op(condition.condition_op));
475
3.20k
            sub_predicate->set_cond_value(condition.condition_values[0]);
476
3.20k
            LOG(INFO) << "store one sub-delete condition. condition="
477
3.20k
                      << fmt::format(" {} {} {}", condition.column_name, condition.condition_op,
478
3.20k
                                     condition.condition_values[0]);
479
3.20k
        }
480
3.40k
    }
481
3.28k
    del_pred->set_version(-1);
482
483
3.28k
    return Status::OK();
484
3.28k
}
485
486
Status DeleteHandler::convert_to_sub_pred_v2(DeletePredicatePB* delete_pred,
487
0
                                             TabletSchemaSPtr schema) {
488
0
    if (!delete_pred->sub_predicates().empty() && delete_pred->sub_predicates_v2().empty()) {
489
0
        for (const auto& condition_str : delete_pred->sub_predicates()) {
490
0
            auto* sub_pred = delete_pred->add_sub_predicates_v2();
491
0
            auto condition = parse_condition(condition_str);
492
0
            const auto& column = *DORIS_TRY(schema->column(condition.column_name));
493
0
            sub_pred->set_column_unique_id(column.unique_id());
494
0
            sub_pred->set_column_name(condition.column_name);
495
0
            sub_pred->set_op(type_to_op_str(condition.condition_op));
496
0
            sub_pred->set_cond_value(condition.value_str.front());
497
0
        }
498
0
    }
499
500
0
    auto* in_pred_list = delete_pred->mutable_in_predicates();
501
0
    for (auto& in_pred : *in_pred_list) {
502
0
        const auto& column = *DORIS_TRY(schema->column(in_pred.column_name()));
503
0
        in_pred.set_column_unique_id(column.unique_id());
504
0
    }
505
0
    return Status::OK();
506
0
}
507
508
bool DeleteHandler::is_condition_value_valid(const TabletColumn& column,
509
                                             const std::string& condition_op,
510
3.84k
                                             const string& value_str) {
511
3.84k
    if ("IS" == condition_op && ("NULL" == value_str || "NOT NULL" == value_str)) {
512
411
        return true;
513
411
    }
514
515
3.42k
    FieldType field_type = column.type();
516
3.42k
    switch (field_type) {
517
25
    case FieldType::OLAP_FIELD_TYPE_TINYINT:
518
25
        return valid_signed_number<int8_t>(value_str);
519
17
    case FieldType::OLAP_FIELD_TYPE_SMALLINT:
520
17
        return valid_signed_number<int16_t>(value_str);
521
808
    case FieldType::OLAP_FIELD_TYPE_INT:
522
808
        return valid_signed_number<int32_t>(value_str);
523
58
    case FieldType::OLAP_FIELD_TYPE_BIGINT:
524
58
        return valid_signed_number<int64_t>(value_str);
525
159
    case FieldType::OLAP_FIELD_TYPE_LARGEINT:
526
159
        return valid_signed_number<int128_t>(value_str);
527
0
    case FieldType::OLAP_FIELD_TYPE_UNSIGNED_TINYINT:
528
0
        return valid_unsigned_number<uint8_t>(value_str);
529
0
    case FieldType::OLAP_FIELD_TYPE_UNSIGNED_SMALLINT:
530
0
        return valid_unsigned_number<uint16_t>(value_str);
531
0
    case FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT:
532
0
        return valid_unsigned_number<uint32_t>(value_str);
533
0
    case FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT:
534
0
        return valid_unsigned_number<uint64_t>(value_str);
535
15
    case FieldType::OLAP_FIELD_TYPE_DECIMAL:
536
15
        return valid_decimal(value_str, column.precision(), column.frac());
537
8
    case FieldType::OLAP_FIELD_TYPE_DECIMAL32:
538
8
        return valid_decimal(value_str, column.precision(), column.frac());
539
10
    case FieldType::OLAP_FIELD_TYPE_DECIMAL64:
540
10
        return valid_decimal(value_str, column.precision(), column.frac());
541
0
    case FieldType::OLAP_FIELD_TYPE_DECIMAL128I:
542
0
        return valid_decimal(value_str, column.precision(), column.frac());
543
1
    case FieldType::OLAP_FIELD_TYPE_DECIMAL256:
544
1
        return valid_decimal(value_str, column.precision(), column.frac());
545
11
    case FieldType::OLAP_FIELD_TYPE_CHAR:
546
232
    case FieldType::OLAP_FIELD_TYPE_VARCHAR:
547
232
        return value_str.size() <= column.length();
548
45
    case FieldType::OLAP_FIELD_TYPE_STRING:
549
45
        return value_str.size() <= config::string_type_length_soft_limit_bytes;
550
14
    case FieldType::OLAP_FIELD_TYPE_DATE:
551
29
    case FieldType::OLAP_FIELD_TYPE_DATETIME:
552
62
    case FieldType::OLAP_FIELD_TYPE_DATEV2:
553
97
    case FieldType::OLAP_FIELD_TYPE_DATETIMEV2:
554
2.00k
    case FieldType::OLAP_FIELD_TYPE_TIMESTAMPTZ:
555
2.00k
        return valid_datetime(value_str, column.frac());
556
5
    case FieldType::OLAP_FIELD_TYPE_BOOL:
557
5
        return valid_bool(value_str);
558
9
    case FieldType::OLAP_FIELD_TYPE_IPV4:
559
9
        return valid_ipv4(value_str);
560
36
    case FieldType::OLAP_FIELD_TYPE_IPV6:
561
36
        return valid_ipv6(value_str);
562
0
    default:
563
0
        LOG(WARNING) << "unknown field type. [type=" << int(field_type) << "]";
564
3.42k
    }
565
0
    return false;
566
3.42k
}
567
568
3.42k
Status DeleteHandler::check_condition_valid(const TabletSchema& schema, const TCondition& cond) {
569
    // Check whether the column exists
570
3.42k
    int32_t field_index = schema.field_index(cond.column_name);
571
3.42k
    if (field_index < 0) {
572
1
        return Status::Error<ErrorCode::INVALID_ARGUMENT>("field is not existent. [field_index={}]",
573
1
                                                          field_index);
574
1
    }
575
576
    // Delete condition should only applied on key columns or duplicate key table, and
577
    // the condition column type should not be float or double.
578
3.42k
    const TabletColumn& column = schema.column(field_index);
579
580
3.42k
    if (column.type() == FieldType::OLAP_FIELD_TYPE_DOUBLE ||
581
3.42k
        column.type() == FieldType::OLAP_FIELD_TYPE_FLOAT) {
582
0
        return Status::Error<ErrorCode::INVALID_ARGUMENT>("data type is float or double.");
583
0
    }
584
585
    // Check operator and operands size are matched.
586
3.42k
    if ("*=" != cond.condition_op && "!*=" != cond.condition_op &&
587
3.42k
        cond.condition_values.size() != 1) {
588
0
        return Status::Error<ErrorCode::INVALID_ARGUMENT>("invalid condition value size. [size={}]",
589
0
                                                          cond.condition_values.size());
590
0
    }
591
592
    // Check each operand is valid
593
3.85k
    for (const auto& condition_value : cond.condition_values) {
594
3.85k
        if (!is_condition_value_valid(column, cond.condition_op, condition_value)) {
595
29
            return Status::Error<ErrorCode::INVALID_ARGUMENT>("invalid condition value. [value={}]",
596
29
                                                              condition_value);
597
29
        }
598
3.85k
    }
599
600
3.39k
    if (!cond.__isset.column_unique_id) {
601
105
        LOG(WARNING) << "column=" << cond.column_name
602
105
                     << " in predicate does not have uid, table id=" << schema.table_id();
603
        // TODO(tsy): make it fail here after FE forbidding hard-link-schema-change
604
105
        return Status::OK();
605
105
    }
606
3.28k
    if (schema.field_index(cond.column_unique_id) == -1) {
607
0
        const auto& err_msg =
608
0
                fmt::format("column id does not exists in table={}, schema version={},",
609
0
                            schema.table_id(), schema.schema_version());
610
0
        return Status::Error<ErrorCode::INVALID_ARGUMENT>(err_msg);
611
0
    }
612
3.28k
    if (!iequal(schema.column_by_uid(cond.column_unique_id).name(), cond.column_name)) {
613
0
        const auto& err_msg = fmt::format(
614
0
                "colum name={} does not belongs to column uid={}, which "
615
0
                "column name={}, "
616
0
                "delete_cond.column_name ={}",
617
0
                cond.column_name, cond.column_unique_id,
618
0
                schema.column_by_uid(cond.column_unique_id).name(), cond.column_name);
619
0
        return Status::Error<ErrorCode::INVALID_ARGUMENT>(err_msg);
620
0
    }
621
622
3.28k
    return Status::OK();
623
3.28k
}
624
625
PredicateType DeleteHandler::parse_condition_op(const std::string& op_str,
626
9.56k
                                                const std::list<std::string>& cond_values) {
627
9.56k
    if (trim(to_lower(op_str)) == "=") {
628
5.08k
        return PredicateType::EQ;
629
5.08k
    } else if (trim(to_lower(op_str)) == "!=") {
630
1.05k
        return PredicateType::NE;
631
3.41k
    } else if (trim(to_lower(op_str)) == ">>") {
632
737
        return PredicateType::GT;
633
2.68k
    } else if (trim(to_lower(op_str)) == "<<") {
634
932
        return PredicateType::LT;
635
1.74k
    } else if (trim(to_lower(op_str)) == ">=") {
636
447
        return PredicateType::GE;
637
1.30k
    } else if (trim(to_lower(op_str)) == "<=") {
638
717
        return PredicateType::LE;
639
717
    } else if (trim(to_lower(op_str)) == "*=") {
640
0
        return cond_values.size() > 1 ? PredicateType::IN_LIST : PredicateType::EQ;
641
585
    } else if (trim(to_lower(op_str)) == "!*=") {
642
0
        return cond_values.size() > 1 ? PredicateType::NOT_IN_LIST : PredicateType::NE;
643
593
    } else if (trim(to_lower(op_str)) == "is") {
644
593
        return to_lower(cond_values.front()) == "null" ? PredicateType::IS_NULL
645
593
                                                       : PredicateType::IS_NOT_NULL;
646
18.4E
    } else {
647
18.4E
        throw Exception(Status::Error<ErrorCode::INVALID_ARGUMENT>(
648
18.4E
                "invalid condition operator. operator={}", op_str));
649
18.4E
    }
650
0
    return PredicateType::UNKNOWN;
651
9.56k
}
652
653
DeleteHandler::ConditionParseResult DeleteHandler::parse_condition(
654
9.36k
        const DeleteSubPredicatePB& sub_cond) {
655
9.36k
    ConditionParseResult res;
656
9.37k
    if (!sub_cond.has_column_name() || !sub_cond.has_op() || !sub_cond.has_cond_value()) {
657
0
        throw Exception(Status::Error<ErrorCode::INVALID_ARGUMENT>(
658
0
                "fail to parse condition. condition={} {} {}", sub_cond.column_name(),
659
0
                sub_cond.op(), sub_cond.cond_value()));
660
0
    }
661
9.36k
    if (sub_cond.has_column_unique_id()) {
662
9.27k
        res.col_unique_id = sub_cond.column_unique_id();
663
9.27k
    }
664
9.36k
    res.column_name = sub_cond.column_name();
665
9.36k
    res.value_str.push_back(sub_cond.cond_value());
666
9.36k
    res.condition_op = parse_condition_op(sub_cond.op(), res.value_str);
667
9.36k
    return res;
668
9.36k
}
669
670
// clang-format off
671
// Condition string format, the format is (column_name)(op)(value)
672
// eg: condition_str="c1 = 1597751948193618247 and length(source)<1;\n;\n"
673
// column_name: matches "c1", must include FeNameFormat.java COLUMN_NAME_REGEX
674
//              and compactible with any the lagacy
675
// operator: matches "="
676
// value: matches "1597751948193618247  and length(source)<1;\n;\n"
677
//
678
// For more info, see DeleteHandler::construct_sub_predicates
679
// FIXME(gavin): This is a tricky implementation, it should not be the final resolution, refactor it.
680
const char* const CONDITION_STR_PATTERN =
681
    // .----------------- column-name --------------------------.   .----------------------- operator ------------------------.   .------------ value ----------.
682
    R"(([_a-zA-Z@0-9\s/\p{L}][.a-zA-Z0-9_+-/?@#$%^&*"\s,:\p{L}]*)\s*((?:=)|(?:!=)|(?:>>)|(?:<<)|(?:>=)|(?:<=)|(?:\*=)|(?: IS ))\s*('((?:[\s\S]+)?)'|(?:[\s\S]+)?))";
683
    // '----------------- group 1 ------------------------------'   '--------------------- group 2 ---------------------------'   | '-- group 4--'              |
684
    //                                                                   match any of: = != >> << >= <= *= " IS "                 '----------- group 3 ---------'
685
    //                                                                                                                             match **ANY THING** without(4)
686
    //                                                                                                                             or with(3) single quote
687
// clang-format on
688
RE2 DELETE_HANDLER_REGEX(CONDITION_STR_PATTERN);
689
690
DeleteHandler::ConditionParseResult DeleteHandler::parse_condition(
691
182
        const std::string& condition_str) {
692
182
    ConditionParseResult res;
693
182
    std::string col_name, op, value, g4;
694
695
182
    bool matched = RE2::FullMatch(condition_str, DELETE_HANDLER_REGEX, &col_name, &op, &value,
696
182
                                  &g4); // exact match
697
698
182
    if (!matched) {
699
0
        throw Exception(
700
0
                Status::InvalidArgument("fail to sub condition. condition={}", condition_str));
701
0
    }
702
703
182
    res.column_name = col_name;
704
705
    // match string with single quotes, a = b  or a = 'b'
706
182
    if (!g4.empty()) {
707
141
        res.value_str.push_back(g4);
708
141
    } else {
709
41
        res.value_str.push_back(value);
710
41
    }
711
182
    res.condition_op = DeleteHandler::parse_condition_op(op, res.value_str);
712
182
    VLOG_NOTICE << "parsed condition_str: col_name={" << col_name << "} op={" << op << "} val={"
713
48
                << res.value_str.back() << "}";
714
182
    return res;
715
182
}
716
717
template <typename SubPredType>
718
    requires(std::is_same_v<SubPredType, DeleteSubPredicatePB> or
719
             std::is_same_v<SubPredType, std::string>)
720
Status DeleteHandler::_parse_column_pred(TabletSchemaSPtr complete_schema,
721
                                         TabletSchemaSPtr delete_pred_related_schema,
722
                                         const RepeatedPtrField<SubPredType>& sub_pred_list,
723
9.39k
                                         DeleteConditions* delete_conditions) {
724
9.44k
    for (const auto& sub_predicate : sub_pred_list) {
725
9.44k
        auto condition = parse_condition(sub_predicate);
726
9.44k
        int32_t col_unique_id = -1;
727
9.44k
        if constexpr (std::is_same_v<SubPredType, DeleteSubPredicatePB>) {
728
9.36k
            if (sub_predicate.has_column_unique_id()) [[likely]] {
729
9.26k
                col_unique_id = sub_predicate.column_unique_id();
730
9.26k
            }
731
9.36k
        }
732
9.44k
        if (col_unique_id < 0) {
733
181
            const auto& column =
734
181
                    *DORIS_TRY(delete_pred_related_schema->column(condition.column_name));
735
181
            col_unique_id = column.unique_id();
736
181
        }
737
9.44k
        condition.col_unique_id = col_unique_id;
738
9.44k
        const auto& column = complete_schema->column_by_uid(col_unique_id);
739
9.44k
        uint32_t index = complete_schema->field_index(col_unique_id);
740
9.44k
        std::shared_ptr<ColumnPredicate> predicate;
741
9.44k
        RETURN_IF_ERROR(parse_to_predicate(index, column.name(), column.get_vec_type(), condition,
742
9.44k
                                           _predicate_arena, predicate));
743
9.44k
        if (predicate != nullptr) {
744
9.44k
            delete_conditions->column_predicate_vec.push_back(predicate);
745
9.44k
        }
746
9.44k
    }
747
9.38k
    return Status::OK();
748
9.39k
}
_ZN5doris13DeleteHandler18_parse_column_predINS_20DeleteSubPredicatePBEQoosr3stdE9is_same_vIT_S2_Esr3stdE9is_same_vIS3_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEENS_6StatusESt10shared_ptrINS_12TabletSchemaEESD_RKN6google8protobuf16RepeatedPtrFieldIS3_EEPNS_16DeleteConditionsE
Line
Count
Source
723
9.05k
                                         DeleteConditions* delete_conditions) {
724
9.36k
    for (const auto& sub_predicate : sub_pred_list) {
725
9.36k
        auto condition = parse_condition(sub_predicate);
726
9.36k
        int32_t col_unique_id = -1;
727
9.36k
        if constexpr (std::is_same_v<SubPredType, DeleteSubPredicatePB>) {
728
9.36k
            if (sub_predicate.has_column_unique_id()) [[likely]] {
729
9.26k
                col_unique_id = sub_predicate.column_unique_id();
730
9.26k
            }
731
9.36k
        }
732
9.36k
        if (col_unique_id < 0) {
733
100
            const auto& column =
734
100
                    *DORIS_TRY(delete_pred_related_schema->column(condition.column_name));
735
100
            col_unique_id = column.unique_id();
736
100
        }
737
9.36k
        condition.col_unique_id = col_unique_id;
738
9.36k
        const auto& column = complete_schema->column_by_uid(col_unique_id);
739
9.36k
        uint32_t index = complete_schema->field_index(col_unique_id);
740
9.36k
        std::shared_ptr<ColumnPredicate> predicate;
741
9.36k
        RETURN_IF_ERROR(parse_to_predicate(index, column.name(), column.get_vec_type(), condition,
742
9.36k
                                           _predicate_arena, predicate));
743
9.36k
        if (predicate != nullptr) {
744
9.36k
            delete_conditions->column_predicate_vec.push_back(predicate);
745
9.36k
        }
746
9.36k
    }
747
9.05k
    return Status::OK();
748
9.05k
}
_ZN5doris13DeleteHandler18_parse_column_predINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEQoosr3stdE9is_same_vIT_NS_20DeleteSubPredicatePBEEsr3stdE9is_same_vIS8_S7_EEENS_6StatusESt10shared_ptrINS_12TabletSchemaEESD_RKN6google8protobuf16RepeatedPtrFieldIS8_EEPNS_16DeleteConditionsE
Line
Count
Source
723
342
                                         DeleteConditions* delete_conditions) {
724
342
    for (const auto& sub_predicate : sub_pred_list) {
725
81
        auto condition = parse_condition(sub_predicate);
726
81
        int32_t col_unique_id = -1;
727
        if constexpr (std::is_same_v<SubPredType, DeleteSubPredicatePB>) {
728
            if (sub_predicate.has_column_unique_id()) [[likely]] {
729
                col_unique_id = sub_predicate.column_unique_id();
730
            }
731
        }
732
81
        if (col_unique_id < 0) {
733
81
            const auto& column =
734
81
                    *DORIS_TRY(delete_pred_related_schema->column(condition.column_name));
735
81
            col_unique_id = column.unique_id();
736
81
        }
737
81
        condition.col_unique_id = col_unique_id;
738
81
        const auto& column = complete_schema->column_by_uid(col_unique_id);
739
81
        uint32_t index = complete_schema->field_index(col_unique_id);
740
81
        std::shared_ptr<ColumnPredicate> predicate;
741
81
        RETURN_IF_ERROR(parse_to_predicate(index, column.name(), column.get_vec_type(), condition,
742
81
                                           _predicate_arena, predicate));
743
74
        if (predicate != nullptr) {
744
74
            delete_conditions->column_predicate_vec.push_back(predicate);
745
74
        }
746
74
    }
747
335
    return Status::OK();
748
342
}
749
750
Status DeleteHandler::init(TabletSchemaSPtr tablet_schema,
751
1.03M
                           const std::vector<RowsetMetaSharedPtr>& delete_preds, int64_t version) {
752
18.4E
    DCHECK(!_is_inited) << "reinitialize delete handler.";
753
18.4E
    DCHECK(version >= 0) << "invalid parameters. version=" << version;
754
755
1.03M
    for (const auto& delete_pred : delete_preds) {
756
        // Skip the delete condition with large version
757
9.39k
        if (delete_pred->version().first > version) {
758
0
            continue;
759
0
        }
760
        // Need the tablet schema at the delete condition to parse the accurate column
761
9.39k
        const auto& delete_pred_related_schema = delete_pred->tablet_schema();
762
9.39k
        const auto& delete_condition = delete_pred->delete_predicate();
763
9.39k
        DeleteConditions temp;
764
9.39k
        temp.filter_version = delete_pred->version().first;
765
9.39k
        if (!delete_condition.sub_predicates_v2().empty()) {
766
9.05k
            RETURN_IF_ERROR(_parse_column_pred(tablet_schema, delete_pred_related_schema,
767
9.05k
                                               delete_condition.sub_predicates_v2(), &temp));
768
9.05k
        } else {
769
            // make it compatible with the former versions
770
345
            RETURN_IF_ERROR(_parse_column_pred(tablet_schema, delete_pred_related_schema,
771
345
                                               delete_condition.sub_predicates(), &temp));
772
345
        }
773
9.39k
        for (const auto& in_predicate : delete_condition.in_predicates()) {
774
503
            ConditionParseResult condition;
775
503
            condition.column_name = in_predicate.column_name();
776
777
503
            int32_t col_unique_id = -1;
778
503
            if (in_predicate.has_column_unique_id()) {
779
501
                col_unique_id = in_predicate.column_unique_id();
780
501
            } else {
781
                // if upgrade from version 2.0.x, column_unique_id maybe not set
782
2
                const auto& pre_column =
783
2
                        *DORIS_TRY(delete_pred_related_schema->column(condition.column_name));
784
2
                col_unique_id = pre_column.unique_id();
785
2
            }
786
503
            if (col_unique_id == -1) {
787
0
                return Status::Error<ErrorCode::DELETE_INVALID_CONDITION>(
788
0
                        "cannot get column_unique_id for column {}", condition.column_name);
789
0
            }
790
503
            condition.col_unique_id = col_unique_id;
791
792
503
            condition.condition_op =
793
503
                    in_predicate.is_not_in() ? PredicateType::NOT_IN_LIST : PredicateType::IN_LIST;
794
1.50k
            for (const auto& value : in_predicate.values()) {
795
1.50k
                condition.value_str.push_back(value);
796
1.50k
            }
797
503
            const auto& column = tablet_schema->column_by_uid(col_unique_id);
798
503
            uint32_t index = tablet_schema->field_index(col_unique_id);
799
503
            std::shared_ptr<ColumnPredicate> predicate;
800
503
            RETURN_IF_ERROR(parse_to_in_predicate(index, column.name(), column.get_vec_type(),
801
503
                                                  condition, _predicate_arena, predicate));
802
503
            temp.column_predicate_vec.push_back(predicate);
803
503
        }
804
805
9.39k
        _del_conds.emplace_back(std::move(temp));
806
9.39k
    }
807
808
1.03M
    _is_inited = true;
809
810
1.03M
    return Status::OK();
811
1.03M
}
812
813
1.06M
DeleteHandler::~DeleteHandler() {
814
1.06M
    if (!_is_inited) {
815
29.5k
        return;
816
29.5k
    }
817
818
1.03M
    _del_conds.clear();
819
1.03M
    _is_inited = false;
820
1.03M
}
821
822
void DeleteHandler::get_delete_conditions_after_version(
823
        int64_t version, AndBlockColumnPredicate* and_block_column_predicate_ptr,
824
        std::unordered_map<int32_t, std::vector<std::shared_ptr<const ColumnPredicate>>>*
825
3.11M
                del_predicates_for_zone_map) const {
826
3.11M
    for (const auto& del_cond : _del_conds) {
827
90.6k
        if (del_cond.filter_version > version) {
828
            // now, only query support delete column predicate operator
829
48.5k
            if (!del_cond.column_predicate_vec.empty()) {
830
48.5k
                if (del_cond.column_predicate_vec.size() == 1) {
831
46.9k
                    auto single_column_block_predicate = SingleColumnBlockPredicate::create_unique(
832
46.9k
                            del_cond.column_predicate_vec[0]);
833
46.9k
                    and_block_column_predicate_ptr->add_column_predicate(
834
46.9k
                            std::move(single_column_block_predicate));
835
46.9k
                    if (del_predicates_for_zone_map->count(
836
46.9k
                                del_cond.column_predicate_vec[0]->column_id()) < 1) {
837
22.6k
                        del_predicates_for_zone_map->insert(
838
22.6k
                                {del_cond.column_predicate_vec[0]->column_id(),
839
22.6k
                                 std::vector<std::shared_ptr<const ColumnPredicate>> {}});
840
22.6k
                    }
841
46.9k
                    (*del_predicates_for_zone_map)[del_cond.column_predicate_vec[0]->column_id()]
842
46.9k
                            .push_back(del_cond.column_predicate_vec[0]);
843
46.9k
                } else {
844
1.64k
                    auto or_column_predicate = OrBlockColumnPredicate::create_unique();
845
846
                    // build or_column_predicate
847
                    // when delete from where a = 1 and b = 2, we can not use del_predicates_for_zone_map to filter zone page,
848
                    // so here do not put predicate to del_predicates_for_zone_map,
849
                    // refer #17145 for more details.
850
                    // // TODO: need refactor design and code to use more version delete and more column delete to filter zone page.
851
1.64k
                    std::for_each(del_cond.column_predicate_vec.cbegin(),
852
1.64k
                                  del_cond.column_predicate_vec.cend(),
853
1.64k
                                  [&or_column_predicate](
854
3.60k
                                          const std::shared_ptr<const ColumnPredicate> predicate) {
855
3.60k
                                      or_column_predicate->add_column_predicate(
856
3.60k
                                              SingleColumnBlockPredicate::create_unique(predicate));
857
3.60k
                                  });
858
1.64k
                    and_block_column_predicate_ptr->add_column_predicate(
859
1.64k
                            std::move(or_column_predicate));
860
1.64k
                }
861
48.5k
            }
862
48.5k
        }
863
90.6k
    }
864
3.11M
}
865
866
} // namespace doris