Coverage Report

Created: 2025-03-13 18:54

/root/doris/be/src/common/status.h
Line
Count
Source (jump to first uncovered line)
1
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
2
// Use of this source code is governed by a BSD-style license that can be
3
// found in the LICENSE file. See the AUTHORS file for names of contributors.
4
5
#pragma once
6
7
#include <fmt/format.h>
8
#include <gen_cpp/Status_types.h> // for TStatus
9
#include <gen_cpp/types.pb.h>
10
#include <glog/logging.h>
11
12
#include <cstdint>
13
#include <iostream>
14
#include <memory>
15
#include <string>
16
#include <string_view>
17
#include <utility>
18
19
#include "common/compiler_util.h" // IWYU pragma: keep
20
#include "common/config.h"
21
#include "common/expected.h"
22
#include "util/stack_util.h"
23
24
namespace doris {
25
26
namespace io {
27
struct ObjectStorageStatus;
28
}
29
30
class Status;
31
32
extern io::ObjectStorageStatus convert_to_obj_response(Status st);
33
34
class PStatus;
35
36
namespace ErrorCode {
37
38
// E thrift_error_name, print_stacktrace
39
#define APPLY_FOR_THRIFT_ERROR_CODES(TStatusError)        \
40
    TStatusError(PUBLISH_TIMEOUT, false);                 \
41
    TStatusError(MEM_ALLOC_FAILED, true);                 \
42
    TStatusError(BUFFER_ALLOCATION_FAILED, true);         \
43
    TStatusError(INVALID_ARGUMENT, false);                \
44
    TStatusError(INVALID_JSON_PATH, false);               \
45
    TStatusError(MINIMUM_RESERVATION_UNAVAILABLE, true);  \
46
    TStatusError(CORRUPTION, true);                       \
47
    TStatusError(IO_ERROR, true);                         \
48
    TStatusError(NOT_FOUND, true);                        \
49
    TStatusError(ALREADY_EXIST, true);                    \
50
    TStatusError(NOT_IMPLEMENTED_ERROR, false);           \
51
    TStatusError(END_OF_FILE, false);                     \
52
    TStatusError(INTERNAL_ERROR, true);                   \
53
    TStatusError(RUNTIME_ERROR, true);                    \
54
    TStatusError(CANCELLED, false);                       \
55
    TStatusError(ANALYSIS_ERROR, false);                  \
56
    TStatusError(MEM_LIMIT_EXCEEDED, false);              \
57
    TStatusError(THRIFT_RPC_ERROR, true);                 \
58
    TStatusError(TIMEOUT, true);                          \
59
    TStatusError(LIMIT_REACH, false);                     \
60
    TStatusError(TOO_MANY_TASKS, true);                   \
61
    TStatusError(UNINITIALIZED, false);                   \
62
    TStatusError(INCOMPLETE, false);                      \
63
    TStatusError(OLAP_ERR_VERSION_ALREADY_MERGED, false); \
64
    TStatusError(ABORTED, false);                         \
65
    TStatusError(DATA_QUALITY_ERROR, false);              \
66
    TStatusError(LABEL_ALREADY_EXISTS, true);             \
67
    TStatusError(NOT_AUTHORIZED, true);                   \
68
    TStatusError(BINLOG_DISABLE, false);                  \
69
    TStatusError(BINLOG_TOO_OLD_COMMIT_SEQ, false);       \
70
    TStatusError(BINLOG_TOO_NEW_COMMIT_SEQ, false);       \
71
    TStatusError(BINLOG_NOT_FOUND_DB, false);             \
72
    TStatusError(BINLOG_NOT_FOUND_TABLE, false);          \
73
    TStatusError(NETWORK_ERROR, false);                   \
74
    TStatusError(ILLEGAL_STATE, false);                   \
75
    TStatusError(SNAPSHOT_NOT_EXIST, true);               \
76
    TStatusError(HTTP_ERROR, true);                       \
77
    TStatusError(TABLET_MISSING, true);                   \
78
    TStatusError(NOT_MASTER, true);                       \
79
    TStatusError(OBTAIN_LOCK_FAILED, false);              \
80
    TStatusError(SNAPSHOT_EXPIRED, false);                \
81
    TStatusError(DELETE_BITMAP_LOCK_ERROR, false);
82
// E error_name, error_code, print_stacktrace
83
#define APPLY_FOR_OLAP_ERROR_CODES(E)                        \
84
    E(OK, 0, false);                                         \
85
    E(CALL_SEQUENCE_ERROR, -202, true);                      \
86
    E(BUFFER_OVERFLOW, -204, true);                          \
87
    E(CONFIG_ERROR, -205, true);                             \
88
    E(INIT_FAILED, -206, true);                              \
89
    E(INVALID_SCHEMA, -207, true);                           \
90
    E(CHECKSUM_ERROR, -208, true);                           \
91
    E(SIGNATURE_ERROR, -209, true);                          \
92
    E(CATCH_EXCEPTION, -210, true);                          \
93
    E(PARSE_PROTOBUF_ERROR, -211, true);                     \
94
    E(SERIALIZE_PROTOBUF_ERROR, -212, true);                 \
95
    E(WRITE_PROTOBUF_ERROR, -213, true);                     \
96
    E(VERSION_NOT_EXIST, -214, false);                       \
97
    E(TABLE_NOT_FOUND, -215, true);                          \
98
    E(TRY_LOCK_FAILED, -216, false);                         \
99
    E(EXCEEDED_LIMIT, -217, false);                          \
100
    E(OUT_OF_BOUND, -218, false);                            \
101
    E(INVALID_ROOT_PATH, -222, true);                        \
102
    E(NO_AVAILABLE_ROOT_PATH, -223, true);                   \
103
    E(CHECK_LINES_ERROR, -224, true);                        \
104
    E(INVALID_CLUSTER_INFO, -225, true);                     \
105
    E(TRANSACTION_NOT_EXIST, -226, false);                   \
106
    E(DISK_FAILURE, -227, true);                             \
107
    E(TRANSACTION_ALREADY_COMMITTED, -228, false);           \
108
    E(TRANSACTION_ALREADY_VISIBLE, -229, false);             \
109
    E(VERSION_ALREADY_MERGED, -230, true);                   \
110
    E(LZO_DISABLED, -231, true);                             \
111
    E(DISK_REACH_CAPACITY_LIMIT, -232, true);                \
112
    E(TOO_MANY_TRANSACTIONS, -233, false);                   \
113
    E(INVALID_SNAPSHOT_VERSION, -234, true);                 \
114
    E(TOO_MANY_VERSION, -235, false);                        \
115
    E(NOT_INITIALIZED, -236, true);                          \
116
    E(ALREADY_CANCELLED, -237, false);                       \
117
    E(TOO_MANY_SEGMENTS, -238, false);                       \
118
    E(ALREADY_CLOSED, -239, false);                          \
119
    E(SERVICE_UNAVAILABLE, -240, true);                      \
120
    E(NEED_SEND_AGAIN, -241, false);                         \
121
    E(OS_ERROR, -242, true);                                 \
122
    E(DIR_NOT_EXIST, -243, true);                            \
123
    E(CREATE_FILE_ERROR, -245, true);                        \
124
    E(STL_ERROR, -246, true);                                \
125
    E(MUTEX_ERROR, -247, true);                              \
126
    E(PTHREAD_ERROR, -248, true);                            \
127
    E(UB_FUNC_ERROR, -250, true);                            \
128
    E(COMPRESS_ERROR, -251, true);                           \
129
    E(DECOMPRESS_ERROR, -252, true);                         \
130
    E(FILE_ALREADY_EXIST, -253, true);                       \
131
    E(BAD_CAST, -254, true);                                 \
132
    E(ARITHMETIC_OVERFLOW_ERRROR, -255, false);              \
133
    E(PERMISSION_DENIED, -256, false);                       \
134
    E(QUERY_MEMORY_EXCEEDED, -257, false);                   \
135
    E(WORKLOAD_GROUP_MEMORY_EXCEEDED, -258, false);          \
136
    E(PROCESS_MEMORY_EXCEEDED, -259, false);                 \
137
    E(CE_CMD_PARAMS_ERROR, -300, true);                      \
138
    E(CE_BUFFER_TOO_SMALL, -301, true);                      \
139
    E(CE_CMD_NOT_VALID, -302, true);                         \
140
    E(CE_LOAD_TABLE_ERROR, -303, true);                      \
141
    E(CE_NOT_FINISHED, -304, true);                          \
142
    E(CE_TABLET_ID_EXIST, -305, true);                       \
143
    E(TABLE_VERSION_DUPLICATE_ERROR, -400, true);            \
144
    E(TABLE_VERSION_INDEX_MISMATCH_ERROR, -401, true);       \
145
    E(TABLE_INDEX_VALIDATE_ERROR, -402, true);               \
146
    E(TABLE_INDEX_FIND_ERROR, -403, true);                   \
147
    E(TABLE_CREATE_FROM_HEADER_ERROR, -404, true);           \
148
    E(TABLE_CREATE_META_ERROR, -405, true);                  \
149
    E(TABLE_ALREADY_DELETED_ERROR, -406, false);             \
150
    E(ENGINE_INSERT_EXISTS_TABLE, -500, true);               \
151
    E(ENGINE_DROP_NOEXISTS_TABLE, -501, true);               \
152
    E(ENGINE_LOAD_INDEX_TABLE_ERROR, -502, true);            \
153
    E(TABLE_INSERT_DUPLICATION_ERROR, -503, true);           \
154
    E(DELETE_VERSION_ERROR, -504, true);                     \
155
    E(GC_SCAN_PATH_ERROR, -505, true);                       \
156
    E(ENGINE_INSERT_OLD_TABLET, -506, true);                 \
157
    E(FETCH_OTHER_ERROR, -600, true);                        \
158
    E(FETCH_TABLE_NOT_EXIST, -601, true);                    \
159
    E(FETCH_VERSION_ERROR, -602, true);                      \
160
    E(FETCH_SCHEMA_ERROR, -603, true);                       \
161
    E(FETCH_COMPRESSION_ERROR, -604, true);                  \
162
    E(FETCH_CONTEXT_NOT_EXIST, -605, true);                  \
163
    E(FETCH_GET_READER_PARAMS_ERR, -606, true);              \
164
    E(FETCH_SAVE_SESSION_ERR, -607, true);                   \
165
    E(FETCH_MEMORY_EXCEEDED, -608, true);                    \
166
    E(READER_IS_UNINITIALIZED, -700, true);                  \
167
    E(READER_GET_ITERATOR_ERROR, -701, true);                \
168
    E(CAPTURE_ROWSET_READER_ERROR, -702, true);              \
169
    E(READER_READING_ERROR, -703, true);                     \
170
    E(READER_INITIALIZE_ERROR, -704, true);                  \
171
    E(BE_VERSION_NOT_MATCH, -800, true);                     \
172
    E(BE_REPLACE_VERSIONS_ERROR, -801, true);                \
173
    E(BE_MERGE_ERROR, -802, true);                           \
174
    E(CAPTURE_ROWSET_ERROR, -804, true);                     \
175
    E(BE_SAVE_HEADER_ERROR, -805, true);                     \
176
    E(BE_INIT_OLAP_DATA, -806, true);                        \
177
    E(BE_TRY_OBTAIN_VERSION_LOCKS, -807, true);              \
178
    E(BE_NO_SUITABLE_VERSION, -808, false);                  \
179
    E(BE_INVALID_NEED_MERGED_VERSIONS, -810, true);          \
180
    E(BE_ERROR_DELETE_ACTION, -811, true);                   \
181
    E(BE_SEGMENTS_OVERLAPPING, -812, true);                  \
182
    E(PUSH_INIT_ERROR, -900, true);                          \
183
    E(PUSH_VERSION_INCORRECT, -902, true);                   \
184
    E(PUSH_SCHEMA_MISMATCH, -903, true);                     \
185
    E(PUSH_CHECKSUM_ERROR, -904, true);                      \
186
    E(PUSH_ACQUIRE_DATASOURCE_ERROR, -905, true);            \
187
    E(PUSH_CREAT_CUMULATIVE_ERROR, -906, true);              \
188
    E(PUSH_BUILD_DELTA_ERROR, -907, true);                   \
189
    E(PUSH_VERSION_ALREADY_EXIST, -908, false);              \
190
    E(PUSH_TABLE_NOT_EXIST, -909, true);                     \
191
    E(PUSH_INPUT_DATA_ERROR, -910, true);                    \
192
    E(PUSH_TRANSACTION_ALREADY_EXIST, -911, false);          \
193
    E(PUSH_BATCH_PROCESS_REMOVED, -912, true);               \
194
    E(PUSH_COMMIT_ROWSET, -913, true);                       \
195
    E(PUSH_ROWSET_NOT_FOUND, -914, true);                    \
196
    E(INDEX_LOAD_ERROR, -1000, true);                        \
197
    E(INDEX_CHECKSUM_ERROR, -1002, true);                    \
198
    E(INDEX_DELTA_PRUNING, -1003, true);                     \
199
    E(DATA_ROW_BLOCK_ERROR, -1100, true);                    \
200
    E(DATA_FILE_TYPE_ERROR, -1101, true);                    \
201
    E(WRITER_INDEX_WRITE_ERROR, -1200, true);                \
202
    E(WRITER_DATA_WRITE_ERROR, -1201, true);                 \
203
    E(WRITER_ROW_BLOCK_ERROR, -1202, true);                  \
204
    E(WRITER_SEGMENT_NOT_FINALIZED, -1203, true);            \
205
    E(ROWBLOCK_DECOMPRESS_ERROR, -1300, true);               \
206
    E(ROWBLOCK_FIND_ROW_EXCEPTION, -1301, true);             \
207
    E(HEADER_ADD_VERSION, -1400, true);                      \
208
    E(HEADER_DELETE_VERSION, -1401, true);                   \
209
    E(HEADER_ADD_PENDING_DELTA, -1402, true);                \
210
    E(HEADER_ADD_INCREMENTAL_VERSION, -1403, true);          \
211
    E(HEADER_INVALID_FLAG, -1404, true);                     \
212
    E(HEADER_LOAD_INVALID_KEY, -1408, true);                 \
213
    E(HEADER_LOAD_JSON_HEADER, -1410, true);                 \
214
    E(HEADER_INIT_FAILED, -1411, true);                      \
215
    E(HEADER_PB_PARSE_FAILED, -1412, true);                  \
216
    E(HEADER_HAS_PENDING_DATA, -1413, true);                 \
217
    E(SCHEMA_SCHEMA_INVALID, -1500, true);                   \
218
    E(SCHEMA_SCHEMA_FIELD_INVALID, -1501, true);             \
219
    E(ALTER_MULTI_TABLE_ERR, -1600, true);                   \
220
    E(ALTER_DELTA_DOES_NOT_EXISTS, -1601, true);             \
221
    E(ALTER_STATUS_ERR, -1602, true);                        \
222
    E(PREVIOUS_SCHEMA_CHANGE_NOT_FINISHED, -1603, true);     \
223
    E(SCHEMA_CHANGE_INFO_INVALID, -1604, true);              \
224
    E(QUERY_SPLIT_KEY_ERR, -1605, true);                     \
225
    E(DATA_QUALITY_ERR, -1606, false);                       \
226
    E(COLUMN_DATA_LOAD_BLOCK, -1700, true);                  \
227
    E(COLUMN_DATA_RECORD_INDEX, -1701, true);                \
228
    E(COLUMN_DATA_MAKE_FILE_HEADER, -1702, true);            \
229
    E(COLUMN_DATA_READ_VAR_INT, -1703, true);                \
230
    E(COLUMN_DATA_PATCH_LIST_NUM, -1704, true);              \
231
    E(COLUMN_READ_STREAM, -1706, true);                      \
232
    E(COLUMN_STREAM_NOT_EXIST, -1716, true);                 \
233
    E(COLUMN_VALUE_NULL, -1717, true);                       \
234
    E(COLUMN_SEEK_ERROR, -1719, true);                       \
235
    E(COLUMN_NO_MATCH_OFFSETS_SIZE, -1720, true);            \
236
    E(COLUMN_NO_MATCH_FILTER_SIZE, -1721, true);             \
237
    E(DELETE_INVALID_CONDITION, -1900, true);                \
238
    E(DELETE_UPDATE_HEADER_FAILED, -1901, true);             \
239
    E(DELETE_SAVE_HEADER_FAILED, -1902, true);               \
240
    E(DELETE_INVALID_PARAMETERS, -1903, true);               \
241
    E(DELETE_INVALID_VERSION, -1904, true);                  \
242
    E(CUMULATIVE_NO_SUITABLE_VERSION, -2000, false);         \
243
    E(CUMULATIVE_REPEAT_INIT, -2001, true);                  \
244
    E(CUMULATIVE_INVALID_PARAMETERS, -2002, true);           \
245
    E(CUMULATIVE_FAILED_ACQUIRE_DATA_SOURCE, -2003, true);   \
246
    E(CUMULATIVE_INVALID_NEED_MERGED_VERSIONS, -2004, true); \
247
    E(CUMULATIVE_ERROR_DELETE_ACTION, -2005, true);          \
248
    E(CUMULATIVE_MISS_VERSION, -2006, true);                 \
249
    E(FULL_NO_SUITABLE_VERSION, -2008, false);               \
250
    E(FULL_MISS_VERSION, -2009, true);                       \
251
    E(META_INVALID_ARGUMENT, -3000, true);                   \
252
    E(META_OPEN_DB_ERROR, -3001, true);                      \
253
    E(META_KEY_NOT_FOUND, -3002, false);                     \
254
    E(META_GET_ERROR, -3003, true);                          \
255
    E(META_PUT_ERROR, -3004, true);                          \
256
    E(META_ITERATOR_ERROR, -3005, true);                     \
257
    E(META_DELETE_ERROR, -3006, true);                       \
258
    E(META_ALREADY_EXIST, -3007, true);                      \
259
    E(ROWSET_WRITER_INIT, -3100, true);                      \
260
    E(ROWSET_SAVE_FAILED, -3101, true);                      \
261
    E(ROWSET_GENERATE_ID_FAILED, -3102, true);               \
262
    E(ROWSET_DELETE_FILE_FAILED, -3103, true);               \
263
    E(ROWSET_BUILDER_INIT, -3104, true);                     \
264
    E(ROWSET_TYPE_NOT_FOUND, -3105, true);                   \
265
    E(ROWSET_ALREADY_EXIST, -3106, true);                    \
266
    E(ROWSET_CREATE_READER, -3107, true);                    \
267
    E(ROWSET_INVALID, -3108, true);                          \
268
    E(ROWSET_READER_INIT, -3110, true);                      \
269
    E(ROWSET_INVALID_STATE_TRANSITION, -3112, true);         \
270
    E(STRING_OVERFLOW_IN_VEC_ENGINE, -3113, true);           \
271
    E(ROWSET_ADD_MIGRATION_V2, -3114, true);                 \
272
    E(PUBLISH_VERSION_NOT_CONTINUOUS, -3115, false);         \
273
    E(ROWSET_RENAME_FILE_FAILED, -3116, false);              \
274
    E(SEGCOMPACTION_INIT_READER, -3117, false);              \
275
    E(SEGCOMPACTION_INIT_WRITER, -3118, false);              \
276
    E(SEGCOMPACTION_FAILED, -3119, false);                   \
277
    E(PIP_WAIT_FOR_RF, -3120, false);                        \
278
    E(PIP_WAIT_FOR_SC, -3121, false);                        \
279
    E(ROWSET_ADD_TO_BINLOG_FAILED, -3122, true);             \
280
    E(ROWSET_BINLOG_NOT_ONLY_ONE_VERSION, -3123, true);      \
281
    E(INVERTED_INDEX_INVALID_PARAMETERS, -6000, false);      \
282
    E(INVERTED_INDEX_NOT_SUPPORTED, -6001, false);           \
283
    E(INVERTED_INDEX_CLUCENE_ERROR, -6002, false);           \
284
    E(INVERTED_INDEX_FILE_NOT_FOUND, -6003, false);          \
285
    E(INVERTED_INDEX_BYPASS, -6004, false);                  \
286
    E(INVERTED_INDEX_NO_TERMS, -6005, false);                \
287
    E(INVERTED_INDEX_RENAME_FILE_FAILED, -6006, true);       \
288
    E(INVERTED_INDEX_EVALUATE_SKIPPED, -6007, false);        \
289
    E(INVERTED_INDEX_BUILD_WAITTING, -6008, false);          \
290
    E(INVERTED_INDEX_NOT_IMPLEMENTED, -6009, false);         \
291
    E(INVERTED_INDEX_COMPACTION_ERROR, -6010, false);        \
292
    E(INVERTED_INDEX_ANALYZER_ERROR, -6011, false);          \
293
    E(INVERTED_INDEX_FILE_CORRUPTED, -6012, false);          \
294
    E(KEY_NOT_FOUND, -7000, false);                          \
295
    E(KEY_ALREADY_EXISTS, -7001, false);                     \
296
    E(ENTRY_NOT_FOUND, -7002, false);                        \
297
    E(INVALID_TABLET_STATE, -7211, false);                   \
298
    E(ROWSETS_EXPIRED, -7311, false);                        \
299
    E(CGROUP_ERROR, -7411, false);                           \
300
    E(FATAL_ERROR, -7412, false);
301
302
// Define constexpr int error_code_name = error_code_value
303
#define M(NAME, ERRORCODE, ENABLESTACKTRACE) constexpr int NAME = ERRORCODE;
304
APPLY_FOR_OLAP_ERROR_CODES(M)
305
#undef M
306
307
#define MM(name, ENABLESTACKTRACE) constexpr int name = TStatusCode::name;
308
APPLY_FOR_THRIFT_ERROR_CODES(MM)
309
#undef MM
310
311
constexpr int MAX_ERROR_CODE_DEFINE_NUM = 65536;
312
struct ErrorCodeState {
313
    int16_t error_code = 0;
314
    bool stacktrace = true;
315
    std::string description;
316
    size_t count = 0; // Used for count the number of error happens
317
    std::mutex mutex; // lock guard for count state
318
};
319
extern ErrorCodeState error_states[MAX_ERROR_CODE_DEFINE_NUM];
320
321
class ErrorCodeInitializer {
322
public:
323
0
    ErrorCodeInitializer(int temp) : signal_value(temp) {
324
0
        for (auto& error_state : error_states) {
325
0
            error_state.error_code = 0;
326
0
        }
327
0
#define M(NAME, ENABLESTACKTRACE)                                  \
328
0
    error_states[TStatusCode::NAME].stacktrace = ENABLESTACKTRACE; \
329
0
    error_states[TStatusCode::NAME].description = #NAME;           \
330
0
    error_states[TStatusCode::NAME].error_code = TStatusCode::NAME;
331
0
        APPLY_FOR_THRIFT_ERROR_CODES(M)
332
0
#undef M
333
0
// In status.h, if error code > 0, then it means it will be used in TStatusCode and will
334
0
// also be used in FE.
335
0
// Other error codes that with error code < 0, will only be used in BE.
336
0
// We use abs(error code) as the index in error_states, so that these two kinds of error
337
0
// codes MUST not have overlap.
338
0
// Add an assert here to make sure the code in TStatusCode and other error code are not
339
0
// overlapped.
340
0
#define M(NAME, ERRORCODE, ENABLESTACKTRACE)                    \
341
0
    assert(error_states[abs(ERRORCODE)].error_code == 0);       \
342
0
    error_states[abs(ERRORCODE)].stacktrace = ENABLESTACKTRACE; \
343
0
    error_states[abs(ERRORCODE)].error_code = ERRORCODE;
344
0
        APPLY_FOR_OLAP_ERROR_CODES(M)
345
0
#undef M
346
0
    }
347
348
1
    void check_init() const {
349
        //the signal value is 0, it means the global error states not inited, it's logical error
350
        // DO NOT use dcheck here, because dcheck depend on glog, and glog maybe not inited at this time.
351
1
        if (signal_value == 0) {
352
0
            exit(-1);
353
0
        }
354
1
    }
355
356
private:
357
    int signal_value = 0;
358
};
359
360
extern ErrorCodeInitializer error_code_init;
361
} // namespace ErrorCode
362
363
class [[nodiscard]] Status {
364
public:
365
336M
    Status() : _code(ErrorCode::OK), _err_msg(nullptr) {}
366
367
    // used to convert Exception to Status
368
    Status(int code, std::string msg, std::string stack = "") : _code(code) {
369
        _err_msg = std::make_unique<ErrMsg>();
370
        _err_msg->_msg = std::move(msg);
371
        if (config::enable_stacktrace) {
372
            _err_msg->_stack = std::move(stack);
373
        }
374
    }
375
376
    // copy c'tor makes copy of error detail so Status can be returned by value
377
230k
    Status(const Status& rhs) { *this = rhs; }
378
379
    // move c'tor
380
30.4k
    Status(Status&& rhs) noexcept = default;
381
382
    // same as copy c'tor
383
230k
    Status& operator=(const Status& rhs) {
384
230k
        _code = rhs._code;
385
230k
        if (rhs._err_msg) {
386
1.12k
            _err_msg = std::make_unique<ErrMsg>(*rhs._err_msg);
387
229k
        } else {
388
            // If rhs error msg is empty, then should also clear current error msg
389
            // For example, if rhs is OK and current status is error, then copy to current
390
            // status, should clear current error message.
391
229k
            _err_msg.reset();
392
229k
        }
393
230k
        return *this;
394
230k
    }
395
396
    // move assign
397
2.87M
    Status& operator=(Status&& rhs) noexcept {
398
2.87M
        _code = rhs._code;
399
2.87M
        if (rhs._err_msg) {
400
40.6k
            _err_msg = std::move(rhs._err_msg);
401
2.83M
        } else {
402
2.83M
            _err_msg.reset();
403
2.83M
        }
404
2.87M
        return *this;
405
2.87M
    }
406
407
    template <bool stacktrace = true>
408
    Status static create(const TStatus& status) {
409
        return Error<stacktrace>(
410
                status.status_code,
411
                "TStatus: " + (status.error_msgs.empty() ? "" : status.error_msgs[0]));
412
    }
413
414
    template <bool stacktrace = true>
415
    Status static create(const PStatus& pstatus) {
416
        return Error<stacktrace>(
417
                pstatus.status_code(),
418
                "PStatus: " + (pstatus.error_msgs_size() == 0 ? "" : pstatus.error_msgs(0)));
419
    }
420
421
    template <int code, bool stacktrace = true, typename... Args>
422
6.64k
    Status static Error(std::string_view msg, Args&&... args) {
423
6.64k
        Status status;
424
6.64k
        status._code = code;
425
6.64k
        status._err_msg = std::make_unique<ErrMsg>();
426
6.64k
        if constexpr (sizeof...(args) == 0) {
427
27
            status._err_msg->_msg = msg;
428
27
        } else {
429
27
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
27
        }
431
6.64k
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
6.64k
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
6.64k
        return status;
438
6.64k
    }
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJRSt17basic_string_viewIcSt11char_traitsIcEEEEES0_S5_DpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJRlEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILi6ELb1EJRKmRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEES0_St17basic_string_viewIcS7_EDpOT1_
_ZN5doris6Status5ErrorILi33ELb0EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
83
    Status static Error(std::string_view msg, Args&&... args) {
423
83
        Status status;
424
83
        status._code = code;
425
83
        status._err_msg = std::make_unique<ErrMsg>();
426
83
        if constexpr (sizeof...(args) == 0) {
427
83
            status._err_msg->_msg = msg;
428
83
        } else {
429
83
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
83
        }
431
83
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
83
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
83
        return status;
438
83
    }
Unexecuted instantiation: _ZN5doris6Status5ErrorILi4ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILi5ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJiEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJRlRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_EEES0_St17basic_string_viewIcS6_EDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin257ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin258ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin259ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEES0_St17basic_string_viewIcS5_EDpOT1_
_ZN5doris6Status5ErrorILi32ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
1
    Status static Error(std::string_view msg, Args&&... args) {
423
1
        Status status;
424
1
        status._code = code;
425
1
        status._err_msg = std::make_unique<ErrMsg>();
426
1
        if constexpr (sizeof...(args) == 0) {
427
1
            status._err_msg->_msg = msg;
428
1
        } else {
429
1
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
1
        }
431
1
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
1
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
1
        return status;
438
1
    }
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJRmEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJPKcEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJPKcS3_EEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_EEES0_St17basic_string_viewIcS5_EDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_S7_EEES0_St17basic_string_viewIcS5_EDpOT1_
_ZN5doris6Status5ErrorILi6ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
58
    Status static Error(std::string_view msg, Args&&... args) {
423
58
        Status status;
424
58
        status._code = code;
425
58
        status._err_msg = std::make_unique<ErrMsg>();
426
58
        if constexpr (sizeof...(args) == 0) {
427
58
            status._err_msg->_msg = msg;
428
58
        } else {
429
58
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
58
        }
431
58
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
58
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
58
        return status;
438
58
    }
_ZN5doris6Status5ErrorILi33ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
30
    Status static Error(std::string_view msg, Args&&... args) {
423
30
        Status status;
424
30
        status._code = code;
425
30
        status._err_msg = std::make_unique<ErrMsg>();
426
30
        if constexpr (sizeof...(args) == 0) {
427
30
            status._err_msg->_msg = msg;
428
30
        } else {
429
30
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
30
        }
431
30
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
30
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
30
        return status;
438
30
    }
_ZN5doris6Status5ErrorILi3ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
2
    Status static Error(std::string_view msg, Args&&... args) {
423
2
        Status status;
424
2
        status._code = code;
425
2
        status._err_msg = std::make_unique<ErrMsg>();
426
2
        if constexpr (sizeof...(args) == 0) {
427
2
            status._err_msg->_msg = msg;
428
2
        } else {
429
2
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
2
        }
431
2
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
2
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
2
        return status;
438
2
    }
Unexecuted instantiation: _ZN5doris6Status5ErrorILi33ELb1EJRmRKtEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILi33ELb1EJRmRiEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
_ZN5doris6Status5ErrorILi33ELb0EJRNS_10segment_v214HashStrategyPBEEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
1
    Status static Error(std::string_view msg, Args&&... args) {
423
1
        Status status;
424
1
        status._code = code;
425
1
        status._err_msg = std::make_unique<ErrMsg>();
426
1
        if constexpr (sizeof...(args) == 0) {
427
1
            status._err_msg->_msg = msg;
428
1
        } else {
429
1
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
1
        }
431
1
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
1
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
1
        return status;
438
1
    }
Unexecuted instantiation: _ZN5doris6Status5ErrorILi3ELb1EJRKNS_13PrimitiveTypeEEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJimEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEES0_St17basic_string_viewIcS5_EDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin6009ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJSt17basic_string_viewIcSt11char_traitsIcEEEEES0_S5_DpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILi6ELb1EJR8CURLcodeEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
_ZN5doris6Status5ErrorILi34ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
10
    Status static Error(std::string_view msg, Args&&... args) {
423
10
        Status status;
424
10
        status._code = code;
425
10
        status._err_msg = std::make_unique<ErrMsg>();
426
10
        if constexpr (sizeof...(args) == 0) {
427
10
            status._err_msg->_msg = msg;
428
10
        } else {
429
10
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
10
        }
431
10
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
10
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
10
        return status;
438
10
    }
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJRNS_19TStorageBackendType4typeEEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
_ZN5doris6Status5ErrorILi34ELb1EJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS7_S7_EEES0_St17basic_string_viewIcS5_EDpOT1_
Line
Count
Source
422
2
    Status static Error(std::string_view msg, Args&&... args) {
423
2
        Status status;
424
2
        status._code = code;
425
2
        status._err_msg = std::make_unique<ErrMsg>();
426
2
        if constexpr (sizeof...(args) == 0) {
427
2
            status._err_msg->_msg = msg;
428
2
        } else {
429
2
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
2
        }
431
2
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
2
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
2
        return status;
438
2
    }
_ZN5doris6Status5ErrorILi34ELb0EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
3
    Status static Error(std::string_view msg, Args&&... args) {
423
3
        Status status;
424
3
        status._code = code;
425
3
        status._err_msg = std::make_unique<ErrMsg>();
426
3
        if constexpr (sizeof...(args) == 0) {
427
3
            status._err_msg->_msg = msg;
428
3
        } else {
429
3
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
3
        }
431
3
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
3
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
3
        return status;
438
3
    }
Unexecuted instantiation: _ZN5doris6Status5ErrorILi33ELb0EJNS_13PredicateTypeEEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
_ZN5doris6Status5ErrorILi6ELb1EJiRA15_KcEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
2
    Status static Error(std::string_view msg, Args&&... args) {
423
2
        Status status;
424
2
        status._code = code;
425
2
        status._err_msg = std::make_unique<ErrMsg>();
426
2
        if constexpr (sizeof...(args) == 0) {
427
2
            status._err_msg->_msg = msg;
428
2
        } else {
429
2
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
2
        }
431
2
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
2
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
2
        return status;
438
2
    }
_ZN5doris6Status5ErrorILin206ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
2
    Status static Error(std::string_view msg, Args&&... args) {
423
2
        Status status;
424
2
        status._code = code;
425
2
        status._err_msg = std::make_unique<ErrMsg>();
426
2
        if constexpr (sizeof...(args) == 0) {
427
2
            status._err_msg->_msg = msg;
428
2
        } else {
429
2
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
2
        }
431
2
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
2
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
2
        return status;
438
2
    }
_ZN5doris6Status5ErrorILin3002ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
38
    Status static Error(std::string_view msg, Args&&... args) {
423
38
        Status status;
424
38
        status._code = code;
425
38
        status._err_msg = std::make_unique<ErrMsg>();
426
38
        if constexpr (sizeof...(args) == 0) {
427
38
            status._err_msg->_msg = msg;
428
38
        } else {
429
38
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
38
        }
431
38
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
38
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
38
        return status;
438
38
    }
_ZN5doris6Status5ErrorILi33ELb1EJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEES0_St17basic_string_viewIcS5_EDpOT1_
Line
Count
Source
422
2
    Status static Error(std::string_view msg, Args&&... args) {
423
2
        Status status;
424
2
        status._code = code;
425
2
        status._err_msg = std::make_unique<ErrMsg>();
426
2
        if constexpr (sizeof...(args) == 0) {
427
2
            status._err_msg->_msg = msg;
428
2
        } else {
429
2
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
2
        }
431
2
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
2
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
2
        return status;
438
2
    }
_ZN5doris6Status5ErrorILi30ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
253
    Status static Error(std::string_view msg, Args&&... args) {
423
253
        Status status;
424
253
        status._code = code;
425
253
        status._err_msg = std::make_unique<ErrMsg>();
426
253
        if constexpr (sizeof...(args) == 0) {
427
253
            status._err_msg->_msg = msg;
428
253
        } else {
429
253
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
253
        }
431
253
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
253
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
253
        return status;
438
253
    }
_ZN5doris6Status5ErrorILin6002ELb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
10
    Status static Error(std::string_view msg, Args&&... args) {
423
10
        Status status;
424
10
        status._code = code;
425
10
        status._err_msg = std::make_unique<ErrMsg>();
426
10
        if constexpr (sizeof...(args) == 0) {
427
10
            status._err_msg->_msg = msg;
428
10
        } else {
429
10
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
10
        }
431
10
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
10
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
10
        return status;
438
10
    }
Unexecuted instantiation: _ZN5doris6Status5ErrorILi6ELb1EJiiEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILi6ELb1EJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_EEES0_St17basic_string_viewIcS5_EDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILi6ELb1EJiiiiEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILi6ELb1EJRNS_10segment_v212idx_query_v29QueryTypeEEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
_ZN5doris6Status5ErrorILi6ELb1EJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEES0_St17basic_string_viewIcS5_EDpOT1_
Line
Count
Source
422
2
    Status static Error(std::string_view msg, Args&&... args) {
423
2
        Status status;
424
2
        status._code = code;
425
2
        status._err_msg = std::make_unique<ErrMsg>();
426
2
        if constexpr (sizeof...(args) == 0) {
427
2
            status._err_msg->_msg = msg;
428
2
        } else {
429
2
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
2
        }
431
2
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
2
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
2
        return status;
438
2
    }
_ZN5doris6Status5ErrorILi36ELb0EJPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS9_lEEES0_St17basic_string_viewIcS7_EDpOT1_
Line
Count
Source
422
2
    Status static Error(std::string_view msg, Args&&... args) {
423
2
        Status status;
424
2
        status._code = code;
425
2
        status._err_msg = std::make_unique<ErrMsg>();
426
2
        if constexpr (sizeof...(args) == 0) {
427
2
            status._err_msg->_msg = msg;
428
2
        } else {
429
2
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
2
        }
431
2
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
2
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
2
        return status;
438
2
    }
_ZN5doris6Status5ErrorILi30ELb0EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
6.11k
    Status static Error(std::string_view msg, Args&&... args) {
423
6.11k
        Status status;
424
6.11k
        status._code = code;
425
6.11k
        status._err_msg = std::make_unique<ErrMsg>();
426
6.11k
        if constexpr (sizeof...(args) == 0) {
427
6.11k
            status._err_msg->_msg = msg;
428
6.11k
        } else {
429
6.11k
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
6.11k
        }
431
6.11k
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
6.11k
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
6.11k
        return status;
438
6.11k
    }
_ZN5doris6Status5ErrorILi6ELb1EJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEES0_St17basic_string_viewIcS5_EDpOT1_
Line
Count
Source
422
2
    Status static Error(std::string_view msg, Args&&... args) {
423
2
        Status status;
424
2
        status._code = code;
425
2
        status._err_msg = std::make_unique<ErrMsg>();
426
2
        if constexpr (sizeof...(args) == 0) {
427
2
            status._err_msg->_msg = msg;
428
2
        } else {
429
2
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
2
        }
431
2
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
2
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
2
        return status;
438
2
    }
Unexecuted instantiation: _ZN5doris6Status5ErrorILi6ELb1EJmNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_jS7_S7_EEES0_St17basic_string_viewIcS5_EDpOT1_
_ZN5doris6Status5ErrorILi1ELb0EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
17
    Status static Error(std::string_view msg, Args&&... args) {
423
17
        Status status;
424
17
        status._code = code;
425
17
        status._err_msg = std::make_unique<ErrMsg>();
426
17
        if constexpr (sizeof...(args) == 0) {
427
17
            status._err_msg->_msg = msg;
428
17
        } else {
429
17
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
17
        }
431
17
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
17
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
17
        return status;
438
17
    }
_ZN5doris6Status5ErrorILi36ELb0EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
1
    Status static Error(std::string_view msg, Args&&... args) {
423
1
        Status status;
424
1
        status._code = code;
425
1
        status._err_msg = std::make_unique<ErrMsg>();
426
1
        if constexpr (sizeof...(args) == 0) {
427
1
            status._err_msg->_msg = msg;
428
1
        } else {
429
1
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
1
        }
431
1
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
1
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
1
        return status;
438
1
    }
Unexecuted instantiation: _ZN5doris6Status5ErrorILi4ELb1EJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEES0_St17basic_string_viewIcS5_EDpOT1_
_ZN5doris6Status5ErrorILi6ELb1EJPKcEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
12
    Status static Error(std::string_view msg, Args&&... args) {
423
12
        Status status;
424
12
        status._code = code;
425
12
        status._err_msg = std::make_unique<ErrMsg>();
426
12
        if constexpr (sizeof...(args) == 0) {
427
12
            status._err_msg->_msg = msg;
428
12
        } else {
429
12
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
12
        }
431
12
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
12
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
12
        return status;
438
12
    }
_ZN5doris6Status5ErrorILi6ELb1EJmEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Line
Count
Source
422
2
    Status static Error(std::string_view msg, Args&&... args) {
423
2
        Status status;
424
2
        status._code = code;
425
2
        status._err_msg = std::make_unique<ErrMsg>();
426
2
        if constexpr (sizeof...(args) == 0) {
427
2
            status._err_msg->_msg = msg;
428
2
        } else {
429
2
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
430
2
        }
431
2
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
432
2
            config::enable_stacktrace) {
433
            // Delete the first one frame pointers, which are inside the status.h
434
0
            status._err_msg->_stack = get_stack_trace(1);
435
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
436
0
        }
437
2
        return status;
438
2
    }
Unexecuted instantiation: _ZN5doris6Status5ErrorILi6ELb1EJRKNS_13TSerdeDialect4typeEEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILi6ELb1EJRiNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmEEES0_St17basic_string_viewIcS6_EDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILi32ELb1EJRmS2_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_EEES0_St17basic_string_viewIcS6_EDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILi32ELb1EJRjRmEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILi6ELb0EJPKcEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILi33ELb0EJRKPKcRiEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILi33ELb0EJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKPKcEEES0_St17basic_string_viewIcS5_EDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJRcEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJRiEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
Unexecuted instantiation: _ZN5doris6Status5ErrorILin7412ELb1EJRlS2_EEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT1_
439
440
    template <bool stacktrace = true, typename... Args>
441
19.8k
    Status static Error(int code, std::string_view msg, Args&&... args) {
442
19.8k
        Status status;
443
19.8k
        status._code = code;
444
19.8k
        status._err_msg = std::make_unique<ErrMsg>();
445
19.8k
        if constexpr (sizeof...(args) == 0) {
446
19.8k
            status._err_msg->_msg = msg;
447
19.8k
        } else {
448
19.8k
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
449
19.8k
        }
450
19.8k
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
451
19.8k
            config::enable_stacktrace) {
452
0
            status._err_msg->_stack = get_stack_trace(1);
453
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
454
0
        }
455
19.8k
        return status;
456
19.8k
    }
_ZN5doris6Status5ErrorILb0EJEEES0_iSt17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Line
Count
Source
441
19.8k
    Status static Error(int code, std::string_view msg, Args&&... args) {
442
19.8k
        Status status;
443
19.8k
        status._code = code;
444
19.8k
        status._err_msg = std::make_unique<ErrMsg>();
445
19.8k
        if constexpr (sizeof...(args) == 0) {
446
19.8k
            status._err_msg->_msg = msg;
447
19.8k
        } else {
448
19.8k
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
449
19.8k
        }
450
19.8k
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
451
19.8k
            config::enable_stacktrace) {
452
0
            status._err_msg->_stack = get_stack_trace(1);
453
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
454
0
        }
455
19.8k
        return status;
456
19.8k
    }
_ZN5doris6Status5ErrorILb1EJEEES0_iSt17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Line
Count
Source
441
68
    Status static Error(int code, std::string_view msg, Args&&... args) {
442
68
        Status status;
443
68
        status._code = code;
444
68
        status._err_msg = std::make_unique<ErrMsg>();
445
68
        if constexpr (sizeof...(args) == 0) {
446
68
            status._err_msg->_msg = msg;
447
68
        } else {
448
68
            status._err_msg->_msg = fmt::format(msg, std::forward<Args>(args)...);
449
68
        }
450
68
        if (stacktrace && ErrorCode::error_states[abs(code)].stacktrace &&
451
68
            config::enable_stacktrace) {
452
0
            status._err_msg->_stack = get_stack_trace(1);
453
0
            LOG(WARNING) << "meet error status: " << status; // may print too many stacks.
454
0
        }
455
68
        return status;
456
68
    }
457
458
336M
    static Status OK() { return {}; }
459
460
    template <bool stacktrace = true, typename... Args>
461
0
    static Status FatalError(std::string_view msg, Args&&... args) {
462
0
#ifndef NDEBUG
463
0
        LOG(FATAL) << fmt::format(msg, std::forward<Args>(args)...);
464
0
#endif
465
0
        return Error<ErrorCode::FATAL_ERROR, stacktrace>(msg, std::forward<Args>(args)...);
466
0
    }
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJRSt17basic_string_viewIcSt11char_traitsIcEEEEES0_S5_DpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJRlEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJiEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJRlRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_EEES0_St17basic_string_viewIcS6_EDpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEES0_St17basic_string_viewIcS5_EDpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJRmEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJPKcEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJPKcS3_EEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_EEES0_St17basic_string_viewIcS5_EDpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_S7_EEES0_St17basic_string_viewIcS5_EDpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJimEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEES0_St17basic_string_viewIcS5_EDpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJSt17basic_string_viewIcSt11char_traitsIcEEEEES0_S5_DpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJRcEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJRiEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status10FatalErrorILb1EJRlS2_EEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
467
468
// default have stacktrace. could disable manually.
469
#define ERROR_CTOR(name, code)                                                       \
470
    template <bool stacktrace = true, typename... Args>                              \
471
91
    static Status name(std::string_view msg, Args&&... args) {                       \
472
91
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
473
91
    }
Unexecuted instantiation: _ZN5doris6Status13InternalErrorILb1EJRKmRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEES0_St17basic_string_viewIcS7_EDpOT0_
Unexecuted instantiation: _ZN5doris6Status12RuntimeErrorILb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status19MemoryLimitExceededILb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
_ZN5doris6Status10CorruptionILb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Line
Count
Source
471
1
    static Status name(std::string_view msg, Args&&... args) {                       \
472
1
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
473
1
    }
_ZN5doris6Status13InternalErrorILb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Line
Count
Source
471
57
    static Status name(std::string_view msg, Args&&... args) {                       \
472
57
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
473
57
    }
Unexecuted instantiation: _ZN5doris6Status12NotSupportedILb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status12NotSupportedILb1EJRKNS_13PrimitiveTypeEEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status13InternalErrorILb1EJR8CURLcodeEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
_ZN5doris6Status7IOErrorILb1EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Line
Count
Source
471
10
    static Status name(std::string_view msg, Args&&... args) {                       \
472
10
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
473
10
    }
_ZN5doris6Status7IOErrorILb1EJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS7_S7_EEES0_St17basic_string_viewIcS5_EDpOT0_
Line
Count
Source
471
2
    static Status name(std::string_view msg, Args&&... args) {                       \
472
2
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
473
2
    }
_ZN5doris6Status7IOErrorILb0EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Line
Count
Source
471
1
    static Status name(std::string_view msg, Args&&... args) {                       \
472
1
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
473
1
    }
_ZN5doris6Status13InternalErrorILb1EJiRA15_KcEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Line
Count
Source
471
2
    static Status name(std::string_view msg, Args&&... args) {                       \
472
2
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
473
2
    }
Unexecuted instantiation: _ZN5doris6Status13InternalErrorILb1EJiiEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status13InternalErrorILb1EJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_EEES0_St17basic_string_viewIcS5_EDpOT0_
Unexecuted instantiation: _ZN5doris6Status13InternalErrorILb1EJiiiiEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status13InternalErrorILb1EJRNS_10segment_v212idx_query_v29QueryTypeEEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
_ZN5doris6Status13InternalErrorILb1EJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEES0_St17basic_string_viewIcS5_EDpOT0_
Line
Count
Source
471
2
    static Status name(std::string_view msg, Args&&... args) {                       \
472
2
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
473
2
    }
_ZN5doris6Status13InternalErrorILb1EJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEES0_St17basic_string_viewIcS5_EDpOT0_
Line
Count
Source
471
2
    static Status name(std::string_view msg, Args&&... args) {                       \
472
2
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
473
2
    }
Unexecuted instantiation: _ZN5doris6Status12RuntimeErrorILb1EJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEES0_St17basic_string_viewIcS5_EDpOT0_
_ZN5doris6Status13InternalErrorILb1EJPKcEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Line
Count
Source
471
12
    static Status name(std::string_view msg, Args&&... args) {                       \
472
12
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
473
12
    }
_ZN5doris6Status13InternalErrorILb1EJmEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Line
Count
Source
471
2
    static Status name(std::string_view msg, Args&&... args) {                       \
472
2
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
473
2
    }
Unexecuted instantiation: _ZN5doris6Status13InternalErrorILb1EJRKNS_13TSerdeDialect4typeEEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status13InternalErrorILb1EJRiNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmEEES0_St17basic_string_viewIcS6_EDpOT0_
Unexecuted instantiation: _ZN5doris6Status10CorruptionILb1EJRmS2_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_EEES0_St17basic_string_viewIcS6_EDpOT0_
Unexecuted instantiation: _ZN5doris6Status10CorruptionILb1EJRjRmEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status13InternalErrorILb0EJPKcEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
474
475
// default have no stacktrace. could enable manually.
476
#define ERROR_CTOR_NOSTACK(name, code)                                               \
477
    template <bool stacktrace = false, typename... Args>                             \
478
6.21k
    static Status name(std::string_view msg, Args&&... args) {                       \
479
6.21k
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
480
6.21k
    }
_ZN5doris6Status15InvalidArgumentILb0EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Line
Count
Source
478
83
    static Status name(std::string_view msg, Args&&... args) {                       \
479
83
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
480
83
    }
_ZN5doris6Status15InvalidArgumentILb0EJRNS_10segment_v214HashStrategyPBEEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Line
Count
Source
478
1
    static Status name(std::string_view msg, Args&&... args) {                       \
479
1
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
480
1
    }
Unexecuted instantiation: _ZN5doris6Status15InvalidArgumentILb0EJNS_13PredicateTypeEEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
_ZN5doris6Status12NetworkErrorILb0EJPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS9_lEEES0_St17basic_string_viewIcS7_EDpOT0_
Line
Count
Source
478
2
    static Status name(std::string_view msg, Args&&... args) {                       \
479
2
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
480
2
    }
_ZN5doris6Status9EndOfFileILb0EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Line
Count
Source
478
6.11k
    static Status name(std::string_view msg, Args&&... args) {                       \
479
6.11k
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
480
6.11k
    }
_ZN5doris6Status9CancelledILb0EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Line
Count
Source
478
17
    static Status name(std::string_view msg, Args&&... args) {                       \
479
17
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
480
17
    }
_ZN5doris6Status12NetworkErrorILb0EJEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Line
Count
Source
478
1
    static Status name(std::string_view msg, Args&&... args) {                       \
479
1
        return Error<ErrorCode::code, stacktrace>(msg, std::forward<Args>(args)...); \
480
1
    }
Unexecuted instantiation: _ZN5doris6Status15InvalidArgumentILb0EJRKPKcRiEEES0_St17basic_string_viewIcSt11char_traitsIcEEDpOT0_
Unexecuted instantiation: _ZN5doris6Status15InvalidArgumentILb0EJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKPKcEEES0_St17basic_string_viewIcS5_EDpOT0_
481
482
    ERROR_CTOR(PublishTimeout, PUBLISH_TIMEOUT)
483
    ERROR_CTOR(MemoryAllocFailed, MEM_ALLOC_FAILED)
484
    ERROR_CTOR(BufferAllocFailed, BUFFER_ALLOCATION_FAILED)
485
    ERROR_CTOR_NOSTACK(InvalidArgument, INVALID_ARGUMENT)
486
    ERROR_CTOR_NOSTACK(InvalidJsonPath, INVALID_JSON_PATH)
487
    ERROR_CTOR(MinimumReservationUnavailable, MINIMUM_RESERVATION_UNAVAILABLE)
488
    ERROR_CTOR(Corruption, CORRUPTION)
489
    ERROR_CTOR(IOError, IO_ERROR)
490
    ERROR_CTOR(NotFound, NOT_FOUND)
491
    ERROR_CTOR_NOSTACK(AlreadyExist, ALREADY_EXIST)
492
    ERROR_CTOR(NotSupported, NOT_IMPLEMENTED_ERROR)
493
    ERROR_CTOR_NOSTACK(EndOfFile, END_OF_FILE)
494
    ERROR_CTOR(InternalError, INTERNAL_ERROR)
495
    ERROR_CTOR_NOSTACK(WaitForRf, PIP_WAIT_FOR_RF)
496
    ERROR_CTOR_NOSTACK(WaitForScannerContext, PIP_WAIT_FOR_SC)
497
    ERROR_CTOR(RuntimeError, RUNTIME_ERROR)
498
    ERROR_CTOR_NOSTACK(Cancelled, CANCELLED)
499
    ERROR_CTOR(MemoryLimitExceeded, MEM_LIMIT_EXCEEDED)
500
    ERROR_CTOR(RpcError, THRIFT_RPC_ERROR)
501
    ERROR_CTOR_NOSTACK(TimedOut, TIMEOUT)
502
    ERROR_CTOR_NOSTACK(TooManyTasks, TOO_MANY_TASKS)
503
    ERROR_CTOR(Uninitialized, UNINITIALIZED)
504
    ERROR_CTOR(Aborted, ABORTED)
505
    ERROR_CTOR_NOSTACK(DataQualityError, DATA_QUALITY_ERROR)
506
    ERROR_CTOR_NOSTACK(NotAuthorized, NOT_AUTHORIZED)
507
    ERROR_CTOR(HttpError, HTTP_ERROR)
508
    ERROR_CTOR_NOSTACK(NeedSendAgain, NEED_SEND_AGAIN)
509
    ERROR_CTOR_NOSTACK(CgroupError, CGROUP_ERROR)
510
    ERROR_CTOR_NOSTACK(ObtainLockFailed, OBTAIN_LOCK_FAILED)
511
    ERROR_CTOR_NOSTACK(NetworkError, NETWORK_ERROR)
512
#undef ERROR_CTOR
513
514
    template <int code>
515
786k
    bool is() const {
516
786k
        return code == _code;
517
786k
    }
_ZNK5doris6Status2isILin7002EEEbv
Line
Count
Source
515
6.02k
    bool is() const {
516
6.02k
        return code == _code;
517
6.02k
    }
_ZNK5doris6Status2isILi6EEEbv
Line
Count
Source
515
4
    bool is() const {
516
4
        return code == _code;
517
4
    }
_ZNK5doris6Status2isILin206EEEbv
Line
Count
Source
515
1
    bool is() const {
516
1
        return code == _code;
517
1
    }
_ZNK5doris6Status2isILi30EEEbv
Line
Count
Source
515
778k
    bool is() const {
516
778k
        return code == _code;
517
778k
    }
_ZNK5doris6Status2isILi33EEEbv
Line
Count
Source
515
1
    bool is() const {
516
1
        return code == _code;
517
1
    }
_ZNK5doris6Status2isILi39EEEbv
Line
Count
Source
515
1
    bool is() const {
516
1
        return code == _code;
517
1
    }
_ZNK5doris6Status2isILin240EEEbv
Line
Count
Source
515
2.45k
    bool is() const {
516
2.45k
        return code == _code;
517
2.45k
    }
518
519
0
    void set_code(int code) { _code = code; }
520
521
331M
    bool ok() const { return _code == ErrorCode::OK; }
522
523
    // Convert into TStatus.
524
    void to_thrift(TStatus* status) const;
525
    TStatus to_thrift() const;
526
    void to_protobuf(PStatus* status) const;
527
528
    std::string to_string() const;
529
    std::string to_string_no_stack() const;
530
531
    /// @return A json representation of this status.
532
    std::string to_json() const;
533
534
26.2k
    int code() const { return _code; }
535
536
    /// Clone this status and add the specified prefix to the message.
537
    ///
538
    /// If this status is OK, then an OK status will be returned.
539
    ///
540
    /// @param [in] msg
541
    ///   The message to prepend.
542
    /// @return A ref to Status object
543
    Status& prepend(std::string_view msg);
544
545
    /// Add the specified suffix to the message.
546
    ///
547
    /// If this status is OK, then an OK status will be returned.
548
    ///
549
    /// @param [in] msg
550
    ///   The message to append.
551
    /// @return A ref to Status object
552
    Status& append(std::string_view msg);
553
554
    // if(!status) or if (status) will use this operator
555
70.4M
    operator bool() const { return this->ok(); }
556
557
    // Used like if ASSERT_EQ(res, Status::OK())
558
    // if the state is ok, then both code and precise code is not initialized properly, so that should check ok state
559
    // ignore error messages during comparison
560
18.9k
    bool operator==(const Status& st) const { return _code == st._code; }
561
562
    // Used like if ASSERT_NE(res, Status::OK())
563
1.21M
    bool operator!=(const Status& st) const { return _code != st._code; }
564
565
    friend std::ostream& operator<<(std::ostream& ostr, const Status& status);
566
567
22.2k
    std::string_view msg() const { return _err_msg ? _err_msg->_msg : std::string_view(""); }
568
569
0
    std::pair<int, std::string> retrieve_error_msg() { return {_code, std::move(_err_msg->_msg)}; }
570
571
    friend io::ObjectStorageStatus convert_to_obj_response(Status st);
572
573
private:
574
    int _code;
575
    struct ErrMsg {
576
        std::string _msg;
577
        std::string _stack;
578
    };
579
    std::unique_ptr<ErrMsg> _err_msg;
580
581
2.31k
    std::string code_as_string() const {
582
2.31k
        return (int)_code >= 0 ? doris::to_string(static_cast<TStatusCode::type>(_code))
583
2.31k
                               : fmt::format("E{}", (int16_t)_code);
584
2.31k
    }
585
};
586
587
// There are many thread using status to indicate the cancel state, one thread may update it and
588
// the other thread will read it. Status is not thread safe, for example, if one thread is update it
589
// and another thread is call to_string method, it may core, because the _err_msg is an unique ptr and
590
// it is deconstructed during copy method.
591
// And also we could not use lock, because we need get status frequently to check if it is cancelled.
592
// The default value is ok.
593
class AtomicStatus {
594
public:
595
17.9k
    AtomicStatus() : error_st_(Status::OK()) {}
596
597
665
    bool ok() const { return error_code_.load(std::memory_order_acquire) == 0; }
598
599
53
    bool update(const Status& new_status) {
600
        // If new status is normal, or the old status is abnormal, then not need update
601
53
        if (new_status.ok() || error_code_.load(std::memory_order_acquire) != 0) {
602
42
            return false;
603
42
        }
604
11
        std::lock_guard l(mutex_);
605
11
        if (error_code_.load(std::memory_order_acquire) != 0) {
606
0
            return false;
607
0
        }
608
11
        error_st_ = new_status;
609
11
        error_code_.store(new_status.code(), std::memory_order_release);
610
11
        return true;
611
11
    }
612
613
    // will copy a new status object to avoid concurrency
614
    // This stauts could only be called when ok==false
615
70
    Status status() const {
616
70
        std::lock_guard l(mutex_);
617
70
        return error_st_;
618
70
    }
619
620
    AtomicStatus(const AtomicStatus&) = delete;
621
    void operator=(const AtomicStatus&) = delete;
622
623
private:
624
    std::atomic_int16_t error_code_ = 0;
625
    Status error_st_;
626
    // mutex's lock is not a const method, but we will use this mutex in
627
    // some const method, so that it should be mutable.
628
    mutable std::mutex mutex_;
629
};
630
631
2.16k
inline std::ostream& operator<<(std::ostream& ostr, const Status& status) {
632
2.16k
    ostr << '[' << status.code_as_string() << ']';
633
2.16k
    ostr << status.msg();
634
2.16k
    if (status._err_msg && !status._err_msg->_stack.empty() && config::enable_stacktrace) {
635
0
        ostr << '\n' << status._err_msg->_stack;
636
0
    }
637
2.16k
    return ostr;
638
2.16k
}
639
640
2.06k
inline std::string Status::to_string() const {
641
2.06k
    std::stringstream ss;
642
2.06k
    ss << *this;
643
2.06k
    return ss.str();
644
2.06k
}
645
646
inline std::string Status::to_string_no_stack() const {
647
    return fmt::format("[{}]{}", code_as_string(), msg());
648
}
649
650
// some generally useful macros
651
#define RETURN_IF_ERROR(stmt)           \
652
2.44k
    do {                                \
653
2.44k
        Status _status_ = (stmt);       \
654
2.44k
        if (UNLIKELY(!_status_.ok())) { \
655
4
            return _status_;            \
656
4
        }                               \
657
2.44k
    } while (false)
658
659
#define PROPAGATE_FALSE(stmt)                     \
660
    do {                                          \
661
        if (UNLIKELY(!static_cast<bool>(stmt))) { \
662
            return false;                         \
663
        }                                         \
664
    } while (false)
665
666
#define THROW_IF_ERROR(stmt)            \
667
    do {                                \
668
        Status _status_ = (stmt);       \
669
        if (UNLIKELY(!_status_.ok())) { \
670
            throw Exception(_status_);  \
671
        }                               \
672
    } while (false)
673
674
#define RETURN_IF_STATUS_ERROR(status, stmt) \
675
    do {                                     \
676
        status = (stmt);                     \
677
        if (UNLIKELY(!status.ok())) {        \
678
            return;                          \
679
        }                                    \
680
    } while (false)
681
682
#define EXIT_IF_ERROR(stmt)             \
683
    do {                                \
684
        Status _status_ = (stmt);       \
685
        if (UNLIKELY(!_status_.ok())) { \
686
            LOG(ERROR) << _status_;     \
687
            exit(1);                    \
688
        }                               \
689
    } while (false)
690
691
#define RETURN_FALSE_IF_ERROR(stmt)   \
692
    do {                              \
693
        Status status = (stmt);       \
694
        if (UNLIKELY(!status.ok())) { \
695
            return false;             \
696
        }                             \
697
    } while (false)
698
699
/// @brief Emit a warning if @c to_call returns a bad status.
700
#define WARN_IF_ERROR(to_call, warning_prefix)              \
701
34
    do {                                                    \
702
34
        Status _s = (to_call);                              \
703
34
        if (UNLIKELY(!_s.ok())) {                           \
704
0
            LOG(WARNING) << (warning_prefix) << ": " << _s; \
705
0
        }                                                   \
706
34
    } while (false);
707
708
#define RETURN_NOT_OK_STATUS_WITH_WARN(stmt, warning_prefix)       \
709
    do {                                                           \
710
        Status _s = (stmt);                                        \
711
        if (UNLIKELY(!_s.ok())) {                                  \
712
            LOG(WARNING) << (warning_prefix) << ", error: " << _s; \
713
            return _s;                                             \
714
        }                                                          \
715
    } while (false);
716
717
template <typename T>
718
using Result = expected<T, Status>;
719
720
using ResultError = unexpected<Status>;
721
722
#define RETURN_IF_ERROR_RESULT(stmt)                \
723
    do {                                            \
724
        Status _status_ = (stmt);                   \
725
        if (UNLIKELY(!_status_.ok())) {             \
726
            return unexpected(std::move(_status_)); \
727
        }                                           \
728
    } while (false)
729
730
#define DORIS_TRY(stmt)                          \
731
5
    ({                                           \
732
5
        auto&& res = (stmt);                     \
733
5
        using T = std::decay_t<decltype(res)>;   \
734
5
        if (!res.has_value()) [[unlikely]] {     \
735
0
            return std::forward<T>(res).error(); \
736
0
        }                                        \
737
5
        std::forward<T>(res).value();            \
738
5
    });
739
740
} // namespace doris
741
742
// specify formatter for Status
743
template <>
744
struct fmt::formatter<doris::Status> {
745
    template <typename ParseContext>
746
9
    constexpr auto parse(ParseContext& ctx) {
747
9
        return ctx.begin();
748
9
    }
749
750
    template <typename FormatContext>
751
9
    auto format(doris::Status const& status, FormatContext& ctx) {
752
9
        return fmt::format_to(ctx.out(), "{}", status.to_string());
753
9
    }
754
};