From e5e0dc421d3f7eb9bf247aab0afce4b29ca3c580 Mon Sep 17 00:00:00 2001 From: yiguolei <676222867@qq.com> Date: Thu, 14 Apr 2022 11:43:49 +0800 Subject: [PATCH] [refactor] Change ALL OLAPStatus to Status (#8855) Currently, there are 2 status code in BE, one is common/Status.h, and the other is olap/olap_define.h called OLAPStatus. OLAPStatus is just an enum type, it is very simple and could not save many informations, I will unify these code to common/Status. --- be/CMakeLists.txt | 2 +- be/src/agent/agent_server.cpp | 25 +- be/src/agent/task_worker_pool.cpp | 87 ++-- be/src/agent/task_worker_pool.h | 2 +- be/src/common/status.cpp | 44 +- be/src/common/status.h | 240 ++++++++- be/src/exec/olap_scan_node.cpp | 6 +- be/src/exec/olap_scanner.cpp | 15 +- be/src/http/action/checksum_action.cpp | 4 +- be/src/http/action/compaction_action.cpp | 34 +- be/src/http/action/compaction_action.h | 2 +- be/src/http/action/reload_tablet_action.cpp | 4 +- be/src/http/action/restore_tablet_action.cpp | 8 +- be/src/http/action/snapshot_action.cpp | 4 +- .../http/action/tablet_migration_action.cpp | 11 +- be/src/olap/CMakeLists.txt | 1 - be/src/olap/base_compaction.cpp | 36 +- be/src/olap/base_compaction.h | 8 +- be/src/olap/base_tablet.cpp | 6 +- be/src/olap/base_tablet.h | 2 +- be/src/olap/bloom_filter_reader.cpp | 6 +- be/src/olap/bloom_filter_reader.h | 2 +- be/src/olap/bloom_filter_writer.cpp | 24 +- be/src/olap/bloom_filter_writer.h | 6 +- be/src/olap/byte_buffer.cpp | 20 +- be/src/olap/byte_buffer.h | 54 +-- be/src/olap/collect_iterator.cpp | 65 ++- be/src/olap/collect_iterator.h | 29 +- be/src/olap/compaction.cpp | 50 +- be/src/olap/compaction.h | 24 +- be/src/olap/compress.cpp | 24 +- be/src/olap/compress.h | 20 +- be/src/olap/cumulative_compaction.cpp | 30 +- be/src/olap/cumulative_compaction.h | 6 +- be/src/olap/data_dir.cpp | 91 ++-- be/src/olap/data_dir.h | 10 +- be/src/olap/decimal12.h | 6 +- be/src/olap/delete_handler.cpp | 42 +- be/src/olap/delete_handler.h | 15 +- be/src/olap/delta_writer.cpp | 86 ++-- be/src/olap/delta_writer.h | 20 +- be/src/olap/field.h | 4 +- be/src/olap/file_helper.cpp | 132 ++--- be/src/olap/file_helper.h | 112 +++-- be/src/olap/file_stream.cpp | 46 +- be/src/olap/file_stream.h | 68 +-- be/src/olap/in_stream.cpp | 81 ++-- be/src/olap/in_stream.h | 36 +- be/src/olap/memtable.cpp | 10 +- be/src/olap/memtable.h | 4 +- be/src/olap/memtable_flush_executor.cpp | 25 +- be/src/olap/memtable_flush_executor.h | 8 +- be/src/olap/merger.cpp | 4 +- be/src/olap/merger.h | 2 +- be/src/olap/olap_cond.cpp | 32 +- be/src/olap/olap_cond.h | 6 +- be/src/olap/olap_define.h | 299 +----------- be/src/olap/olap_index.cpp | 56 +-- be/src/olap/olap_index.h | 14 +- be/src/olap/olap_meta.cpp | 44 +- be/src/olap/olap_meta.h | 10 +- be/src/olap/olap_server.cpp | 10 +- be/src/olap/options.cpp | 22 +- be/src/olap/options.h | 4 +- be/src/olap/out_stream.cpp | 66 +-- be/src/olap/out_stream.h | 26 +- be/src/olap/push_handler.cpp | 210 ++++---- be/src/olap/push_handler.h | 40 +- be/src/olap/reader.cpp | 82 ++-- be/src/olap/reader.h | 18 +- be/src/olap/row_block.cpp | 6 +- be/src/olap/row_block.h | 2 +- be/src/olap/row_cursor.cpp | 76 +-- be/src/olap/row_cursor.h | 34 +- be/src/olap/rowset/CMakeLists.txt | 2 + be/src/olap/rowset/alpha_rowset.cpp | 124 +++-- be/src/olap/rowset/alpha_rowset.h | 20 +- be/src/olap/rowset/alpha_rowset_reader.cpp | 92 ++-- be/src/olap/rowset/alpha_rowset_reader.h | 26 +- be/src/olap/rowset/alpha_rowset_writer.cpp | 50 +- be/src/olap/rowset/alpha_rowset_writer.h | 18 +- be/src/olap/rowset/beta_rowset.cpp | 58 +-- be/src/olap/rowset/beta_rowset.h | 22 +- be/src/olap/rowset/beta_rowset_reader.cpp | 30 +- be/src/olap/rowset/beta_rowset_reader.h | 6 +- be/src/olap/rowset/beta_rowset_writer.cpp | 46 +- be/src/olap/rowset/beta_rowset_writer.h | 20 +- be/src/olap/rowset/bit_field_reader.cpp | 46 +- be/src/olap/rowset/bit_field_reader.h | 12 +- be/src/olap/rowset/bit_field_writer.cpp | 22 +- be/src/olap/rowset/bit_field_writer.h | 8 +- be/src/olap/rowset/column_data.cpp | 186 ++++--- be/src/olap/rowset/column_data.h | 30 +- be/src/olap/rowset/column_data_writer.cpp | 109 +++-- be/src/olap/rowset/column_data_writer.h | 16 +- be/src/olap/rowset/column_reader.cpp | 314 ++++++------ be/src/olap/rowset/column_reader.h | 226 ++++----- be/src/olap/rowset/column_writer.cpp | 196 ++++---- be/src/olap/rowset/column_writer.h | 192 ++++---- be/src/olap/rowset/rowset.cpp | 6 +- be/src/olap/rowset/rowset.h | 44 +- be/src/olap/rowset/rowset_factory.cpp | 8 +- be/src/olap/rowset/rowset_factory.h | 4 +- be/src/olap/rowset/rowset_meta_manager.cpp | 46 +- be/src/olap/rowset/rowset_meta_manager.h | 12 +- be/src/olap/rowset/rowset_reader.h | 8 +- be/src/olap/rowset/rowset_writer.h | 16 +- be/src/olap/rowset/run_length_byte_reader.cpp | 42 +- be/src/olap/rowset/run_length_byte_reader.h | 10 +- be/src/olap/rowset/run_length_byte_writer.cpp | 26 +- be/src/olap/rowset/run_length_byte_writer.h | 6 +- .../olap/rowset/run_length_integer_reader.cpp | 92 ++-- .../olap/rowset/run_length_integer_reader.h | 22 +- .../olap/rowset/run_length_integer_writer.cpp | 112 ++--- .../olap/rowset/run_length_integer_writer.h | 14 +- be/src/olap/rowset/segment_group.cpp | 194 ++++---- be/src/olap/rowset/segment_group.h | 48 +- be/src/olap/rowset/segment_reader.cpp | 174 +++---- be/src/olap/rowset/segment_reader.h | 38 +- .../olap/rowset/segment_v2/column_reader.cpp | 7 +- be/src/olap/rowset/segment_writer.cpp | 66 +-- be/src/olap/rowset/segment_writer.h | 8 +- be/src/olap/schema_change.cpp | 273 ++++++----- be/src/olap/schema_change.h | 30 +- be/src/olap/segment_loader.cpp | 10 +- be/src/olap/segment_loader.h | 4 +- be/src/olap/serialize.cpp | 56 +-- be/src/olap/serialize.h | 18 +- be/src/olap/snapshot_manager.cpp | 99 ++-- be/src/olap/snapshot_manager.h | 16 +- be/src/olap/storage_engine.cpp | 68 +-- be/src/olap/storage_engine.h | 18 +- be/src/olap/stream_index_common.cpp | 12 +- be/src/olap/stream_index_common.h | 4 +- be/src/olap/stream_index_reader.cpp | 32 +- be/src/olap/stream_index_reader.h | 6 +- be/src/olap/stream_index_writer.cpp | 34 +- be/src/olap/stream_index_writer.h | 12 +- be/src/olap/tablet.cpp | 132 ++--- be/src/olap/tablet.h | 32 +- be/src/olap/tablet_manager.cpp | 161 +++--- be/src/olap/tablet_manager.h | 36 +- be/src/olap/tablet_meta.cpp | 75 ++- be/src/olap/tablet_meta.h | 22 +- be/src/olap/tablet_meta_manager.cpp | 34 +- be/src/olap/tablet_meta_manager.h | 14 +- be/src/olap/tablet_sync_service.cpp | 161 ------ be/src/olap/tablet_sync_service.h | 142 ------ be/src/olap/task/engine_alter_tablet_task.cpp | 6 +- be/src/olap/task/engine_alter_tablet_task.h | 2 +- be/src/olap/task/engine_batch_load_task.cpp | 51 +- be/src/olap/task/engine_batch_load_task.h | 6 +- be/src/olap/task/engine_checksum_task.cpp | 37 +- be/src/olap/task/engine_checksum_task.h | 4 +- be/src/olap/task/engine_clone_task.cpp | 83 ++-- be/src/olap/task/engine_clone_task.h | 10 +- .../olap/task/engine_publish_version_task.cpp | 32 +- .../olap/task/engine_publish_version_task.h | 2 +- .../task/engine_storage_migration_task.cpp | 84 ++-- .../olap/task/engine_storage_migration_task.h | 16 +- be/src/olap/task/engine_task.h | 8 +- be/src/olap/tuple_reader.cpp | 56 +-- be/src/olap/tuple_reader.h | 16 +- be/src/olap/txn_manager.cpp | 60 +-- be/src/olap/txn_manager.h | 20 +- be/src/olap/types.h | 122 ++--- be/src/olap/utils.cpp | 112 +++-- be/src/olap/utils.h | 24 +- be/src/olap/version_graph.cpp | 18 +- be/src/olap/version_graph.h | 6 +- be/src/olap/wrapper_field.h | 2 +- be/src/runtime/dpp_writer.cpp | 4 +- be/src/runtime/mem_pool.h | 8 +- be/src/runtime/snapshot_loader.cpp | 8 +- be/src/runtime/tablets_channel.cpp | 16 +- be/src/service/doris_main.cpp | 2 +- be/src/tools/meta_tool.cpp | 24 +- be/src/util/broker_storage_backend.cpp | 12 +- be/src/vec/exec/volap_scanner.cpp | 4 +- be/src/vec/olap/block_reader.cpp | 54 +-- be/src/vec/olap/block_reader.h | 20 +- be/src/vec/olap/vcollect_iterator.cpp | 88 ++-- be/src/vec/olap/vcollect_iterator.h | 36 +- be/test/agent/agent_server_test.cpp | 8 +- be/test/olap/bit_field_test.cpp | 40 +- be/test/olap/bloom_filter_index_test.cpp | 14 +- be/test/olap/byte_buffer_test.cpp | 56 +-- be/test/olap/column_reader_test.cpp | 458 +++++++++--------- be/test/olap/comparison_predicate_test.cpp | 2 +- be/test/olap/delete_handler_test.cpp | 144 +++--- be/test/olap/delta_writer_test.cpp | 42 +- .../engine_storage_migration_task_test.cpp | 20 +- be/test/olap/file_helper_test.cpp | 4 +- be/test/olap/file_utils_test.cpp | 4 +- be/test/olap/memtable_flush_executor_test.cpp | 6 +- be/test/olap/olap_meta_test.cpp | 28 +- be/test/olap/options_test.cpp | 16 +- be/test/olap/row_cursor_test.cpp | 38 +- be/test/olap/rowset/alpha_rowset_test.cpp | 24 +- be/test/olap/rowset/beta_rowset_test.cpp | 28 +- .../olap/rowset/rowset_meta_manager_test.cpp | 20 +- be/test/olap/rowset/rowset_meta_test.cpp | 4 +- .../olap/rowset/segment_v2/segment_test.cpp | 20 +- be/test/olap/run_length_byte_test.cpp | 86 ++-- be/test/olap/run_length_integer_test.cpp | 194 ++++---- be/test/olap/schema_change_test.cpp | 222 ++++----- be/test/olap/stream_index_test.cpp | 32 +- be/test/olap/tablet_meta_manager_test.cpp | 18 +- be/test/olap/tablet_meta_test.cpp | 2 +- be/test/olap/tablet_mgr_test.cpp | 50 +- be/test/olap/txn_manager_test.cpp | 86 ++-- be/test/runtime/load_channel_mgr_test.cpp | 48 +- 212 files changed, 4754 insertions(+), 5148 deletions(-) delete mode 100644 be/src/olap/tablet_sync_service.cpp delete mode 100644 be/src/olap/tablet_sync_service.h diff --git a/be/CMakeLists.txt b/be/CMakeLists.txt index 1b89319e18..aed9103ec3 100644 --- a/be/CMakeLists.txt +++ b/be/CMakeLists.txt @@ -51,7 +51,7 @@ endif () # Set boost/stacktrace use backtrace api to unwind add_definitions(-DBOOST_STACKTRACE_USE_BACKTRACE) -add_definitions(-DPRINT_ALL_ERR_STATUS_STACKTRACE) +#add_definitions(-DPRINT_ALL_ERR_STATUS_STACKTRACE) option(GLIBC_COMPATIBILITY "Enable compatibility with older glibc libraries." ON) message(STATUS "GLIBC_COMPATIBILITY is ${GLIBC_COMPATIBILITY}") diff --git a/be/src/agent/agent_server.cpp b/be/src/agent/agent_server.cpp index a3205f1d83..bf536213a7 100644 --- a/be/src/agent/agent_server.cpp +++ b/be/src/agent/agent_server.cpp @@ -208,17 +208,14 @@ void AgentServer::submit_tasks(TAgentResult& agent_result, void AgentServer::make_snapshot(TAgentResult& t_agent_result, const TSnapshotRequest& snapshot_request) { - Status ret_st; string snapshot_path; bool allow_incremental_clone = false; - OLAPStatus err_code = + Status err_code = SnapshotManager::instance()->make_snapshot(snapshot_request, &snapshot_path, &allow_incremental_clone); - if (err_code != OLAP_SUCCESS) { + if (!err_code) { LOG(WARNING) << "fail to make_snapshot. tablet_id=" << snapshot_request.tablet_id << ", schema_hash=" << snapshot_request.schema_hash - << ", error_code=" << err_code; - ret_st = Status::RuntimeError( - strings::Substitute("fail to make_snapshot. err_code=$0", err_code)); + << ", error_code=" << err_code.to_string(); } else { LOG(INFO) << "success to make_snapshot. tablet_id=" << snapshot_request.tablet_id << ", schema_hash=" << snapshot_request.schema_hash @@ -227,23 +224,19 @@ void AgentServer::make_snapshot(TAgentResult& t_agent_result, t_agent_result.__set_allow_incremental_clone(allow_incremental_clone); } - ret_st.to_thrift(&t_agent_result.status); + err_code.to_thrift(&t_agent_result.status); t_agent_result.__set_snapshot_version(snapshot_request.preferred_snapshot_version); } void AgentServer::release_snapshot(TAgentResult& t_agent_result, const std::string& snapshot_path) { - Status ret_st; - OLAPStatus err_code = SnapshotManager::instance()->release_snapshot(snapshot_path); - if (err_code != OLAP_SUCCESS) { + Status err_code = SnapshotManager::instance()->release_snapshot(snapshot_path); + if (!err_code) { LOG(WARNING) << "failed to release_snapshot. snapshot_path: " << snapshot_path - << ", err_code: " << err_code; - ret_st = Status::RuntimeError( - strings::Substitute("fail to release_snapshot. err_code=$0", err_code)); + << ", err_code: " << err_code.to_string(); } else { - LOG(INFO) << "success to release_snapshot. snapshot_path=" << snapshot_path - << ", err_code=" << err_code; + LOG(INFO) << "success to release_snapshot. snapshot_path=" << snapshot_path; } - ret_st.to_thrift(&t_agent_result.status); + err_code.to_thrift(&t_agent_result.status); } void AgentServer::publish_cluster_state(TAgentResult& t_agent_result, diff --git a/be/src/agent/task_worker_pool.cpp b/be/src/agent/task_worker_pool.cpp index 5ae03100ce..7b85d12271 100644 --- a/be/src/agent/task_worker_pool.cpp +++ b/be/src/agent/task_worker_pool.cpp @@ -357,11 +357,10 @@ void TaskWorkerPool::_create_tablet_worker_thread_callback() { TStatus task_status; std::vector finish_tablet_infos; - OLAPStatus create_status = _env->storage_engine()->create_tablet(create_tablet_req); - if (create_status != OLAPStatus::OLAP_SUCCESS) { + Status create_status = _env->storage_engine()->create_tablet(create_tablet_req); + if (!create_status.ok()) { LOG(WARNING) << "create table failed. status: " << create_status << ", signature: " << agent_task_req.signature; - // TODO liutao09 distinguish the OLAPStatus status_code = TStatusCode::RUNTIME_ERROR; } else { ++_s_report_version; @@ -379,7 +378,6 @@ void TaskWorkerPool::_create_tablet_worker_thread_callback() { tablet_info.__set_path_hash(tablet->data_dir()->path_hash()); finish_tablet_infos.push_back(tablet_info); } - TRACE("StorageEngine create tablet finish, status: $0", create_status); task_status.__set_status_code(status_code); task_status.__set_error_msgs(error_msgs); @@ -422,9 +420,9 @@ void TaskWorkerPool::_drop_tablet_worker_thread_callback() { TabletSharedPtr dropped_tablet = StorageEngine::instance()->tablet_manager()->get_tablet( drop_tablet_req.tablet_id, false, &err); if (dropped_tablet != nullptr) { - OLAPStatus drop_status = StorageEngine::instance()->tablet_manager()->drop_tablet( + Status drop_status = StorageEngine::instance()->tablet_manager()->drop_tablet( drop_tablet_req.tablet_id, drop_tablet_req.schema_hash); - if (drop_status != OLAP_SUCCESS) { + if (!drop_status.ok()) { LOG(WARNING) << "drop table failed! signature: " << agent_task_req.signature; error_msgs.push_back("drop table failed!"); status_code = TStatusCode::RUNTIME_ERROR; @@ -524,9 +522,9 @@ void TaskWorkerPool::_alter_tablet(const TAgentTaskRequest& agent_task_req, int6 new_tablet_id = agent_task_req.alter_tablet_req_v2.new_tablet_id; new_schema_hash = agent_task_req.alter_tablet_req_v2.new_schema_hash; EngineAlterTabletTask engine_task(agent_task_req.alter_tablet_req_v2); - OLAPStatus sc_status = _env->storage_engine()->execute_task(&engine_task); - if (sc_status != OLAP_SUCCESS) { - if (sc_status == OLAP_ERR_DATA_QUALITY_ERR) { + Status sc_status = _env->storage_engine()->execute_task(&engine_task); + if (!sc_status.ok()) { + if (sc_status == Status::OLAPInternalError(OLAP_ERR_DATA_QUALITY_ERR)) { error_msgs.push_back("The data quality does not satisfy, please check your data. "); } status = Status::DataQualityError("The data quality does not satisfy"); @@ -685,15 +683,14 @@ void TaskWorkerPool::_publish_version_worker_thread_callback() { DorisMetrics::instance()->publish_task_request_total->increment(1); VLOG_NOTICE << "get publish version task, signature:" << agent_task_req.signature; - Status st; std::vector error_tablet_ids; uint32_t retry_time = 0; - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); while (retry_time < PUBLISH_VERSION_MAX_RETRY) { error_tablet_ids.clear(); EnginePublishVersionTask engine_task(publish_version_req, &error_tablet_ids); res = _env->storage_engine()->execute_task(&engine_task); - if (res == OLAP_SUCCESS) { + if (res.ok()) { break; } else { LOG(WARNING) << "publish version error, retry. [transaction_id=" @@ -705,19 +702,18 @@ void TaskWorkerPool::_publish_version_worker_thread_callback() { } TFinishTaskRequest finish_task_request; - if (res != OLAP_SUCCESS) { + if (!res) { DorisMetrics::instance()->publish_task_failed_total->increment(1); // if publish failed, return failed, FE will ignore this error and // check error tablet ids and FE will also republish this task LOG(WARNING) << "publish version failed. signature:" << agent_task_req.signature << ", error_code=" << res; - st = Status::RuntimeError(strings::Substitute("publish version failed. error=$0", res)); finish_task_request.__set_error_tablet_ids(error_tablet_ids); } else { LOG(INFO) << "publish_version success. signature:" << agent_task_req.signature; } - st.to_thrift(&finish_task_request.task_status); + res.to_thrift(&finish_task_request.task_status); finish_task_request.__set_backend(_backend); finish_task_request.__set_task_type(agent_task_req.task_type); finish_task_request.__set_signature(agent_task_req.signature); @@ -929,13 +925,12 @@ void TaskWorkerPool::_storage_medium_migrate_worker_thread_callback() { // check request and get info TabletSharedPtr tablet; DataDir* dest_store = nullptr; - if (_check_migrate_request(storage_medium_migrate_req, tablet, &dest_store) != - OLAP_SUCCESS) { + if (!_check_migrate_request(storage_medium_migrate_req, tablet, &dest_store)) { status_code = TStatusCode::RUNTIME_ERROR; } else { EngineStorageMigrationTask engine_task(tablet, dest_store); - OLAPStatus res = _env->storage_engine()->execute_task(&engine_task); - if (res != OLAP_SUCCESS) { + Status res = _env->storage_engine()->execute_task(&engine_task); + if (!res.ok()) { LOG(WARNING) << "storage media migrate failed. status: " << res << ", signature: " << agent_task_req.signature; status_code = TStatusCode::RUNTIME_ERROR; @@ -961,13 +956,13 @@ void TaskWorkerPool::_storage_medium_migrate_worker_thread_callback() { } } -OLAPStatus TaskWorkerPool::_check_migrate_request(const TStorageMediumMigrateReq& req, +Status TaskWorkerPool::_check_migrate_request(const TStorageMediumMigrateReq& req, TabletSharedPtr& tablet, DataDir** dest_store) { int64_t tablet_id = req.tablet_id; tablet = StorageEngine::instance()->tablet_manager()->get_tablet(tablet_id); if (tablet == nullptr) { LOG(WARNING) << "can't find tablet. tablet_id= " << tablet_id; - return OLAP_ERR_TABLE_NOT_FOUND; + return Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); } if (req.__isset.data_dir) { @@ -975,7 +970,7 @@ OLAPStatus TaskWorkerPool::_check_migrate_request(const TStorageMediumMigrateReq *dest_store = StorageEngine::instance()->get_store(req.data_dir); if (*dest_store == nullptr) { LOG(WARNING) << "data dir not found: " << req.data_dir; - return OLAP_ERR_DIR_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_DIR_NOT_EXIST); } } else { // this is a storage medium @@ -986,7 +981,7 @@ OLAPStatus TaskWorkerPool::_check_migrate_request(const TStorageMediumMigrateReq if (count <= 1) { LOG(INFO) << "available storage medium type count is less than 1, " << "no need to migrate. count=" << count; - return OLAP_REQUEST_FAILED; + return Status::OLAPInternalError(OLAP_REQUEST_FAILED); } // check current tablet storage medium TStorageMedium::type storage_medium = req.storage_medium; @@ -994,21 +989,21 @@ OLAPStatus TaskWorkerPool::_check_migrate_request(const TStorageMediumMigrateReq if (src_storage_medium == storage_medium) { LOG(INFO) << "tablet is already on specified storage medium. " << "storage_medium=" << storage_medium; - return OLAP_REQUEST_FAILED; + return Status::OLAPInternalError(OLAP_REQUEST_FAILED); } // get a random store of specified storage medium auto stores = StorageEngine::instance()->get_stores_for_create_tablet(storage_medium); if (stores.empty()) { LOG(WARNING) << "fail to get root path for create tablet."; - return OLAP_ERR_INVALID_ROOT_PATH; + return Status::OLAPInternalError(OLAP_ERR_INVALID_ROOT_PATH); } *dest_store = stores[0]; } if (tablet->data_dir()->path() == (*dest_store)->path()) { LOG(INFO) << "tablet is already on specified path. " - << "path=" << tablet->data_dir()->path(); - return OLAP_REQUEST_FAILED; + << "path=" << tablet->data_dir()->path(); + return Status::OLAPInternalError(OLAP_REQUEST_FAILED); } // check disk capacity @@ -1016,10 +1011,10 @@ OLAPStatus TaskWorkerPool::_check_migrate_request(const TStorageMediumMigrateReq if ((*dest_store)->reach_capacity_limit(tablet_size)) { LOG(WARNING) << "reach the capacity limit of path: " << (*dest_store)->path() << ", tablet size: " << tablet_size; - return OLAP_ERR_DISK_REACH_CAPACITY_LIMIT; + return Status::OLAPInternalError(OLAP_ERR_DISK_REACH_CAPACITY_LIMIT); } - return OLAP_SUCCESS; + return Status::OK(); } void TaskWorkerPool::_check_consistency_worker_thread_callback() { @@ -1048,8 +1043,8 @@ void TaskWorkerPool::_check_consistency_worker_thread_callback() { EngineChecksumTask engine_task(check_consistency_req.tablet_id, check_consistency_req.schema_hash, check_consistency_req.version, &checksum); - OLAPStatus res = _env->storage_engine()->execute_task(&engine_task); - if (res != OLAP_SUCCESS) { + Status res = _env->storage_engine()->execute_task(&engine_task); + if (!res.ok()) { LOG(WARNING) << "check consistency failed. status: " << res << ", signature: " << agent_task_req.signature; status_code = TStatusCode::RUNTIME_ERROR; @@ -1190,7 +1185,7 @@ void TaskWorkerPool::_report_tablet_worker_thread_callback() { _random_sleep(5); request.tablets.clear(); uint64_t report_version = _s_report_version; - OLAPStatus build_all_report_tablets_info_status = + Status build_all_report_tablets_info_status = StorageEngine::instance()->tablet_manager()->build_all_report_tablets_info( &request.tablets); if (report_version < _s_report_version) { @@ -1203,7 +1198,7 @@ void TaskWorkerPool::_report_tablet_worker_thread_callback() { DorisMetrics::instance()->report_all_tablets_requests_skip->increment(1); continue; } - if (build_all_report_tablets_info_status != OLAP_SUCCESS) { + if (!build_all_report_tablets_info_status.ok()) { LOG(WARNING) << "build all report tablets info failed. status: " << build_all_report_tablets_info_status; continue; @@ -1370,18 +1365,15 @@ void TaskWorkerPool::_make_snapshot_thread_callback() { string snapshot_path; bool allow_incremental_clone = false; // not used std::vector snapshot_files; - OLAPStatus make_snapshot_status = SnapshotManager::instance()->make_snapshot( + Status make_snapshot_status = SnapshotManager::instance()->make_snapshot( snapshot_request, &snapshot_path, &allow_incremental_clone); - if (make_snapshot_status != OLAP_SUCCESS) { - status_code = make_snapshot_status == OLAP_ERR_VERSION_ALREADY_MERGED - ? TStatusCode::OLAP_ERR_VERSION_ALREADY_MERGED - : TStatusCode::RUNTIME_ERROR; + if (!make_snapshot_status.ok()) { + status_code = make_snapshot_status.code(); LOG(WARNING) << "make_snapshot failed. tablet_id:" << snapshot_request.tablet_id << ", schema_hash:" << snapshot_request.schema_hash << ", version:" << snapshot_request.version - << ", status: " << make_snapshot_status; - error_msgs.push_back("make_snapshot failed. status: " + - boost::lexical_cast(make_snapshot_status)); + << ", status: " << make_snapshot_status.to_string(); + error_msgs.push_back("make_snapshot failed. status: " + make_snapshot_status.get_error_msg()); } else { LOG(INFO) << "make_snapshot success. tablet_id:" << snapshot_request.tablet_id << ", schema_hash:" << snapshot_request.schema_hash @@ -1400,9 +1392,8 @@ void TaskWorkerPool::_make_snapshot_thread_callback() { LOG(WARNING) << "make_snapshot failed. tablet_id:" << snapshot_request.tablet_id << ", schema_hash:" << snapshot_request.schema_hash << ", version:" << snapshot_request.version - << ",list file failed: " << st.get_error_msg(); - error_msgs.push_back("make_snapshot failed. list file failed: " + - st.get_error_msg()); + << ",list file failed: " << st.to_string(); + error_msgs.push_back("make_snapshot failed. list file failed: " + st.get_error_msg()); } } } @@ -1447,9 +1438,9 @@ void TaskWorkerPool::_release_snapshot_thread_callback() { TStatus task_status; string& snapshot_path = release_snapshot_request.snapshot_path; - OLAPStatus release_snapshot_status = + Status release_snapshot_status = SnapshotManager::instance()->release_snapshot(snapshot_path); - if (release_snapshot_status != OLAP_SUCCESS) { + if (!release_snapshot_status.ok()) { status_code = TStatusCode::RUNTIME_ERROR; LOG(WARNING) << "release_snapshot failed. snapshot_path: " << snapshot_path << ". status: " << release_snapshot_status; @@ -1480,9 +1471,9 @@ Status TaskWorkerPool::_get_tablet_info(const TTabletId tablet_id, Status status = Status::OK(); tablet_info->__set_tablet_id(tablet_id); tablet_info->__set_schema_hash(schema_hash); - OLAPStatus olap_status = + Status olap_status = StorageEngine::instance()->tablet_manager()->report_tablet_info(tablet_info); - if (olap_status != OLAP_SUCCESS) { + if (!olap_status.ok()) { LOG(WARNING) << "get tablet info failed. status: " << olap_status << ", signature: " << signature; status = Status::InternalError("Get tablet info failed"); diff --git a/be/src/agent/task_worker_pool.h b/be/src/agent/task_worker_pool.h index 5bb90de10b..d03afb1790 100644 --- a/be/src/agent/task_worker_pool.h +++ b/be/src/agent/task_worker_pool.h @@ -197,7 +197,7 @@ private: Status _move_dir(const TTabletId tablet_id, const std::string& src, int64_t job_id, bool overwrite); - OLAPStatus _check_migrate_request(const TStorageMediumMigrateReq& req, TabletSharedPtr& tablet, + Status _check_migrate_request(const TStorageMediumMigrateReq& req, TabletSharedPtr& tablet, DataDir** dest_store); // random sleep 1~second seconds diff --git a/be/src/common/status.cpp b/be/src/common/status.cpp index bb38e40be4..bb283e11ea 100644 --- a/be/src/common/status.cpp +++ b/be/src/common/status.cpp @@ -4,10 +4,35 @@ #include "common/status.h" -#include "gutil/strings/fastmem.h" // for memcpy_inlined +#include +#include +#include "gutil/strings/fastmem.h" // for memcpy_inlined namespace doris { +constexpr int MAX_ERROR_NUM = 65536; +struct ErrorCodeState { + int16_t error_code = 0; + bool stacktrace = true; + std::string description; + size_t count = 0; // Used for count the number of error happens + std::mutex mutex; // lock guard for count state +}; +ErrorCodeState error_states[MAX_ERROR_NUM]; +class Initializer { +public: + Initializer() { + #define M(NAME, ERRORCODE, DESC, STACKTRACEENABLED) error_states[abs(ERRORCODE)].stacktrace = STACKTRACEENABLED; + APPLY_FOR_ERROR_CODES(M) + #undef M + // Currently, most of description is empty, so that we use NAME as description + #define M(NAME, ERRORCODE, DESC, STACKTRACEENABLED) error_states[abs(ERRORCODE)].description = #NAME; + APPLY_FOR_ERROR_CODES(M) + #undef M + } +}; +Initializer init; // Used to init the error_states array + Status::Status(const TStatus& s) { if (s.status_code != TStatusCode::OK) { // It is ok to set precise code == 1 here, because we do not know the precise code @@ -39,6 +64,23 @@ Status::Status(const PStatus& s) { } } +// Implement it here to remove the boost header file from status.h to reduce precompile time +Status Status::ConstructErrorStatus(int16_t precise_code, const Slice& msg) { + // This will print all error status's stack, it maybe too many, but it is just used for debug + #ifdef PRINT_ALL_ERR_STATUS_STACKTRACE + LOG(WARNING) << "Error occurred, error code = " << precise_code << ", with message: " << msg + << "\n caused by:" << boost::stacktrace::stacktrace(); + #endif + if (error_states[abs(precise_code)].stacktrace) { + // Add stacktrace as part of message, could use LOG(WARN) << "" << status will print both + // the error message and the stacktrace + return Status(TStatusCode::INTERNAL_ERROR, msg, precise_code, + boost::stacktrace::to_string(boost::stacktrace::stacktrace())); + } else { + return Status(TStatusCode::INTERNAL_ERROR, msg, precise_code, Slice()); + } +} + void Status::to_thrift(TStatus* s) const { s->error_msgs.clear(); if (ok()) { diff --git a/be/src/common/status.h b/be/src/common/status.h index 9e419800f1..ec74be3ef0 100644 --- a/be/src/common/status.h +++ b/be/src/common/status.h @@ -4,6 +4,7 @@ #pragma once +#include #include #include #include @@ -19,6 +20,224 @@ namespace doris { +// ErrorName, ErrorCode, String Description, Should print stacktrace +#define APPLY_FOR_ERROR_CODES(M) \ + M(OLAP_SUCCESS, 0, "", true) \ + M(OLAP_ERR_OTHER_ERROR, -1, "", true) \ + M(OLAP_REQUEST_FAILED, -2, "", true) \ + M(OLAP_ERR_OS_ERROR, -100, "", true) \ + M(OLAP_ERR_DIR_NOT_EXIST, -101, "", true) \ + M(OLAP_ERR_FILE_NOT_EXIST, -102, "", true) \ + M(OLAP_ERR_CREATE_FILE_ERROR, -103, "", true) \ + M(OLAP_ERR_MALLOC_ERROR, -104, "", true) \ + M(OLAP_ERR_STL_ERROR, -105, "", true) \ + M(OLAP_ERR_IO_ERROR, -106, "", true) \ + M(OLAP_ERR_MUTEX_ERROR, -107, "", true) \ + M(OLAP_ERR_PTHREAD_ERROR, -108, "", true) \ + M(OLAP_ERR_NETWORK_ERROR, -109, "", true) \ + M(OLAP_ERR_UB_FUNC_ERROR, -110, "", true) \ + M(OLAP_ERR_COMPRESS_ERROR, -111, "", true) \ + M(OLAP_ERR_DECOMPRESS_ERROR, -112, "", true) \ + M(OLAP_ERR_UNKNOWN_COMPRESSION_TYPE, -113, "", true) \ + M(OLAP_ERR_MMAP_ERROR, -114, "", true) \ + M(OLAP_ERR_RWLOCK_ERROR, -115, "", true) \ + M(OLAP_ERR_READ_UNENOUGH, -116, "", true) \ + M(OLAP_ERR_CANNOT_CREATE_DIR, -117, "", true) \ + M(OLAP_ERR_UB_NETWORK_ERROR, -118, "", true) \ + M(OLAP_ERR_FILE_FORMAT_ERROR, -119, "", true) \ + M(OLAP_ERR_EVAL_CONJUNCTS_ERROR, -120, "", true) \ + M(OLAP_ERR_COPY_FILE_ERROR, -121, "", true) \ + M(OLAP_ERR_FILE_ALREADY_EXIST, -122, "", true) \ + M(OLAP_ERR_NOT_INITED, -200, "", true) \ + M(OLAP_ERR_FUNC_NOT_IMPLEMENTED, -201, "", true) \ + M(OLAP_ERR_CALL_SEQUENCE_ERROR, -202, "", true) \ + M(OLAP_ERR_INPUT_PARAMETER_ERROR, -203, "", true) \ + M(OLAP_ERR_BUFFER_OVERFLOW, -204, "", true) \ + M(OLAP_ERR_CONFIG_ERROR, -205, "", true) \ + M(OLAP_ERR_INIT_FAILED, -206, "", true) \ + M(OLAP_ERR_INVALID_SCHEMA, -207, "", true) \ + M(OLAP_ERR_CHECKSUM_ERROR, -208, "", true) \ + M(OLAP_ERR_SIGNATURE_ERROR, -209, "", true) \ + M(OLAP_ERR_CATCH_EXCEPTION, -210, "", true) \ + M(OLAP_ERR_PARSE_PROTOBUF_ERROR, -211, "", true) \ + M(OLAP_ERR_SERIALIZE_PROTOBUF_ERROR, -212, "", true) \ + M(OLAP_ERR_WRITE_PROTOBUF_ERROR, -213, "", true) \ + M(OLAP_ERR_VERSION_NOT_EXIST, -214, "", true) \ + M(OLAP_ERR_TABLE_NOT_FOUND, -215, "", true) \ + M(OLAP_ERR_TRY_LOCK_FAILED, -216, "", true) \ + M(OLAP_ERR_OUT_OF_BOUND, -218, "", true) \ + M(OLAP_ERR_UNDERFLOW, -219, "", true) \ + M(OLAP_ERR_FILE_DATA_ERROR, -220, "", true) \ + M(OLAP_ERR_TEST_FILE_ERROR, -221, "", true) \ + M(OLAP_ERR_INVALID_ROOT_PATH, -222, "", true) \ + M(OLAP_ERR_NO_AVAILABLE_ROOT_PATH, -223, "", true) \ + M(OLAP_ERR_CHECK_LINES_ERROR, -224, "", true) \ + M(OLAP_ERR_INVALID_CLUSTER_INFO, -225, "", true) \ + M(OLAP_ERR_TRANSACTION_NOT_EXIST, -226, "", true) \ + M(OLAP_ERR_DISK_FAILURE, -227, "", true) \ + M(OLAP_ERR_TRANSACTION_ALREADY_COMMITTED, -228, "", true) \ + M(OLAP_ERR_TRANSACTION_ALREADY_VISIBLE, -229, "", true) \ + M(OLAP_ERR_VERSION_ALREADY_MERGED, -230, "", true) \ + M(OLAP_ERR_LZO_DISABLED, -231, "", true) \ + M(OLAP_ERR_DISK_REACH_CAPACITY_LIMIT, -232, "", true) \ + M(OLAP_ERR_TOO_MANY_TRANSACTIONS, -233, "", true) \ + M(OLAP_ERR_INVALID_SNAPSHOT_VERSION, -234, "", true) \ + M(OLAP_ERR_TOO_MANY_VERSION, -235, "", true) \ + M(OLAP_ERR_NOT_INITIALIZED, -236, "", true) \ + M(OLAP_ERR_ALREADY_CANCELLED, -237, "", true) \ + M(OLAP_ERR_TOO_MANY_SEGMENTS, -238, "", true) \ + M(OLAP_ERR_CE_CMD_PARAMS_ERROR, -300, "", true) \ + M(OLAP_ERR_CE_BUFFER_TOO_SMALL, -301, "", true) \ + M(OLAP_ERR_CE_CMD_NOT_VALID, -302, "", true) \ + M(OLAP_ERR_CE_LOAD_TABLE_ERROR, -303, "", true) \ + M(OLAP_ERR_CE_NOT_FINISHED, -304, "", true) \ + M(OLAP_ERR_CE_TABLET_ID_EXIST, -305, "", true) \ + M(OLAP_ERR_CE_TRY_CE_LOCK_ERROR, -306, "", true) \ + M(OLAP_ERR_TABLE_VERSION_DUPLICATE_ERROR, -400, "", true) \ + M(OLAP_ERR_TABLE_VERSION_INDEX_MISMATCH_ERROR, -401, "", true) \ + M(OLAP_ERR_TABLE_INDEX_VALIDATE_ERROR, -402, "", true) \ + M(OLAP_ERR_TABLE_INDEX_FIND_ERROR, -403, "", true) \ + M(OLAP_ERR_TABLE_CREATE_FROM_HEADER_ERROR, -404, "", true) \ + M(OLAP_ERR_TABLE_CREATE_META_ERROR, -405, "", true) \ + M(OLAP_ERR_TABLE_ALREADY_DELETED_ERROR, -406, "", true) \ + M(OLAP_ERR_ENGINE_INSERT_EXISTS_TABLE, -500, "", true) \ + M(OLAP_ERR_ENGINE_DROP_NOEXISTS_TABLE, -501, "", true) \ + M(OLAP_ERR_ENGINE_LOAD_INDEX_TABLE_ERROR, -502, "", true) \ + M(OLAP_ERR_TABLE_INSERT_DUPLICATION_ERROR, -503, "", true) \ + M(OLAP_ERR_DELETE_VERSION_ERROR, -504, "", true) \ + M(OLAP_ERR_GC_SCAN_PATH_ERROR, -505, "", true) \ + M(OLAP_ERR_ENGINE_INSERT_OLD_TABLET, -506, "", true) \ + M(OLAP_ERR_FETCH_OTHER_ERROR, -600, "", true) \ + M(OLAP_ERR_FETCH_TABLE_NOT_EXIST, -601, "", true) \ + M(OLAP_ERR_FETCH_VERSION_ERROR, -602, "", true) \ + M(OLAP_ERR_FETCH_SCHEMA_ERROR, -603, "", true) \ + M(OLAP_ERR_FETCH_COMPRESSION_ERROR, -604, "", true) \ + M(OLAP_ERR_FETCH_CONTEXT_NOT_EXIST, -605, "", true) \ + M(OLAP_ERR_FETCH_GET_READER_PARAMS_ERR, -606, "", true) \ + M(OLAP_ERR_FETCH_SAVE_SESSION_ERR, -607, "", true) \ + M(OLAP_ERR_FETCH_MEMORY_EXCEEDED, -608, "", true) \ + M(OLAP_ERR_READER_IS_UNINITIALIZED, -700, "", true) \ + M(OLAP_ERR_READER_GET_ITERATOR_ERROR, -701, "", true) \ + M(OLAP_ERR_CAPTURE_ROWSET_READER_ERROR, -702, "", true) \ + M(OLAP_ERR_READER_READING_ERROR, -703, "", true) \ + M(OLAP_ERR_READER_INITIALIZE_ERROR, -704, "", true) \ + M(OLAP_ERR_BE_VERSION_NOT_MATCH, -800, "", true) \ + M(OLAP_ERR_BE_REPLACE_VERSIONS_ERROR, -801, "", true) \ + M(OLAP_ERR_BE_MERGE_ERROR, -802, "", true) \ + M(OLAP_ERR_CAPTURE_ROWSET_ERROR, -804, "", true) \ + M(OLAP_ERR_BE_SAVE_HEADER_ERROR, -805, "", true) \ + M(OLAP_ERR_BE_INIT_OLAP_DATA, -806, "", true) \ + M(OLAP_ERR_BE_TRY_OBTAIN_VERSION_LOCKS, -807, "", true) \ + M(OLAP_ERR_BE_NO_SUITABLE_VERSION, -808, "", false) \ + M(OLAP_ERR_BE_TRY_BE_LOCK_ERROR, -809, "", true) \ + M(OLAP_ERR_BE_INVALID_NEED_MERGED_VERSIONS, -810, "", true) \ + M(OLAP_ERR_BE_ERROR_DELETE_ACTION, -811, "", true) \ + M(OLAP_ERR_BE_SEGMENTS_OVERLAPPING, -812, "", true) \ + M(OLAP_ERR_BE_CLONE_OCCURRED, -813, "", true) \ + M(OLAP_ERR_PUSH_INIT_ERROR, -900, "", true) \ + M(OLAP_ERR_PUSH_DELTA_FILE_EOF, -901, "", false) \ + M(OLAP_ERR_PUSH_VERSION_INCORRECT, -902, "", true) \ + M(OLAP_ERR_PUSH_SCHEMA_MISMATCH, -903, "", true) \ + M(OLAP_ERR_PUSH_CHECKSUM_ERROR, -904, "", true) \ + M(OLAP_ERR_PUSH_ACQUIRE_DATASOURCE_ERROR, -905, "", true) \ + M(OLAP_ERR_PUSH_CREAT_CUMULATIVE_ERROR, -906, "", true) \ + M(OLAP_ERR_PUSH_BUILD_DELTA_ERROR, -907, "", true) \ + M(OLAP_ERR_PUSH_VERSION_ALREADY_EXIST, -908, "", true) \ + M(OLAP_ERR_PUSH_TABLE_NOT_EXIST, -909, "", true) \ + M(OLAP_ERR_PUSH_INPUT_DATA_ERROR, -910, "", true) \ + M(OLAP_ERR_PUSH_TRANSACTION_ALREADY_EXIST, -911, "", true) \ + M(OLAP_ERR_PUSH_BATCH_PROCESS_REMOVED, -912, "", true) \ + M(OLAP_ERR_PUSH_COMMIT_ROWSET, -913, "", true) \ + M(OLAP_ERR_PUSH_ROWSET_NOT_FOUND, -914, "", true) \ + M(OLAP_ERR_INDEX_LOAD_ERROR, -1000, "", true) \ + M(OLAP_ERR_INDEX_EOF, -1001, "", false) \ + M(OLAP_ERR_INDEX_CHECKSUM_ERROR, -1002, "", true) \ + M(OLAP_ERR_INDEX_DELTA_PRUNING, -1003, "", true) \ + M(OLAP_ERR_DATA_ROW_BLOCK_ERROR, -1100, "", true) \ + M(OLAP_ERR_DATA_FILE_TYPE_ERROR, -1101, "", true) \ + M(OLAP_ERR_DATA_EOF, -1102, "", false) \ + M(OLAP_ERR_WRITER_INDEX_WRITE_ERROR, -1200, "", true) \ + M(OLAP_ERR_WRITER_DATA_WRITE_ERROR, -1201, "", true) \ + M(OLAP_ERR_WRITER_ROW_BLOCK_ERROR, -1202, "", true) \ + M(OLAP_ERR_WRITER_SEGMENT_NOT_FINALIZED, -1203, "", true) \ + M(OLAP_ERR_ROWBLOCK_DECOMPRESS_ERROR, -1300, "", true) \ + M(OLAP_ERR_ROWBLOCK_FIND_ROW_EXCEPTION, -1301, "", true) \ + M(OLAP_ERR_ROWBLOCK_READ_INFO_ERROR, -1302, "", true) \ + M(OLAP_ERR_HEADER_ADD_VERSION, -1400, "", true) \ + M(OLAP_ERR_HEADER_DELETE_VERSION, -1401, "", true) \ + M(OLAP_ERR_HEADER_ADD_PENDING_DELTA, -1402, "", true) \ + M(OLAP_ERR_HEADER_ADD_INCREMENTAL_VERSION, -1403, "", true) \ + M(OLAP_ERR_HEADER_INVALID_FLAG, -1404, "", true) \ + M(OLAP_ERR_HEADER_PUT, -1405, "", true) \ + M(OLAP_ERR_HEADER_DELETE, -1406, "", true) \ + M(OLAP_ERR_HEADER_GET, -1407, "", true) \ + M(OLAP_ERR_HEADER_LOAD_INVALID_KEY, -1408, "", true) \ + M(OLAP_ERR_HEADER_FLAG_PUT, -1409, "", true) \ + M(OLAP_ERR_HEADER_LOAD_JSON_HEADER, -1410, "", true) \ + M(OLAP_ERR_HEADER_INIT_FAILED, -1411, "", true) \ + M(OLAP_ERR_HEADER_PB_PARSE_FAILED, -1412, "", true) \ + M(OLAP_ERR_HEADER_HAS_PENDING_DATA, -1413, "", true) \ + M(OLAP_ERR_SCHEMA_SCHEMA_INVALID, -1500, "", true) \ + M(OLAP_ERR_SCHEMA_SCHEMA_FIELD_INVALID, -1501, "", true) \ + M(OLAP_ERR_ALTER_MULTI_TABLE_ERR, -1600, "", true) \ + M(OLAP_ERR_ALTER_DELTA_DOES_NOT_EXISTS, -1601, "", true) \ + M(OLAP_ERR_ALTER_STATUS_ERR, -1602, "", true) \ + M(OLAP_ERR_PREVIOUS_SCHEMA_CHANGE_NOT_FINISHED, -1603, "", true) \ + M(OLAP_ERR_SCHEMA_CHANGE_INFO_INVALID, -1604, "", true) \ + M(OLAP_ERR_QUERY_SPLIT_KEY_ERR, -1605, "", true) \ + M(OLAP_ERR_DATA_QUALITY_ERR, -1606, "", true) \ + M(OLAP_ERR_COLUMN_DATA_LOAD_BLOCK, -1700, "", true) \ + M(OLAP_ERR_COLUMN_DATA_RECORD_INDEX, -1701, "", true) \ + M(OLAP_ERR_COLUMN_DATA_MAKE_FILE_HEADER, -1702, "", true) \ + M(OLAP_ERR_COLUMN_DATA_READ_VAR_INT, -1703, "", true) \ + M(OLAP_ERR_COLUMN_DATA_PATCH_LIST_NUM, -1704, "", true) \ + M(OLAP_ERR_COLUMN_STREAM_EOF, -1705, "", false) \ + M(OLAP_ERR_COLUMN_READ_STREAM, -1706, "", true) \ + M(OLAP_ERR_COLUMN_STREAM_NOT_EXIST, -1716, "", true) \ + M(OLAP_ERR_COLUMN_VALUE_NULL, -1717, "", true) \ + M(OLAP_ERR_COLUMN_SEEK_ERROR, -1719, "", true) \ + M(OLAP_ERR_DELETE_INVALID_CONDITION, -1900, "", true) \ + M(OLAP_ERR_DELETE_UPDATE_HEADER_FAILED, -1901, "", true) \ + M(OLAP_ERR_DELETE_SAVE_HEADER_FAILED, -1902, "", true) \ + M(OLAP_ERR_DELETE_INVALID_PARAMETERS, -1903, "", true) \ + M(OLAP_ERR_DELETE_INVALID_VERSION, -1904, "", true) \ + M(OLAP_ERR_CUMULATIVE_NO_SUITABLE_VERSION, -2000, "", true) \ + M(OLAP_ERR_CUMULATIVE_REPEAT_INIT, -2001, "", true) \ + M(OLAP_ERR_CUMULATIVE_INVALID_PARAMETERS, -2002, "", true) \ + M(OLAP_ERR_CUMULATIVE_FAILED_ACQUIRE_DATA_SOURCE, -2003, "", true) \ + M(OLAP_ERR_CUMULATIVE_INVALID_NEED_MERGED_VERSIONS, -2004, "", true) \ + M(OLAP_ERR_CUMULATIVE_ERROR_DELETE_ACTION, -2005, "", true) \ + M(OLAP_ERR_CUMULATIVE_MISS_VERSION, -2006, "", true) \ + M(OLAP_ERR_CUMULATIVE_CLONE_OCCURRED, -2007, "", true) \ + M(OLAP_ERR_META_INVALID_ARGUMENT, -3000, "", true) \ + M(OLAP_ERR_META_OPEN_DB, -3001, "", true) \ + M(OLAP_ERR_META_KEY_NOT_FOUND, -3002, "", true) \ + M(OLAP_ERR_META_GET, -3003, "", true) \ + M(OLAP_ERR_META_PUT, -3004, "", true) \ + M(OLAP_ERR_META_ITERATOR, -3005, "", true) \ + M(OLAP_ERR_META_DELETE, -3006, "", true) \ + M(OLAP_ERR_META_ALREADY_EXIST, -3007, "", true) \ + M(OLAP_ERR_ROWSET_WRITER_INIT, -3100, "", true) \ + M(OLAP_ERR_ROWSET_SAVE_FAILED, -3101, "", true) \ + M(OLAP_ERR_ROWSET_GENERATE_ID_FAILED, -3102, "", true) \ + M(OLAP_ERR_ROWSET_DELETE_FILE_FAILED, -3103, "", true) \ + M(OLAP_ERR_ROWSET_BUILDER_INIT, -3104, "", true) \ + M(OLAP_ERR_ROWSET_TYPE_NOT_FOUND, -3105, "", true) \ + M(OLAP_ERR_ROWSET_ALREADY_EXIST, -3106, "", true) \ + M(OLAP_ERR_ROWSET_CREATE_READER, -3107, "", true) \ + M(OLAP_ERR_ROWSET_INVALID, -3108, "", true) \ + M(OLAP_ERR_ROWSET_LOAD_FAILED, -3109, "", true) \ + M(OLAP_ERR_ROWSET_READER_INIT, -3110, "", true) \ + M(OLAP_ERR_ROWSET_READ_FAILED, -3111, "", true) \ + M(OLAP_ERR_ROWSET_INVALID_STATE_TRANSITION, -3112, "", true) \ + M(OLAP_ERR_STRING_OVERFLOW_IN_VEC_ENGINE, -3113, "", true) \ + +enum ErrorCode { +#define M(NAME, ERRORCODE, DESC, STACKTRACEENABLED) NAME = ERRORCODE, + APPLY_FOR_ERROR_CODES(M) +#undef M +}; + class Status { enum { // If the error and log returned by the query are truncated, the status to string may be too long. @@ -155,17 +374,20 @@ public: return Status(TStatusCode::DATA_QUALITY_ERROR, msg, precise_code, msg2); } - // A wrapper for OLAPStatus - // Precise code is for OLAPStatus's enum value - // All Status Error is treated as Internal Error - static Status OLAPInternalError(int16_t precise_code, const Slice& msg = Slice()) { - #ifdef PRINT_ALL_ERR_STATUS_STACKTRACE - LOG(WARNING) << "Error occurred, error code = " << precise_code << ", with message: " << msg - << "\n" << boost::stacktrace::stacktrace(); - #endif - return Status(TStatusCode::INTERNAL_ERROR, Slice(), precise_code, msg); + template + static Status OLAPInternalError(int16_t precise_code, const std::string & fmt, Args&&... args) { + return ConstructErrorStatus(precise_code, fmt::format(fmt, std::forward(args)...)); } + // A wrapper for ErrorCode + // Precise code is for ErrorCode's enum value + // All Status Error is treated as Internal Error + static Status OLAPInternalError(int16_t precise_code) { + return ConstructErrorStatus(precise_code, Slice()); + } + + static Status ConstructErrorStatus(int16_t precise_code, const Slice& msg); + bool ok() const { return _length == 0; } bool is_cancelled() const { return code() == TStatusCode::CANCELLED; } diff --git a/be/src/exec/olap_scan_node.cpp b/be/src/exec/olap_scan_node.cpp index c2d577b948..c98969b226 100644 --- a/be/src/exec/olap_scan_node.cpp +++ b/be/src/exec/olap_scan_node.cpp @@ -703,11 +703,11 @@ static Status get_hints(TabletSharedPtr table, const TPaloScanRange& scan_range, } SCOPED_TIMER(show_hints_timer); - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); std::vector range; res = table->split_range(key_range->begin_scan_range, key_range->end_scan_range, block_row_count, &range); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { return Status::InternalError("fail to show hints"); } ranges.emplace_back(std::move(range)); @@ -717,7 +717,7 @@ static Status get_hints(TabletSharedPtr table, const TPaloScanRange& scan_range, if (!have_valid_range) { std::vector range; auto res = table->split_range({}, {}, block_row_count, &range); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { return Status::InternalError("fail to show hints"); } ranges.emplace_back(std::move(range)); diff --git a/be/src/exec/olap_scanner.cpp b/be/src/exec/olap_scanner.cpp index e2ad167f59..a905dc9841 100644 --- a/be/src/exec/olap_scanner.cpp +++ b/be/src/exec/olap_scanner.cpp @@ -97,9 +97,9 @@ Status OlapScanner::prepare( // to prevent this case: when there are lots of olap scanners to run for example 10000 // the rowsets maybe compacted when the last olap scanner starts Version rd_version(0, _version); - OLAPStatus acquire_reader_st = + Status acquire_reader_st = _tablet->capture_rs_readers(rd_version, &_tablet_reader_params.rs_readers); - if (acquire_reader_st != OLAP_SUCCESS) { + if (!acquire_reader_st.ok()) { LOG(WARNING) << "fail to init reader.res=" << acquire_reader_st; std::stringstream ss; ss << "failed to initialize storage reader. tablet=" << _tablet->full_name() @@ -129,8 +129,7 @@ Status OlapScanner::open() { _runtime_filter_marks.resize(_parent->runtime_filter_descs().size(), false); auto res = _tablet_reader->init(_tablet_reader_params); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("fail to init reader.[res=%d]", res); + if (!res.ok()) { std::stringstream ss; ss << "failed to initialize storage reader. tablet=" << _tablet_reader_params.tablet->full_name() << ", res=" << res @@ -214,10 +213,10 @@ Status OlapScanner::_init_tablet_reader_params( } // use _tablet_reader_params.return_columns, because reader use this to merge sort - OLAPStatus res = + Status res = _read_row_cursor.init(_tablet->tablet_schema(), _tablet_reader_params.return_columns); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("fail to init row cursor.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to init row cursor.res = " << res; return Status::InternalError("failed to initialize storage read row cursor"); } _read_row_cursor.allocate_memory_for_string_type(_tablet->tablet_schema()); @@ -299,7 +298,7 @@ Status OlapScanner::get_batch(RuntimeState* state, RowBatch* batch, bool* eof) { // Read one row from reader auto res = _tablet_reader->next_row_with_aggregation(&_read_row_cursor, mem_pool.get(), batch->agg_object_pool(), eof); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { std::stringstream ss; ss << "Internal Error: read storage fail. res=" << res << ", tablet=" << _tablet->full_name() diff --git a/be/src/http/action/checksum_action.cpp b/be/src/http/action/checksum_action.cpp index 2ba5bd0956..1a2e30efbe 100644 --- a/be/src/http/action/checksum_action.cpp +++ b/be/src/http/action/checksum_action.cpp @@ -107,11 +107,11 @@ void ChecksumAction::handle(HttpRequest* req) { int64_t ChecksumAction::do_checksum(int64_t tablet_id, int64_t version, int32_t schema_hash, HttpRequest* req) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); uint32_t checksum; EngineChecksumTask engine_task(tablet_id, schema_hash, version, &checksum); res = engine_task.execute(); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "checksum failed. status: " << res << ", signature: " << tablet_id; return -1L; } else { diff --git a/be/src/http/action/compaction_action.cpp b/be/src/http/action/compaction_action.cpp index 0540d71cf0..6c90ff06c1 100644 --- a/be/src/http/action/compaction_action.cpp +++ b/be/src/http/action/compaction_action.cpp @@ -19,6 +19,7 @@ #include +#include #include #include @@ -99,10 +100,10 @@ Status CompactionAction::_handle_run_compaction(HttpRequest* req, std::string* j } // 3. execute compaction task - std::packaged_task task([this, tablet, compaction_type]() { + std::packaged_task task([this, tablet, compaction_type]() { return _execute_compaction_callback(tablet, compaction_type); }); - std::future future_obj = task.get_future(); + std::future future_obj = task.get_future(); { // 3.1 check is there compaction running @@ -120,10 +121,9 @@ Status CompactionAction::_handle_run_compaction(HttpRequest* req, std::string* j std::future_status status = future_obj.wait_for(std::chrono::seconds(2)); if (status == std::future_status::ready) { // fetch execute result - OLAPStatus olap_status = future_obj.get(); - if (olap_status != OLAP_SUCCESS) { - return Status::InternalError( - strings::Substitute("fail to execute compaction, error = $0", olap_status)); + Status olap_status = future_obj.get(); + if (!olap_status.ok()) { + return olap_status; } } else { LOG(INFO) << "Manual compaction task is timeout for waiting " @@ -198,7 +198,7 @@ Status CompactionAction::_handle_run_status_compaction(HttpRequest* req, std::st } } -OLAPStatus CompactionAction::_execute_compaction_callback(TabletSharedPtr tablet, +Status CompactionAction::_execute_compaction_callback(TabletSharedPtr tablet, const std::string& compaction_type) { std::shared_ptr cumulative_compaction_policy = _create_cumulative_compaction_policy(); @@ -207,12 +207,12 @@ OLAPStatus CompactionAction::_execute_compaction_callback(TabletSharedPtr tablet tablet->set_cumulative_compaction_policy(cumulative_compaction_policy); } - OLAPStatus status = OLAP_SUCCESS; + Status res = Status::OK(); if (compaction_type == PARAM_COMPACTION_BASE) { BaseCompaction base_compaction(tablet); - OLAPStatus res = base_compaction.compact(); - if (res != OLAP_SUCCESS) { - if (res == OLAP_ERR_BE_NO_SUITABLE_VERSION) { + res = base_compaction.compact(); + if (!res) { + if (res == Status::OLAPInternalError(OLAP_ERR_BE_NO_SUITABLE_VERSION)) { // Ignore this error code. VLOG_NOTICE << "failed to init base compaction due to no suitable version, tablet=" << tablet->full_name(); @@ -222,12 +222,11 @@ OLAPStatus CompactionAction::_execute_compaction_callback(TabletSharedPtr tablet << ", tablet=" << tablet->full_name(); } } - status = res; } else if (compaction_type == PARAM_COMPACTION_CUMULATIVE) { CumulativeCompaction cumulative_compaction(tablet); - OLAPStatus res = cumulative_compaction.compact(); - if (res != OLAP_SUCCESS) { - if (res == OLAP_ERR_CUMULATIVE_NO_SUITABLE_VERSION) { + res = cumulative_compaction.compact(); + if (!res) { + if (res == Status::OLAPInternalError(OLAP_ERR_BE_NO_SUITABLE_VERSION)) { // Ignore this error code. VLOG_NOTICE << "failed to init cumulative compaction due to no suitable version," << "tablet=" << tablet->full_name(); @@ -237,14 +236,13 @@ OLAPStatus CompactionAction::_execute_compaction_callback(TabletSharedPtr tablet << ", table=" << tablet->full_name(); } } - status = res; } - LOG(INFO) << "Manual compaction task finish, status = " << status; + LOG(INFO) << "Manual compaction task finish, status = " << res; std::lock_guard lock(_compaction_running_mutex); _is_compaction_running = false; - return status; + return res; } void CompactionAction::handle(HttpRequest* req) { diff --git a/be/src/http/action/compaction_action.h b/be/src/http/action/compaction_action.h index 19caec6431..f4cb792fab 100644 --- a/be/src/http/action/compaction_action.h +++ b/be/src/http/action/compaction_action.h @@ -58,7 +58,7 @@ private: Status _handle_run_compaction(HttpRequest* req, std::string* json_result); /// thread callback function for the tablet to do compaction - OLAPStatus _execute_compaction_callback(TabletSharedPtr tablet, + Status _execute_compaction_callback(TabletSharedPtr tablet, const std::string& compaction_type); /// fetch compaction running status diff --git a/be/src/http/action/reload_tablet_action.cpp b/be/src/http/action/reload_tablet_action.cpp index 0e308e0be7..4b6aa09061 100644 --- a/be/src/http/action/reload_tablet_action.cpp +++ b/be/src/http/action/reload_tablet_action.cpp @@ -95,9 +95,9 @@ void ReloadTabletAction::reload(const std::string& path, int64_t tablet_id, int3 clone_req.__set_tablet_id(tablet_id); clone_req.__set_schema_hash(schema_hash); - OLAPStatus res = OLAPStatus::OLAP_SUCCESS; + Status res = Status::OK(); res = _exec_env->storage_engine()->load_header(path, clone_req); - if (res != OLAPStatus::OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "load header failed. status: " << res << ", signature: " << tablet_id; std::string error_msg = std::string("load header failed"); HttpChannel::send_reply(req, HttpStatus::INTERNAL_SERVER_ERROR, error_msg); diff --git a/be/src/http/action/restore_tablet_action.cpp b/be/src/http/action/restore_tablet_action.cpp index cc5e3d0f94..94109f704d 100644 --- a/be/src/http/action/restore_tablet_action.cpp +++ b/be/src/http/action/restore_tablet_action.cpp @@ -114,9 +114,9 @@ Status RestoreTabletAction::_reload_tablet(const std::string& key, const std::st TCloneReq clone_req; clone_req.__set_tablet_id(tablet_id); clone_req.__set_schema_hash(schema_hash); - OLAPStatus res = OLAPStatus::OLAP_SUCCESS; + Status res = Status::OK(); res = _exec_env->storage_engine()->load_header(shard_path, clone_req, /*restore=*/true); - if (res != OLAPStatus::OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "load header failed. status: " << res << ", signature: " << tablet_id; // remove tablet data path in data path // path: /roo_path/data/shard/tablet_id @@ -156,8 +156,8 @@ Status RestoreTabletAction::_restore(const std::string& key, int64_t tablet_id, std::string original_header_path = latest_tablet_path + "/" + std::to_string(tablet_id) + ".hdr"; TabletMeta tablet_meta; - OLAPStatus load_status = tablet_meta.create_from_file(original_header_path); - if (load_status != OLAP_SUCCESS) { + Status load_status = tablet_meta.create_from_file(original_header_path); + if (!load_status.ok()) { LOG(WARNING) << "header load and init error, header path:" << original_header_path; return Status::InternalError("load header failed"); } diff --git a/be/src/http/action/snapshot_action.cpp b/be/src/http/action/snapshot_action.cpp index 86336b45d9..aa16b406d4 100644 --- a/be/src/http/action/snapshot_action.cpp +++ b/be/src/http/action/snapshot_action.cpp @@ -99,11 +99,11 @@ int64_t SnapshotAction::make_snapshot(int64_t tablet_id, int32_t schema_hash, request.tablet_id = tablet_id; request.schema_hash = schema_hash; - OLAPStatus res = OLAPStatus::OLAP_SUCCESS; + Status res = Status::OK(); bool allow_incremental_clone; // not used res = SnapshotManager::instance()->make_snapshot(request, snapshot_path, &allow_incremental_clone); - if (res != OLAPStatus::OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "make snapshot failed. status: " << res << ", signature: " << tablet_id; return -1L; } else { diff --git a/be/src/http/action/tablet_migration_action.cpp b/be/src/http/action/tablet_migration_action.cpp index 31d3d6ece4..dd5203838f 100644 --- a/be/src/http/action/tablet_migration_action.cpp +++ b/be/src/http/action/tablet_migration_action.cpp @@ -222,19 +222,16 @@ Status TabletMigrationAction::_execute_tablet_migration(TabletSharedPtr tablet, int32_t schema_hash = tablet->schema_hash(); string dest_disk = dest_store->path(); EngineStorageMigrationTask engine_task(tablet, dest_store); - OLAPStatus res = StorageEngine::instance()->execute_task(&engine_task); - Status status = Status::OK(); - if (res != OLAP_SUCCESS) { + Status res = StorageEngine::instance()->execute_task(&engine_task); + if (!res.ok()) { LOG(WARNING) << "tablet migrate failed. tablet_id=" << tablet_id << ", schema_hash=" << schema_hash << ", dest_disk=" << dest_disk << ", status:" << res; - status = Status::InternalError(strings::Substitute("migration task failed, res: $0", res)); } else { LOG(INFO) << "tablet migrate success. tablet_id=" << tablet_id - << ", schema_hash=" << schema_hash << ", dest_disk=" << dest_disk - << ", status:" << res; + << ", schema_hash=" << schema_hash << ", dest_disk=" << dest_disk; } - return status; + return res; } } // namespace doris diff --git a/be/src/olap/CMakeLists.txt b/be/src/olap/CMakeLists.txt index 27442cfa3b..4298d48bf9 100644 --- a/be/src/olap/CMakeLists.txt +++ b/be/src/olap/CMakeLists.txt @@ -85,7 +85,6 @@ add_library(Olap STATIC tablet_meta.cpp tablet_meta_manager.cpp tablet_schema.cpp - tablet_sync_service.cpp txn_manager.cpp types.cpp utils.cpp diff --git a/be/src/olap/base_compaction.cpp b/be/src/olap/base_compaction.cpp index e0de10534f..8e988c99c6 100644 --- a/be/src/olap/base_compaction.cpp +++ b/be/src/olap/base_compaction.cpp @@ -27,15 +27,15 @@ BaseCompaction::BaseCompaction(TabletSharedPtr tablet) BaseCompaction::~BaseCompaction() {} -OLAPStatus BaseCompaction::prepare_compact() { +Status BaseCompaction::prepare_compact() { if (!_tablet->init_succeeded()) { - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } std::unique_lock lock(_tablet->get_base_compaction_lock(), std::try_to_lock); if (!lock.owns_lock()) { LOG(WARNING) << "another base compaction is running. tablet=" << _tablet->full_name(); - return OLAP_ERR_BE_TRY_BE_LOCK_ERROR; + return Status::OLAPInternalError(OLAP_ERR_BE_TRY_BE_LOCK_ERROR); } TRACE("got base compaction lock"); @@ -45,14 +45,14 @@ OLAPStatus BaseCompaction::prepare_compact() { TRACE_COUNTER_INCREMENT("input_rowsets_count", _input_rowsets.size()); _tablet->set_clone_occurred(false); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BaseCompaction::execute_compact_impl() { +Status BaseCompaction::execute_compact_impl() { std::unique_lock lock(_tablet->get_base_compaction_lock(), std::try_to_lock); if (!lock.owns_lock()) { LOG(WARNING) << "another base compaction is running. tablet=" << _tablet->full_name(); - return OLAP_ERR_BE_TRY_BE_LOCK_ERROR; + return Status::OLAPInternalError(OLAP_ERR_BE_TRY_BE_LOCK_ERROR); } TRACE("got base compaction lock"); @@ -60,7 +60,7 @@ OLAPStatus BaseCompaction::execute_compact_impl() { // for compaction may change. In this case, current compaction task should not be executed. if (_tablet->get_clone_occurred()) { _tablet->set_clone_occurred(false); - return OLAP_ERR_BE_CLONE_OCCURRED; + return Status::OLAPInternalError(OLAP_ERR_BE_CLONE_OCCURRED); } // 2. do base compaction, merge rowsets @@ -76,14 +76,14 @@ OLAPStatus BaseCompaction::execute_compact_impl() { DorisMetrics::instance()->base_compaction_bytes_total->increment(_input_rowsets_size); TRACE("save base compaction metrics"); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BaseCompaction::pick_rowsets_to_compact() { +Status BaseCompaction::pick_rowsets_to_compact() { _input_rowsets.clear(); _tablet->pick_candidate_rowsets_to_base_compaction(&_input_rowsets); if (_input_rowsets.size() <= 1) { - return OLAP_ERR_BE_NO_SUITABLE_VERSION; + return Status::OLAPInternalError(OLAP_ERR_BE_NO_SUITABLE_VERSION); } std::sort(_input_rowsets.begin(), _input_rowsets.end(), Rowset::comparator); @@ -93,7 +93,7 @@ OLAPStatus BaseCompaction::pick_rowsets_to_compact() { if (_input_rowsets.size() == 2 && _input_rowsets[0]->end_version() == 1) { // the tablet is with rowset: [0-1], [2-y] // and [0-1] has no data. in this situation, no need to do base compaction. - return OLAP_ERR_BE_NO_SUITABLE_VERSION; + return Status::OLAPInternalError(OLAP_ERR_BE_NO_SUITABLE_VERSION); } // 1. cumulative rowset must reach base_compaction_num_cumulative_deltas threshold @@ -102,7 +102,7 @@ OLAPStatus BaseCompaction::pick_rowsets_to_compact() { << ", num_cumulative_rowsets=" << _input_rowsets.size() - 1 << ", base_compaction_num_cumulative_rowsets=" << config::base_compaction_num_cumulative_deltas; - return OLAP_SUCCESS; + return Status::OK(); } // 2. the ratio between base rowset and all input cumulative rowsets reaches the threshold @@ -130,7 +130,7 @@ OLAPStatus BaseCompaction::pick_rowsets_to_compact() { << ", base_size=" << base_size << ", cumulative_base_ratio=" << cumulative_base_ratio << ", policy_ratio=" << base_cumulative_delta_ratio; - return OLAP_SUCCESS; + return Status::OK(); } // 3. the interval since last base compaction reaches the threshold @@ -141,27 +141,27 @@ OLAPStatus BaseCompaction::pick_rowsets_to_compact() { VLOG_NOTICE << "satisfy the base compaction policy. tablet=" << _tablet->full_name() << ", interval_since_last_base_compaction=" << interval_since_last_base_compaction << ", interval_threshold=" << interval_threshold; - return OLAP_SUCCESS; + return Status::OK(); } VLOG_NOTICE << "don't satisfy the base compaction policy. tablet=" << _tablet->full_name() << ", num_cumulative_rowsets=" << _input_rowsets.size() - 1 << ", cumulative_base_ratio=" << cumulative_base_ratio << ", interval_since_last_base_compaction=" << interval_since_last_base_compaction; - return OLAP_ERR_BE_NO_SUITABLE_VERSION; + return Status::OLAPInternalError(OLAP_ERR_BE_NO_SUITABLE_VERSION); } -OLAPStatus BaseCompaction::_check_rowset_overlapping(const std::vector& rowsets) { +Status BaseCompaction::_check_rowset_overlapping(const std::vector& rowsets) { for (auto& rs : rowsets) { if (rs->rowset_meta()->is_segments_overlapping()) { LOG(WARNING) << "There is overlapping rowset before cumulative point, " << "rowset version=" << rs->start_version() << "-" << rs->end_version() << ", cumulative point=" << _tablet->cumulative_layer_point() << ", tablet=" << _tablet->full_name(); - return OLAP_ERR_BE_SEGMENTS_OVERLAPPING; + return Status::OLAPInternalError(OLAP_ERR_BE_SEGMENTS_OVERLAPPING); } } - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/base_compaction.h b/be/src/olap/base_compaction.h index d4c2c2f360..8425a5dbe4 100644 --- a/be/src/olap/base_compaction.h +++ b/be/src/olap/base_compaction.h @@ -32,13 +32,13 @@ public: BaseCompaction(TabletSharedPtr tablet); ~BaseCompaction() override; - OLAPStatus prepare_compact() override; - OLAPStatus execute_compact_impl() override; + Status prepare_compact() override; + Status execute_compact_impl() override; std::vector get_input_rowsets() { return _input_rowsets; } protected: - OLAPStatus pick_rowsets_to_compact() override; + Status pick_rowsets_to_compact() override; std::string compaction_name() const override { return "base compaction"; } ReaderType compaction_type() const override { return ReaderType::READER_BASE_COMPACTION; } @@ -46,7 +46,7 @@ protected: private: // check if all input rowsets are non overlapping among segments. // a rowset with overlapping segments should be compacted by cumulative compaction first. - OLAPStatus _check_rowset_overlapping(const vector& rowsets); + Status _check_rowset_overlapping(const vector& rowsets); DISALLOW_COPY_AND_ASSIGN(BaseCompaction); }; diff --git a/be/src/olap/base_tablet.cpp b/be/src/olap/base_tablet.cpp index f73bf2953a..0de5b0434d 100644 --- a/be/src/olap/base_tablet.cpp +++ b/be/src/olap/base_tablet.cpp @@ -54,14 +54,14 @@ BaseTablet::~BaseTablet() { DorisMetrics::instance()->metric_registry()->deregister_entity(_metric_entity); } -OLAPStatus BaseTablet::set_tablet_state(TabletState state) { +Status BaseTablet::set_tablet_state(TabletState state) { if (_tablet_meta->tablet_state() == TABLET_SHUTDOWN && state != TABLET_SHUTDOWN) { LOG(WARNING) << "could not change tablet state from shutdown to " << state; - return OLAP_ERR_META_INVALID_ARGUMENT; + return Status::OLAPInternalError(OLAP_ERR_META_INVALID_ARGUMENT); } _tablet_meta->set_tablet_state(state); _state = state; - return OLAP_SUCCESS; + return Status::OK(); } void BaseTablet::_gen_tablet_path() { diff --git a/be/src/olap/base_tablet.h b/be/src/olap/base_tablet.h index 4c6946931f..ead5e04013 100644 --- a/be/src/olap/base_tablet.h +++ b/be/src/olap/base_tablet.h @@ -41,7 +41,7 @@ public: FilePathDesc tablet_path_desc() const; TabletState tablet_state() const { return _state; } - OLAPStatus set_tablet_state(TabletState state); + Status set_tablet_state(TabletState state); // Property encapsulated in TabletMeta const TabletMetaSharedPtr tablet_meta(); diff --git a/be/src/olap/bloom_filter_reader.cpp b/be/src/olap/bloom_filter_reader.cpp index 2ade6c9b11..b98bac0352 100644 --- a/be/src/olap/bloom_filter_reader.cpp +++ b/be/src/olap/bloom_filter_reader.cpp @@ -27,9 +27,9 @@ BloomFilterIndexReader::~BloomFilterIndexReader() { } } -OLAPStatus BloomFilterIndexReader::init(char* buffer, size_t buffer_size, bool is_using_cache, +Status BloomFilterIndexReader::init(char* buffer, size_t buffer_size, bool is_using_cache, uint32_t hash_function_num, uint32_t bit_num) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); _buffer = buffer; _buffer_size = buffer_size; @@ -45,7 +45,7 @@ OLAPStatus BloomFilterIndexReader::init(char* buffer, size_t buffer_size, bool i "invalid param found. " "[buffer_size=%lu bit_num=%u block_count=%lu header_size=%lu]", buffer_size, bit_num, _entry_count, _start_offset); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } return res; diff --git a/be/src/olap/bloom_filter_reader.h b/be/src/olap/bloom_filter_reader.h index 9507d42fc6..aa337e42d5 100644 --- a/be/src/olap/bloom_filter_reader.h +++ b/be/src/olap/bloom_filter_reader.h @@ -35,7 +35,7 @@ public: ~BloomFilterIndexReader(); // Init BloomFilterIndexReader with given bloom filter index buffer - OLAPStatus init(char* buffer, size_t buffer_size, bool is_using_cache, + Status init(char* buffer, size_t buffer_size, bool is_using_cache, uint32_t hash_function_num, uint32_t bit_num); // Get specified bloom filter entry diff --git a/be/src/olap/bloom_filter_writer.cpp b/be/src/olap/bloom_filter_writer.cpp index b69c9d08f7..582e787244 100644 --- a/be/src/olap/bloom_filter_writer.cpp +++ b/be/src/olap/bloom_filter_writer.cpp @@ -28,15 +28,15 @@ BloomFilterIndexWriter::~BloomFilterIndexWriter() { } } -OLAPStatus BloomFilterIndexWriter::add_bloom_filter(BloomFilter* bf) { +Status BloomFilterIndexWriter::add_bloom_filter(BloomFilter* bf) { try { _bloom_filters.push_back(bf); } catch (...) { OLAP_LOG_WARNING("add bloom filter to vector fail"); - return OLAP_ERR_STL_ERROR; + return Status::OLAPInternalError(OLAP_ERR_STL_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } uint64_t BloomFilterIndexWriter::estimate_buffered_memory() { @@ -48,17 +48,17 @@ uint64_t BloomFilterIndexWriter::estimate_buffered_memory() { return buffered_size; } -OLAPStatus BloomFilterIndexWriter::write_to_buffer(OutStream* out_stream) { - OLAPStatus res = OLAP_SUCCESS; +Status BloomFilterIndexWriter::write_to_buffer(OutStream* out_stream) { + Status res = Status::OK(); if (nullptr == out_stream) { OLAP_LOG_WARNING("out stream is null"); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } // write header _header.block_count = _bloom_filters.size(); res = out_stream->write(reinterpret_cast(&_header), sizeof(_header)); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("write bloom filter index header fail"); return res; } @@ -68,7 +68,7 @@ OLAPStatus BloomFilterIndexWriter::write_to_buffer(OutStream* out_stream) { uint64_t* data = _bloom_filters[i]->bit_set_data(); uint32_t data_len = _bloom_filters[i]->bit_set_data_len(); res = out_stream->write(reinterpret_cast(data), sizeof(uint64_t) * data_len); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("write bloom filter index fail, i=%u", i); return res; } @@ -77,17 +77,17 @@ OLAPStatus BloomFilterIndexWriter::write_to_buffer(OutStream* out_stream) { return res; } -OLAPStatus BloomFilterIndexWriter::write_to_buffer(char* buffer, size_t buffer_size) { - OLAPStatus res = OLAP_SUCCESS; +Status BloomFilterIndexWriter::write_to_buffer(char* buffer, size_t buffer_size) { + Status res = Status::OK(); if (nullptr == buffer) { OLAP_LOG_WARNING("out stream is nullptr."); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } if (estimate_buffered_memory() > buffer_size) { OLAP_LOG_WARNING("need more buffer. [scr_size=%lu buffer_size=%lu]", estimate_buffered_memory(), buffer_size); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } // write header diff --git a/be/src/olap/bloom_filter_writer.h b/be/src/olap/bloom_filter_writer.h index c66ff31c70..15313cbdb9 100644 --- a/be/src/olap/bloom_filter_writer.h +++ b/be/src/olap/bloom_filter_writer.h @@ -30,10 +30,10 @@ public: BloomFilterIndexWriter() {} ~BloomFilterIndexWriter(); - OLAPStatus add_bloom_filter(BloomFilter* bf); + Status add_bloom_filter(BloomFilter* bf); uint64_t estimate_buffered_memory(); - OLAPStatus write_to_buffer(OutStream* out_stream); - OLAPStatus write_to_buffer(char* buffer, size_t buffer_size); + Status write_to_buffer(OutStream* out_stream); + Status write_to_buffer(char* buffer, size_t buffer_size); private: std::vector _bloom_filters; diff --git a/be/src/olap/byte_buffer.cpp b/be/src/olap/byte_buffer.cpp index 6b2747c12e..a3099e4e25 100644 --- a/be/src/olap/byte_buffer.cpp +++ b/be/src/olap/byte_buffer.cpp @@ -154,39 +154,39 @@ StorageByteBuffer* StorageByteBuffer::mmap(FileHandler* handler, uint64_t offset return buf; } -OLAPStatus StorageByteBuffer::put(char src) { +Status StorageByteBuffer::put(char src) { if (_position < _limit) { _array[_position++] = src; - return OLAP_SUCCESS; + return Status::OK(); } - return OLAP_ERR_BUFFER_OVERFLOW; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } -OLAPStatus StorageByteBuffer::put(uint64_t index, char src) { +Status StorageByteBuffer::put(uint64_t index, char src) { if (index < _limit) { _array[index] = src; - return OLAP_SUCCESS; + return Status::OK(); } - return OLAP_ERR_BUFFER_OVERFLOW; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } -OLAPStatus StorageByteBuffer::put(const char* src, uint64_t src_size, uint64_t offset, +Status StorageByteBuffer::put(const char* src, uint64_t src_size, uint64_t offset, uint64_t length) { //没有足够的空间可以写 if (length > remaining()) { - return OLAP_ERR_BUFFER_OVERFLOW; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } //src不够大 if (offset + length > src_size) { - return OLAP_ERR_OUT_OF_BOUND; + return Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND); } memory_copy(&_array[_position], &src[offset], length); _position += length; - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/byte_buffer.h b/be/src/olap/byte_buffer.h index 8afbffd6f3..9d142c3bd0 100644 --- a/be/src/olap/byte_buffer.h +++ b/be/src/olap/byte_buffer.h @@ -74,23 +74,23 @@ public: uint64_t position() const { return _position; } // Set the position of the internal pointer - // If the new position is greater than or equal to limit, return OLAP_ERR_INPUT_PARAMETER_ERROR - OLAPStatus set_position(uint64_t new_position) { + // If the new position is greater than or equal to limit, return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR) + Status set_position(uint64_t new_position) { if (new_position <= _limit) { _position = new_position; - return OLAP_SUCCESS; + return Status::OK(); } else { - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } } uint64_t limit() const { return _limit; } //set new limit - //If limit is greater than capacity, return OLAP_ERR_INPUT_PARAMETER_ERROR + //If limit is greater than capacity, return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR) //If position is greater than the new limit, set position equal to limit - OLAPStatus set_limit(uint64_t new_limit) { + Status set_limit(uint64_t new_limit) { if (new_limit > _capacity) { - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } _limit = new_limit; @@ -99,7 +99,7 @@ public: _position = _limit; } - return OLAP_SUCCESS; + return Status::OK(); } uint64_t remaining() const { return _limit - _position; } @@ -116,62 +116,62 @@ public: // The following three read functions are inline optimized // Read one byte of data, increase position after completion - OLAPStatus get(char* result) { + Status get(char* result) { if (OLAP_LIKELY(_position < _limit)) { *result = _array[_position++]; - return OLAP_SUCCESS; + return Status::OK(); } else { - return OLAP_ERR_OUT_OF_BOUND; + return Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND); } } // Read one byte of data at the specified location - OLAPStatus get(uint64_t index, char* result) { + Status get(uint64_t index, char* result) { if (OLAP_LIKELY(index < _limit)) { *result = _array[index]; - return OLAP_SUCCESS; + return Status::OK(); } else { - return OLAP_ERR_OUT_OF_BOUND; + return Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND); } } // Read a piece of data of length length to dst, and increase the position after completion - OLAPStatus get(char* dst, uint64_t dst_size, uint64_t length) { + Status get(char* dst, uint64_t dst_size, uint64_t length) { // Not enough data to read if (OLAP_UNLIKELY(length > remaining())) { - return OLAP_ERR_OUT_OF_BOUND; + return Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND); } // dst is not big enough if (OLAP_UNLIKELY(length > dst_size)) { - return OLAP_ERR_BUFFER_OVERFLOW; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } memory_copy(dst, &_array[_position], length); _position += length; - return OLAP_SUCCESS; + return Status::OK(); } // Read dst_size long data to dst - OLAPStatus get(char* dst, uint64_t dst_size) { return get(dst, dst_size, dst_size); } + Status get(char* dst, uint64_t dst_size) { return get(dst, dst_size, dst_size); } // Write a byte, increment position when done - // If position >= limit before writing, return OLAP_ERR_BUFFER_OVERFLOW - OLAPStatus put(char src); + // If position >= limit before writing, return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW) + Status put(char src); // Write data at the index position without changing the position // Returns: - // OLAP_ERR_BUFFER_OVERFLOW : index >= limit - OLAPStatus put(uint64_t index, char src); + // Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW) : index >= limit + Status put(uint64_t index, char src); // Read length bytes from &src[offset], write to buffer, and increase position after completion // Returns: - // OLAP_ERR_BUFFER_OVERFLOW: remaining() < length - // OLAP_ERR_OUT_OF_BOUND: offset + length > src_size - OLAPStatus put(const char* src, uint64_t src_size, uint64_t offset, uint64_t length); + // Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW): remaining() < length + // Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND): offset + length > src_size + Status put(const char* src, uint64_t src_size, uint64_t offset, uint64_t length); // write a set of data - OLAPStatus put(const char* src, uint64_t src_size) { return put(src, src_size, 0, src_size); } + Status put(const char* src, uint64_t src_size) { return put(src, src_size, 0, src_size); } // Returns the char array inside the ByteBuffer const char* array() const { return _array; } diff --git a/be/src/olap/collect_iterator.cpp b/be/src/olap/collect_iterator.cpp index b9ed8a9773..a475a4ad45 100644 --- a/be/src/olap/collect_iterator.cpp +++ b/be/src/olap/collect_iterator.cpp @@ -39,15 +39,15 @@ void CollectIterator::init(TabletReader* reader) { } } -OLAPStatus CollectIterator::add_child(RowsetReaderSharedPtr rs_reader) { +Status CollectIterator::add_child(RowsetReaderSharedPtr rs_reader) { std::unique_ptr child(new Level0Iterator(rs_reader, _reader)); RETURN_NOT_OK(child->init()); if (child->current_row() == nullptr) { - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } _children.push_back(child.release()); - return OLAP_SUCCESS; + return Status::OK(); } // Build a merge heap. If _merge is true, a rowset with the max rownum @@ -176,11 +176,11 @@ const RowCursor* CollectIterator::current_row(bool* delete_flag) const { return nullptr; } -OLAPStatus CollectIterator::next(const RowCursor** row, bool* delete_flag) { +Status CollectIterator::next(const RowCursor** row, bool* delete_flag) { if (LIKELY(_inner_iter)) { return _inner_iter->next(row, delete_flag); } else { - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } } @@ -195,7 +195,7 @@ CollectIterator::Level0Iterator::Level0Iterator(RowsetReaderSharedPtr rs_reader, CollectIterator::Level0Iterator::~Level0Iterator() = default; -OLAPStatus CollectIterator::Level0Iterator::init() { +Status CollectIterator::Level0Iterator::init() { RETURN_NOT_OK_LOG(_row_cursor.init(_reader->_tablet->tablet_schema(), _reader->_seek_columns), "failed to init row cursor"); return (this->*_refresh_current_row)(); @@ -214,7 +214,7 @@ int64_t CollectIterator::Level0Iterator::version() const { return _rs_reader->version().second; } -OLAPStatus CollectIterator::Level0Iterator::_refresh_current_row_v1() { +Status CollectIterator::Level0Iterator::_refresh_current_row_v1() { do { if (_row_block != nullptr && _row_block->has_remaining()) { size_t pos = _row_block->pos(); @@ -226,39 +226,39 @@ OLAPStatus CollectIterator::Level0Iterator::_refresh_current_row_v1() { continue; } _current_row = &_row_cursor; - return OLAP_SUCCESS; + return Status::OK(); } else { auto res = _rs_reader->next_block(&_row_block); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { _current_row = nullptr; return res; } } } while (_row_block != nullptr); _current_row = nullptr; - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } -OLAPStatus CollectIterator::Level0Iterator::_refresh_current_row_v2() { +Status CollectIterator::Level0Iterator::_refresh_current_row_v2() { do { if (_row_block != nullptr && _row_block->has_remaining()) { size_t pos = _row_block->pos(); _row_block->get_row(pos, &_row_cursor); _current_row = &_row_cursor; - return OLAP_SUCCESS; + return Status::OK(); } else { auto res = _rs_reader->next_block(&_row_block); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { _current_row = nullptr; return res; } } } while (_row_block != nullptr); _current_row = nullptr; - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } -OLAPStatus CollectIterator::Level0Iterator::next(const RowCursor** row, bool* delete_flag) { +Status CollectIterator::Level0Iterator::next(const RowCursor** row, bool* delete_flag) { _row_block->pos_inc(); auto res = (this->*_refresh_current_row)(); *row = _current_row; @@ -300,12 +300,11 @@ CollectIterator::Level1Iterator::~Level1Iterator() { // Read next row into *row. // Returns -// OLAP_SUCCESS when read successfully. -// OLAP_ERR_DATA_EOF and set *row to nullptr when EOF is reached. +// Status::OLAPInternalError(OLAP_ERR_DATA_EOF) and set *row to nullptr when EOF is reached. // Others when error happens -OLAPStatus CollectIterator::Level1Iterator::next(const RowCursor** row, bool* delete_flag) { +Status CollectIterator::Level1Iterator::next(const RowCursor** row, bool* delete_flag) { if (UNLIKELY(_cur_child == nullptr)) { - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } if (_merge) { return _merge_next(row, delete_flag); @@ -337,9 +336,9 @@ int64_t CollectIterator::Level1Iterator::version() const { return -1; } -OLAPStatus CollectIterator::Level1Iterator::init() { +Status CollectIterator::Level1Iterator::init() { if (_children.empty()) { - return OLAP_SUCCESS; + return Status::OK(); } // Only when there are multiple children that need to be merged @@ -365,24 +364,24 @@ OLAPStatus CollectIterator::Level1Iterator::init() { _heap.reset(nullptr); _cur_child = *(_children.begin()); } - return OLAP_SUCCESS; + return Status::OK(); } -inline OLAPStatus CollectIterator::Level1Iterator::_merge_next(const RowCursor** row, +inline Status CollectIterator::Level1Iterator::_merge_next(const RowCursor** row, bool* delete_flag) { _heap->pop(); auto res = _cur_child->next(row, delete_flag); - if (LIKELY(res == OLAP_SUCCESS)) { + if (LIKELY(res.ok())) { _heap->push(_cur_child); _cur_child = _heap->top(); - } else if (res == OLAP_ERR_DATA_EOF) { + } else if (res == Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { // current child has been read, to read next delete _cur_child; if (!_heap->empty()) { _cur_child = _heap->top(); } else { _cur_child = nullptr; - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } } else { _cur_child = nullptr; @@ -396,25 +395,25 @@ inline OLAPStatus CollectIterator::Level1Iterator::_merge_next(const RowCursor** return _merge_next(row, delete_flag); } *row = _cur_child->current_row(delete_flag); - return OLAP_SUCCESS; + return Status::OK(); } -inline OLAPStatus CollectIterator::Level1Iterator::_normal_next(const RowCursor** row, +inline Status CollectIterator::Level1Iterator::_normal_next(const RowCursor** row, bool* delete_flag) { auto res = _cur_child->next(row, delete_flag); - if (LIKELY(res == OLAP_SUCCESS)) { - return OLAP_SUCCESS; - } else if (res == OLAP_ERR_DATA_EOF) { + if (LIKELY(res.ok())) { + return Status::OK(); + } else if (res == Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { // current child has been read, to read next delete _cur_child; _children.pop_front(); if (!_children.empty()) { _cur_child = *(_children.begin()); *row = _cur_child->current_row(delete_flag); - return OLAP_SUCCESS; + return Status::OK(); } else { _cur_child = nullptr; - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } } else { _cur_child = nullptr; diff --git a/be/src/olap/collect_iterator.h b/be/src/olap/collect_iterator.h index 04886558b6..1342987707 100644 --- a/be/src/olap/collect_iterator.h +++ b/be/src/olap/collect_iterator.h @@ -36,7 +36,7 @@ public: // Hold reader point to get reader params void init(TabletReader* reader); - OLAPStatus add_child(RowsetReaderSharedPtr rs_reader); + Status add_child(RowsetReaderSharedPtr rs_reader); void build_heap(const std::vector& rs_readers); @@ -45,10 +45,9 @@ public: // Read next row into *row. // Returns - // OLAP_SUCCESS when read successfully. - // OLAP_ERR_DATA_EOF and set *row to nullptr when EOF is reached. + // Status::OLAPInternalError(OLAP_ERR_DATA_EOF) and set *row to nullptr when EOF is reached. // Others when error happens - OLAPStatus next(const RowCursor** row, bool* delete_flag); + Status next(const RowCursor** row, bool* delete_flag); private: // This interface is the actual implementation of the new version of iterator. @@ -59,7 +58,7 @@ private: // then merged with other rowset readers. class LevelIterator { public: - virtual OLAPStatus init() = 0; + virtual Status init() = 0; virtual const RowCursor* current_row(bool* delete_flag) const = 0; @@ -67,7 +66,7 @@ private: virtual int64_t version() const = 0; - virtual OLAPStatus next(const RowCursor** row, bool* delete_flag) = 0; + virtual Status next(const RowCursor** row, bool* delete_flag) = 0; virtual ~LevelIterator() = 0; bool need_skip() const { return _skip_row; } @@ -125,7 +124,7 @@ private: public: Level0Iterator(RowsetReaderSharedPtr rs_reader, TabletReader* reader); - OLAPStatus init() override; + Status init() override; const RowCursor* current_row(bool* delete_flag) const override; @@ -133,15 +132,15 @@ private: int64_t version() const override; - OLAPStatus next(const RowCursor** row, bool* delete_flag) override; + Status next(const RowCursor** row, bool* delete_flag) override; ~Level0Iterator(); private: - OLAPStatus (Level0Iterator::*_refresh_current_row)() = nullptr; + Status (Level0Iterator::*_refresh_current_row)() = nullptr; - OLAPStatus _refresh_current_row_v1(); - OLAPStatus _refresh_current_row_v2(); + Status _refresh_current_row_v1(); + Status _refresh_current_row_v2(); RowsetReaderSharedPtr _rs_reader; const RowCursor* _current_row = nullptr; // It points to the returned row @@ -158,7 +157,7 @@ private: int sequence_id_idx, uint64_t* merge_count, SortType sort_type, int sort_col_num); - OLAPStatus init() override; + Status init() override; const RowCursor* current_row(bool* delete_flag) const override; @@ -166,13 +165,13 @@ private: int64_t version() const override; - OLAPStatus next(const RowCursor** row, bool* delete_flag) override; + Status next(const RowCursor** row, bool* delete_flag) override; ~Level1Iterator(); private: - OLAPStatus _merge_next(const RowCursor** row, bool* delete_flag); - OLAPStatus _normal_next(const RowCursor** row, bool* delete_flag); + Status _merge_next(const RowCursor** row, bool* delete_flag); + Status _normal_next(const RowCursor** row, bool* delete_flag); // Each LevelIterator corresponds to a rowset reader, // it will be cleared after '_heap' has been initilized when '_merge == true'. diff --git a/be/src/olap/compaction.cpp b/be/src/olap/compaction.cpp index 08a49b54b8..4f90a0e3db 100644 --- a/be/src/olap/compaction.cpp +++ b/be/src/olap/compaction.cpp @@ -35,31 +35,31 @@ Compaction::Compaction(TabletSharedPtr tablet, const std::string& label) Compaction::~Compaction() {} -OLAPStatus Compaction::compact() { +Status Compaction::compact() { RETURN_NOT_OK(prepare_compact()); RETURN_NOT_OK(execute_compact()); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus Compaction::execute_compact() { - OLAPStatus st = execute_compact_impl(); - if (st != OLAP_SUCCESS) { +Status Compaction::execute_compact() { + Status st = execute_compact_impl(); + if (!st.ok()) { gc_output_rowset(); } return st; } -OLAPStatus Compaction::do_compaction(int64_t permits) { +Status Compaction::do_compaction(int64_t permits) { TRACE("start to do compaction"); _tablet->data_dir()->disks_compaction_score_increment(permits); _tablet->data_dir()->disks_compaction_num_increment(1); - OLAPStatus st = do_compaction_impl(permits); + Status st = do_compaction_impl(permits); _tablet->data_dir()->disks_compaction_score_increment(-permits); _tablet->data_dir()->disks_compaction_num_increment(-1); return st; } -OLAPStatus Compaction::do_compaction_impl(int64_t permits) { +Status Compaction::do_compaction_impl(int64_t permits) { OlapStopWatch watch; // 1. prepare input and output parameters @@ -88,7 +88,7 @@ OLAPStatus Compaction::do_compaction_impl(int64_t permits) { Merger::Statistics stats; auto res = Merger::merge_rowsets(_tablet, compaction_type(), _input_rs_readers, _output_rs_writer.get(), &stats); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to do " << compaction_name() << ". res=" << res << ", tablet=" << _tablet->full_name() << ", output_version=" << _output_version; @@ -102,7 +102,7 @@ OLAPStatus Compaction::do_compaction_impl(int64_t permits) { if (_output_rowset == nullptr) { LOG(WARNING) << "rowset writer build failed. writer version:" << ", output_version=" << _output_version; - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } TRACE_COUNTER_INCREMENT("output_rowset_data_size", _output_rowset->data_disk_size()); TRACE_COUNTER_INCREMENT("output_row_num", _output_rowset->num_rows()); @@ -140,10 +140,10 @@ OLAPStatus Compaction::do_compaction_impl(int64_t permits) { << "s. cumulative_compaction_policy=" << _tablet->cumulative_compaction_policy()->name() << "."; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus Compaction::construct_output_rowset_writer() { +Status Compaction::construct_output_rowset_writer() { RowsetWriterContext context; context.rowset_id = StorageEngine::instance()->next_rowset_id(); context.tablet_uid = _tablet->tablet_uid(); @@ -162,16 +162,16 @@ OLAPStatus Compaction::construct_output_rowset_writer() { context.segments_overlap = NONOVERLAPPING; // The test results show that one rs writer is low-memory-footprint, there is no need to tracker its mem pool RETURN_NOT_OK(RowsetFactory::create_rowset_writer(context, &_output_rs_writer)); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus Compaction::construct_input_rowset_readers() { +Status Compaction::construct_input_rowset_readers() { for (auto& rowset : _input_rowsets) { RowsetReaderSharedPtr rs_reader; RETURN_NOT_OK(rowset->create_reader(&rs_reader)); _input_rs_readers.push_back(std::move(rs_reader)); } - return OLAP_SUCCESS; + return Status::OK(); } void Compaction::modify_rowsets() { @@ -192,10 +192,10 @@ void Compaction::gc_output_rowset() { // Find the longest consecutive version path in "rowset", from begining. // Two versions before and after the missing version will be saved in missing_version, // if missing_version is not null. -OLAPStatus Compaction::find_longest_consecutive_version(std::vector* rowsets, +Status Compaction::find_longest_consecutive_version(std::vector* rowsets, std::vector* missing_version) { if (rowsets->empty()) { - return OLAP_SUCCESS; + return Status::OK(); } RowsetSharedPtr prev_rowset = rowsets->front(); size_t i = 1; @@ -212,10 +212,10 @@ OLAPStatus Compaction::find_longest_consecutive_version(std::vectorresize(i); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus Compaction::check_version_continuity(const std::vector& rowsets) { +Status Compaction::check_version_continuity(const std::vector& rowsets) { RowsetSharedPtr prev_rowset = rowsets.front(); for (size_t i = 1; i < rowsets.size(); ++i) { RowsetSharedPtr rowset = rowsets[i]; @@ -225,15 +225,15 @@ OLAPStatus Compaction::check_version_continuity(const std::vectorend_version() << ", rowset version=" << rowset->start_version() << "-" << rowset->end_version(); - return OLAP_ERR_CUMULATIVE_MISS_VERSION; + return Status::OLAPInternalError(OLAP_ERR_CUMULATIVE_MISS_VERSION); } prev_rowset = rowset; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus Compaction::check_correctness(const Merger::Statistics& stats) { +Status Compaction::check_correctness(const Merger::Statistics& stats) { // 1. check row number if (_input_row_num != _output_rowset->num_rows() + stats.merged_rows + stats.filtered_rows) { LOG(WARNING) << "row_num does not match between cumulative input and output! " @@ -250,7 +250,7 @@ OLAPStatus Compaction::check_correctness(const Merger::Statistics& stats) { // Only handle alpha rowset because we only find this bug in alpha rowset int64_t num_rows = _get_input_num_rows_from_seg_grps(); if (num_rows == -1) { - return OLAP_ERR_CHECK_LINES_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CHECK_LINES_ERROR); } if (num_rows != _output_rowset->num_rows() + stats.merged_rows + stats.filtered_rows) { // If it is still incorrect, it may be another problem @@ -260,10 +260,10 @@ OLAPStatus Compaction::check_correctness(const Merger::Statistics& stats) { << ", filtered_row_num=" << stats.filtered_rows << ", output_row_num=" << _output_rowset->num_rows(); - return OLAP_ERR_CHECK_LINES_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CHECK_LINES_ERROR); } } - return OLAP_SUCCESS; + return Status::OK(); } int64_t Compaction::_get_input_num_rows_from_seg_grps() { diff --git a/be/src/olap/compaction.h b/be/src/olap/compaction.h index 3a41f3fe73..43c0acc7f1 100644 --- a/be/src/olap/compaction.h +++ b/be/src/olap/compaction.h @@ -48,29 +48,29 @@ public: virtual ~Compaction(); // This is only for http CompactionAction - OLAPStatus compact(); + Status compact(); - virtual OLAPStatus prepare_compact() = 0; - OLAPStatus execute_compact(); - virtual OLAPStatus execute_compact_impl() = 0; + virtual Status prepare_compact() = 0; + Status execute_compact(); + virtual Status execute_compact_impl() = 0; protected: - virtual OLAPStatus pick_rowsets_to_compact() = 0; + virtual Status pick_rowsets_to_compact() = 0; virtual std::string compaction_name() const = 0; virtual ReaderType compaction_type() const = 0; - OLAPStatus do_compaction(int64_t permits); - OLAPStatus do_compaction_impl(int64_t permits); + Status do_compaction(int64_t permits); + Status do_compaction_impl(int64_t permits); void modify_rowsets(); void gc_output_rowset(); - OLAPStatus construct_output_rowset_writer(); - OLAPStatus construct_input_rowset_readers(); + Status construct_output_rowset_writer(); + Status construct_input_rowset_readers(); - OLAPStatus check_version_continuity(const std::vector& rowsets); - OLAPStatus check_correctness(const Merger::Statistics& stats); - OLAPStatus find_longest_consecutive_version(std::vector* rowsets, + Status check_version_continuity(const std::vector& rowsets); + Status check_correctness(const Merger::Statistics& stats); + Status find_longest_consecutive_version(std::vector* rowsets, std::vector* missing_version); int64_t get_compaction_permits(); diff --git a/be/src/olap/compress.cpp b/be/src/olap/compress.cpp index 7876a47782..db07a87812 100644 --- a/be/src/olap/compress.cpp +++ b/be/src/olap/compress.cpp @@ -23,15 +23,15 @@ namespace doris { #ifdef DORIS_WITH_LZO -OLAPStatus lzo_compress(StorageByteBuffer* in, StorageByteBuffer* out, bool* smaller) { +Status lzo_compress(StorageByteBuffer* in, StorageByteBuffer* out, bool* smaller) { size_t out_length = 0; - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); *smaller = false; res = olap_compress(&(in->array()[in->position()]), in->remaining(), &(out->array()[out->position()]), out->remaining(), &out_length, OLAP_COMP_STORAGE); - if (OLAP_SUCCESS == res) { + if (res.ok()) { if (out_length < in->remaining()) { *smaller = true; out->set_position(out->position() + out_length); @@ -41,14 +41,14 @@ OLAPStatus lzo_compress(StorageByteBuffer* in, StorageByteBuffer* out, bool* sma return res; } -OLAPStatus lzo_decompress(StorageByteBuffer* in, StorageByteBuffer* out) { +Status lzo_decompress(StorageByteBuffer* in, StorageByteBuffer* out) { size_t out_length = 0; - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); res = olap_decompress(&(in->array()[in->position()]), in->remaining(), &(out->array()[out->position()]), out->remaining(), &out_length, OLAP_COMP_STORAGE); - if (OLAP_SUCCESS == res) { + if (res.ok()) { out->set_limit(out_length); } @@ -56,15 +56,15 @@ OLAPStatus lzo_decompress(StorageByteBuffer* in, StorageByteBuffer* out) { } #endif -OLAPStatus lz4_compress(StorageByteBuffer* in, StorageByteBuffer* out, bool* smaller) { +Status lz4_compress(StorageByteBuffer* in, StorageByteBuffer* out, bool* smaller) { size_t out_length = 0; - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); *smaller = false; res = olap_compress(&(in->array()[in->position()]), in->remaining(), &(out->array()[out->position()]), out->remaining(), &out_length, OLAP_COMP_LZ4); - if (OLAP_SUCCESS == res) { + if (res.ok()) { if (out_length < in->remaining()) { *smaller = true; out->set_position(out->position() + out_length); @@ -74,14 +74,14 @@ OLAPStatus lz4_compress(StorageByteBuffer* in, StorageByteBuffer* out, bool* sma return res; } -OLAPStatus lz4_decompress(StorageByteBuffer* in, StorageByteBuffer* out) { +Status lz4_decompress(StorageByteBuffer* in, StorageByteBuffer* out) { size_t out_length = 0; - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); res = olap_decompress(&(in->array()[in->position()]), in->remaining(), &(out->array()[out->position()]), out->remaining(), &out_length, OLAP_COMP_LZ4); - if (OLAP_SUCCESS == res) { + if (res.ok()) { out->set_limit(out_length); } diff --git a/be/src/olap/compress.h b/be/src/olap/compress.h index 769da51555..6b853475d3 100644 --- a/be/src/olap/compress.h +++ b/be/src/olap/compress.h @@ -31,9 +31,9 @@ class StorageByteBuffer; // out - output buffer,The space from position to limit can be used to store data // smaller - Whether the compressed data size is smaller than the data size before compression // Returns: -// OLAP_ERR_BUFFER_OVERFLOW - Insufficient space left in output buffer -// OLAP_ERR_COMPRESS_ERROR - Compression error -typedef OLAPStatus (*Compressor)(StorageByteBuffer* in, StorageByteBuffer* out, bool* smaller); +// Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW) - Insufficient space left in output buffer +// Status::OLAPInternalError(OLAP_ERR_COMPRESS_ERROR) - Compression error +typedef Status (*Compressor)(StorageByteBuffer* in, StorageByteBuffer* out, bool* smaller); // Define a decompression function to decompress the remaining memory in the input buffer // and save it to the remaining space in the output buffer @@ -41,17 +41,17 @@ typedef OLAPStatus (*Compressor)(StorageByteBuffer* in, StorageByteBuffer* out, // in - input buffer,Decompress memory from position to limit // out - output buffer,The space from position to limit can be used to store data // Returns: -// OLAP_ERR_BUFFER_OVERFLOW - Insufficient space left in output buffer -// OLAP_ERR_DECOMPRESS_ERROR - decompression error -typedef OLAPStatus (*Decompressor)(StorageByteBuffer* in, StorageByteBuffer* out); +// Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW) - Insufficient space left in output buffer +// Status::OLAPInternalError(OLAP_ERR_DECOMPRESS_ERROR) - decompression error +typedef Status (*Decompressor)(StorageByteBuffer* in, StorageByteBuffer* out); #ifdef DORIS_WITH_LZO -OLAPStatus lzo_compress(StorageByteBuffer* in, StorageByteBuffer* out, bool* smaller); -OLAPStatus lzo_decompress(StorageByteBuffer* in, StorageByteBuffer* out); +Status lzo_compress(StorageByteBuffer* in, StorageByteBuffer* out, bool* smaller); +Status lzo_decompress(StorageByteBuffer* in, StorageByteBuffer* out); #endif -OLAPStatus lz4_compress(StorageByteBuffer* in, StorageByteBuffer* out, bool* smaller); -OLAPStatus lz4_decompress(StorageByteBuffer* in, StorageByteBuffer* out); +Status lz4_compress(StorageByteBuffer* in, StorageByteBuffer* out, bool* smaller); +Status lz4_decompress(StorageByteBuffer* in, StorageByteBuffer* out); } // namespace doris #endif // DORIS_BE_SRC_OLAP_COLUMN_FILE_COMPRESS_H diff --git a/be/src/olap/cumulative_compaction.cpp b/be/src/olap/cumulative_compaction.cpp index 94e0a8344c..1886bdc53d 100644 --- a/be/src/olap/cumulative_compaction.cpp +++ b/be/src/olap/cumulative_compaction.cpp @@ -28,15 +28,15 @@ CumulativeCompaction::CumulativeCompaction(TabletSharedPtr tablet) CumulativeCompaction::~CumulativeCompaction() {} -OLAPStatus CumulativeCompaction::prepare_compact() { +Status CumulativeCompaction::prepare_compact() { if (!_tablet->init_succeeded()) { - return OLAP_ERR_CUMULATIVE_INVALID_PARAMETERS; + return Status::OLAPInternalError(OLAP_ERR_CUMULATIVE_INVALID_PARAMETERS); } std::unique_lock lock(_tablet->get_cumulative_compaction_lock(), std::try_to_lock); if (!lock.owns_lock()) { LOG(INFO) << "The tablet is under cumulative compaction. tablet=" << _tablet->full_name(); - return OLAP_ERR_CE_TRY_CE_LOCK_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CE_TRY_CE_LOCK_ERROR); } TRACE("got cumulative compaction lock"); @@ -52,14 +52,14 @@ OLAPStatus CumulativeCompaction::prepare_compact() { TRACE_COUNTER_INCREMENT("input_rowsets_count", _input_rowsets.size()); _tablet->set_clone_occurred(false); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus CumulativeCompaction::execute_compact_impl() { +Status CumulativeCompaction::execute_compact_impl() { std::unique_lock lock(_tablet->get_cumulative_compaction_lock(), std::try_to_lock); if (!lock.owns_lock()) { LOG(INFO) << "The tablet is under cumulative compaction. tablet=" << _tablet->full_name(); - return OLAP_ERR_CE_TRY_CE_LOCK_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CE_TRY_CE_LOCK_ERROR); } TRACE("got cumulative compaction lock"); @@ -67,7 +67,7 @@ OLAPStatus CumulativeCompaction::execute_compact_impl() { // for compaction may change. In this case, current compaction task should not be executed. if (_tablet->get_clone_occurred()) { _tablet->set_clone_occurred(false); - return OLAP_ERR_CUMULATIVE_CLONE_OCCURRED; + return Status::OLAPInternalError(OLAP_ERR_CUMULATIVE_CLONE_OCCURRED); } // 3. do cumulative compaction, merge rowsets @@ -89,17 +89,17 @@ OLAPStatus CumulativeCompaction::execute_compact_impl() { DorisMetrics::instance()->cumulative_compaction_bytes_total->increment(_input_rowsets_size); TRACE("save cumulative compaction metrics"); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus CumulativeCompaction::pick_rowsets_to_compact() { +Status CumulativeCompaction::pick_rowsets_to_compact() { std::vector candidate_rowsets; _tablet->pick_candidate_rowsets_to_cumulative_compaction( config::cumulative_compaction_skip_window_seconds, &candidate_rowsets); if (candidate_rowsets.empty()) { - return OLAP_ERR_CUMULATIVE_NO_SUITABLE_VERSION; + return Status::OLAPInternalError(OLAP_ERR_CUMULATIVE_NO_SUITABLE_VERSION); } // candidate_rowsets may not be continuous. Because some rowset may not be selected @@ -123,14 +123,14 @@ OLAPStatus CumulativeCompaction::pick_rowsets_to_compact() { &_last_delete_version, &compaction_score); // Cumulative compaction will process with at least 1 rowset. - // So when there is no rowset being chosen, we should return OLAP_ERR_CUMULATIVE_NO_SUITABLE_VERSION: + // So when there is no rowset being chosen, we should return Status::OLAPInternalError(OLAP_ERR_CUMULATIVE_NO_SUITABLE_VERSION): if (_input_rowsets.empty()) { if (_last_delete_version.first != -1) { // we meet a delete version, should increase the cumulative point to let base compaction handle the delete version. // plus 1 to skip the delete version. // NOTICE: after that, the cumulative point may be larger than max version of this tablet, but it doesn't matter. _tablet->set_cumulative_layer_point(_last_delete_version.first + 1); - return OLAP_ERR_CUMULATIVE_NO_SUITABLE_VERSION; + return Status::OLAPInternalError(OLAP_ERR_CUMULATIVE_NO_SUITABLE_VERSION); } // we did not meet any delete version. which means compaction_score is not enough to do cumulative compaction. @@ -156,7 +156,7 @@ OLAPStatus CumulativeCompaction::pick_rowsets_to_compact() { for (auto& rs : candidate_rowsets) { if (rs->rowset_meta()->is_segments_overlapping()) { _input_rowsets = candidate_rowsets; - return OLAP_SUCCESS; + return Status::OK(); } } @@ -174,10 +174,10 @@ OLAPStatus CumulativeCompaction::pick_rowsets_to_compact() { } } - return OLAP_ERR_CUMULATIVE_NO_SUITABLE_VERSION; + return Status::OLAPInternalError(OLAP_ERR_CUMULATIVE_NO_SUITABLE_VERSION); } - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/cumulative_compaction.h b/be/src/olap/cumulative_compaction.h index d7c26ed669..a15394f8cc 100644 --- a/be/src/olap/cumulative_compaction.h +++ b/be/src/olap/cumulative_compaction.h @@ -30,13 +30,13 @@ public: CumulativeCompaction(TabletSharedPtr tablet); ~CumulativeCompaction() override; - OLAPStatus prepare_compact() override; - OLAPStatus execute_compact_impl() override; + Status prepare_compact() override; + Status execute_compact_impl() override; std::vector get_input_rowsets() { return _input_rowsets; } protected: - OLAPStatus pick_rowsets_to_compact() override; + Status pick_rowsets_to_compact() override; std::string compaction_name() const override { return "cumulative compaction"; } diff --git a/be/src/olap/data_dir.cpp b/be/src/olap/data_dir.cpp index d882391bb7..25c876ac01 100644 --- a/be/src/olap/data_dir.cpp +++ b/be/src/olap/data_dir.cpp @@ -195,8 +195,8 @@ Status DataDir::_init_meta() { Status::MemoryAllocFailed("allocate memory for OlapMeta failed"), "new OlapMeta failed"); } - OLAPStatus res = _meta->init(); - if (res != OLAP_SUCCESS) { + Status res = _meta->init(); + if (!res.ok()) { RETURN_NOT_OK_STATUS_WITH_WARN( Status::IOError( strings::Substitute("open rocksdb failed, path=$0", _path_desc.filepath)), @@ -233,8 +233,8 @@ Status DataDir::_write_cluster_id_to_path(const FilePathDesc& path_desc, int32_t void DataDir::health_check() { // check disk if (_is_used) { - OLAPStatus res = OLAP_SUCCESS; - if ((res = _read_and_write_test_file()) != OLAP_SUCCESS) { + Status res = _read_and_write_test_file(); + if (!res) { LOG(WARNING) << "store read/write test file occur IO Error. path=" << _path_desc.filepath; if (is_io_error(res)) { @@ -245,12 +245,12 @@ void DataDir::health_check() { disks_state->set_value(_is_used ? 1 : 0); } -OLAPStatus DataDir::_read_and_write_test_file() { +Status DataDir::_read_and_write_test_file() { std::string test_file = _path_desc.filepath + kTestFilePath; return read_write_test_file(test_file); } -OLAPStatus DataDir::get_shard(uint64_t* shard) { +Status DataDir::get_shard(uint64_t* shard) { std::stringstream shard_path_stream; uint32_t next_shard = 0; { @@ -260,11 +260,11 @@ OLAPStatus DataDir::get_shard(uint64_t* shard) { } shard_path_stream << _path_desc.filepath << DATA_PREFIX << "/" << next_shard; std::string shard_path = shard_path_stream.str(); - RETURN_WITH_WARN_IF_ERROR(Env::Default()->create_dirs(shard_path), OLAP_ERR_CANNOT_CREATE_DIR, + RETURN_WITH_WARN_IF_ERROR(Env::Default()->create_dirs(shard_path), Status::OLAPInternalError(OLAP_ERR_CANNOT_CREATE_DIR), "fail to create path. path=" + shard_path); *shard = next_shard; - return OLAP_SUCCESS; + return Status::OK(); } void DataDir::register_tablet(Tablet* tablet) { @@ -327,7 +327,7 @@ std::string DataDir::get_root_path_from_schema_hash_path_in_trash( .string(); } -OLAPStatus DataDir::_check_incompatible_old_format_tablet() { +Status DataDir::_check_incompatible_old_format_tablet() { auto check_incompatible_old_func = [](int64_t tablet_id, int32_t schema_hash, const std::string& value) -> bool { // if strict check incompatible old format, then log fatal @@ -346,9 +346,9 @@ OLAPStatus DataDir::_check_incompatible_old_format_tablet() { }; // seek old header prefix. when check_incompatible_old_func is called, it has old format in olap_meta - OLAPStatus check_incompatible_old_status = TabletMetaManager::traverse_headers( + Status check_incompatible_old_status = TabletMetaManager::traverse_headers( _meta, check_incompatible_old_func, OLD_HEADER_PREFIX); - if (check_incompatible_old_status != OLAP_SUCCESS) { + if (!check_incompatible_old_status) { LOG(WARNING) << "check incompatible old format meta fails, it may lead to data missing!!! " << _path_desc.filepath; } else { @@ -358,11 +358,11 @@ OLAPStatus DataDir::_check_incompatible_old_format_tablet() { } // TODO(ygl): deal with rowsets and tablets when load failed -OLAPStatus DataDir::load() { +Status DataDir::load() { LOG(INFO) << "start to load tablets from " << _path_desc.filepath; if (is_remote()) { RETURN_WITH_WARN_IF_ERROR(StorageBackendMgr::instance()->init(_path_desc.filepath + STORAGE_PARAM_PREFIX), - OLAP_ERR_INIT_FAILED, "DataDir init failed."); + Status::OLAPInternalError(OLAP_ERR_INIT_FAILED), "DataDir init failed."); } // load rowset meta from meta env and create rowset // COMMITTED: add to txn manager @@ -386,10 +386,10 @@ OLAPStatus DataDir::load() { dir_rowset_metas.push_back(rowset_meta); return true; }; - OLAPStatus load_rowset_status = + Status load_rowset_status = RowsetMetaManager::traverse_rowset_metas(_meta, load_rowset_func); - if (load_rowset_status != OLAP_SUCCESS) { + if (!load_rowset_status) { LOG(WARNING) << "errors when load rowset meta from meta env, skip this data dir:" << _path_desc.filepath; } else { @@ -404,11 +404,11 @@ OLAPStatus DataDir::load() { auto load_tablet_func = [this, &tablet_ids, &failed_tablet_ids]( int64_t tablet_id, int32_t schema_hash, const std::string& value) -> bool { - OLAPStatus status = _tablet_manager->load_tablet_from_meta( + Status status = _tablet_manager->load_tablet_from_meta( this, tablet_id, schema_hash, value, false, false, false, false); - if (status != OLAP_SUCCESS && status != OLAP_ERR_TABLE_ALREADY_DELETED_ERROR && - status != OLAP_ERR_ENGINE_INSERT_OLD_TABLET) { - // load_tablet_from_meta() may return OLAP_ERR_TABLE_ALREADY_DELETED_ERROR + if (!status.ok() && status != Status::OLAPInternalError(OLAP_ERR_TABLE_ALREADY_DELETED_ERROR) && + status != Status::OLAPInternalError(OLAP_ERR_ENGINE_INSERT_OLD_TABLET)) { + // load_tablet_from_meta() may return Status::OLAPInternalError(OLAP_ERR_TABLE_ALREADY_DELETED_ERROR) // which means the tablet status is DELETED // This may happen when the tablet was just deleted before the BE restarted, // but it has not been cleared from rocksdb. At this time, restarting the BE @@ -416,7 +416,7 @@ OLAPStatus DataDir::load() { // added to the garbage collection queue and will be automatically deleted afterwards. // Therefore, we believe that this situation is not a failure. - // Besides, load_tablet_from_meta() may return OLAP_ERR_ENGINE_INSERT_OLD_TABLET + // Besides, load_tablet_from_meta() may return Status::OLAPInternalError(OLAP_ERR_ENGINE_INSERT_OLD_TABLET) // when BE is restarting and the older tablet have been added to the // garbage collection queue but not deleted yet. // In this case, since the data_dirs are parallel loaded, a later loaded tablet @@ -430,7 +430,7 @@ OLAPStatus DataDir::load() { } return true; }; - OLAPStatus load_tablet_status = TabletMetaManager::traverse_headers(_meta, load_tablet_func); + Status load_tablet_status = TabletMetaManager::traverse_headers(_meta, load_tablet_func); if (failed_tablet_ids.size() != 0) { LOG(WARNING) << "load tablets from header failed" << ", loaded tablet: " << tablet_ids.size() @@ -441,7 +441,7 @@ OLAPStatus DataDir::load() { << _path_desc.filepath; } } - if (load_tablet_status != OLAP_SUCCESS) { + if (!load_tablet_status) { LOG(WARNING) << "there is failure when loading tablet headers" << ", loaded tablet: " << tablet_ids.size() << ", error tablet: " << failed_tablet_ids.size() @@ -470,9 +470,9 @@ OLAPStatus DataDir::load() { continue; } RowsetSharedPtr rowset; - OLAPStatus create_status = RowsetFactory::create_rowset( + Status create_status = RowsetFactory::create_rowset( &tablet->tablet_schema(), tablet->tablet_path_desc(), rowset_meta, &rowset); - if (create_status != OLAP_SUCCESS) { + if (!create_status) { LOG(WARNING) << "could not create rowset from rowsetmeta: " << " rowset_id: " << rowset_meta->rowset_id() << " rowset_type: " << rowset_meta->rowset_type() @@ -481,12 +481,12 @@ OLAPStatus DataDir::load() { } if (rowset_meta->rowset_state() == RowsetStatePB::COMMITTED && rowset_meta->tablet_uid() == tablet->tablet_uid()) { - OLAPStatus commit_txn_status = _txn_manager->commit_txn( + Status commit_txn_status = _txn_manager->commit_txn( _meta, rowset_meta->partition_id(), rowset_meta->txn_id(), rowset_meta->tablet_id(), rowset_meta->tablet_schema_hash(), rowset_meta->tablet_uid(), rowset_meta->load_id(), rowset, true); - if (commit_txn_status != OLAP_SUCCESS && - commit_txn_status != OLAP_ERR_PUSH_TRANSACTION_ALREADY_EXIST) { + if (!commit_txn_status && + commit_txn_status != Status::OLAPInternalError(OLAP_ERR_PUSH_TRANSACTION_ALREADY_EXIST)) { LOG(WARNING) << "failed to add committed rowset: " << rowset_meta->rowset_id() << " to tablet: " << rowset_meta->tablet_id() << " for txn: " << rowset_meta->txn_id(); @@ -498,9 +498,9 @@ OLAPStatus DataDir::load() { } } else if (rowset_meta->rowset_state() == RowsetStatePB::VISIBLE && rowset_meta->tablet_uid() == tablet->tablet_uid()) { - OLAPStatus publish_status = tablet->add_rowset(rowset, false); - if (publish_status != OLAP_SUCCESS && - publish_status != OLAP_ERR_PUSH_VERSION_ALREADY_EXIST) { + Status publish_status = tablet->add_rowset(rowset, false); + if (!publish_status && + publish_status != Status::OLAPInternalError(OLAP_ERR_PUSH_VERSION_ALREADY_EXIST)) { LOG(WARNING) << "add visible rowset to tablet failed rowset_id:" << rowset->rowset_id() << " tablet id: " << rowset_meta->tablet_id() << " txn id:" << rowset_meta->txn_id() @@ -524,7 +524,7 @@ OLAPStatus DataDir::load() { << ", total rowset meta: " << dir_rowset_metas.size() << ", invalid rowset num: " << invalid_rowset_counter; - return OLAP_SUCCESS; + return Status::OK(); } void DataDir::add_pending_ids(const std::string& id) { @@ -760,22 +760,19 @@ void DataDir::disks_compaction_num_increment(int64_t delta) { // this is moved from src/olap/utils.h, the old move_to_trash() can only support local files, // and it is more suitable in DataDir because one trash path is in one DataDir -OLAPStatus DataDir::move_to_trash(const FilePathDesc& segment_path_desc) { - OLAPStatus res = OLAP_SUCCESS; +Status DataDir::move_to_trash(const FilePathDesc& segment_path_desc) { + Status res = Status::OK(); FilePathDesc storage_root_desc = _path_desc; if (is_remote() && !StorageBackendMgr::instance()->get_root_path( segment_path_desc.storage_name, &(storage_root_desc.remote_path)).ok()) { LOG(WARNING) << "get_root_path failed for storage_name: " << segment_path_desc.storage_name; - return OLAP_ERR_OTHER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OTHER_ERROR); } // 1. get timestamp string string time_str; - if ((res = gen_timestamp_string(&time_str)) != OLAP_SUCCESS) { - OLAP_LOG_WARNING( - "failed to generate time_string when move file to trash." - "[err code=%d]", - res); + if ((res = gen_timestamp_string(&time_str)) != Status::OK()) { + LOG(WARNING) << "failed to generate time_string when move file to trash.err code=" << res; return res; } @@ -811,7 +808,7 @@ OLAPStatus DataDir::move_to_trash(const FilePathDesc& segment_path_desc) { if (!FileUtils::check_exist(trash_local_dir) && !FileUtils::create_dir(trash_local_dir).ok()) { OLAP_LOG_WARNING("delete file failed. due to mkdir failed. [file=%s new_dir=%s]", segment_path_desc.filepath.c_str(), trash_local_dir.c_str()); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } // 4. move remote file to trash if needed @@ -822,13 +819,13 @@ OLAPStatus DataDir::move_to_trash(const FilePathDesc& segment_path_desc) { if (!st.ok()) { LOG(WARNING) << "fail to write storage_name to trash path: " << trash_storage_name_path << ", error:" << st.to_string(); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } std::shared_ptr storage_backend = StorageBackendMgr::instance()-> get_storage_backend(segment_path_desc.storage_name); if (storage_backend == nullptr) { LOG(WARNING) << "storage_backend is invalid: " << segment_path_desc.storage_name; - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } Status status = storage_backend->exist_dir(segment_path_desc.remote_path); if (status.ok()) { @@ -838,13 +835,13 @@ OLAPStatus DataDir::move_to_trash(const FilePathDesc& segment_path_desc) { if (!rename_status.ok()) { OLAP_LOG_WARNING("Move remote file to trash failed. [file=%s target='%s']", segment_path_desc.remote_path.c_str(), trash_path_desc.remote_path.c_str()); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } } else if (status.is_not_found()) { LOG(WARNING) << "File may be removed before: " << segment_path_desc.remote_path; } else { LOG(WARNING) << "File check exist error: " << segment_path_desc.remote_path; - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } } @@ -853,7 +850,7 @@ OLAPStatus DataDir::move_to_trash(const FilePathDesc& segment_path_desc) { if (rename(segment_path_desc.filepath.c_str(), trash_local_file.c_str()) < 0) { OLAP_LOG_WARNING("move file to trash failed. [file=%s target='%s' err='%m']", segment_path_desc.filepath.c_str(), trash_local_file.c_str()); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } // 6. check parent dir of source file, delete it when empty @@ -862,7 +859,7 @@ OLAPStatus DataDir::move_to_trash(const FilePathDesc& segment_path_desc) { RETURN_WITH_WARN_IF_ERROR( FileUtils::list_dirs_files(source_parent_dir, &sub_dirs, &sub_files, Env::Default()), - OLAP_SUCCESS, "access dir failed. [dir=" + source_parent_dir); + Status::OK(), "access dir failed. [dir=" + source_parent_dir); if (sub_dirs.empty() && sub_files.empty()) { LOG(INFO) << "remove empty dir " << source_parent_dir; @@ -870,7 +867,7 @@ OLAPStatus DataDir::move_to_trash(const FilePathDesc& segment_path_desc) { Env::Default()->delete_dir(source_parent_dir); } - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/data_dir.h b/be/src/olap/data_dir.h index 5af18d6991..1d197cb6f0 100644 --- a/be/src/olap/data_dir.h +++ b/be/src/olap/data_dir.h @@ -76,7 +76,7 @@ public: Status set_cluster_id(int32_t cluster_id); void health_check(); - OLAPStatus get_shard(uint64_t* shard); + Status get_shard(uint64_t* shard); OlapMeta* get_meta() { return _meta; } @@ -99,7 +99,7 @@ public: const std::string& schema_hash_dir_in_trash); // load data from meta and data files - OLAPStatus load(); + Status load(); void add_pending_ids(const std::string& id); @@ -137,7 +137,7 @@ public: // storage_root/trash/20150619154308.delete_counter/tablet_path/segment_path, // remote_path is replaced by： // storage_root/trash/20150619154308.delete_counter/tablet_path/segment_path/tablet_uid - OLAPStatus move_to_trash(const FilePathDesc& segment_path_desc); + Status move_to_trash(const FilePathDesc& segment_path_desc); private: Status _init_cluster_id(); @@ -145,13 +145,13 @@ private: Status _init_meta(); Status _check_disk(); - OLAPStatus _read_and_write_test_file(); + Status _read_and_write_test_file(); Status read_cluster_id(Env* env, const std::string& cluster_id_path, int32_t* cluster_id); Status _write_cluster_id_to_path(const FilePathDesc& path_desc, int32_t cluster_id); // Check whether has old format (hdr_ start) in olap. When doris updating to current version, // it may lead to data missing. When conf::storage_strict_check_incompatible_old_format is true, // process will log fatal. - OLAPStatus _check_incompatible_old_format_tablet(); + Status _check_incompatible_old_format_tablet(); void _process_garbage_path(const std::string& path); diff --git a/be/src/olap/decimal12.h b/be/src/olap/decimal12.h index b73a44bb8c..e73f6304ad 100644 --- a/be/src/olap/decimal12.h +++ b/be/src/olap/decimal12.h @@ -89,7 +89,7 @@ struct decimal12_t { return std::string(buf); } - OLAPStatus from_string(const std::string& str) { + Status from_string(const std::string& str) { integer = 0; fraction = 0; const char* value_string = str.c_str(); @@ -97,7 +97,7 @@ struct decimal12_t { if (sign != nullptr) { if (sign != value_string) { - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } else { ++value_string; } @@ -131,7 +131,7 @@ struct decimal12_t { integer = -integer; } - return OLAP_SUCCESS; + return Status::OK(); } static const int32_t FRAC_RATIO = 1000000000; diff --git a/be/src/olap/delete_handler.cpp b/be/src/olap/delete_handler.cpp index 22340443e8..2479b35cc4 100644 --- a/be/src/olap/delete_handler.cpp +++ b/be/src/olap/delete_handler.cpp @@ -48,20 +48,20 @@ using google::protobuf::RepeatedPtrField; namespace doris { -OLAPStatus DeleteConditionHandler::generate_delete_predicate( +Status DeleteConditionHandler::generate_delete_predicate( const TabletSchema& schema, const std::vector& conditions, DeletePredicatePB* del_pred) { if (conditions.empty()) { LOG(WARNING) << "invalid parameters for store_cond." << " condition_size=" << conditions.size(); - return OLAP_ERR_DELETE_INVALID_PARAMETERS; + return Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_PARAMETERS); } // Check whether the delete condition meets the requirements for (const TCondition& condition : conditions) { - if (check_condition_valid(schema, condition) != OLAP_SUCCESS) { + if (check_condition_valid(schema, condition) != Status::OK()) { LOG(WARNING) << "invalid condition. condition=" << ThriftDebugString(condition); - return OLAP_ERR_DELETE_INVALID_CONDITION; + return Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION); } } @@ -86,7 +86,7 @@ OLAPStatus DeleteConditionHandler::generate_delete_predicate( } del_pred->set_version(-1); - return OLAP_SUCCESS; + return Status::OK(); } std::string DeleteConditionHandler::construct_sub_predicates(const TCondition& condition) { @@ -155,13 +155,13 @@ bool DeleteConditionHandler::is_condition_value_valid(const TabletColumn& column return false; } -OLAPStatus DeleteConditionHandler::check_condition_valid(const TabletSchema& schema, +Status DeleteConditionHandler::check_condition_valid(const TabletSchema& schema, const TCondition& cond) { // Check whether the column exists int32_t field_index = schema.field_index(cond.column_name); if (field_index < 0) { OLAP_LOG_WARNING("field is not existent. [field_index=%d]", field_index); - return OLAP_ERR_DELETE_INVALID_CONDITION; + return Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION); } // Delete condition should only applied on key columns or duplicate key table, and @@ -172,25 +172,25 @@ OLAPStatus DeleteConditionHandler::check_condition_valid(const TabletSchema& sch column.type() == OLAP_FIELD_TYPE_DOUBLE || column.type() == OLAP_FIELD_TYPE_FLOAT) { LOG(WARNING) << "field is not key column, or storage model is not duplicate, or data type " "is float or double."; - return OLAP_ERR_DELETE_INVALID_CONDITION; + return Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION); } // Check operator and operands size are matched. if ("*=" != cond.condition_op && "!*=" != cond.condition_op && cond.condition_values.size() != 1) { OLAP_LOG_WARNING("invalid condition value size. [size=%ld]", cond.condition_values.size()); - return OLAP_ERR_DELETE_INVALID_CONDITION; + return Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION); } // Check each operand is valid for (const auto& condition_value : cond.condition_values) { if (!is_condition_value_valid(column, cond.condition_op, condition_value)) { LOG(WARNING) << "invalid condition value. [value=" << condition_value << "]"; - return OLAP_ERR_DELETE_INVALID_CONDITION; + return Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION); } } - return OLAP_SUCCESS; + return Status::OK(); } bool DeleteHandler::_parse_condition(const std::string& condition_str, TCondition* condition) { @@ -229,7 +229,7 @@ bool DeleteHandler::_parse_condition(const std::string& condition_str, TConditio return true; } -OLAPStatus DeleteHandler::init(const TabletSchema& schema, +Status DeleteHandler::init(const TabletSchema& schema, const DelPredicateArray& delete_conditions, int64_t version, const TabletReader* reader) { DCHECK(!_is_inited) << "reinitialize delete handler."; @@ -247,7 +247,7 @@ OLAPStatus DeleteHandler::init(const TabletSchema& schema, if (temp.del_cond == nullptr) { LOG(FATAL) << "fail to malloc Conditions. size=" << sizeof(Conditions); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } temp.del_cond->set_tablet_schema(&schema); @@ -255,12 +255,12 @@ OLAPStatus DeleteHandler::init(const TabletSchema& schema, TCondition condition; if (!_parse_condition(sub_predicate, &condition)) { OLAP_LOG_WARNING("fail to parse condition. [condition=%s]", sub_predicate.c_str()); - return OLAP_ERR_DELETE_INVALID_PARAMETERS; + return Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_PARAMETERS); } - OLAPStatus res = temp.del_cond->append_condition(condition); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to append condition.[res=%d]", res); + Status res = temp.del_cond->append_condition(condition); + if (!res.ok()) { + LOG(WARNING) << "fail to append condition.res = " << res; return res; } @@ -283,9 +283,9 @@ OLAPStatus DeleteHandler::init(const TabletSchema& schema, for (const auto& value : in_predicate.values()) { condition.condition_values.push_back(value); } - OLAPStatus res = temp.del_cond->append_condition(condition); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to append condition.[res=%d]", res); + Status res = temp.del_cond->append_condition(condition); + if (!res.ok()) { + LOG(WARNING) << "fail to append condition.res = " << res; return res; } @@ -299,7 +299,7 @@ OLAPStatus DeleteHandler::init(const TabletSchema& schema, _is_inited = true; - return OLAP_SUCCESS; + return Status::OK(); } bool DeleteHandler::is_filter_data(const int64_t data_version, const RowCursor& row) const { diff --git a/be/src/olap/delete_handler.h b/be/src/olap/delete_handler.h index d95f0f9ac8..70c95ce49e 100644 --- a/be/src/olap/delete_handler.h +++ b/be/src/olap/delete_handler.h @@ -40,7 +40,7 @@ public: ~DeleteConditionHandler() {} // generated DeletePredicatePB by TCondition - OLAPStatus generate_delete_predicate(const TabletSchema& schema, + Status generate_delete_predicate(const TabletSchema& schema, const std::vector& conditions, DeletePredicatePB* del_pred); @@ -49,9 +49,7 @@ public: private: // Validate the condition on the schema. - // Return OLAP_SUCCESS, if valid - // OLAP_ERR_DELETE_INVALID_CONDITION, otherwise - OLAPStatus check_condition_valid(const TabletSchema& tablet_schema, const TCondition& cond); + Status check_condition_valid(const TabletSchema& tablet_schema, const TCondition& cond); // Check whether the condition value is valid according to its type. // 1. For integers(int8,int16,in32,int64,uint8,uint16,uint32,uint64), check whether they are overflow @@ -72,7 +70,7 @@ struct DeleteConditions { // This class is used for checking whether a row should be deleted. // It is used in the following processes： // 1. Create and initialize a DeleteHandler object: -// OLAPStatus res; +// Status res; // DeleteHandler delete_handler; // res = delete_handler.init(tablet, condition_version); // 2. Use it to check whether a row should be deleted: @@ -97,10 +95,9 @@ public: // * schema: tablet's schema, the delete conditions and data rows are in this schema // * version: maximum version // return: - // * OLAP_SUCCESS: succeed - // * OLAP_ERR_DELETE_INVALID_PARAMETERS: input parameters are not valid - // * OLAP_ERR_MALLOC_ERROR: alloc memory failed - OLAPStatus init(const TabletSchema& schema, const DelPredicateArray& delete_conditions, + // * Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_PARAMETERS): input parameters are not valid + // * Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR): alloc memory failed + Status init(const TabletSchema& schema, const DelPredicateArray& delete_conditions, int64_t version, const doris::TabletReader* = nullptr); // Check whether a row should be deleted. diff --git a/be/src/olap/delta_writer.cpp b/be/src/olap/delta_writer.cpp index 60ea864282..14b442c738 100644 --- a/be/src/olap/delta_writer.cpp +++ b/be/src/olap/delta_writer.cpp @@ -29,9 +29,9 @@ namespace doris { -OLAPStatus DeltaWriter::open(WriteRequest* req, DeltaWriter** writer) { +Status DeltaWriter::open(WriteRequest* req, DeltaWriter** writer) { *writer = new DeltaWriter(req, StorageEngine::instance()); - return OLAP_SUCCESS; + return Status::OK(); } DeltaWriter::DeltaWriter(WriteRequest* req, StorageEngine* storage_engine) @@ -72,7 +72,7 @@ DeltaWriter::~DeltaWriter() { } void DeltaWriter::_garbage_collection() { - OLAPStatus rollback_status = OLAP_SUCCESS; + Status rollback_status = Status::OK(); TxnManager* txn_mgr = _storage_engine->txn_manager(); if (_tablet != nullptr) { rollback_status = txn_mgr->rollback_txn(_req.partition_id, _tablet, _req.txn_id); @@ -80,18 +80,18 @@ void DeltaWriter::_garbage_collection() { // has to check rollback status, because the rowset maybe committed in this thread and // published in another thread, then rollback will failed. // when rollback failed should not delete rowset - if (rollback_status == OLAP_SUCCESS) { + if (rollback_status.ok()) { _storage_engine->add_unused_rowset(_cur_rowset); } } -OLAPStatus DeltaWriter::init() { +Status DeltaWriter::init() { TabletManager* tablet_mgr = _storage_engine->tablet_manager(); _tablet = tablet_mgr->get_tablet(_req.tablet_id); if (_tablet == nullptr) { LOG(WARNING) << "fail to find tablet. tablet_id=" << _req.tablet_id << ", schema_hash=" << _req.schema_hash; - return OLAP_ERR_TABLE_NOT_FOUND; + return Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); } _mem_tracker = @@ -101,13 +101,13 @@ OLAPStatus DeltaWriter::init() { LOG(WARNING) << "failed to init delta writer. version count: " << _tablet->version_count() << ", exceed limit: " << config::max_tablet_version_num << ". tablet: " << _tablet->full_name(); - return OLAP_ERR_TOO_MANY_VERSION; + return Status::OLAPInternalError(OLAP_ERR_TOO_MANY_VERSION); } { std::shared_lock base_migration_rlock(_tablet->get_migration_lock(), std::try_to_lock); if (!base_migration_rlock.owns_lock()) { - return OLAP_ERR_RWLOCK_ERROR; + return Status::OLAPInternalError(OLAP_ERR_RWLOCK_ERROR); } std::lock_guard push_lock(_tablet->get_push_lock()); RETURN_NOT_OK(_storage_engine->txn_manager()->prepare_txn(_req.partition_id, _tablet, @@ -143,10 +143,10 @@ OLAPStatus DeltaWriter::init() { &_flush_token, writer_context.rowset_type, _req.is_high_priority)); _is_init = true; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus DeltaWriter::write(Tuple* tuple) { +Status DeltaWriter::write(Tuple* tuple) { std::lock_guard l(_lock); if (!_is_init && !_is_cancelled) { RETURN_NOT_OK(init()); @@ -155,7 +155,7 @@ OLAPStatus DeltaWriter::write(Tuple* tuple) { if (_is_cancelled) { // The writer may be cancelled at any time by other thread. // just return ERROR if writer is cancelled. - return OLAP_ERR_ALREADY_CANCELLED; + return Status::OLAPInternalError(OLAP_ERR_ALREADY_CANCELLED); } _mem_table->insert(tuple); @@ -164,23 +164,23 @@ OLAPStatus DeltaWriter::write(Tuple* tuple) { // and create a new memtable for incoming data if (_mem_table->memory_usage() >= config::write_buffer_size) { if (++_segment_counter > config::max_segment_num_per_rowset) { - return OLAP_ERR_TOO_MANY_SEGMENTS; + return Status::OLAPInternalError(OLAP_ERR_TOO_MANY_SEGMENTS); } RETURN_NOT_OK(_flush_memtable_async()); // create a new memtable for new incoming data _reset_mem_table(); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus DeltaWriter::write(const RowBatch* row_batch, const std::vector& row_idxs) { +Status DeltaWriter::write(const RowBatch* row_batch, const std::vector& row_idxs) { std::lock_guard l(_lock); if (!_is_init && !_is_cancelled) { RETURN_NOT_OK(init()); } if (_is_cancelled) { - return OLAP_ERR_ALREADY_CANCELLED; + return Status::OLAPInternalError(OLAP_ERR_ALREADY_CANCELLED); } for (const auto& row_idx : row_idxs) { @@ -192,28 +192,28 @@ OLAPStatus DeltaWriter::write(const RowBatch* row_batch, const std::vector& _reset_mem_table(); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus DeltaWriter::_flush_memtable_async() { +Status DeltaWriter::_flush_memtable_async() { if (++_segment_counter > config::max_segment_num_per_rowset) { - return OLAP_ERR_TOO_MANY_SEGMENTS; + return Status::OLAPInternalError(OLAP_ERR_TOO_MANY_SEGMENTS); } return _flush_token->submit(_mem_table); } -OLAPStatus DeltaWriter::flush_memtable_and_wait(bool need_wait) { +Status DeltaWriter::flush_memtable_and_wait(bool need_wait) { std::lock_guard l(_lock); if (!_is_init) { // This writer is not initialized before flushing. Do nothing - // But we return OLAP_SUCCESS instead of OLAP_ERR_ALREADY_CANCELLED, + // But we return OLAP_SUCCESS instead of Status::OLAPInternalError(OLAP_ERR_ALREADY_CANCELLED), // Because this method maybe called when trying to reduce mem consumption, // and at that time, the writer may not be initialized yet and that is a normal case. - return OLAP_SUCCESS; + return Status::OK(); } if (_is_cancelled) { - return OLAP_ERR_ALREADY_CANCELLED; + return Status::OLAPInternalError(OLAP_ERR_ALREADY_CANCELLED); } if (mem_consumption() == _mem_table->memory_usage()) { @@ -232,21 +232,21 @@ OLAPStatus DeltaWriter::flush_memtable_and_wait(bool need_wait) { // wait all memtables in flush queue to be flushed. RETURN_NOT_OK(_flush_token->wait()); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus DeltaWriter::wait_flush() { +Status DeltaWriter::wait_flush() { std::lock_guard l(_lock); if (!_is_init) { - // return OLAP_SUCCESS instead of OLAP_ERR_ALREADY_CANCELLED for same reason + // return OLAP_SUCCESS instead of Status::OLAPInternalError(OLAP_ERR_ALREADY_CANCELLED) for same reason // as described in flush_memtable_and_wait() - return OLAP_SUCCESS; + return Status::OK(); } if (_is_cancelled) { - return OLAP_ERR_ALREADY_CANCELLED; + return Status::OLAPInternalError(OLAP_ERR_ALREADY_CANCELLED); } RETURN_NOT_OK(_flush_token->wait()); - return OLAP_SUCCESS; + return Status::OK(); } void DeltaWriter::_reset_mem_table() { @@ -255,7 +255,7 @@ void DeltaWriter::_reset_mem_table() { _mem_tracker)); } -OLAPStatus DeltaWriter::close() { +Status DeltaWriter::close() { std::lock_guard l(_lock); if (!_is_init && !_is_cancelled) { // if this delta writer is not initialized, but close() is called. @@ -267,22 +267,21 @@ OLAPStatus DeltaWriter::close() { } if (_is_cancelled) { - return OLAP_ERR_ALREADY_CANCELLED; + return Status::OLAPInternalError(OLAP_ERR_ALREADY_CANCELLED); } RETURN_NOT_OK(_flush_memtable_async()); _mem_table.reset(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus DeltaWriter::close_wait(google::protobuf::RepeatedPtrField* tablet_vec, - bool is_broken) { +Status DeltaWriter::close_wait(google::protobuf::RepeatedPtrField* tablet_vec, bool is_broken) { std::lock_guard l(_lock); DCHECK(_is_init) << "delta writer is supposed be to initialized before close_wait() being called"; if (_is_cancelled) { - return OLAP_ERR_ALREADY_CANCELLED; + return Status::OLAPInternalError(OLAP_ERR_ALREADY_CANCELLED); } // return error if previous flush failed @@ -292,11 +291,11 @@ OLAPStatus DeltaWriter::close_wait(google::protobuf::RepeatedPtrFieldbuild(); if (_cur_rowset == nullptr) { LOG(WARNING) << "fail to build rowset"; - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } - OLAPStatus res = _storage_engine->txn_manager()->commit_txn( + Status res = _storage_engine->txn_manager()->commit_txn( _req.partition_id, _tablet, _req.txn_id, _req.load_id, _cur_rowset, false); - if (res != OLAP_SUCCESS && res != OLAP_ERR_PUSH_TRANSACTION_ALREADY_EXIST) { + if (!res && res != Status::OLAPInternalError(OLAP_ERR_PUSH_TRANSACTION_ALREADY_EXIST)) { LOG(WARNING) << "Failed to commit txn: " << _req.txn_id << " for rowset: " << _cur_rowset->rowset_id(); return res; @@ -313,15 +312,16 @@ OLAPStatus DeltaWriter::close_wait(google::protobuf::RepeatedPtrFieldget_stats(); - VLOG_CRITICAL << "close delta writer for tablet: " << _tablet->tablet_id() - << ", load id: " << print_id(_req.load_id) << ", stats: " << stat; - return OLAP_SUCCESS; + VLOG_CRITICAL << "close delta writer for tablet: " << _tablet->tablet_id() + << ", load id: " << print_id(_req.load_id) + << ", stats: " << stat; + return Status::OK(); } -OLAPStatus DeltaWriter::cancel() { +Status DeltaWriter::cancel() { std::lock_guard l(_lock); if (!_is_init || _is_cancelled) { - return OLAP_SUCCESS; + return Status::OK(); } _mem_table.reset(); if (_flush_token != nullptr) { @@ -329,7 +329,7 @@ OLAPStatus DeltaWriter::cancel() { _flush_token->cancel(); } _is_cancelled = true; - return OLAP_SUCCESS; + return Status::OK(); } int64_t DeltaWriter::mem_consumption() const { diff --git a/be/src/olap/delta_writer.h b/be/src/olap/delta_writer.h index c46dad3f85..e026919325 100644 --- a/be/src/olap/delta_writer.h +++ b/be/src/olap/delta_writer.h @@ -54,37 +54,37 @@ struct WriteRequest { // This class is NOT thread-safe, external synchronization is required. class DeltaWriter { public: - static OLAPStatus open(WriteRequest* req, DeltaWriter** writer); + static Status open(WriteRequest* req, DeltaWriter** writer); ~DeltaWriter(); - OLAPStatus init(); + Status init(); - OLAPStatus write(Tuple* tuple); - OLAPStatus write(const RowBatch* row_batch, const std::vector& row_idxs); + Status write(Tuple* tuple); + Status write(const RowBatch* row_batch, const std::vector& row_idxs); // flush the last memtable to flush queue, must call it before close_wait() - OLAPStatus close(); + Status close(); // wait for all memtables to be flushed. // mem_consumption() should be 0 after this function returns. - OLAPStatus close_wait(google::protobuf::RepeatedPtrField* tablet_vec, bool is_broken); + Status close_wait(google::protobuf::RepeatedPtrField* tablet_vec, bool is_broken); // abandon current memtable and wait for all pending-flushing memtables to be destructed. // mem_consumption() should be 0 after this function returns. - OLAPStatus cancel(); + Status cancel(); // submit current memtable to flush queue, and wait all memtables in flush queue // to be flushed. // This is currently for reducing mem consumption of this delta writer. // If need_wait is true, it will wait for all memtable in flush queue to be flushed. // Otherwise, it will just put memtables to the flush queue and return. - OLAPStatus flush_memtable_and_wait(bool need_wait); + Status flush_memtable_and_wait(bool need_wait); int64_t partition_id() const; int64_t mem_consumption() const; // Wait all memtable in flush queue to be flushed - OLAPStatus wait_flush(); + Status wait_flush(); int64_t tablet_id() { return _tablet->tablet_id(); } @@ -92,7 +92,7 @@ private: DeltaWriter(WriteRequest* req, StorageEngine* storage_engine); // push a full memtable to flush executor - OLAPStatus _flush_memtable_async(); + Status _flush_memtable_async(); void _garbage_collection(); diff --git a/be/src/olap/field.h b/be/src/olap/field.h index 3950df4ab8..f21c21e74b 100644 --- a/be/src/olap/field.h +++ b/be/src/olap/field.h @@ -235,7 +235,7 @@ public: } //convert and copy field from src to desc - OLAPStatus convert_from(char* dest, const char* src, const TypeInfo* src_type, + Status convert_from(char* dest, const char* src, const TypeInfo* src_type, MemPool* mem_pool) const { return _type_info->convert_from(dest, src, src_type, mem_pool, get_variable_len()); } @@ -246,7 +246,7 @@ public: // used by init scan key stored in string format // value_string should end with '\0' - OLAPStatus from_string(char* buf, const std::string& value_string) const { + Status from_string(char* buf, const std::string& value_string) const { if (type() == OLAP_FIELD_TYPE_STRING && !value_string.empty()) { auto slice = reinterpret_cast(buf); if (slice->size < value_string.size()) { diff --git a/be/src/olap/file_helper.cpp b/be/src/olap/file_helper.cpp index 7be2854aaf..7d2b351772 100644 --- a/be/src/olap/file_helper.cpp +++ b/be/src/olap/file_helper.cpp @@ -59,13 +59,13 @@ FileHandler::~FileHandler() { this->close(); } -OLAPStatus FileHandler::open(const string& file_name, int flag) { +Status FileHandler::open(const string& file_name, int flag) { if (_fd != -1 && _file_name == file_name) { - return OLAP_SUCCESS; + return Status::OK(); } - if (OLAP_SUCCESS != this->close()) { - return OLAP_ERR_IO_ERROR; + if (!this->close()) { + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } _fd = ::open(file_name.c_str(), flag); @@ -75,29 +75,29 @@ OLAPStatus FileHandler::open(const string& file_name, int flag) { LOG(WARNING) << "failed to open file. [err=" << strerror_r(errno, errmsg, 64) << ", file_name='" << file_name << "' flag=" << flag << "]"; if (errno == EEXIST) { - return OLAP_ERR_FILE_ALREADY_EXIST; + return Status::OLAPInternalError(OLAP_ERR_FILE_ALREADY_EXIST); } - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } VLOG_NOTICE << "success to open file. file_name=" << file_name << ", mode=" << flag << " fd=" << _fd; _is_using_cache = false; _file_name = file_name; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus FileHandler::open_with_cache(const string& file_name, int flag) { +Status FileHandler::open_with_cache(const string& file_name, int flag) { if (_s_fd_cache == nullptr) { return open(file_name, flag); } if (_fd != -1 && _file_name == file_name) { - return OLAP_SUCCESS; + return Status::OK(); } - if (OLAP_SUCCESS != this->close()) { - return OLAP_ERR_IO_ERROR; + if (!this->close()) { + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } CacheKey key(file_name.c_str(), file_name.size()); @@ -115,9 +115,9 @@ OLAPStatus FileHandler::open_with_cache(const string& file_name, int flag) { LOG(WARNING) << "failed to open file. [err=" << strerror_r(errno, errmsg, 64) << " file_name='" << file_name << "' flag=" << flag << "]"; if (errno == EEXIST) { - return OLAP_ERR_FILE_ALREADY_EXIST; + return Status::OLAPInternalError(OLAP_ERR_FILE_ALREADY_EXIST); } - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } FileDescriptor* file_desc = new FileDescriptor(_fd); _cache_handle = _s_fd_cache->insert(key, file_desc, 1, &_delete_cache_file_descriptor); @@ -126,16 +126,16 @@ OLAPStatus FileHandler::open_with_cache(const string& file_name, int flag) { } _is_using_cache = true; _file_name = file_name; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus FileHandler::open_with_mode(const string& file_name, int flag, int mode) { +Status FileHandler::open_with_mode(const string& file_name, int flag, int mode) { if (_fd != -1 && _file_name == file_name) { - return OLAP_SUCCESS; + return Status::OK(); } - if (OLAP_SUCCESS != this->close()) { - return OLAP_ERR_IO_ERROR; + if (!this->close()) { + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } _fd = ::open(file_name.c_str(), flag, mode); @@ -145,27 +145,27 @@ OLAPStatus FileHandler::open_with_mode(const string& file_name, int flag, int mo LOG(WARNING) << "failed to open file. [err=" << strerror_r(errno, err_buf, 64) << " file_name='" << file_name << "' flag=" << flag << " mode=" << mode << "]"; if (errno == EEXIST) { - return OLAP_ERR_FILE_ALREADY_EXIST; + return Status::OLAPInternalError(OLAP_ERR_FILE_ALREADY_EXIST); } - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } VLOG_NOTICE << "success to open file. file_name=" << file_name << ", mode=" << mode << ", fd=" << _fd; _file_name = file_name; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus FileHandler::_release() { +Status FileHandler::_release() { _s_fd_cache->release(_cache_handle); _cache_handle = nullptr; _is_using_cache = false; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus FileHandler::close() { +Status FileHandler::close() { if (_fd < 0) { - return OLAP_SUCCESS; + return Status::OK(); } if (_is_using_cache && _s_fd_cache != nullptr) { @@ -184,7 +184,7 @@ OLAPStatus FileHandler::close() { char errmsg[64]; LOG(WARNING) << "failed to close file. [err= " << strerror_r(errno, errmsg, 64) << " file_name='" << _file_name << "' fd=" << _fd << "]"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } } @@ -193,10 +193,10 @@ OLAPStatus FileHandler::close() { _fd = -1; _file_name = ""; _wr_length = 0; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus FileHandler::pread(void* buf, size_t size, size_t offset) { +Status FileHandler::pread(void* buf, size_t size, size_t offset) { char* ptr = reinterpret_cast(buf); while (size > 0) { @@ -207,13 +207,13 @@ OLAPStatus FileHandler::pread(void* buf, size_t size, size_t offset) { LOG(WARNING) << "failed to pread from file. [err= " << strerror_r(errno, errmsg, 64) << " file_name='" << _file_name << "' fd=" << _fd << " size=" << size << " offset=" << offset << "]"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } else if (0 == rd_size) { char errmsg[64]; LOG(WARNING) << "read unenough from file. [err= " << strerror_r(errno, errmsg, 64) << " file_name='" << _file_name << "' fd=" << _fd << " size=" << size << " offset=" << offset << "]"; - return OLAP_ERR_READ_UNENOUGH; + return Status::OLAPInternalError(OLAP_ERR_READ_UNENOUGH); } size -= rd_size; @@ -221,10 +221,10 @@ OLAPStatus FileHandler::pread(void* buf, size_t size, size_t offset) { ptr += rd_size; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus FileHandler::write(const void* buf, size_t buf_size) { +Status FileHandler::write(const void* buf, size_t buf_size) { size_t org_buf_size = buf_size; const char* ptr = reinterpret_cast(buf); while (buf_size > 0) { @@ -235,13 +235,13 @@ OLAPStatus FileHandler::write(const void* buf, size_t buf_size) { LOG(WARNING) << "failed to write to file. [err= " << strerror_r(errno, errmsg, 64) << " file_name='" << _file_name << "' fd=" << _fd << " size=" << buf_size << "]"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } else if (0 == wr_size) { char errmsg[64]; LOG(WARNING) << "write unenough to file. [err=" << strerror_r(errno, errmsg, 64) << " file_name='" << _file_name << "' fd=" << _fd << " size=" << buf_size << "]"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } buf_size -= wr_size; @@ -255,10 +255,10 @@ OLAPStatus FileHandler::write(const void* buf, size_t buf_size) { sync_file_range(_fd, 0, 0, SYNC_FILE_RANGE_WRITE | SYNC_FILE_RANGE_WAIT_AFTER); _wr_length = 0; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus FileHandler::pwrite(const void* buf, size_t buf_size, size_t offset) { +Status FileHandler::pwrite(const void* buf, size_t buf_size, size_t offset) { const char* ptr = reinterpret_cast(buf); size_t org_buf_size = buf_size; @@ -270,13 +270,13 @@ OLAPStatus FileHandler::pwrite(const void* buf, size_t buf_size, size_t offset) LOG(WARNING) << "failed to pwrite to file. [err= " << strerror_r(errno, errmsg, 64) << " file_name='" << _file_name << "' fd=" << _fd << " size=" << buf_size << " offset=" << offset << "]"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } else if (0 == wr_size) { char errmsg[64]; LOG(WARNING) << "pwrite unenough to file. [err= " << strerror_r(errno, errmsg, 64) << " file_name='" << _file_name << "' fd=" << _fd << " size=" << buf_size << " offset=" << offset << "]"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } buf_size -= wr_size; @@ -285,7 +285,7 @@ OLAPStatus FileHandler::pwrite(const void* buf, size_t buf_size, size_t offset) } _wr_length += org_buf_size; - return OLAP_SUCCESS; + return Status::OK(); } off_t FileHandler::length() const { @@ -305,13 +305,13 @@ FileHandlerWithBuf::~FileHandlerWithBuf() { this->close(); } -OLAPStatus FileHandlerWithBuf::open(const string& file_name, const char* mode) { +Status FileHandlerWithBuf::open(const string& file_name, const char* mode) { if (_fp != nullptr && _file_name == file_name) { - return OLAP_SUCCESS; + return Status::OK(); } - if (OLAP_SUCCESS != this->close()) { - return OLAP_ERR_IO_ERROR; + if (!this->close()) { + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } _fp = ::fopen(file_name.c_str(), mode); @@ -321,24 +321,24 @@ OLAPStatus FileHandlerWithBuf::open(const string& file_name, const char* mode) { LOG(WARNING) << "failed to open file. [err= " << strerror_r(errno, errmsg, 64) << " file_name='" << file_name << "' flag='" << mode << "']"; if (errno == EEXIST) { - return OLAP_ERR_FILE_ALREADY_EXIST; + return Status::OLAPInternalError(OLAP_ERR_FILE_ALREADY_EXIST); } - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } VLOG_NOTICE << "success to open file. " << "file_name=" << file_name << ", mode=" << mode; _file_name = file_name; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus FileHandlerWithBuf::open_with_mode(const string& file_name, const char* mode) { +Status FileHandlerWithBuf::open_with_mode(const string& file_name, const char* mode) { return this->open(file_name, mode); } -OLAPStatus FileHandlerWithBuf::close() { +Status FileHandlerWithBuf::close() { if (nullptr == _fp) { - return OLAP_SUCCESS; + return Status::OK(); } // In some cases (fd is available, but fsync fails) can cause handle leaks @@ -346,42 +346,42 @@ OLAPStatus FileHandlerWithBuf::close() { char errmsg[64]; LOG(WARNING) << "failed to close file. [err= " << strerror_r(errno, errmsg, 64) << " file_name='" << _file_name << "']"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } _fp = nullptr; _file_name = ""; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus FileHandlerWithBuf::read(void* buf, size_t size) { +Status FileHandlerWithBuf::read(void* buf, size_t size) { if (OLAP_UNLIKELY(nullptr == _fp)) { OLAP_LOG_WARNING("Fail to write, fp is nullptr!"); - return OLAP_ERR_NOT_INITED; + return Status::OLAPInternalError(OLAP_ERR_NOT_INITED); } size_t rd_size = ::fread(buf, 1, size, _fp); if (rd_size == size) { - return OLAP_SUCCESS; + return Status::OK(); } else if (::feof(_fp)) { char errmsg[64]; LOG(WARNING) << "read unenough from file. [err=" << strerror_r(errno, errmsg, 64) << " file_name='" << _file_name << "' size=" << size << " rd_size=" << rd_size << "]"; - return OLAP_ERR_READ_UNENOUGH; + return Status::OLAPInternalError(OLAP_ERR_READ_UNENOUGH); } else { char errmsg[64]; LOG(WARNING) << "failed to read from file. [err=" << strerror_r(errno, errmsg, 64) << " file_name='" << _file_name << "' size=" << size << "]"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } } -OLAPStatus FileHandlerWithBuf::pread(void* buf, size_t size, size_t offset) { +Status FileHandlerWithBuf::pread(void* buf, size_t size, size_t offset) { if (OLAP_UNLIKELY(nullptr == _fp)) { OLAP_LOG_WARNING("Fail to write, fp is nullptr!"); - return OLAP_ERR_NOT_INITED; + return Status::OLAPInternalError(OLAP_ERR_NOT_INITED); } if (0 != ::fseek(_fp, offset, SEEK_SET)) { @@ -389,16 +389,16 @@ OLAPStatus FileHandlerWithBuf::pread(void* buf, size_t size, size_t offset) { LOG(WARNING) << "failed to seek file. [err= " << strerror_r(errno, errmsg, 64) << " file_name='" << _file_name << "' size=" << size << " offset=" << offset << "]"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } return this->read(buf, size); } -OLAPStatus FileHandlerWithBuf::write(const void* buf, size_t buf_size) { +Status FileHandlerWithBuf::write(const void* buf, size_t buf_size) { if (OLAP_UNLIKELY(nullptr == _fp)) { OLAP_LOG_WARNING("Fail to write, fp is nullptr!"); - return OLAP_ERR_NOT_INITED; + return Status::OLAPInternalError(OLAP_ERR_NOT_INITED); } size_t wr_size = ::fwrite(buf, 1, buf_size, _fp); @@ -407,16 +407,16 @@ OLAPStatus FileHandlerWithBuf::write(const void* buf, size_t buf_size) { char errmsg[64]; LOG(WARNING) << "failed to write to file. [err= " << strerror_r(errno, errmsg, 64) << " file_name='" << _file_name << "' size=" << buf_size << "]"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus FileHandlerWithBuf::pwrite(const void* buf, size_t buf_size, size_t offset) { +Status FileHandlerWithBuf::pwrite(const void* buf, size_t buf_size, size_t offset) { if (OLAP_UNLIKELY(nullptr == _fp)) { OLAP_LOG_WARNING("Fail to write, fp is nullptr!"); - return OLAP_ERR_NOT_INITED; + return Status::OLAPInternalError(OLAP_ERR_NOT_INITED); } if (0 != ::fseek(_fp, offset, SEEK_SET)) { @@ -424,7 +424,7 @@ OLAPStatus FileHandlerWithBuf::pwrite(const void* buf, size_t buf_size, size_t o LOG(WARNING) << "failed to seek file. [err= " << strerror_r(errno, errmsg, 64) << " file_name='" << _file_name << "' size=" << buf_size << " offset=" << offset << "]"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } return this->write(buf, buf_size); diff --git a/be/src/olap/file_helper.h b/be/src/olap/file_helper.h index 0d348b7a01..6a4a93564f 100644 --- a/be/src/olap/file_helper.h +++ b/be/src/olap/file_helper.h @@ -44,15 +44,15 @@ public: FileHandler(); ~FileHandler(); - OLAPStatus open(const std::string& file_name, int flag); - OLAPStatus open_with_cache(const std::string& file_name, int flag); + Status open(const std::string& file_name, int flag); + Status open_with_cache(const std::string& file_name, int flag); // The argument mode specifies the permissions to use in case a new file is created. - OLAPStatus open_with_mode(const std::string& file_name, int flag, int mode); - OLAPStatus close(); + Status open_with_mode(const std::string& file_name, int flag, int mode); + Status close(); - OLAPStatus pread(void* buf, size_t size, size_t offset); - OLAPStatus write(const void* buf, size_t buf_size); - OLAPStatus pwrite(const void* buf, size_t buf_size, size_t offset); + Status pread(void* buf, size_t size, size_t offset); + Status write(const void* buf, size_t buf_size); + Status pwrite(const void* buf, size_t buf_size, size_t offset); int32_t sync() { return 0; } @@ -95,7 +95,7 @@ public: static Cache* get_fd_cache() { return _s_fd_cache; } private: - OLAPStatus _release(); + Status _release(); static Cache* _s_fd_cache; int _fd; @@ -111,15 +111,15 @@ public: FileHandlerWithBuf(); ~FileHandlerWithBuf(); - OLAPStatus open(const std::string& file_name, const char* mode); + Status open(const std::string& file_name, const char* mode); // The argument mode specifies the permissions to use in case a new file is created. - OLAPStatus open_with_mode(const std::string& file_name, const char* mode); - OLAPStatus close(); + Status open_with_mode(const std::string& file_name, const char* mode); + Status close(); - OLAPStatus read(void* buf, size_t size); - OLAPStatus pread(void* buf, size_t size, size_t offset); - OLAPStatus write(const void* buf, size_t buf_size); - OLAPStatus pwrite(const void* buf, size_t buf_size, size_t offset); + Status read(void* buf, size_t size); + Status pread(void* buf, size_t size, size_t offset); + Status write(const void* buf, size_t buf_size); + Status pwrite(const void* buf, size_t buf_size, size_t offset); int32_t sync() { int32_t res = -1; @@ -199,19 +199,19 @@ public: ~FileHeader() {} // To calculate the length of the proto part, it needs to be called after the proto is operated, and prepare must be called before calling serialize - OLAPStatus prepare(FileHandlerType* file_handler); + Status prepare(FileHandlerType* file_handler); // call prepare() first, serialize() will write fixed header and protobuffer. // Write the header to the starting position of the incoming file handle - OLAPStatus serialize(FileHandlerType* file_handler); + Status serialize(FileHandlerType* file_handler); // read from file, validate file length, signature and alder32 of protobuffer. // Read the header from the beginning of the incoming file handle - OLAPStatus unserialize(FileHandlerType* file_handler); + Status unserialize(FileHandlerType* file_handler); // Check the validity of Header // it is actually call unserialize(). - OLAPStatus validate(const std::string& filename); + Status validate(const std::string& filename); uint64_t file_length() const { return _fixed_file_header.file_length; } uint32_t checksum() const { return _fixed_file_header.checksum; } @@ -238,10 +238,10 @@ private: // FileHandler implementation template -OLAPStatus FileHeader::prepare( +Status FileHeader::prepare( FileHandlerType* file_handler) { if (nullptr == file_handler) { - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } // Use the file name as Signature to prevent problems caused by some misoperations @@ -251,12 +251,12 @@ OLAPStatus FileHeader::prepare( if (!_proto.SerializeToString(&_proto_string)) { LOG(WARNING) << "serialize file header to string error. [path='" << file_handler->file_name() << "']"; - return OLAP_ERR_SERIALIZE_PROTOBUF_ERROR; + return Status::OLAPInternalError(OLAP_ERR_SERIALIZE_PROTOBUF_ERROR); } } catch (...) { LOG(WARNING) << "serialize file header to string error. [path='" << file_handler->file_name() << "']"; - return OLAP_ERR_SERIALIZE_PROTOBUF_ERROR; + return Status::OLAPInternalError(OLAP_ERR_SERIALIZE_PROTOBUF_ERROR); } _fixed_file_header.protobuf_checksum = @@ -268,72 +268,71 @@ OLAPStatus FileHeader::prepare( _fixed_file_header.version = OLAP_DATA_VERSION_APPLIED; _fixed_file_header.magic_number = OLAP_FIX_HEADER_MAGIC_NUMBER; - return OLAP_SUCCESS; + return Status::OK(); } template -OLAPStatus FileHeader::serialize( +Status FileHeader::serialize( FileHandlerType* file_handler) { if (nullptr == file_handler) { - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } // write to file - if (OLAP_SUCCESS != file_handler->pwrite(&_fixed_file_header, _fixed_file_header_size, 0)) { + if (!file_handler->pwrite(&_fixed_file_header, _fixed_file_header_size, 0)) { char errmsg[64]; LOG(WARNING) << "fail to write fixed header to file. [file='" << file_handler->file_name() << "' err=" << strerror_r(errno, errmsg, 64) << "]"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } - if (OLAP_SUCCESS != file_handler->pwrite(&_extra_fixed_header, sizeof(_extra_fixed_header), + if (!file_handler->pwrite(&_extra_fixed_header, sizeof(_extra_fixed_header), _fixed_file_header_size)) { char errmsg[64]; LOG(WARNING) << "fail to write extra fixed header to file. [file='" << file_handler->file_name() << "' err=" << strerror_r(errno, errmsg, 64) << "]"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } - if (OLAP_SUCCESS != - file_handler->pwrite(_proto_string.c_str(), _proto_string.size(), + if (!file_handler->pwrite(_proto_string.c_str(), _proto_string.size(), _fixed_file_header_size + sizeof(_extra_fixed_header))) { char errmsg[64]; LOG(WARNING) << "fail to write proto header to file. [file='" << file_handler->file_name() << "' err='" << strerror_r(errno, errmsg, 64) << "']"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } template -OLAPStatus FileHeader::unserialize( +Status FileHeader::unserialize( FileHandlerType* file_handler) { if (nullptr == file_handler) { - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } off_t real_file_length = 0; uint32_t real_protobuf_checksum = 0; - if (OLAP_SUCCESS != file_handler->pread(&_fixed_file_header, _fixed_file_header_size, 0)) { + if (!file_handler->pread(&_fixed_file_header, _fixed_file_header_size, 0)) { char errmsg[64]; LOG(WARNING) << "fail to load header structure from file. file=" << file_handler->file_name() << ", error=" << strerror_r(errno, errmsg, 64); - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } if (_fixed_file_header.magic_number != OLAP_FIX_HEADER_MAGIC_NUMBER) { VLOG_TRACE << "old fix header found, magic num=" << _fixed_file_header.magic_number; FixedFileHeader tmp_header; - if (OLAP_SUCCESS != file_handler->pread(&tmp_header, sizeof(tmp_header), 0)) { + if (!file_handler->pread(&tmp_header, sizeof(tmp_header), 0)) { char errmsg[64]; LOG(WARNING) << "fail to load header structure from file. file=" << file_handler->file_name() << ", error=" << strerror_r(errno, errmsg, 64); - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } _fixed_file_header.file_length = tmp_header.file_length; @@ -352,12 +351,12 @@ OLAPStatus FileHeader::unserialize( << ", magic_number=" << _fixed_file_header.magic_number << ", version=" << _fixed_file_header.version; - if (OLAP_SUCCESS != file_handler->pread(&_extra_fixed_header, sizeof(_extra_fixed_header), + if (!file_handler->pread(&_extra_fixed_header, sizeof(_extra_fixed_header), _fixed_file_header_size)) { char errmsg[64]; LOG(WARNING) << "fail to load extra fixed header from file. file=" << file_handler->file_name() << ", error=" << strerror_r(errno, errmsg, 64); - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } std::unique_ptr buf(new (std::nothrow) char[_fixed_file_header.protobuf_length]); @@ -366,16 +365,15 @@ OLAPStatus FileHeader::unserialize( char errmsg[64]; LOG(WARNING) << "malloc protobuf buf error. file=" << file_handler->file_name() << ", error=" << strerror_r(errno, errmsg, 64); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } - if (OLAP_SUCCESS != - file_handler->pread(buf.get(), _fixed_file_header.protobuf_length, + if (!file_handler->pread(buf.get(), _fixed_file_header.protobuf_length, _fixed_file_header_size + sizeof(_extra_fixed_header))) { char errmsg[64]; LOG(WARNING) << "fail to load protobuf from file. file=" << file_handler->file_name() << ", error=" << strerror_r(errno, errmsg, 64); - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } real_file_length = file_handler->length(); @@ -384,7 +382,7 @@ OLAPStatus FileHeader::unserialize( LOG(WARNING) << "file length is not match. file=" << file_handler->file_name() << ", file_length=" << file_length() << ", real_file_length=" << real_file_length; - return OLAP_ERR_FILE_DATA_ERROR; + return Status::OLAPInternalError(OLAP_ERR_FILE_DATA_ERROR); } // check proto checksum @@ -395,7 +393,7 @@ OLAPStatus FileHeader::unserialize( LOG(WARNING) << "checksum is not match. file=" << file_handler->file_name() << ", expect=" << _fixed_file_header.protobuf_checksum << ", actual=" << real_protobuf_checksum; - return OLAP_ERR_CHECKSUM_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CHECKSUM_ERROR); } try { @@ -404,35 +402,35 @@ OLAPStatus FileHeader::unserialize( if (!_proto.ParseFromString(protobuf_str)) { LOG(WARNING) << "fail to parse file content to protobuf object. file=" << file_handler->file_name(); - return OLAP_ERR_PARSE_PROTOBUF_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PARSE_PROTOBUF_ERROR); } } catch (...) { LOG(WARNING) << "fail to load protobuf. file='" << file_handler->file_name(); - return OLAP_ERR_PARSE_PROTOBUF_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PARSE_PROTOBUF_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } template -OLAPStatus FileHeader::validate( +Status FileHeader::validate( const std::string& filename) { FileHandler file_handler; - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); - if (OLAP_SUCCESS != file_handler.open(filename.c_str(), O_RDONLY)) { + if (!file_handler.open(filename.c_str(), O_RDONLY)) { char errmsg[64]; LOG(WARNING) << "fail to open file. [file='" << filename << "' err=" << strerror_r(errno, errmsg, 64) << "]"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } - if (OLAP_SUCCESS != (res = unserialize(&file_handler))) { + if (!(res = unserialize(&file_handler))) { LOG(WARNING) << "unserialize file header error. [file='" << filename << "']"; return res; } - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/file_stream.cpp b/be/src/olap/file_stream.cpp index ad1614f720..e789721ffe 100644 --- a/be/src/olap/file_stream.cpp +++ b/be/src/olap/file_stream.cpp @@ -46,28 +46,28 @@ ReadOnlyFileStream::ReadOnlyFileStream(FileHandler* handler, StorageByteBuffer** _current_compress_position(std::numeric_limits::max()), _stats(stats) {} -OLAPStatus ReadOnlyFileStream::_assure_data() { +Status ReadOnlyFileStream::_assure_data() { // if still has data in uncompressed if (OLAP_LIKELY(_uncompressed != nullptr && _uncompressed->remaining() > 0)) { - return OLAP_SUCCESS; + return Status::OK(); } else if (_file_cursor.eof()) { VLOG_TRACE << "STREAM EOF. length=" << _file_cursor.length() << ", used=" << _file_cursor.position(); - return OLAP_ERR_COLUMN_STREAM_EOF; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF); } StreamHead header; size_t file_cursor_used = _file_cursor.position(); - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); { SCOPED_RAW_TIMER(&_stats->io_ns); res = _file_cursor.read(reinterpret_cast(&header), sizeof(header)); - if (OLAP_UNLIKELY(OLAP_SUCCESS != res)) { + if (OLAP_UNLIKELY(!res.ok())) { OLAP_LOG_WARNING("read header fail"); return res; } res = _fill_compressed(header.length); - if (OLAP_UNLIKELY(OLAP_SUCCESS != res)) { + if (OLAP_UNLIKELY(!res.ok())) { OLAP_LOG_WARNING("read header fail"); return res; } @@ -84,8 +84,8 @@ OLAPStatus ReadOnlyFileStream::_assure_data() { { SCOPED_RAW_TIMER(&_stats->decompress_ns); res = _decompressor(*_shared_buffer, _compressed_helper); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to decompress err=%d", res); + if (!res.ok()) { + LOG(WARNING) << "fail to decompress err=" << res; return res; } } @@ -98,8 +98,8 @@ OLAPStatus ReadOnlyFileStream::_assure_data() { } // 设置读取的位置 -OLAPStatus ReadOnlyFileStream::seek(PositionProvider* position) { - OLAPStatus res = OLAP_SUCCESS; +Status ReadOnlyFileStream::seek(PositionProvider* position) { + Status res = Status::OK(); // 先seek到解压前的位置，也就是writer中写入的spilled byte int64_t compressed_position = position->get_next(); int64_t uncompressed_bytes = position->get_next(); @@ -116,9 +116,9 @@ OLAPStatus ReadOnlyFileStream::seek(PositionProvider* position) { _uncompressed = nullptr; res = _assure_data(); - if (OLAP_LIKELY(OLAP_SUCCESS == res)) { + if (OLAP_LIKELY(res.ok())) { // assure data will be successful in most case - } else if (res == OLAP_ERR_COLUMN_STREAM_EOF) { + } else if (res == Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF)) { VLOG_TRACE << "file stream eof."; return res; } else { @@ -128,19 +128,19 @@ OLAPStatus ReadOnlyFileStream::seek(PositionProvider* position) { } res = _uncompressed->set_position(uncompressed_bytes); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to set position.[res=%d, position=%lu]", res, uncompressed_bytes); + if (!res.ok()) { + LOG(WARNING) << "fail to set position. res= " << res << ", position=" << uncompressed_bytes; return res; } - return OLAP_SUCCESS; + return Status::OK(); } // 跳过指定的size的流 -OLAPStatus ReadOnlyFileStream::skip(uint64_t skip_length) { - OLAPStatus res = _assure_data(); +Status ReadOnlyFileStream::skip(uint64_t skip_length) { + Status res = _assure_data(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } @@ -157,20 +157,20 @@ OLAPStatus ReadOnlyFileStream::skip(uint64_t skip_length) { // 如果当前块就可以满足skip_length,那么_assure_data没任何作用。 res = _assure_data(); // while放下面，通常会少判断一次 - } while (byte_to_skip != 0 && res == OLAP_SUCCESS); + } while (byte_to_skip != 0 && res.ok()); return res; } -OLAPStatus ReadOnlyFileStream::_fill_compressed(size_t length) { +Status ReadOnlyFileStream::_fill_compressed(size_t length) { if (length > _compress_buffer_size) { LOG(WARNING) << "overflow when fill compressed." << ", length=" << length << ", compress_size" << _compress_buffer_size; - return OLAP_ERR_OUT_OF_BOUND; + return Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND); } - OLAPStatus res = _file_cursor.read((*_shared_buffer)->array(), length); - if (OLAP_SUCCESS != res) { + Status res = _file_cursor.read((*_shared_buffer)->array(), length); + if (!res.ok()) { OLAP_LOG_WARNING("fail to fill compressed buffer."); return res; } diff --git a/be/src/olap/file_stream.h b/be/src/olap/file_stream.h index a120a07b13..2ebcb8a183 100644 --- a/be/src/olap/file_stream.h +++ b/be/src/olap/file_stream.h @@ -62,36 +62,36 @@ public: ~ReadOnlyFileStream() { SAFE_DELETE(_compressed_helper); } - OLAPStatus init() { + Status init() { _compressed_helper = StorageByteBuffer::create(_compress_buffer_size); if (nullptr == _compressed_helper) { OLAP_LOG_WARNING("fail to create compressed buffer"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } _uncompressed = nullptr; - return OLAP_SUCCESS; + return Status::OK(); } void reset(uint64_t offset, uint64_t length) { _file_cursor.reset(offset, length); } // 从数据流中读取一个字节,内部指针后移 - // 如果数据流结束, 返回OLAP_ERR_COLUMN_STREAM_EOF - OLAPStatus read(char* byte); + // 如果数据流结束, 返回Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF) + Status read(char* byte); // 从数据流读入一段数据 // Input: // buffer - 存储读入的数据 // buf_size - 输入时给出buffer的大小,返回时给出实际读取的字节数 - // 如果数据流结束, 返回OLAP_ERR_COLUMN_STREAM_EOF - OLAPStatus read(char* buffer, uint64_t* buf_size); + // 如果数据流结束, 返回Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF) + Status read(char* buffer, uint64_t* buf_size); - OLAPStatus read_all(char* buffer, uint64_t* buf_size); + Status read_all(char* buffer, uint64_t* buf_size); // 设置读取的位置 - OLAPStatus seek(PositionProvider* position); + Status seek(PositionProvider* position); // 跳过指定size的流 - OLAPStatus skip(uint64_t skip_length); + Status skip(uint64_t skip_length); // 返回流的總長度 uint64_t stream_length() { return _file_cursor.length(); } @@ -145,20 +145,20 @@ private: _used = 0; } - OLAPStatus read(char* out_buffer, size_t length) { + Status read(char* out_buffer, size_t length) { if (_used + length <= _length) { - OLAPStatus res = _file_handler->pread(out_buffer, length, _used + _offset); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read from file. [res=%d]", res); + Status res = _file_handler->pread(out_buffer, length, _used + _offset); + if (!res.ok()) { + LOG(WARNING) << "fail to read from file. res = " << res; return res; } _used += length; } else { - return OLAP_ERR_COLUMN_STREAM_EOF; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF); } - return OLAP_SUCCESS; + return Status::OK(); } size_t position() { return _used; } @@ -169,13 +169,13 @@ private: bool eof() { return _used == _length; } - OLAPStatus seek(size_t offset) { + Status seek(size_t offset) { if (offset > _length) { - return OLAP_ERR_OUT_OF_BOUND; + return Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND); } _used = offset; - return OLAP_SUCCESS; + return Status::OK(); } const std::string& file_name() const { return _file_handler->file_name(); } @@ -189,8 +189,8 @@ private: size_t _used; }; - OLAPStatus _assure_data(); - OLAPStatus _fill_compressed(size_t length); + Status _assure_data(); + Status _fill_compressed(size_t length); FileCursor _file_cursor; StorageByteBuffer* _compressed_helper; @@ -206,10 +206,10 @@ private: DISALLOW_COPY_AND_ASSIGN(ReadOnlyFileStream); }; -inline OLAPStatus ReadOnlyFileStream::read(char* byte) { - OLAPStatus res = _assure_data(); +inline Status ReadOnlyFileStream::read(char* byte) { + Status res = _assure_data(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } @@ -217,21 +217,21 @@ inline OLAPStatus ReadOnlyFileStream::read(char* byte) { return res; } -inline OLAPStatus ReadOnlyFileStream::read(char* buffer, uint64_t* buf_size) { - OLAPStatus res; +inline Status ReadOnlyFileStream::read(char* buffer, uint64_t* buf_size) { + Status res; uint64_t read_length = *buf_size; *buf_size = 0; do { res = _assure_data(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { break; } uint64_t actual_length = std::min(read_length - *buf_size, _uncompressed->remaining()); res = _uncompressed->get(buffer, actual_length); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { break; } @@ -242,21 +242,21 @@ inline OLAPStatus ReadOnlyFileStream::read(char* buffer, uint64_t* buf_size) { return res; } -inline OLAPStatus ReadOnlyFileStream::read_all(char* buffer, uint64_t* buffer_size) { - OLAPStatus res; +inline Status ReadOnlyFileStream::read_all(char* buffer, uint64_t* buffer_size) { + Status res; uint64_t read_length = 0; uint64_t buffer_remain = *buffer_size; - while (OLAP_SUCCESS == _assure_data()) { + while (_assure_data()) { read_length = _uncompressed->remaining(); if (buffer_remain < read_length) { - res = OLAP_ERR_BUFFER_OVERFLOW; + res = Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); break; } res = _uncompressed->get(buffer, read_length); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { break; } @@ -266,7 +266,7 @@ inline OLAPStatus ReadOnlyFileStream::read_all(char* buffer, uint64_t* buffer_si if (eof()) { *buffer_size -= buffer_remain; - return OLAP_SUCCESS; + return Status::OK(); } return res; diff --git a/be/src/olap/in_stream.cpp b/be/src/olap/in_stream.cpp index 0809b274c7..8e8e297ff8 100644 --- a/be/src/olap/in_stream.cpp +++ b/be/src/olap/in_stream.cpp @@ -39,7 +39,7 @@ InStream::~InStream() { SAFE_DELETE(_uncompressed); } -OLAPStatus InStream::_slice(uint64_t chunk_size, StorageByteBuffer** out_slice) { +Status InStream::_slice(uint64_t chunk_size, StorageByteBuffer** out_slice) { uint64_t len = chunk_size; uint64_t old_offset = _current_offset; StorageByteBuffer* slice = nullptr; @@ -49,25 +49,25 @@ OLAPStatus InStream::_slice(uint64_t chunk_size, StorageByteBuffer** out_slice) slice = StorageByteBuffer::reference_buffer(_compressed, _compressed->position(), len); if (OLAP_UNLIKELY(nullptr == slice)) { - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } _compressed->set_position(_compressed->position() + len); *out_slice = slice; // 这里之前没有设置_current_offset _current_offset += len; - return OLAP_SUCCESS; + return Status::OK(); } else if (_current_range >= _inputs.size() - 1) { // 如果buffer用完了 OLAP_LOG_WARNING("EOF in InStream. [Need=%lu]", chunk_size); - return OLAP_ERR_OUT_OF_BOUND; + return Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND); } // 这里并不分配chuck_size, 而是分配一个最大值, 这样利于减少内存碎片 slice = StorageByteBuffer::create(_compress_buffer_size); if (OLAP_UNLIKELY(nullptr == slice)) { - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } // 当前的compress里的buffer不够了 @@ -88,7 +88,7 @@ OLAPStatus InStream::_slice(uint64_t chunk_size, StorageByteBuffer** out_slice) if (OLAP_UNLIKELY(nullptr == _compressed)) { SAFE_DELETE(slice); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } // 如果剩下的大于需要取的部分，拿出来 @@ -99,7 +99,7 @@ OLAPStatus InStream::_slice(uint64_t chunk_size, StorageByteBuffer** out_slice) _current_offset += len; slice->flip(); *out_slice = slice; - return OLAP_SUCCESS; + return Status::OK(); } else { _current_offset += _compressed->remaining(); len -= _compressed->remaining(); @@ -113,17 +113,17 @@ OLAPStatus InStream::_slice(uint64_t chunk_size, StorageByteBuffer** out_slice) // 回退到进来之前的状态 _seek(old_offset); OLAP_LOG_WARNING("EOF in InStream. [Need=%lu]", chunk_size); - return OLAP_ERR_OUT_OF_BOUND; + return Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND); } -OLAPStatus InStream::_assure_data() { - OLAPStatus res = OLAP_SUCCESS; +Status InStream::_assure_data() { + Status res = Status::OK(); if (OLAP_LIKELY(_uncompressed != nullptr && _uncompressed->remaining() > 0)) { - return OLAP_SUCCESS; + return Status::OK(); } else if (OLAP_UNLIKELY((_uncompressed == nullptr || _uncompressed->remaining() == 0) && (_current_offset == _length))) { - return OLAP_ERR_COLUMN_STREAM_EOF; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF); } // read head and data @@ -133,7 +133,7 @@ OLAPStatus InStream::_assure_data() { // 如果没有compress。或者compress耗尽，用_seek向后一个buff移动 if (_compressed == nullptr || _compressed->remaining() == 0) { res = _seek(_current_offset); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } } @@ -148,7 +148,7 @@ OLAPStatus InStream::_assure_data() { if (head.length > _compress_buffer_size) { OLAP_LOG_WARNING("chunk size is larger than buffer size. [chunk=%u buffer_size=%u]", head.length, _compress_buffer_size); - return OLAP_ERR_COLUMN_READ_STREAM; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_READ_STREAM); } // 向后移动整体偏移 @@ -157,9 +157,9 @@ OLAPStatus InStream::_assure_data() { // 根据head取一块buf，这里应该要调整_current_offset res = _slice(head.length, &slice); - if (OLAP_LIKELY(OLAP_SUCCESS != res)) { + if (OLAP_LIKELY(!res.ok())) { OLAP_LOG_WARNING("fail to slice data from stream."); - return OLAP_ERR_COLUMN_READ_STREAM; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_READ_STREAM); } // 如果没压缩，就直接读这块 @@ -170,7 +170,7 @@ OLAPStatus InStream::_assure_data() { _uncompressed = StorageByteBuffer::create(_compress_buffer_size); if (OLAP_UNLIKELY(nullptr == _uncompressed)) { - res = OLAP_ERR_MALLOC_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } else { res = _decompressor(slice, _uncompressed); } @@ -183,17 +183,17 @@ OLAPStatus InStream::_assure_data() { "compressed remaining size less than stream head size. " "[compressed_remaining_size=%lu stream_head_size=%lu]", _compressed->remaining(), sizeof(StreamHead)); - return OLAP_ERR_COLUMN_READ_STREAM; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_READ_STREAM); } return res; } uint64_t InStream::available() { - OLAPStatus res; + Status res; res = _assure_data(); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { return 0; } @@ -201,7 +201,7 @@ uint64_t InStream::available() { } // seek的是解压前的数据。 -OLAPStatus InStream::_seek(uint64_t position) { +Status InStream::_seek(uint64_t position) { for (uint32_t i = 0; i < _inputs.size(); i++) { if (_offsets[i] <= position && position - _offsets[i] < _inputs[i]->remaining()) { // don't need to malloc _compressed if current range don't be changed. @@ -215,7 +215,7 @@ OLAPStatus InStream::_seek(uint64_t position) { uint64_t pos = _inputs[i]->position() + position - _offsets[i]; _compressed->set_position(pos); _current_offset = position; - return OLAP_SUCCESS; + return Status::OK(); } } @@ -226,19 +226,19 @@ OLAPStatus InStream::_seek(uint64_t position) { _compressed = StorageByteBuffer::reference_buffer(_inputs[_current_range], 0, _inputs[_current_range]->limit()); _current_offset = position; - return OLAP_SUCCESS; + return Status::OK(); } - return OLAP_ERR_OUT_OF_BOUND; + return Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND); } -OLAPStatus InStream::seek(PositionProvider* position) { - OLAPStatus res = OLAP_SUCCESS; +Status InStream::seek(PositionProvider* position) { + Status res = Status::OK(); // 先seek到解压前的位置，也就是writer中写入的spilled byte res = _seek(position->get_next()); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to seek.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to seek.res = " << res; return res; } @@ -249,37 +249,36 @@ OLAPStatus InStream::seek(PositionProvider* position) { SAFE_DELETE(_uncompressed); res = _assure_data(); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to assure data.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to assure data.res = " << res; return res; } res = _uncompressed->set_position(uncompressed_bytes); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to set position.[res=%d, position=%lu]", res, - _uncompressed->position() + uncompressed_bytes); + if (!res.ok()) { + LOG(WARNING) << "fail to set position. res= " << res + << ", position=" << (_uncompressed->position() + uncompressed_bytes); return res; } } else if (_uncompressed != nullptr) { // mark the uncompressed buffer as done res = _uncompressed->set_position(_uncompressed->limit()); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to set position.[res=%d, position=%lu]", res, - _uncompressed->limit()); + if (!res.ok()) { + LOG(WARNING) << "fail to set position.res=" << res << ", position=" << _uncompressed->limit(); return res; } } - return OLAP_SUCCESS; + return Status::OK(); } // skip的是解压后的数据 -OLAPStatus InStream::skip(uint64_t skip_length) { - OLAPStatus res = _assure_data(); +Status InStream::skip(uint64_t skip_length) { + Status res = _assure_data(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } @@ -297,7 +296,7 @@ OLAPStatus InStream::skip(uint64_t skip_length) { // 如果当前块就可以满足skip_length，那么_assure_data没任何作用。 res = _assure_data(); // while 放下边，通常会少一次判断 - } while (byte_to_skip != 0 && res == OLAP_SUCCESS); + } while (byte_to_skip != 0 && res.ok()); return res; } diff --git a/be/src/olap/in_stream.h b/be/src/olap/in_stream.h index e4786b0c74..6d9ce10867 100644 --- a/be/src/olap/in_stream.h +++ b/be/src/olap/in_stream.h @@ -63,21 +63,21 @@ public: ~InStream(); // 从数据流中读取一个字节,内部指针后移 - // 如果数据流结束, 返回OLAP_ERR_COLUMN_STREAM_EOF - OLAPStatus read(char* byte); + // 如果数据流结束, 返回Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF) + Status read(char* byte); // 从数据流读入一段数据 // Input: // buffer - 存储读入的数据 // buf_size - 输入时给出buffer的大小,返回时给出实际读取的字节数 - // 如果数据流结束, 返回OLAP_ERR_COLUMN_STREAM_EOF - OLAPStatus read(char* buffer, uint64_t* buf_size); + // 如果数据流结束, 返回Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF) + Status read(char* buffer, uint64_t* buf_size); // 设置读取的位置 - OLAPStatus seek(PositionProvider* position); + Status seek(PositionProvider* position); // 跳过指定size的流 - OLAPStatus skip(uint64_t skip_length); + Status skip(uint64_t skip_length); // 返回流的總長度 uint64_t stream_length() { @@ -99,7 +99,7 @@ public: // 返回当前块剩余的内存 const char* available_buffer() { - if (OLAP_SUCCESS == _assure_data()) { + if (_assure_data()) { size_t offset = _uncompressed->position(); return _uncompressed->array(offset); } @@ -108,9 +108,9 @@ public: } private: - OLAPStatus _assure_data(); - OLAPStatus _slice(uint64_t chunk_size, StorageByteBuffer** out_slice); - OLAPStatus _seek(uint64_t position); + Status _assure_data(); + Status _slice(uint64_t chunk_size, StorageByteBuffer** out_slice); + Status _seek(uint64_t position); std::vector _inputs; std::vector _offsets; @@ -133,7 +133,7 @@ public: virtual ~InStreamBufferWrapper() {} virtual int_type underflow() { if (nullptr != _stream) { - if (OLAP_SUCCESS == _stream->skip(_skip_size)) { + if (_stream->skip(_skip_size)) { char* buf = const_cast(_stream->available_buffer()); if (nullptr != buf) { @@ -153,32 +153,32 @@ protected: size_t _skip_size; }; -inline OLAPStatus InStream::read(char* byte) { - OLAPStatus res; +inline Status InStream::read(char* byte) { + Status res; - if (OLAP_SUCCESS != (res = _assure_data())) { + if (!(res = _assure_data())) { return res; } return _uncompressed->get(byte); } -inline OLAPStatus InStream::read(char* buffer, uint64_t* buf_size) { - OLAPStatus res; +inline Status InStream::read(char* buffer, uint64_t* buf_size) { + Status res; uint64_t read_length = *buf_size; *buf_size = 0; do { res = _assure_data(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { break; } uint64_t actual_length = std::min(read_length - *buf_size, _uncompressed->remaining()); res = _uncompressed->get(buffer, actual_length); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { break; } diff --git a/be/src/olap/memtable.cpp b/be/src/olap/memtable.cpp index 7b92121752..9ff9cc3b48 100644 --- a/be/src/olap/memtable.cpp +++ b/be/src/olap/memtable.cpp @@ -124,14 +124,14 @@ void MemTable::_aggregate_two_row(const ContiguousRow& src_row, TableKey row_in_ } } -OLAPStatus MemTable::flush() { +Status MemTable::flush() { VLOG_CRITICAL << "begin to flush memtable for tablet: " << _tablet_id << ", memsize: " << memory_usage() << ", rows: " << _rows; int64_t duration_ns = 0; { SCOPED_RAW_TIMER(&duration_ns); - OLAPStatus st = _rowset_writer->flush_single_memtable(this, &_flush_size); - if (st == OLAP_ERR_FUNC_NOT_IMPLEMENTED) { + Status st = _rowset_writer->flush_single_memtable(this, &_flush_size); + if (st == Status::OLAPInternalError(OLAP_ERR_FUNC_NOT_IMPLEMENTED)) { // For alpha rowset, we do not implement "flush_single_memtable". // Flush the memtable like the old way. Table::Iterator it(_skip_list); @@ -150,10 +150,10 @@ OLAPStatus MemTable::flush() { DorisMetrics::instance()->memtable_flush_duration_us->increment(duration_ns / 1000); VLOG_CRITICAL << "after flush memtable for tablet: " << _tablet_id << ", flushsize: " << _flush_size; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus MemTable::close() { +Status MemTable::close() { return flush(); } diff --git a/be/src/olap/memtable.h b/be/src/olap/memtable.h index 6849bf45f4..cad27ae1a2 100644 --- a/be/src/olap/memtable.h +++ b/be/src/olap/memtable.h @@ -49,8 +49,8 @@ public: std::shared_ptr mem_tracker() { return _mem_tracker; } void insert(const Tuple* tuple); /// Flush - OLAPStatus flush(); - OLAPStatus close(); + Status flush(); + Status close(); int64_t flush_size() const { return _flush_size; } diff --git a/be/src/olap/memtable_flush_executor.cpp b/be/src/olap/memtable_flush_executor.cpp index 75ae89136e..6031304984 100644 --- a/be/src/olap/memtable_flush_executor.cpp +++ b/be/src/olap/memtable_flush_executor.cpp @@ -40,20 +40,24 @@ std::ostream& operator<<(std::ostream& os, const FlushStatistic& stat) { // after the submit() method returns, even if the caller immediately releases the // passed shared_ptr object, the Memtable object will not be destructed because // its reference count is not 0. -OLAPStatus FlushToken::submit(const std::shared_ptr& memtable) { - RETURN_NOT_OK(_flush_status.load()); +Status FlushToken::submit(const std::shared_ptr& memtable) { + ErrorCode s = _flush_status.load(); + if (s != OLAP_SUCCESS) { + return Status::OLAPInternalError(s); + } int64_t submit_task_time = MonotonicNanos(); _flush_token->submit_func(std::bind(&FlushToken::_flush_memtable, this, memtable, submit_task_time)); - return OLAP_SUCCESS; + return Status::OK(); } void FlushToken::cancel() { _flush_token->shutdown(); } -OLAPStatus FlushToken::wait() { +Status FlushToken::wait() { _flush_token->wait(); - return _flush_status.load(); + ErrorCode s = _flush_status.load(); + return s == OLAP_SUCCESS ? Status::OK() : Status::OLAPInternalError(s); } void FlushToken::_flush_memtable(std::shared_ptr memtable, int64_t submit_task_time) { @@ -67,7 +71,12 @@ void FlushToken::_flush_memtable(std::shared_ptr memtable, int64_t sub MonotonicStopWatch timer; timer.start(); - _flush_status.store(memtable->flush()); + Status s = memtable->flush(); + if (!s) { + LOG(WARNING) << "Flush memtable failed with res = " << s; + } + // If s is not ok, ignore the code, just use other code is ok + _flush_status.store(s.ok() ? OLAP_SUCCESS : OLAP_ERR_OTHER_ERROR); if (_flush_status.load() != OLAP_SUCCESS) { return; } @@ -100,7 +109,7 @@ void MemTableFlushExecutor::init(const std::vector& data_dirs) { } // NOTE: we use SERIAL mode here to ensure all mem-tables from one tablet are flushed in order. -OLAPStatus MemTableFlushExecutor::create_flush_token( +Status MemTableFlushExecutor::create_flush_token( std::unique_ptr* flush_token, RowsetTypePB rowset_type, bool is_high_priority) { if (!is_high_priority) { @@ -120,7 +129,7 @@ OLAPStatus MemTableFlushExecutor::create_flush_token( flush_token->reset(new FlushToken(_high_prio_flush_pool->new_token(ThreadPool::ExecutionMode::SERIAL))); } } - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/memtable_flush_executor.h b/be/src/olap/memtable_flush_executor.h index c880b3c307..274f583c43 100644 --- a/be/src/olap/memtable_flush_executor.h +++ b/be/src/olap/memtable_flush_executor.h @@ -56,14 +56,14 @@ public: explicit FlushToken(std::unique_ptr flush_pool_token) : _flush_token(std::move(flush_pool_token)), _flush_status(OLAP_SUCCESS) {} - OLAPStatus submit(const std::shared_ptr& mem_table); + Status submit(const std::shared_ptr& mem_table); // error has happpens, so we cancel this token // And remove all tasks in the queue. void cancel(); // wait all tasks in token to be completed. - OLAPStatus wait(); + Status wait(); // get flush operations' statistics const FlushStatistic& get_stats() const { return _stats; } @@ -75,7 +75,7 @@ private: // Records the current flush status of the tablet. // Note: Once its value is set to Failed, it cannot return to SUCCESS. - std::atomic _flush_status; + std::atomic _flush_status; FlushStatistic _stats; }; @@ -101,7 +101,7 @@ public: // because it needs path hash of each data dir. void init(const std::vector& data_dirs); - OLAPStatus create_flush_token( + Status create_flush_token( std::unique_ptr* flush_token, RowsetTypePB rowset_type, bool is_high_priority); diff --git a/be/src/olap/merger.cpp b/be/src/olap/merger.cpp index 66dfaaf597..e28a3b4a4e 100644 --- a/be/src/olap/merger.cpp +++ b/be/src/olap/merger.cpp @@ -28,7 +28,7 @@ namespace doris { -OLAPStatus Merger::merge_rowsets(TabletSharedPtr tablet, ReaderType reader_type, +Status Merger::merge_rowsets(TabletSharedPtr tablet, ReaderType reader_type, const std::vector& src_rowset_readers, RowsetWriter* dst_rowset_writer, Merger::Statistics* stats_output) { @@ -84,7 +84,7 @@ OLAPStatus Merger::merge_rowsets(TabletSharedPtr tablet, ReaderType reader_type, RETURN_NOT_OK_LOG( dst_rowset_writer->flush(), "failed to flush rowset when merging rowsets of tablet " + tablet->full_name()); - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/merger.h b/be/src/olap/merger.h index beef4fe991..c2047d07d9 100644 --- a/be/src/olap/merger.h +++ b/be/src/olap/merger.h @@ -36,7 +36,7 @@ public: // merge rows from `src_rowset_readers` and write into `dst_rowset_writer`. // return OLAP_SUCCESS and set statistics into `*stats_output`. // return others on error - static OLAPStatus merge_rowsets(TabletSharedPtr tablet, ReaderType reader_type, + static Status merge_rowsets(TabletSharedPtr tablet, ReaderType reader_type, const std::vector& src_rowset_readers, RowsetWriter* dst_rowset_writer, Statistics* stats_output); }; diff --git a/be/src/olap/olap_cond.cpp b/be/src/olap/olap_cond.cpp index fec9c8a513..d4a6ee4979 100644 --- a/be/src/olap/olap_cond.cpp +++ b/be/src/olap/olap_cond.cpp @@ -96,13 +96,13 @@ Cond::~Cond() { max_value_field = nullptr; } -OLAPStatus Cond::init(const TCondition& tcond, const TabletColumn& column) { +Status Cond::init(const TCondition& tcond, const TabletColumn& column) { // Parse op type op = parse_op_type(tcond.condition_op); if (op == OP_NULL || (op != OP_IN && op != OP_NOT_IN && tcond.condition_values.size() != 1)) { OLAP_LOG_WARNING("Condition op type is invalid. [name=%s, op=%d, size=%d]", tcond.column_name.c_str(), op, tcond.condition_values.size()); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } if (op == OP_IS) { // 'is null' or 'is not null' @@ -112,7 +112,7 @@ OLAPStatus Cond::init(const TCondition& tcond, const TabletColumn& column) { if (f == nullptr) { OLAP_LOG_WARNING("Create field failed. [name=%s, operand=%s, op_type=%d]", tcond.column_name.c_str(), operand->c_str(), op); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } if (strcasecmp(operand->c_str(), "NULL") == 0) { f->set_null(); @@ -127,10 +127,10 @@ OLAPStatus Cond::init(const TCondition& tcond, const TabletColumn& column) { if (f == nullptr) { OLAP_LOG_WARNING("Create field failed. [name=%s, operand=%s, op_type=%d]", tcond.column_name.c_str(), operand->c_str(), op); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } - OLAPStatus res = f->from_string(*operand); - if (res != OLAP_SUCCESS) { + Status res = f->from_string(*operand); + if (!res.ok()) { OLAP_LOG_WARNING("Convert from string failed. [name=%s, operand=%s, op_type=%d]", tcond.column_name.c_str(), operand->c_str(), op); return res; @@ -144,10 +144,10 @@ OLAPStatus Cond::init(const TCondition& tcond, const TabletColumn& column) { if (f == nullptr) { OLAP_LOG_WARNING("Create field failed. [name=%s, operand=%s, op_type=%d]", tcond.column_name.c_str(), operand.c_str(), op); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } - OLAPStatus res = f->from_string(operand); - if (res != OLAP_SUCCESS) { + Status res = f->from_string(operand); + if (!res.ok()) { OLAP_LOG_WARNING("Convert from string failed. [name=%s, operand=%s, op_type=%d]", tcond.column_name.c_str(), operand.c_str(), op); return res; @@ -171,7 +171,7 @@ OLAPStatus Cond::init(const TCondition& tcond, const TabletColumn& column) { } } - return OLAP_SUCCESS; + return Status::OK(); } bool Cond::eval(const RowCursorCell& cell) const { @@ -500,14 +500,14 @@ CondColumn::~CondColumn() { } // PRECONDITION 1. index is valid; 2. at least has one operand -OLAPStatus CondColumn::add_cond(const TCondition& tcond, const TabletColumn& column) { +Status CondColumn::add_cond(const TCondition& tcond, const TabletColumn& column) { std::unique_ptr cond(new Cond()); auto res = cond->init(tcond, column); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { return res; } _conds.push_back(cond.release()); - return OLAP_SUCCESS; + return Status::OK(); } bool CondColumn::eval(const RowCursor& row) const { @@ -587,18 +587,18 @@ bool CondColumn::eval(const segment_v2::BloomFilter* bf) const { return true; } -OLAPStatus Conditions::append_condition(const TCondition& tcond) { +Status Conditions::append_condition(const TCondition& tcond) { DCHECK(_schema != nullptr); int32_t index = _schema->field_index(tcond.column_name); if (index < 0) { LOG(WARNING) << "fail to get field index, field name=" << tcond.column_name; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } // Skip column which is non-key, or whose type is string or float const TabletColumn& column = _schema->column(index); if (column.type() == OLAP_FIELD_TYPE_DOUBLE || column.type() == OLAP_FIELD_TYPE_FLOAT) { - return OLAP_SUCCESS; + return Status::OK(); } CondColumn* cond_col = nullptr; diff --git a/be/src/olap/olap_cond.h b/be/src/olap/olap_cond.h index ef11c7b229..490c21f136 100644 --- a/be/src/olap/olap_cond.h +++ b/be/src/olap/olap_cond.h @@ -68,7 +68,7 @@ public: Cond() = default; ~Cond(); - OLAPStatus init(const TCondition& tcond, const TabletColumn& column); + Status init(const TCondition& tcond, const TabletColumn& column); // 用一行数据的指定列同条件进行比较，如果符合过滤条件， // 即按照此条件，行应被过滤掉，则返回true，否则返回false @@ -103,7 +103,7 @@ public: } ~CondColumn(); - OLAPStatus add_cond(const TCondition& tcond, const TabletColumn& column); + Status add_cond(const TCondition& tcond, const TabletColumn& column); // 对一行数据中的指定列，用所有过滤条件进行比较，如果所有条件都满足，则过滤此行 // Return true means this row should be filtered out, otherwise return false @@ -170,7 +170,7 @@ public: // 对于下列情况，将不会被处理 // 1. column不属于key列 // 2. column类型是double, float - OLAPStatus append_condition(const TCondition& condition); + Status append_condition(const TCondition& condition); // 通过所有列上的删除条件对RowCursor进行过滤 // Return true means this row should be filtered out, otherwise return false diff --git a/be/src/olap/olap_define.h b/be/src/olap/olap_define.h index c37004287e..d24695607b 100644 --- a/be/src/olap/olap_define.h +++ b/be/src/olap/olap_define.h @@ -15,14 +15,14 @@ // specific language governing permissions and limitations // under the License. -#ifndef DORIS_BE_SRC_OLAP_OLAP_DEFINE_H -#define DORIS_BE_SRC_OLAP_OLAP_DEFINE_H +#pragma once #include #include #include #include +#include "common/status.h" namespace doris { // 以下是一些统一的define @@ -108,289 +108,6 @@ static const double BLOOM_FILTER_DEFAULT_FPP = 0.05; #define OLAP_GOTO(label) goto label -// OLAP的函数的返回值的定义. 当一个函数在调用下层函数错误时, -// 可以根据自己的需要选择直接返回下层函数的OLAPStatus, -// 或者返回自己的一个新OLAPStatus. 但是一个类只能返回自己对应的Status或者公共OLAPStatus, -// 例如_OLAP_ERR_FETCH*系列只能在FetchHandler中返回, 这样便于管理, 同时也方便查找最初的错误发生地. -enum OLAPStatus { - OLAP_SUCCESS = 0, - - // other errors except following errors - OLAP_ERR_OTHER_ERROR = -1, - OLAP_REQUEST_FAILED = -2, - - // system error codessuch as file system memory and other system call failures - // [-100, -200) - OLAP_ERR_OS_ERROR = -100, - OLAP_ERR_DIR_NOT_EXIST = -101, - OLAP_ERR_FILE_NOT_EXIST = -102, - OLAP_ERR_CREATE_FILE_ERROR = -103, - OLAP_ERR_MALLOC_ERROR = -104, - OLAP_ERR_STL_ERROR = -105, - OLAP_ERR_IO_ERROR = -106, - OLAP_ERR_MUTEX_ERROR = -107, - OLAP_ERR_PTHREAD_ERROR = -108, - OLAP_ERR_NETWORK_ERROR = -109, - OLAP_ERR_UB_FUNC_ERROR = -110, - OLAP_ERR_COMPRESS_ERROR = -111, - OLAP_ERR_DECOMPRESS_ERROR = -112, - OLAP_ERR_UNKNOWN_COMPRESSION_TYPE = -113, - OLAP_ERR_MMAP_ERROR = -114, - OLAP_ERR_RWLOCK_ERROR = -115, - OLAP_ERR_READ_UNENOUGH = -116, - OLAP_ERR_CANNOT_CREATE_DIR = -117, - OLAP_ERR_UB_NETWORK_ERROR = -118, - OLAP_ERR_FILE_FORMAT_ERROR = -119, - OLAP_ERR_EVAL_CONJUNCTS_ERROR = -120, - OLAP_ERR_COPY_FILE_ERROR = -121, - OLAP_ERR_FILE_ALREADY_EXIST = -122, - - // common errors codes - // [-200, -300) - OLAP_ERR_NOT_INITED = -200, - OLAP_ERR_FUNC_NOT_IMPLEMENTED = -201, - OLAP_ERR_CALL_SEQUENCE_ERROR = -202, - OLAP_ERR_INPUT_PARAMETER_ERROR = -203, - OLAP_ERR_BUFFER_OVERFLOW = -204, - OLAP_ERR_CONFIG_ERROR = -205, - OLAP_ERR_INIT_FAILED = -206, - OLAP_ERR_INVALID_SCHEMA = -207, - OLAP_ERR_CHECKSUM_ERROR = -208, - OLAP_ERR_SIGNATURE_ERROR = -209, - OLAP_ERR_CATCH_EXCEPTION = -210, - OLAP_ERR_PARSE_PROTOBUF_ERROR = -211, - OLAP_ERR_SERIALIZE_PROTOBUF_ERROR = -212, - OLAP_ERR_WRITE_PROTOBUF_ERROR = -213, - OLAP_ERR_VERSION_NOT_EXIST = -214, - OLAP_ERR_TABLE_NOT_FOUND = -215, - OLAP_ERR_TRY_LOCK_FAILED = -216, - OLAP_ERR_OUT_OF_BOUND = -218, - OLAP_ERR_UNDERFLOW = -219, - OLAP_ERR_FILE_DATA_ERROR = -220, - OLAP_ERR_TEST_FILE_ERROR = -221, - OLAP_ERR_INVALID_ROOT_PATH = -222, - OLAP_ERR_NO_AVAILABLE_ROOT_PATH = -223, - OLAP_ERR_CHECK_LINES_ERROR = -224, - OLAP_ERR_INVALID_CLUSTER_INFO = -225, - OLAP_ERR_TRANSACTION_NOT_EXIST = -226, - OLAP_ERR_DISK_FAILURE = -227, - OLAP_ERR_TRANSACTION_ALREADY_COMMITTED = -228, - OLAP_ERR_TRANSACTION_ALREADY_VISIBLE = -229, - OLAP_ERR_VERSION_ALREADY_MERGED = -230, - OLAP_ERR_LZO_DISABLED = -231, - OLAP_ERR_DISK_REACH_CAPACITY_LIMIT = -232, - OLAP_ERR_TOO_MANY_TRANSACTIONS = -233, - OLAP_ERR_INVALID_SNAPSHOT_VERSION = -234, - OLAP_ERR_TOO_MANY_VERSION = -235, - OLAP_ERR_NOT_INITIALIZED = -236, - OLAP_ERR_ALREADY_CANCELLED = -237, - OLAP_ERR_TOO_MANY_SEGMENTS = -238, - - // CommandExecutor - // [-300, -400) - OLAP_ERR_CE_CMD_PARAMS_ERROR = -300, - OLAP_ERR_CE_BUFFER_TOO_SMALL = -301, - OLAP_ERR_CE_CMD_NOT_VALID = -302, - OLAP_ERR_CE_LOAD_TABLE_ERROR = -303, - OLAP_ERR_CE_NOT_FINISHED = -304, - OLAP_ERR_CE_TABLET_ID_EXIST = -305, - OLAP_ERR_CE_TRY_CE_LOCK_ERROR = -306, - - // Tablet - // [-400, -500) - OLAP_ERR_TABLE_VERSION_DUPLICATE_ERROR = -400, - OLAP_ERR_TABLE_VERSION_INDEX_MISMATCH_ERROR = -401, - OLAP_ERR_TABLE_INDEX_VALIDATE_ERROR = -402, - OLAP_ERR_TABLE_INDEX_FIND_ERROR = -403, - OLAP_ERR_TABLE_CREATE_FROM_HEADER_ERROR = -404, - OLAP_ERR_TABLE_CREATE_META_ERROR = -405, - OLAP_ERR_TABLE_ALREADY_DELETED_ERROR = -406, - - // StorageEngine - // [-500, -600) - OLAP_ERR_ENGINE_INSERT_EXISTS_TABLE = -500, - OLAP_ERR_ENGINE_DROP_NOEXISTS_TABLE = -501, - OLAP_ERR_ENGINE_LOAD_INDEX_TABLE_ERROR = -502, - OLAP_ERR_TABLE_INSERT_DUPLICATION_ERROR = -503, - OLAP_ERR_DELETE_VERSION_ERROR = -504, - OLAP_ERR_GC_SCAN_PATH_ERROR = -505, - OLAP_ERR_ENGINE_INSERT_OLD_TABLET = -506, - - // FetchHandler - // [-600, -700) - OLAP_ERR_FETCH_OTHER_ERROR = -600, - OLAP_ERR_FETCH_TABLE_NOT_EXIST = -601, - OLAP_ERR_FETCH_VERSION_ERROR = -602, - OLAP_ERR_FETCH_SCHEMA_ERROR = -603, - OLAP_ERR_FETCH_COMPRESSION_ERROR = -604, - OLAP_ERR_FETCH_CONTEXT_NOT_EXIST = -605, - OLAP_ERR_FETCH_GET_READER_PARAMS_ERR = -606, - OLAP_ERR_FETCH_SAVE_SESSION_ERR = -607, - OLAP_ERR_FETCH_MEMORY_EXCEEDED = -608, - - // Reader - // [-700, -800) - OLAP_ERR_READER_IS_UNINITIALIZED = -700, - OLAP_ERR_READER_GET_ITERATOR_ERROR = -701, - OLAP_ERR_CAPTURE_ROWSET_READER_ERROR = -702, - OLAP_ERR_READER_READING_ERROR = -703, - OLAP_ERR_READER_INITIALIZE_ERROR = -704, - - // BaseCompaction - // [-800, -900) - OLAP_ERR_BE_VERSION_NOT_MATCH = -800, - OLAP_ERR_BE_REPLACE_VERSIONS_ERROR = -801, - OLAP_ERR_BE_MERGE_ERROR = -802, - OLAP_ERR_CAPTURE_ROWSET_ERROR = -804, - OLAP_ERR_BE_SAVE_HEADER_ERROR = -805, - OLAP_ERR_BE_INIT_OLAP_DATA = -806, - OLAP_ERR_BE_TRY_OBTAIN_VERSION_LOCKS = -807, - OLAP_ERR_BE_NO_SUITABLE_VERSION = -808, - OLAP_ERR_BE_TRY_BE_LOCK_ERROR = -809, - OLAP_ERR_BE_INVALID_NEED_MERGED_VERSIONS = -810, - OLAP_ERR_BE_ERROR_DELETE_ACTION = -811, - OLAP_ERR_BE_SEGMENTS_OVERLAPPING = -812, - OLAP_ERR_BE_CLONE_OCCURRED = -813, - - // PUSH - // [-900, -1000) - OLAP_ERR_PUSH_INIT_ERROR = -900, - OLAP_ERR_PUSH_DELTA_FILE_EOF = -901, - OLAP_ERR_PUSH_VERSION_INCORRECT = -902, - OLAP_ERR_PUSH_SCHEMA_MISMATCH = -903, - OLAP_ERR_PUSH_CHECKSUM_ERROR = -904, - OLAP_ERR_PUSH_ACQUIRE_DATASOURCE_ERROR = -905, - OLAP_ERR_PUSH_CREAT_CUMULATIVE_ERROR = -906, - OLAP_ERR_PUSH_BUILD_DELTA_ERROR = -907, - OLAP_ERR_PUSH_VERSION_ALREADY_EXIST = -908, - OLAP_ERR_PUSH_TABLE_NOT_EXIST = -909, - OLAP_ERR_PUSH_INPUT_DATA_ERROR = -910, - OLAP_ERR_PUSH_TRANSACTION_ALREADY_EXIST = -911, - // only support realtime push api, batch process is deprecated and is removed - OLAP_ERR_PUSH_BATCH_PROCESS_REMOVED = -912, - OLAP_ERR_PUSH_COMMIT_ROWSET = -913, - OLAP_ERR_PUSH_ROWSET_NOT_FOUND = -914, - - // SegmentGroup - // [-1000, -1100) - OLAP_ERR_INDEX_LOAD_ERROR = -1000, - OLAP_ERR_INDEX_EOF = -1001, - OLAP_ERR_INDEX_CHECKSUM_ERROR = -1002, - OLAP_ERR_INDEX_DELTA_PRUNING = -1003, - - // OLAPData - // [-1100, -1200) - OLAP_ERR_DATA_ROW_BLOCK_ERROR = -1100, - OLAP_ERR_DATA_FILE_TYPE_ERROR = -1101, - OLAP_ERR_DATA_EOF = -1102, - - // OLAPDataWriter - // [-1200, -1300) - OLAP_ERR_WRITER_INDEX_WRITE_ERROR = -1200, - OLAP_ERR_WRITER_DATA_WRITE_ERROR = -1201, - OLAP_ERR_WRITER_ROW_BLOCK_ERROR = -1202, - OLAP_ERR_WRITER_SEGMENT_NOT_FINALIZED = -1203, - - // RowBlock - // [-1300, -1400) - OLAP_ERR_ROWBLOCK_DECOMPRESS_ERROR = -1300, - OLAP_ERR_ROWBLOCK_FIND_ROW_EXCEPTION = -1301, - OLAP_ERR_ROWBLOCK_READ_INFO_ERROR = -1302, - - // TabletMeta - // [-1400, -1500) - OLAP_ERR_HEADER_ADD_VERSION = -1400, - OLAP_ERR_HEADER_DELETE_VERSION = -1401, - OLAP_ERR_HEADER_ADD_PENDING_DELTA = -1402, - OLAP_ERR_HEADER_ADD_INCREMENTAL_VERSION = -1403, - OLAP_ERR_HEADER_INVALID_FLAG = -1404, - OLAP_ERR_HEADER_PUT = -1405, - OLAP_ERR_HEADER_DELETE = -1406, - OLAP_ERR_HEADER_GET = -1407, - OLAP_ERR_HEADER_LOAD_INVALID_KEY = -1408, - OLAP_ERR_HEADER_FLAG_PUT = -1409, - OLAP_ERR_HEADER_LOAD_JSON_HEADER = -1410, - OLAP_ERR_HEADER_INIT_FAILED = -1411, - OLAP_ERR_HEADER_PB_PARSE_FAILED = -1412, - OLAP_ERR_HEADER_HAS_PENDING_DATA = -1413, - - // TabletSchema - // [-1500, -1600) - OLAP_ERR_SCHEMA_SCHEMA_INVALID = -1500, - OLAP_ERR_SCHEMA_SCHEMA_FIELD_INVALID = -1501, - - // SchemaHandler - // [-1600, -1606) - OLAP_ERR_ALTER_MULTI_TABLE_ERR = -1600, - OLAP_ERR_ALTER_DELTA_DOES_NOT_EXISTS = -1601, - OLAP_ERR_ALTER_STATUS_ERR = -1602, - OLAP_ERR_PREVIOUS_SCHEMA_CHANGE_NOT_FINISHED = -1603, - OLAP_ERR_SCHEMA_CHANGE_INFO_INVALID = -1604, - OLAP_ERR_QUERY_SPLIT_KEY_ERR = -1605, - //Error caused by a data quality issue during schema change/materialized view - OLAP_ERR_DATA_QUALITY_ERR = -1606, - - // Column File - // [-1700, -1800) - OLAP_ERR_COLUMN_DATA_LOAD_BLOCK = -1700, - OLAP_ERR_COLUMN_DATA_RECORD_INDEX = -1701, - OLAP_ERR_COLUMN_DATA_MAKE_FILE_HEADER = -1702, - OLAP_ERR_COLUMN_DATA_READ_VAR_INT = -1703, - OLAP_ERR_COLUMN_DATA_PATCH_LIST_NUM = -1704, - OLAP_ERR_COLUMN_STREAM_EOF = -1705, - OLAP_ERR_COLUMN_READ_STREAM = -1706, - OLAP_ERR_COLUMN_STREAM_NOT_EXIST = -1716, - OLAP_ERR_COLUMN_VALUE_NULL = -1717, - OLAP_ERR_COLUMN_SEEK_ERROR = -1719, - - // DeleteHandler - // [-1900, -2000) - OLAP_ERR_DELETE_INVALID_CONDITION = -1900, - OLAP_ERR_DELETE_UPDATE_HEADER_FAILED = -1901, - OLAP_ERR_DELETE_SAVE_HEADER_FAILED = -1902, - OLAP_ERR_DELETE_INVALID_PARAMETERS = -1903, - OLAP_ERR_DELETE_INVALID_VERSION = -1904, - - // Cumulative Handler - // [-2000, -3000) - OLAP_ERR_CUMULATIVE_NO_SUITABLE_VERSION = -2000, - OLAP_ERR_CUMULATIVE_REPEAT_INIT = -2001, - OLAP_ERR_CUMULATIVE_INVALID_PARAMETERS = -2002, - OLAP_ERR_CUMULATIVE_FAILED_ACQUIRE_DATA_SOURCE = -2003, - OLAP_ERR_CUMULATIVE_INVALID_NEED_MERGED_VERSIONS = -2004, - OLAP_ERR_CUMULATIVE_ERROR_DELETE_ACTION = -2005, - OLAP_ERR_CUMULATIVE_MISS_VERSION = -2006, - OLAP_ERR_CUMULATIVE_CLONE_OCCURRED = -2007, - - // OLAPMeta - // [-3000, -3100) - OLAP_ERR_META_INVALID_ARGUMENT = -3000, - OLAP_ERR_META_OPEN_DB = -3001, - OLAP_ERR_META_KEY_NOT_FOUND = -3002, - OLAP_ERR_META_GET = -3003, - OLAP_ERR_META_PUT = -3004, - OLAP_ERR_META_ITERATOR = -3005, - OLAP_ERR_META_DELETE = -3006, - OLAP_ERR_META_ALREADY_EXIST = -3007, - - // Rowset - // [-3100, -3200) - OLAP_ERR_ROWSET_WRITER_INIT = -3100, - OLAP_ERR_ROWSET_SAVE_FAILED = -3101, - OLAP_ERR_ROWSET_GENERATE_ID_FAILED = -3102, - OLAP_ERR_ROWSET_DELETE_FILE_FAILED = -3103, - OLAP_ERR_ROWSET_BUILDER_INIT = -3104, - OLAP_ERR_ROWSET_TYPE_NOT_FOUND = -3105, - OLAP_ERR_ROWSET_ALREADY_EXIST = -3106, - OLAP_ERR_ROWSET_CREATE_READER = -3107, - OLAP_ERR_ROWSET_INVALID = -3108, - OLAP_ERR_ROWSET_LOAD_FAILED = -3109, - OLAP_ERR_ROWSET_READER_INIT = -3110, - OLAP_ERR_ROWSET_READ_FAILED = -3111, - OLAP_ERR_ROWSET_INVALID_STATE_TRANSITION = -3112, - OLAP_ERR_STRING_OVERFLOW_IN_VEC_ENGINE = -3113 -}; - enum ColumnFamilyIndex { DEFAULT_COLUMN_FAMILY_INDEX = 0, DORIS_COLUMN_FAMILY_INDEX, @@ -423,8 +140,8 @@ const std::string ROWSET_ID_PREFIX = "s_"; #ifndef RETURN_NOT_OK #define RETURN_NOT_OK(s) \ do { \ - OLAPStatus _s = (s); \ - if (OLAP_UNLIKELY(_s != OLAP_SUCCESS)) { \ + Status _s = (s); \ + if (OLAP_UNLIKELY(!_s.ok())) { \ return _s; \ } \ } while (0); @@ -433,8 +150,8 @@ const std::string ROWSET_ID_PREFIX = "s_"; #ifndef RETURN_NOT_OK_LOG #define RETURN_NOT_OK_LOG(s, msg) \ do { \ - OLAPStatus _s = (s); \ - if (OLAP_UNLIKELY(_s != OLAP_SUCCESS)) { \ + Status _s = (s); \ + if (OLAP_UNLIKELY(!_s)) { \ LOG(WARNING) << (msg) << "[res=" << _s << "]"; \ return _s; \ } \ @@ -491,6 +208,4 @@ private: \ #define BUILD_VERSION "Unknown" #endif -} // namespace doris - -#endif // DORIS_BE_SRC_OLAP_OLAP_DEFINE_H +} // namespace doris \ No newline at end of file diff --git a/be/src/olap/olap_index.cpp b/be/src/olap/olap_index.cpp index 85f0625889..95a4d2a700 100644 --- a/be/src/olap/olap_index.cpp +++ b/be/src/olap/olap_index.cpp @@ -51,34 +51,34 @@ MemIndex::~MemIndex() { } } -OLAPStatus MemIndex::load_segment(const char* file, size_t* current_num_rows_per_row_block, +Status MemIndex::load_segment(const char* file, size_t* current_num_rows_per_row_block, bool use_cache) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); SegmentMetaInfo meta; uint32_t adler_checksum = 0; uint32_t num_entries = 0; if (file == nullptr) { - res = OLAP_ERR_INPUT_PARAMETER_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); LOG(WARNING) << "load index error. file=" << file << ", res=" << res; return res; } FileHandler file_handler; if (use_cache) { - if ((res = file_handler.open_with_cache(file, O_RDONLY)) != OLAP_SUCCESS) { + if ((res = file_handler.open_with_cache(file, O_RDONLY)) != Status::OK()) { LOG(WARNING) << "open index error. file=" << file << ", res=" << res; return res; } } else { - if ((res = file_handler.open(file, O_RDONLY)) != OLAP_SUCCESS) { + if ((res = file_handler.open(file, O_RDONLY)) != Status::OK()) { LOG(WARNING) << "open index error. file=" << file << ", res=" << res; return res; } } - if ((res = meta.file_header.unserialize(&file_handler)) != OLAP_SUCCESS) { + if ((res = meta.file_header.unserialize(&file_handler)) != Status::OK()) { LOG(WARNING) << "load index error. file=" << file << ", res=" << res; file_handler.close(); return res; @@ -104,7 +104,7 @@ OLAPStatus MemIndex::load_segment(const char* file, size_t* current_num_rows_per is_align = (0 == storage_length % entry_length()); } if (!is_align) { - res = OLAP_ERR_INDEX_LOAD_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_INDEX_LOAD_ERROR); LOG(WARNING) << "load index error. file=" << file << ", res=" << res; file_handler.close(); return res; @@ -131,7 +131,7 @@ OLAPStatus MemIndex::load_segment(const char* file, size_t* current_num_rows_per if (OLAP_UNLIKELY(num_entries == 0)) { file_handler.close(); - return OLAP_SUCCESS; + return Status::OK(); } // convert index memory layout for string type @@ -139,17 +139,17 @@ OLAPStatus MemIndex::load_segment(const char* file, size_t* current_num_rows_per // target type is ptr|size, ptr pointer to data char* storage_data = reinterpret_cast(calloc(storage_length, 1)); if (storage_data == nullptr) { - res = OLAP_ERR_MALLOC_ERROR; - OLAP_LOG_WARNING("load segment for loading index error. [file=%s; res=%d]", file, res); + res = Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); + LOG(WARNING) << "load segment for loading index error. file=" << file << " res=" << res; file_handler.close(); return res; } // 读取索引内容 // 为了启动加速，此处可使用mmap方式。 - if (file_handler.pread(storage_data, storage_length, meta.file_header.size()) != OLAP_SUCCESS) { - res = OLAP_ERR_IO_ERROR; - OLAP_LOG_WARNING("load segment for loading index error. [file=%s; res=%d]", file, res); + if (file_handler.pread(storage_data, storage_length, meta.file_header.size()) != Status::OK()) { + res = Status::OLAPInternalError(OLAP_ERR_IO_ERROR); + LOG(WARNING) << "load segment for loading index error. file=" << file << "res=" << res; file_handler.close(); free(storage_data); return res; @@ -158,9 +158,9 @@ OLAPStatus MemIndex::load_segment(const char* file, size_t* current_num_rows_per // checksum validation adler_checksum = olap_adler32(ADLER32_INIT, storage_data, storage_length); if (adler_checksum != meta.file_header.checksum()) { - res = OLAP_ERR_INDEX_CHECKSUM_ERROR; - OLAP_LOG_WARNING("checksum validation error."); - OLAP_LOG_WARNING("load segment for loading index error. [file=%s; res=%d]", file, res); + res = Status::OLAPInternalError(OLAP_ERR_INDEX_CHECKSUM_ERROR); + LOG(WARNING) << "checksum validation error."; + LOG(WARNING) << "load segment for loading index error. file=" << file << "res=" << res; file_handler.close(); free(storage_data); return res; @@ -311,14 +311,14 @@ OLAPStatus MemIndex::load_segment(const char* file, size_t* current_num_rows_per free(storage_data); file_handler.close(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus MemIndex::init(size_t short_key_len, size_t new_short_key_len, size_t short_key_num, +Status MemIndex::init(size_t short_key_len, size_t new_short_key_len, size_t short_key_num, std::vector* short_key_columns) { if (short_key_columns == nullptr) { LOG(WARNING) << "fail to init MemIndex, nullptr short key columns."; - return OLAP_ERR_INDEX_LOAD_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INDEX_LOAD_ERROR); } _key_length = short_key_len; @@ -326,7 +326,7 @@ OLAPStatus MemIndex::init(size_t short_key_len, size_t new_short_key_len, size_t _key_num = short_key_num; _short_key_columns = short_key_columns; - return OLAP_SUCCESS; + return Status::OK(); } // Find and return the IndexOffset of the element prior to the first element which @@ -376,7 +376,7 @@ const OLAPIndexOffset MemIndex::find(const RowCursor& k, RowCursor* helper_curso BinarySearchIterator index_beg(0); BinarySearchIterator index_fin(_meta[off].count()); - if (index_comparator.set_segment_id(off) != OLAP_SUCCESS) { + if (index_comparator.set_segment_id(off) != Status::OK()) { throw "index of of range"; } @@ -458,21 +458,21 @@ const OLAPIndexOffset MemIndex::get_offset(const RowBlockPosition& pos) const { return off; } -OLAPStatus MemIndex::get_entry(const OLAPIndexOffset& pos, EntrySlice* slice) const { +Status MemIndex::get_entry(const OLAPIndexOffset& pos, EntrySlice* slice) const { if (pos.segment >= segment_count() || pos.offset >= _meta[pos.segment].count()) { - return OLAP_ERR_INDEX_EOF; + return Status::OLAPInternalError(OLAP_ERR_INDEX_EOF); } slice->length = new_entry_length(); slice->data = _meta[pos.segment].buffer.data + pos.offset * new_entry_length(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus MemIndex::get_row_block_position(const OLAPIndexOffset& pos, +Status MemIndex::get_row_block_position(const OLAPIndexOffset& pos, RowBlockPosition* rbp) const { if (zero_num_rows()) { - return OLAP_ERR_INDEX_EOF; + return Status::OLAPInternalError(OLAP_ERR_INDEX_EOF); } if (pos.segment >= segment_count() || pos.offset >= _meta[pos.segment].count()) { @@ -481,7 +481,7 @@ OLAPStatus MemIndex::get_row_block_position(const OLAPIndexOffset& pos, "[IndexOffset={segment=%u offset=%u} segment_count=%lu items_count=%lu]", pos.segment, pos.offset, segment_count(), pos.segment < segment_count() ? _meta[pos.segment].count() : 0); - return OLAP_ERR_INDEX_EOF; + return Status::OLAPInternalError(OLAP_ERR_INDEX_EOF); } rbp->segment = pos.segment; @@ -499,7 +499,7 @@ OLAPStatus MemIndex::get_row_block_position(const OLAPIndexOffset& pos, rbp->block_size = next_offset - rbp->data_offset; } - return OLAP_SUCCESS; + return Status::OK(); } const OLAPIndexOffset MemIndex::get_relative_offset(iterator_offset_t absolute_offset) const { diff --git a/be/src/olap/olap_index.h b/be/src/olap/olap_index.h index 11e22d2b67..422749beb7 100644 --- a/be/src/olap/olap_index.h +++ b/be/src/olap/olap_index.h @@ -159,11 +159,11 @@ public: ~MemIndex(); // 初始化MemIndex, 传入short_key的总长度和对应的Field数组 - OLAPStatus init(size_t short_key_len, size_t new_short_key_len, size_t short_key_num, + Status init(size_t short_key_len, size_t new_short_key_len, size_t short_key_num, std::vector* short_key_columns); // 加载一个segment到内存 - OLAPStatus load_segment(const char* file, size_t* current_num_rows_per_row_block, + Status load_segment(const char* file, size_t* current_num_rows_per_row_block, bool use_cache = true); // Return the IndexOffset of the first element, physically, it's (0, 0) @@ -228,10 +228,10 @@ public: const OLAPIndexOffset get_relative_offset(iterator_offset_t absolute_offset) const; // Return content of index item, which IndexOffset is pos - OLAPStatus get_entry(const OLAPIndexOffset& pos, EntrySlice* slice) const; + Status get_entry(const OLAPIndexOffset& pos, EntrySlice* slice) const; // Return RowBlockPosition from IndexOffset - OLAPStatus get_row_block_position(const OLAPIndexOffset& pos, RowBlockPosition* rbp) const; + Status get_row_block_position(const OLAPIndexOffset& pos, RowBlockPosition* rbp) const; const size_t short_key_num() const { return _key_num; } @@ -312,13 +312,13 @@ public: return _compare(index, key, COMPARATOR_LARGER); } - OLAPStatus set_segment_id(const iterator_offset_t& segment_id) { + Status set_segment_id(const iterator_offset_t& segment_id) { if (segment_id >= _index->segment_count()) { - return OLAP_ERR_INDEX_EOF; + return Status::OLAPInternalError(OLAP_ERR_INDEX_EOF); } _cur_seg = segment_id; - return OLAP_SUCCESS; + return Status::OK(); } private: diff --git a/be/src/olap/olap_meta.cpp b/be/src/olap/olap_meta.cpp index fa72121da9..ff6ca5325a 100644 --- a/be/src/olap/olap_meta.cpp +++ b/be/src/olap/olap_meta.cpp @@ -58,7 +58,7 @@ OlapMeta::~OlapMeta() { } } -OLAPStatus OlapMeta::init() { +Status OlapMeta::init() { // init db DBOptions options; options.IncreaseParallelism(); @@ -77,12 +77,12 @@ OLAPStatus OlapMeta::init() { rocksdb::Status s = DB::Open(options, db_path, column_families, &_handles, &_db); if (!s.ok() || _db == nullptr) { LOG(WARNING) << "rocks db open failed, reason:" << s.ToString(); - return OLAP_ERR_META_OPEN_DB; + return Status::OLAPInternalError(OLAP_ERR_META_OPEN_DB); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus OlapMeta::get(const int column_family_index, const std::string& key, +Status OlapMeta::get(const int column_family_index, const std::string& key, std::string* value) { DorisMetrics::instance()->meta_read_request_total->increment(1); rocksdb::ColumnFamilyHandle* handle = _handles[column_family_index]; @@ -90,16 +90,16 @@ OLAPStatus OlapMeta::get(const int column_family_index, const std::string& key, rocksdb::Status s; { SCOPED_RAW_TIMER(&duration_ns); - s = _db->Get(ReadOptions(), handle, Slice(key), value); + s = _db->Get(ReadOptions(), handle, rocksdb::Slice(key), value); } DorisMetrics::instance()->meta_read_request_duration_us->increment(duration_ns / 1000); if (s.IsNotFound()) { - return OLAP_ERR_META_KEY_NOT_FOUND; + return Status::OLAPInternalError(OLAP_ERR_META_KEY_NOT_FOUND); } else if (!s.ok()) { LOG(WARNING) << "rocks db get key:" << key << " failed, reason:" << s.ToString(); - return OLAP_ERR_META_GET; + return Status::OLAPInternalError(OLAP_ERR_META_GET); } - return OLAP_SUCCESS; + return Status::OK(); } bool OlapMeta::key_may_exist(const int column_family_index, const std::string& key, @@ -110,14 +110,14 @@ bool OlapMeta::key_may_exist(const int column_family_index, const std::string& k bool is_exist = false; { SCOPED_RAW_TIMER(&duration_ns); - is_exist = _db->KeyMayExist(ReadOptions(), handle, Slice(key), value); + is_exist = _db->KeyMayExist(ReadOptions(), handle, rocksdb::Slice(key), value); } DorisMetrics::instance()->meta_read_request_duration_us->increment(duration_ns / 1000); return is_exist; } -OLAPStatus OlapMeta::put(const int column_family_index, const std::string& key, +Status OlapMeta::put(const int column_family_index, const std::string& key, const std::string& value) { DorisMetrics::instance()->meta_write_request_total->increment(1); rocksdb::ColumnFamilyHandle* handle = _handles[column_family_index]; @@ -127,17 +127,17 @@ OLAPStatus OlapMeta::put(const int column_family_index, const std::string& key, SCOPED_RAW_TIMER(&duration_ns); WriteOptions write_options; write_options.sync = config::sync_tablet_meta; - s = _db->Put(write_options, handle, Slice(key), Slice(value)); + s = _db->Put(write_options, handle, rocksdb::Slice(key), rocksdb::Slice(value)); } DorisMetrics::instance()->meta_write_request_duration_us->increment(duration_ns / 1000); if (!s.ok()) { LOG(WARNING) << "rocks db put key:" << key << " failed, reason:" << s.ToString(); - return OLAP_ERR_META_PUT; + return Status::OLAPInternalError(OLAP_ERR_META_PUT); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus OlapMeta::remove(const int column_family_index, const std::string& key) { +Status OlapMeta::remove(const int column_family_index, const std::string& key) { DorisMetrics::instance()->meta_write_request_total->increment(1); rocksdb::ColumnFamilyHandle* handle = _handles[column_family_index]; rocksdb::Status s; @@ -146,17 +146,17 @@ OLAPStatus OlapMeta::remove(const int column_family_index, const std::string& ke SCOPED_RAW_TIMER(&duration_ns); WriteOptions write_options; write_options.sync = config::sync_tablet_meta; - s = _db->Delete(write_options, handle, Slice(key)); + s = _db->Delete(write_options, handle, rocksdb::Slice(key)); } DorisMetrics::instance()->meta_write_request_duration_us->increment(duration_ns / 1000); if (!s.ok()) { LOG(WARNING) << "rocks db delete key:" << key << " failed, reason:" << s.ToString(); - return OLAP_ERR_META_DELETE; + return Status::OLAPInternalError(OLAP_ERR_META_DELETE); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus OlapMeta::iterate( +Status OlapMeta::iterate( const int column_family_index, const std::string& prefix, std::function const& func) { rocksdb::ColumnFamilyHandle* handle = _handles[column_family_index]; @@ -169,12 +169,12 @@ OLAPStatus OlapMeta::iterate( rocksdb::Status status = it->status(); if (!status.ok()) { LOG(WARNING) << "rocksdb seek failed. reason:" << status.ToString(); - return OLAP_ERR_META_ITERATOR; + return Status::OLAPInternalError(OLAP_ERR_META_ITERATOR); } for (; it->Valid(); it->Next()) { if (prefix != "") { if (!it->key().starts_with(prefix)) { - return OLAP_SUCCESS; + return Status::OK(); } } std::string key = it->key().ToString(); @@ -186,9 +186,9 @@ OLAPStatus OlapMeta::iterate( } if (!it->status().ok()) { LOG(WARNING) << "rocksdb iterator failed. reason:" << status.ToString(); - return OLAP_ERR_META_ITERATOR; + return Status::OLAPInternalError(OLAP_ERR_META_ITERATOR); } - return OLAP_SUCCESS; + return Status::OK(); } std::string OlapMeta::get_root_path() { diff --git a/be/src/olap/olap_meta.h b/be/src/olap/olap_meta.h index da6e33254d..c6495fc295 100644 --- a/be/src/olap/olap_meta.h +++ b/be/src/olap/olap_meta.h @@ -33,17 +33,17 @@ public: virtual ~OlapMeta(); - OLAPStatus init(); + Status init(); - OLAPStatus get(const int column_family_index, const std::string& key, std::string* value); + Status get(const int column_family_index, const std::string& key, std::string* value); bool key_may_exist(const int column_family_index, const std::string& key, std::string* value); - OLAPStatus put(const int column_family_index, const std::string& key, const std::string& value); + Status put(const int column_family_index, const std::string& key, const std::string& value); - OLAPStatus remove(const int column_family_index, const std::string& key); + Status remove(const int column_family_index, const std::string& key); - OLAPStatus iterate(const int column_family_index, const std::string& prefix, + Status iterate(const int column_family_index, const std::string& prefix, std::function const& func); std::string get_root_path(); diff --git a/be/src/olap/olap_server.cpp b/be/src/olap/olap_server.cpp index d27f12be20..836ad1d486 100644 --- a/be/src/olap/olap_server.cpp +++ b/be/src/olap/olap_server.cpp @@ -179,12 +179,10 @@ void StorageEngine::_garbage_sweeper_thread_callback() { curr_interval = std::min(curr_interval, max_interval); // start clean trash and update usage. - OLAPStatus res = start_trash_sweep(&usage); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING( - "one or more errors occur when sweep trash." - "see previous message for detail. [err code=%d]", - res); + Status res = start_trash_sweep(&usage); + if (!res.ok()) { + LOG(WARNING) << "one or more errors occur when sweep trash." + << "see previous message for detail. err code=" << res; // do nothing. continue next loop. } } diff --git a/be/src/olap/options.cpp b/be/src/olap/options.cpp index c480c91958..d73d54cee7 100644 --- a/be/src/olap/options.cpp +++ b/be/src/olap/options.cpp @@ -51,7 +51,7 @@ static std::string to_upper(const std::string& str) { // format 1: /home/disk1/palo.HDD,50 // format 2: /home/disk1/palo,medium:ssd,capacity:50 // remote cache format: /home/disk/palo/cache,medium:remote_cache,capacity:50 -OLAPStatus parse_root_path(const string& root_path, StorePath* path) { +Status parse_root_path(const string& root_path, StorePath* path) { std::vector tmp_vec = strings::Split(root_path, ",", strings::SkipWhitespace()); // parse root path name @@ -59,14 +59,14 @@ OLAPStatus parse_root_path(const string& root_path, StorePath* path) { tmp_vec[0].erase(tmp_vec[0].find_last_not_of("/") + 1); if (tmp_vec[0].empty() || tmp_vec[0][0] != '/') { LOG(WARNING) << "invalid store path. path=" << tmp_vec[0]; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } string canonicalized_path; Status status = Env::Default()->canonicalize(tmp_vec[0], &canonicalized_path); if (!status.ok()) { LOG(WARNING) << "path can not be canonicalized. may be not exist. path=" << tmp_vec[0]; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } path->path = tmp_vec[0]; @@ -105,7 +105,7 @@ OLAPStatus parse_root_path(const string& root_path, StorePath* path) { medium_str = to_upper(value); } else { LOG(WARNING) << "invalid property of store path, " << tmp_vec[i]; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } } @@ -114,7 +114,7 @@ OLAPStatus parse_root_path(const string& root_path, StorePath* path) { if (!valid_signed_number(capacity_str) || strtol(capacity_str.c_str(), nullptr, 10) < 0) { LOG(WARNING) << "invalid capacity of store path, capacity=" << capacity_str; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } path->capacity_bytes = strtol(capacity_str.c_str(), nullptr, 10) * GB_EXCHANGE_BYTE; } @@ -129,19 +129,19 @@ OLAPStatus parse_root_path(const string& root_path, StorePath* path) { path->storage_medium = TStorageMedium::REMOTE_CACHE; } else { LOG(WARNING) << "invalid storage medium. medium=" << medium_str; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus parse_conf_store_paths(const string& config_path, std::vector* paths) { +Status parse_conf_store_paths(const string& config_path, std::vector* paths) { std::vector path_vec = strings::Split(config_path, ";", strings::SkipWhitespace()); for (auto& item : path_vec) { StorePath path; auto res = parse_root_path(item, &path); - if (res == OLAP_SUCCESS) { + if (res.ok()) { paths->emplace_back(std::move(path)); } else { LOG(WARNING) << "failed to parse store path " << item << ", res=" << res; @@ -149,9 +149,9 @@ OLAPStatus parse_conf_store_paths(const string& config_path, std::vectorempty() || (path_vec.size() != paths->size() && !config::ignore_broken_disk)) { LOG(WARNING) << "fail to parse storage_root_path config. value=[" << config_path << "]"; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } } // end namespace doris diff --git a/be/src/olap/options.h b/be/src/olap/options.h index fd6d9c9688..8a21c46829 100644 --- a/be/src/olap/options.h +++ b/be/src/olap/options.h @@ -38,9 +38,9 @@ struct StorePath { }; // parse a single root path of storage_root_path -OLAPStatus parse_root_path(const std::string& root_path, StorePath* path); +Status parse_root_path(const std::string& root_path, StorePath* path); -OLAPStatus parse_conf_store_paths(const std::string& config_path, std::vector* path); +Status parse_conf_store_paths(const std::string& config_path, std::vector* path); struct EngineOptions { // list paths that tablet will be put into. diff --git a/be/src/olap/out_stream.cpp b/be/src/olap/out_stream.cpp index 3c032d4467..475d0ca98f 100644 --- a/be/src/olap/out_stream.cpp +++ b/be/src/olap/out_stream.cpp @@ -93,38 +93,38 @@ OutStream::~OutStream() { } } -OLAPStatus OutStream::_create_new_input_buffer() { +Status OutStream::_create_new_input_buffer() { SAFE_DELETE(_current); _current = StorageByteBuffer::create(_buffer_size + sizeof(StreamHead)); if (nullptr != _current) { _current->set_position(sizeof(StreamHead)); - return OLAP_SUCCESS; + return Status::OK(); } else { - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } } -OLAPStatus OutStream::_write_head(StorageByteBuffer* buf, uint64_t position, +Status OutStream::_write_head(StorageByteBuffer* buf, uint64_t position, StreamHead::StreamType type, uint32_t length) { if (buf->limit() < sizeof(StreamHead) + length) { - return OLAP_ERR_BUFFER_OVERFLOW; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } StreamHead* head = reinterpret_cast(&(buf->array()[position])); head->type = type; head->length = length; head->checksum = 0; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus OutStream::_compress(StorageByteBuffer* input, StorageByteBuffer* output, +Status OutStream::_compress(StorageByteBuffer* input, StorageByteBuffer* output, StorageByteBuffer* overflow, bool* smaller) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); res = _compressor(input, overflow, smaller); - if (OLAP_SUCCESS == res && *smaller) { + if (res.ok() && *smaller) { if (output->remaining() >= overflow->position()) { memory_copy(&(output->array()[output->position()]), overflow->array(), overflow->position()); @@ -141,7 +141,7 @@ OLAPStatus OutStream::_compress(StorageByteBuffer* input, StorageByteBuffer* out } } - return OLAP_SUCCESS; + return Status::OK(); } void OutStream::_output_uncompress() { @@ -158,12 +158,12 @@ void OutStream::_output_compressed() { _overflow = nullptr; } -OLAPStatus OutStream::_make_sure_output_buffer() { +Status OutStream::_make_sure_output_buffer() { if (nullptr == _compressed) { _compressed = StorageByteBuffer::create(_buffer_size + sizeof(StreamHead)); if (nullptr == _compressed) { - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } } @@ -171,18 +171,18 @@ OLAPStatus OutStream::_make_sure_output_buffer() { _overflow = StorageByteBuffer::create(_buffer_size + sizeof(StreamHead)); if (nullptr == _overflow) { - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus OutStream::_spill() { - OLAPStatus res = OLAP_SUCCESS; +Status OutStream::_spill() { + Status res = Status::OK(); if (_current == nullptr || _current->position() == sizeof(StreamHead)) { - return OLAP_SUCCESS; + return Status::OK(); } // If it is not compressed, read current directly. Note that current will be cleared and set to NULL after output @@ -196,7 +196,7 @@ OLAPStatus OutStream::_spill() { _current->set_position(sizeof(StreamHead)); //Allocate compress and overflow, the two buffer sizes are actually the same - if (OLAP_SUCCESS != (res = _make_sure_output_buffer())) { + if (!(res = _make_sure_output_buffer())) { return res; } @@ -206,9 +206,9 @@ OLAPStatus OutStream::_spill() { bool smaller = false; res = _compress(_current, _compressed, _overflow, &smaller); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to compress data."); - return OLAP_ERR_COMPRESS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_COMPRESS_ERROR); } if (smaller) { @@ -242,11 +242,11 @@ OLAPStatus OutStream::_spill() { } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus OutStream::write(const char* buffer, uint64_t length) { - OLAPStatus res = OLAP_SUCCESS; +Status OutStream::write(const char* buffer, uint64_t length) { + Status res = Status::OK(); uint64_t offset = 0; uint64_t remain = length; @@ -258,7 +258,7 @@ OLAPStatus OutStream::write(const char* buffer, uint64_t length) { // Only allocate once and the second block will hang up if (nullptr == _current) { res = _create_new_input_buffer(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } } @@ -267,7 +267,7 @@ OLAPStatus OutStream::write(const char* buffer, uint64_t length) { if (OLAP_LIKELY(0 != to_put)) { res = _current->put(&buffer[offset], to_put); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to put buffer."); return res; } @@ -278,14 +278,14 @@ OLAPStatus OutStream::write(const char* buffer, uint64_t length) { if (_current->remaining() == 0) { res = _spill(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to spill current buffer."); return res; } } } - return OLAP_SUCCESS; + return Status::OK(); } void OutStream::get_position(PositionEntryWriter* index_entry) const { @@ -332,8 +332,8 @@ uint64_t OutStream::get_total_buffer_size() const { return result; } -OLAPStatus OutStream::write_to_file(FileHandler* file_handle, uint32_t write_mbytes_per_sec) const { - OLAPStatus res = OLAP_SUCCESS; +Status OutStream::write_to_file(FileHandler* file_handle, uint32_t write_mbytes_per_sec) const { + Status res = Status::OK(); uint64_t total_stream_len = 0; OlapStopWatch speed_limit_watch; @@ -345,7 +345,7 @@ OLAPStatus OutStream::write_to_file(FileHandler* file_handle, uint32_t write_mby VLOG_TRACE << "write stream begin:" << file_handle->tell(); res = file_handle->write((*it)->array(), (*it)->limit()); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write stream to fail."); return res; } @@ -367,11 +367,11 @@ OLAPStatus OutStream::write_to_file(FileHandler* file_handle, uint32_t write_mby return res; } -OLAPStatus OutStream::flush() { - OLAPStatus res = OLAP_SUCCESS; +Status OutStream::flush() { + Status res = Status::OK(); res = _spill(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to spill stream."); return res; } diff --git a/be/src/olap/out_stream.h b/be/src/olap/out_stream.h index 266a1eb590..79e29a6322 100644 --- a/be/src/olap/out_stream.h +++ b/be/src/olap/out_stream.h @@ -47,23 +47,23 @@ public: ~OutStream(); // Output a byte to the stream - OLAPStatus write(char byte) { - OLAPStatus res = OLAP_SUCCESS; + Status write(char byte) { + Status res = Status::OK(); if (_current == nullptr) { res = _create_new_input_buffer(); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { return res; } } if (_current->remaining() < 1) { res = _spill(); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to spill current buffer."); return res; } if (_current == nullptr) { res = _create_new_input_buffer(); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { return res; } } @@ -72,7 +72,7 @@ public: } // Output a piece of data to the stream - OLAPStatus write(const char* buffer, uint64_t length); + Status write(const char* buffer, uint64_t length); // Record the current position of the stream in the index entry void get_position(PositionEntryWriter* index_entry) const; @@ -84,12 +84,12 @@ public: uint64_t get_total_buffer_size() const; // Output the cached data stream to a file - OLAPStatus write_to_file(FileHandler* file_handle, uint32_t write_mbytes_per_sec) const; + Status write_to_file(FileHandler* file_handle, uint32_t write_mbytes_per_sec) const; bool is_suppressed() const { return _is_suppressed; } void suppress() { _is_suppressed = true; } // Output data to output_buffers - OLAPStatus flush(); + Status flush(); // Calculate the crc32 value of the output data uint32_t crc32(uint32_t checksum) const; const std::vector& output_buffers() { return _output_buffers; } @@ -105,15 +105,15 @@ public: } private: - OLAPStatus _create_new_input_buffer(); - OLAPStatus _write_head(StorageByteBuffer* buf, uint64_t position, StreamHead::StreamType type, + Status _create_new_input_buffer(); + Status _write_head(StorageByteBuffer* buf, uint64_t position, StreamHead::StreamType type, uint32_t length); - OLAPStatus _spill(); - OLAPStatus _compress(StorageByteBuffer* input, StorageByteBuffer* output, + Status _spill(); + Status _compress(StorageByteBuffer* input, StorageByteBuffer* output, StorageByteBuffer* overflow, bool* smaller); void _output_uncompress(); void _output_compressed(); - OLAPStatus _make_sure_output_buffer(); + Status _make_sure_output_buffer(); uint32_t _buffer_size; // Compressed block size Compressor _compressor; // Compression function, if NULL means no compression diff --git a/be/src/olap/push_handler.cpp b/be/src/olap/push_handler.cpp index 234db7ad63..42ac5aa9b8 100644 --- a/be/src/olap/push_handler.cpp +++ b/be/src/olap/push_handler.cpp @@ -53,19 +53,19 @@ namespace doris { // clear schema change info in both current tablet and related // tablets, finally we will only push for current tablets. this is // very useful in rollup action. -OLAPStatus PushHandler::process_streaming_ingestion(TabletSharedPtr tablet, const TPushReq& request, +Status PushHandler::process_streaming_ingestion(TabletSharedPtr tablet, const TPushReq& request, PushType push_type, std::vector* tablet_info_vec) { LOG(INFO) << "begin to realtime push. tablet=" << tablet->full_name() << ", transaction_id=" << request.transaction_id; - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); _request = request; std::vector tablet_vars(1); tablet_vars[0].tablet = tablet; res = _do_streaming_ingestion(tablet, request, push_type, &tablet_vars, tablet_info_vec); - if (res == OLAP_SUCCESS) { + if (res.ok()) { if (tablet_info_vec != nullptr) { _get_tablet_infos(tablet_vars, tablet_info_vec); } @@ -77,19 +77,19 @@ OLAPStatus PushHandler::process_streaming_ingestion(TabletSharedPtr tablet, cons return res; } -OLAPStatus PushHandler::_do_streaming_ingestion(TabletSharedPtr tablet, const TPushReq& request, +Status PushHandler::_do_streaming_ingestion(TabletSharedPtr tablet, const TPushReq& request, PushType push_type, std::vector* tablet_vars, std::vector* tablet_info_vec) { // add transaction in engine, then check sc status // lock, prevent sc handler checking transaction concurrently if (tablet == nullptr) { - return OLAP_ERR_TABLE_NOT_FOUND; + return Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); } std::shared_lock base_migration_rlock(tablet->get_migration_lock(), std::try_to_lock); if (!base_migration_rlock.owns_lock()) { - return OLAP_ERR_RWLOCK_ERROR; + return Status::OLAPInternalError(OLAP_ERR_RWLOCK_ERROR); } PUniqueId load_id; load_id.set_hi(0); @@ -107,7 +107,7 @@ OLAPStatus PushHandler::_do_streaming_ingestion(TabletSharedPtr tablet, const TP // not call validate request here, because realtime load does not // contain version info - OLAPStatus res; + Status res; // check delete condition if push for delete std::queue del_preds; if (push_type == PUSH_FOR_DELETE) { @@ -124,7 +124,7 @@ OLAPStatus PushHandler::_do_streaming_ingestion(TabletSharedPtr tablet, const TP tablet_var.tablet->tablet_schema(), request.delete_conditions, &del_pred); del_preds.push(del_pred); } - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to generate delete condition. res=" << res << ", tablet=" << tablet_var.tablet->full_name(); return res; @@ -138,7 +138,7 @@ OLAPStatus PushHandler::_do_streaming_ingestion(TabletSharedPtr tablet, const TP << tablet_vars->at(0).tablet->version_count() << ", exceed limit: " << config::max_tablet_version_num << ". tablet: " << tablet_vars->at(0).tablet->full_name(); - return OLAP_ERR_TOO_MANY_VERSION; + return Status::OLAPInternalError(OLAP_ERR_TOO_MANY_VERSION); } // write @@ -150,7 +150,7 @@ OLAPStatus PushHandler::_do_streaming_ingestion(TabletSharedPtr tablet, const TP res = _convert(tablet_vars->at(0).tablet, tablet_vars->at(1).tablet, &(tablet_vars->at(0).rowset_to_add), &(tablet_vars->at(1).rowset_to_add)); } - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to convert tmp file when realtime push. res=" << res << ", failed to process realtime push." << ", tablet=" << tablet->full_name() @@ -160,10 +160,10 @@ OLAPStatus PushHandler::_do_streaming_ingestion(TabletSharedPtr tablet, const TP continue; } - OLAPStatus rollback_status = StorageEngine::instance()->txn_manager()->rollback_txn( + Status rollback_status = StorageEngine::instance()->txn_manager()->rollback_txn( request.partition_id, tablet_var.tablet, request.transaction_id); // has to check rollback status to ensure not delete a committed rowset - if (rollback_status == OLAP_SUCCESS) { + if (rollback_status.ok()) { // actually, olap_index may has been deleted in delete_transaction() StorageEngine::instance()->add_unused_rowset(tablet_var.rowset_to_add); } @@ -181,11 +181,11 @@ OLAPStatus PushHandler::_do_streaming_ingestion(TabletSharedPtr tablet, const TP tablet_var.rowset_to_add->rowset_meta()->set_delete_predicate(del_preds.front()); del_preds.pop(); } - OLAPStatus commit_status = StorageEngine::instance()->txn_manager()->commit_txn( + Status commit_status = StorageEngine::instance()->txn_manager()->commit_txn( request.partition_id, tablet_var.tablet, request.transaction_id, load_id, tablet_var.rowset_to_add, false); - if (commit_status != OLAP_SUCCESS && - commit_status != OLAP_ERR_PUSH_TRANSACTION_ALREADY_EXIST) { + if (commit_status != Status::OK() && + commit_status != Status::OLAPInternalError(OLAP_ERR_PUSH_TRANSACTION_ALREADY_EXIST)) { res = commit_status; } } @@ -207,9 +207,9 @@ void PushHandler::_get_tablet_infos(const std::vector& tablet_vars, } } -OLAPStatus PushHandler::_convert_v2(TabletSharedPtr cur_tablet, TabletSharedPtr new_tablet, +Status PushHandler::_convert_v2(TabletSharedPtr cur_tablet, TabletSharedPtr new_tablet, RowsetSharedPtr* cur_rowset, RowsetSharedPtr* new_rowset) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); uint32_t num_rows = 0; PUniqueId load_id; load_id.set_hi(0); @@ -244,7 +244,7 @@ OLAPStatus PushHandler::_convert_v2(TabletSharedPtr cur_tablet, TabletSharedPtr std::unique_ptr rowset_writer; res = RowsetFactory::create_rowset_writer(context, &rowset_writer); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { LOG(WARNING) << "failed to init rowset writer, tablet=" << cur_tablet->full_name() << ", txn_id=" << _request.transaction_id << ", res=" << res; break; @@ -260,7 +260,7 @@ OLAPStatus PushHandler::_convert_v2(TabletSharedPtr cur_tablet, TabletSharedPtr std::unique_ptr reader(new (std::nothrow) PushBrokerReader()); if (reader == nullptr) { LOG(WARNING) << "fail to create reader. tablet=" << cur_tablet->full_name(); - res = OLAP_ERR_MALLOC_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); break; } @@ -268,16 +268,15 @@ OLAPStatus PushHandler::_convert_v2(TabletSharedPtr cur_tablet, TabletSharedPtr std::unique_ptr schema(new (std::nothrow) Schema(cur_tablet->tablet_schema())); if (schema == nullptr) { LOG(WARNING) << "fail to create schema. tablet=" << cur_tablet->full_name(); - res = OLAP_ERR_MALLOC_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); break; } // init Reader - if (OLAP_SUCCESS != - (res = reader->init(schema.get(), _request.broker_scan_range, _request.desc_tbl))) { + if (!(res = reader->init(schema.get(), _request.broker_scan_range, _request.desc_tbl))) { LOG(WARNING) << "fail to init reader. res=" << res << ", tablet=" << cur_tablet->full_name(); - res = OLAP_ERR_PUSH_INIT_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_PUSH_INIT_ERROR); break; } @@ -290,7 +289,7 @@ OLAPStatus PushHandler::_convert_v2(TabletSharedPtr cur_tablet, TabletSharedPtr VLOG_NOTICE << "start to convert etl file to delta."; while (!reader->eof()) { res = reader->next(&row); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { LOG(WARNING) << "read next row failed." << " res=" << res << " read_rows=" << num_rows; break; @@ -302,7 +301,7 @@ OLAPStatus PushHandler::_convert_v2(TabletSharedPtr cur_tablet, TabletSharedPtr if (!reader->is_fill_tuple()) { break; } - if (OLAP_SUCCESS != (res = rowset_writer->add_row(row))) { + if (!(res = rowset_writer->add_row(row))) { LOG(WARNING) << "fail to attach row to rowset_writer. " << "res=" << res << ", tablet=" << cur_tablet->full_name() << ", read_rows=" << num_rows; @@ -316,14 +315,14 @@ OLAPStatus PushHandler::_convert_v2(TabletSharedPtr cur_tablet, TabletSharedPtr reader->close(); } - if (rowset_writer->flush() != OLAP_SUCCESS) { + if (rowset_writer->flush() != Status::OK()) { LOG(WARNING) << "failed to finalize writer"; break; } *cur_rowset = rowset_writer->build(); if (*cur_rowset == nullptr) { LOG(WARNING) << "fail to build rowset"; - res = OLAP_ERR_MALLOC_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); break; } @@ -336,7 +335,7 @@ OLAPStatus PushHandler::_convert_v2(TabletSharedPtr cur_tablet, TabletSharedPtr auto schema_change_handler = SchemaChangeHandler::instance(); res = schema_change_handler->schema_version_convert(cur_tablet, new_tablet, cur_rowset, new_rowset); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to change schema version for delta." << "[res=" << res << " new_tablet='" << new_tablet->full_name() << "']"; @@ -349,9 +348,9 @@ OLAPStatus PushHandler::_convert_v2(TabletSharedPtr cur_tablet, TabletSharedPtr return res; } -OLAPStatus PushHandler::_convert(TabletSharedPtr cur_tablet, TabletSharedPtr new_tablet, +Status PushHandler::_convert(TabletSharedPtr cur_tablet, TabletSharedPtr new_tablet, RowsetSharedPtr* cur_rowset, RowsetSharedPtr* new_rowset) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); RowCursor row; BinaryFile raw_file; IBinaryReader* reader = nullptr; @@ -367,10 +366,10 @@ OLAPStatus PushHandler::_convert(TabletSharedPtr cur_tablet, TabletSharedPtr new // in case of empty push and delete data, this will be skipped. if (_request.__isset.http_file_path) { // open raw file - if (OLAP_SUCCESS != (res = raw_file.init(_request.http_file_path.c_str()))) { + if (!(res = raw_file.init(_request.http_file_path.c_str()))) { LOG(WARNING) << "failed to read raw file. res=" << res << ", file=" << _request.http_file_path; - res = OLAP_ERR_INPUT_PARAMETER_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); break; } @@ -383,7 +382,7 @@ OLAPStatus PushHandler::_convert(TabletSharedPtr cur_tablet, TabletSharedPtr new #ifndef DORIS_WITH_LZO if (need_decompress) { // if lzo is disabled, compressed data is not allowed here - res = OLAP_ERR_LZO_DISABLED; + res = Status::OLAPInternalError(OLAP_ERR_VERSION_ALREADY_MERGED); break; } #endif @@ -392,16 +391,16 @@ OLAPStatus PushHandler::_convert(TabletSharedPtr cur_tablet, TabletSharedPtr new if (reader == nullptr) { LOG(WARNING) << "fail to create reader. tablet=" << cur_tablet->full_name() << ", file=" << _request.http_file_path; - res = OLAP_ERR_MALLOC_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); break; } // init BinaryReader - if (OLAP_SUCCESS != (res = reader->init(cur_tablet, &raw_file))) { + if (!(res = reader->init(cur_tablet, &raw_file))) { LOG(WARNING) << "fail to init reader. res=" << res << ", tablet=" << cur_tablet->full_name() << ", file=" << _request.http_file_path; - res = OLAP_ERR_PUSH_INIT_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_PUSH_INIT_ERROR); break; } } @@ -431,7 +430,7 @@ OLAPStatus PushHandler::_convert(TabletSharedPtr cur_tablet, TabletSharedPtr new std::unique_ptr rowset_writer; res = RowsetFactory::create_rowset_writer(context, &rowset_writer); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { LOG(WARNING) << "failed to init rowset writer, tablet=" << cur_tablet->full_name() << ", txn_id=" << _request.transaction_id << ", res=" << res; break; @@ -442,7 +441,7 @@ OLAPStatus PushHandler::_convert(TabletSharedPtr cur_tablet, TabletSharedPtr new << ", block_row_size=" << cur_tablet->num_rows_per_row_block(); // 4. Init RowCursor - if (OLAP_SUCCESS != (res = row.init(cur_tablet->tablet_schema()))) { + if (!(res = row.init(cur_tablet->tablet_schema()))) { LOG(WARNING) << "fail to init rowcursor. res=" << res; break; } @@ -453,12 +452,12 @@ OLAPStatus PushHandler::_convert(TabletSharedPtr cur_tablet, TabletSharedPtr new VLOG_NOTICE << "start to convert row file to delta."; while (!reader->eof()) { res = reader->next(&row); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { LOG(WARNING) << "read next row failed." << " res=" << res << " read_rows=" << num_rows; break; } else { - if (OLAP_SUCCESS != (res = rowset_writer->add_row(row))) { + if (!(res = rowset_writer->add_row(row))) { LOG(WARNING) << "fail to attach row to rowset_writer. " << " res=" << res << ", tablet=" << cur_tablet->full_name() << " read_rows=" << num_rows; @@ -472,12 +471,12 @@ OLAPStatus PushHandler::_convert(TabletSharedPtr cur_tablet, TabletSharedPtr new if (!reader->validate_checksum()) { LOG(WARNING) << "pushed delta file has wrong checksum."; - res = OLAP_ERR_PUSH_BUILD_DELTA_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_PUSH_BUILD_DELTA_ERROR); break; } } - if (rowset_writer->flush() != OLAP_SUCCESS) { + if (rowset_writer->flush() != Status::OK()) { LOG(WARNING) << "failed to finalize writer."; break; } @@ -485,7 +484,7 @@ OLAPStatus PushHandler::_convert(TabletSharedPtr cur_tablet, TabletSharedPtr new if (*cur_rowset == nullptr) { LOG(WARNING) << "fail to build rowset"; - res = OLAP_ERR_MALLOC_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); break; } @@ -498,7 +497,7 @@ OLAPStatus PushHandler::_convert(TabletSharedPtr cur_tablet, TabletSharedPtr new auto schema_change_handler = SchemaChangeHandler::instance(); res = schema_change_handler->schema_version_convert(cur_tablet, new_tablet, cur_rowset, new_rowset); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to change schema version for delta." << "[res=" << res << " new_tablet='" << new_tablet->full_name() << "']"; @@ -512,21 +511,21 @@ OLAPStatus PushHandler::_convert(TabletSharedPtr cur_tablet, TabletSharedPtr new return res; } -OLAPStatus BinaryFile::init(const char* path) { +Status BinaryFile::init(const char* path) { // open file - if (OLAP_SUCCESS != open(path, "rb")) { + if (!open(path, "rb")) { LOG(WARNING) << "fail to open file. file=" << path; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } // load header - if (OLAP_SUCCESS != _header.unserialize(this)) { + if (!_header.unserialize(this)) { LOG(WARNING) << "fail to read file header. file=" << path; close(); - return OLAP_ERR_PUSH_INIT_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PUSH_INIT_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } IBinaryReader* IBinaryReader::create(bool need_decompress) { @@ -543,8 +542,8 @@ IBinaryReader* IBinaryReader::create(bool need_decompress) { BinaryReader::BinaryReader() : IBinaryReader(), _row_buf(nullptr), _row_buf_size(0) {} -OLAPStatus BinaryReader::init(TabletSharedPtr tablet, BinaryFile* file) { - OLAPStatus res = OLAP_SUCCESS; +Status BinaryReader::init(TabletSharedPtr tablet, BinaryFile* file) { + Status res = Status::OK(); do { _file = file; @@ -554,13 +553,13 @@ OLAPStatus BinaryReader::init(TabletSharedPtr tablet, BinaryFile* file) { _row_buf = new (std::nothrow) char[_row_buf_size]; if (_row_buf == nullptr) { LOG(WARNING) << "fail to malloc one row buf. size=" << _row_buf_size; - res = OLAP_ERR_MALLOC_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); break; } if (-1 == _file->seek(_file->header_size(), SEEK_SET)) { LOG(WARNING) << "skip header, seek fail."; - res = OLAP_ERR_IO_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_IO_ERROR); break; } @@ -568,24 +567,24 @@ OLAPStatus BinaryReader::init(TabletSharedPtr tablet, BinaryFile* file) { _ready = true; } while (0); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { SAFE_DELETE_ARRAY(_row_buf); } return res; } -OLAPStatus BinaryReader::finalize() { +Status BinaryReader::finalize() { _ready = false; SAFE_DELETE_ARRAY(_row_buf); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BinaryReader::next(RowCursor* row) { - OLAPStatus res = OLAP_SUCCESS; +Status BinaryReader::next(RowCursor* row) { + Status res = Status::OK(); if (!_ready || nullptr == row) { // Here i assume _ready means all states were set up correctly - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } const TabletSchema& schema = _tablet->tablet_schema(); @@ -593,7 +592,7 @@ OLAPStatus BinaryReader::next(RowCursor* row) { size_t field_size = 0; size_t num_null_bytes = (_tablet->num_null_columns() + 7) / 8; - if (OLAP_SUCCESS != (res = _file->read(_row_buf + offset, num_null_bytes))) { + if (!(res = _file->read(_row_buf + offset, num_null_bytes))) { LOG(WARNING) << "read file for one row fail. res=" << res; return res; } @@ -619,7 +618,7 @@ OLAPStatus BinaryReader::next(RowCursor* row) { } if (column.type() == OLAP_FIELD_TYPE_VARCHAR || column.type() == OLAP_FIELD_TYPE_HLL) { // Read varchar length buffer first - if (OLAP_SUCCESS != (res = _file->read(_row_buf + offset, sizeof(VarcharLengthType)))) { + if (!(res = _file->read(_row_buf + offset, sizeof(VarcharLengthType)))) { LOG(WARNING) << "read file for one row fail. res=" << res; return res; } @@ -631,11 +630,11 @@ OLAPStatus BinaryReader::next(RowCursor* row) { LOG(WARNING) << "invalid data length for VARCHAR! " << "max_len=" << column.length() - sizeof(VarcharLengthType) << ", real_len=" << field_size; - return OLAP_ERR_PUSH_INPUT_DATA_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PUSH_INPUT_DATA_ERROR); } } else if (column.type() == OLAP_FIELD_TYPE_STRING) { // Read string length buffer first - if (OLAP_SUCCESS != (res = _file->read(_row_buf + offset, sizeof(StringLengthType)))) { + if (!(res = _file->read(_row_buf + offset, sizeof(StringLengthType)))) { LOG(WARNING) << "read file for one row fail. res=" << res; return res; } @@ -647,14 +646,14 @@ OLAPStatus BinaryReader::next(RowCursor* row) { LOG(WARNING) << "invalid data length for string! " << "max_len=" << column.length() - sizeof(StringLengthType) << ", real_len=" << field_size; - return OLAP_ERR_PUSH_INPUT_DATA_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PUSH_INPUT_DATA_ERROR); } } else { field_size = column.length(); } // Read field content according to field size - if (OLAP_SUCCESS != (res = _file->read(_row_buf + offset, field_size))) { + if (!(res = _file->read(_row_buf + offset, field_size))) { LOG(WARNING) << "read file for one row fail. res=" << res; return res; } @@ -686,8 +685,8 @@ LzoBinaryReader::LzoBinaryReader() _row_num(0), _next_row_start(0) {} -OLAPStatus LzoBinaryReader::init(TabletSharedPtr tablet, BinaryFile* file) { - OLAPStatus res = OLAP_SUCCESS; +Status LzoBinaryReader::init(TabletSharedPtr tablet, BinaryFile* file) { + Status res = Status::OK(); do { _file = file; @@ -697,13 +696,13 @@ OLAPStatus LzoBinaryReader::init(TabletSharedPtr tablet, BinaryFile* file) { _row_info_buf = new (std::nothrow) char[row_info_buf_size]; if (_row_info_buf == nullptr) { LOG(WARNING) << "fail to malloc rows info buf. size=" << row_info_buf_size; - res = OLAP_ERR_MALLOC_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); break; } if (-1 == _file->seek(_file->header_size(), SEEK_SET)) { LOG(WARNING) << "skip header, seek fail."; - res = OLAP_ERR_IO_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_IO_ERROR); break; } @@ -711,31 +710,31 @@ OLAPStatus LzoBinaryReader::init(TabletSharedPtr tablet, BinaryFile* file) { _ready = true; } while (0); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { SAFE_DELETE_ARRAY(_row_info_buf); } return res; } -OLAPStatus LzoBinaryReader::finalize() { +Status LzoBinaryReader::finalize() { _ready = false; SAFE_DELETE_ARRAY(_row_buf); SAFE_DELETE_ARRAY(_row_compressed_buf); SAFE_DELETE_ARRAY(_row_info_buf); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus LzoBinaryReader::next(RowCursor* row) { - OLAPStatus res = OLAP_SUCCESS; +Status LzoBinaryReader::next(RowCursor* row) { + Status res = Status::OK(); if (!_ready || nullptr == row) { // Here i assume _ready means all states were set up correctly - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } if (_row_num == 0) { // read next block - if (OLAP_SUCCESS != (res = _next_block())) { + if (!(res = _next_block())) { return res; } } @@ -774,7 +773,7 @@ OLAPStatus LzoBinaryReader::next(RowCursor* row) { LOG(WARNING) << "invalid data length for VARCHAR! " << "max_len=" << column.length() - sizeof(VarcharLengthType) << ", real_len=" << field_size; - return OLAP_ERR_PUSH_INPUT_DATA_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PUSH_INPUT_DATA_ERROR); } } else if (column.type() == OLAP_FIELD_TYPE_STRING) { // Get string field size @@ -785,7 +784,7 @@ OLAPStatus LzoBinaryReader::next(RowCursor* row) { LOG(WARNING) << "invalid data length for string! " << "max_len=" << column.length() - sizeof(StringLengthType) << ", real_len=" << field_size; - return OLAP_ERR_PUSH_INPUT_DATA_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PUSH_INPUT_DATA_ERROR); } } else { field_size = column.length(); @@ -810,12 +809,12 @@ OLAPStatus LzoBinaryReader::next(RowCursor* row) { return res; } -OLAPStatus LzoBinaryReader::_next_block() { - OLAPStatus res = OLAP_SUCCESS; +Status LzoBinaryReader::_next_block() { + Status res = Status::OK(); // Get row num and compressed data size size_t row_info_buf_size = sizeof(RowNumType) + sizeof(CompressedSizeType); - if (OLAP_SUCCESS != (res = _file->read(_row_info_buf, row_info_buf_size))) { + if (!(res = _file->read(_row_info_buf, row_info_buf_size))) { LOG(WARNING) << "read rows info fail. res=" << res; return res; } @@ -835,7 +834,7 @@ OLAPStatus LzoBinaryReader::_next_block() { _row_buf = new (std::nothrow) char[_max_row_buf_size]; if (_row_buf == nullptr) { LOG(WARNING) << "fail to malloc rows buf. size=" << _max_row_buf_size; - res = OLAP_ERR_MALLOC_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); return res; } } @@ -848,12 +847,12 @@ OLAPStatus LzoBinaryReader::_next_block() { _row_compressed_buf = new (std::nothrow) char[_max_compressed_buf_size]; if (_row_compressed_buf == nullptr) { LOG(WARNING) << "fail to malloc rows compressed buf. size=" << _max_compressed_buf_size; - res = OLAP_ERR_MALLOC_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); return res; } } - if (OLAP_SUCCESS != (res = _file->read(_row_compressed_buf, compressed_size))) { + if (!(res = _file->read(_row_compressed_buf, compressed_size))) { LOG(WARNING) << "read compressed rows fail. res=" << res; return res; } @@ -862,8 +861,7 @@ OLAPStatus LzoBinaryReader::_next_block() { // and add 5 bytes header (\xf0 + 4 bytes(uncompress data size)) size_t written_len = 0; size_t block_header_size = 5; - if (OLAP_SUCCESS != - (res = olap_decompress(_row_compressed_buf + block_header_size, + if (!(res = olap_decompress(_row_compressed_buf + block_header_size, compressed_size - block_header_size, _row_buf, _max_row_buf_size, &written_len, OLAP_COMP_TRANSPORT))) { LOG(WARNING) << "olap decompress fail. res=" << res; @@ -875,7 +873,7 @@ OLAPStatus LzoBinaryReader::_next_block() { return res; } -OLAPStatus PushBrokerReader::init(const Schema* schema, const TBrokerScanRange& t_scan_range, +Status PushBrokerReader::init(const Schema* schema, const TBrokerScanRange& t_scan_range, const TDescriptorTable& t_desc_tbl) { // init schema _schema = schema; @@ -898,13 +896,13 @@ OLAPStatus PushBrokerReader::init(const Schema* schema, const TBrokerScanRange& Status status = DescriptorTbl::create(_runtime_state->obj_pool(), t_desc_tbl, &desc_tbl); if (UNLIKELY(!status.ok())) { LOG(WARNING) << "Failed to create descriptor table, msg: " << status.get_error_msg(); - return OLAP_ERR_PUSH_INIT_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PUSH_INIT_ERROR); } _runtime_state->set_desc_tbl(desc_tbl); status = _runtime_state->init_mem_trackers(dummy_id); if (UNLIKELY(!status.ok())) { LOG(WARNING) << "Failed to init mem trackers, msg: " << status.get_error_msg(); - return OLAP_ERR_PUSH_INIT_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PUSH_INIT_ERROR); } _runtime_profile = _runtime_state->runtime_profile(); _runtime_profile->set_name("PushBrokerReader"); @@ -921,13 +919,13 @@ OLAPStatus PushBrokerReader::init(const Schema* schema, const TBrokerScanRange& break; default: LOG(WARNING) << "Unsupported file format type: " << t_scan_range.ranges[0].format_type; - return OLAP_ERR_PUSH_INIT_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PUSH_INIT_ERROR); } _scanner.reset(scanner); status = _scanner->open(); if (UNLIKELY(!status.ok())) { LOG(WARNING) << "Failed to open scanner, msg: " << status.get_error_msg(); - return OLAP_ERR_PUSH_INIT_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PUSH_INIT_ERROR); } // init tuple @@ -936,22 +934,22 @@ OLAPStatus PushBrokerReader::init(const Schema* schema, const TBrokerScanRange& if (_tuple_desc == nullptr) { std::stringstream ss; LOG(WARNING) << "Failed to get tuple descriptor, tuple_id: " << tuple_id; - return OLAP_ERR_PUSH_INIT_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PUSH_INIT_ERROR); } int tuple_buffer_size = _tuple_desc->byte_size(); void* tuple_buffer = _mem_pool->allocate(tuple_buffer_size); if (tuple_buffer == nullptr) { LOG(WARNING) << "Allocate memory for tuple failed"; - return OLAP_ERR_PUSH_INIT_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PUSH_INIT_ERROR); } _tuple = reinterpret_cast(tuple_buffer); _ready = true; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus PushBrokerReader::fill_field_row(RowCursorCell* dst, const char* src, bool src_null, +Status PushBrokerReader::fill_field_row(RowCursorCell* dst, const char* src, bool src_null, MemPool* mem_pool, FieldType type) { switch (type) { case OLAP_FIELD_TYPE_DECIMAL: { @@ -1010,15 +1008,15 @@ OLAPStatus PushBrokerReader::fill_field_row(RowCursorCell* dst, const char* src, break; } default: - return OLAP_ERR_INVALID_SCHEMA; + return Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus PushBrokerReader::next(ContiguousRow* row) { +Status PushBrokerReader::next(ContiguousRow* row) { if (!_ready || row == nullptr) { - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } memset(_tuple, 0, _tuple_desc->num_null_bytes()); @@ -1026,10 +1024,10 @@ OLAPStatus PushBrokerReader::next(ContiguousRow* row) { Status status = _scanner->get_next(_tuple, _mem_pool.get(), &_eof, &_fill_tuple); if (UNLIKELY(!status.ok())) { LOG(WARNING) << "Scanner get next tuple failed"; - return OLAP_ERR_PUSH_INPUT_DATA_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PUSH_INPUT_DATA_ERROR); } if (_eof || !_fill_tuple) { - return OLAP_SUCCESS; + return Status::OK(); } auto slot_descs = _tuple_desc->slots(); @@ -1041,16 +1039,16 @@ OLAPStatus PushBrokerReader::next(ContiguousRow* row) { const void* value = _tuple->get_slot(slot->tuple_offset()); FieldType type = _schema->column(i)->type(); - OLAPStatus field_status = + Status field_status = fill_field_row(&cell, (const char*)value, is_null, _mem_pool.get(), type); - if (field_status != OLAP_SUCCESS) { + if (field_status != Status::OK()) { LOG(WARNING) << "fill field row failed in spark load, slot index: " << i << ", type: " << type; - return OLAP_ERR_SCHEMA_SCHEMA_FIELD_INVALID; + return Status::OLAPInternalError(OLAP_ERR_SCHEMA_SCHEMA_FIELD_INVALID); } } - return OLAP_SUCCESS; + return Status::OK(); } void PushBrokerReader::print_profile() { diff --git a/be/src/olap/push_handler.h b/be/src/olap/push_handler.h index 767cbc0e0a..aa1aa6eb10 100644 --- a/be/src/olap/push_handler.h +++ b/be/src/olap/push_handler.h @@ -52,7 +52,7 @@ public: ~PushHandler() {} // Load local data file into specified tablet. - OLAPStatus process_streaming_ingestion(TabletSharedPtr tablet, const TPushReq& request, + Status process_streaming_ingestion(TabletSharedPtr tablet, const TPushReq& request, PushType push_type, std::vector* tablet_info_vec); @@ -60,11 +60,11 @@ public: int64_t write_rows() const { return _write_rows; } private: - OLAPStatus _convert_v2(TabletSharedPtr cur_tablet, TabletSharedPtr new_tablet_vec, + Status _convert_v2(TabletSharedPtr cur_tablet, TabletSharedPtr new_tablet_vec, RowsetSharedPtr* cur_rowset, RowsetSharedPtr* new_rowset); // Convert local data file to internal formatted delta, // return new delta's SegmentGroup - OLAPStatus _convert(TabletSharedPtr cur_tablet, TabletSharedPtr new_tablet_vec, + Status _convert(TabletSharedPtr cur_tablet, TabletSharedPtr new_tablet_vec, RowsetSharedPtr* cur_rowset, RowsetSharedPtr* new_rowset); // Only for debug @@ -73,7 +73,7 @@ private: void _get_tablet_infos(const std::vector& tablet_infos, std::vector* tablet_info_vec); - OLAPStatus _do_streaming_ingestion(TabletSharedPtr tablet, const TPushReq& request, + Status _do_streaming_ingestion(TabletSharedPtr tablet, const TPushReq& request, PushType push_type, vector* tablet_vars, std::vector* tablet_info_vec); @@ -92,7 +92,7 @@ public: BinaryFile() {} virtual ~BinaryFile() { close(); } - OLAPStatus init(const char* path); + Status init(const char* path); size_t header_size() const { return _header.size(); } size_t file_length() const { return _header.file_length(); } @@ -110,10 +110,10 @@ public: static IBinaryReader* create(bool need_decompress); virtual ~IBinaryReader() {} - virtual OLAPStatus init(TabletSharedPtr tablet, BinaryFile* file) = 0; - virtual OLAPStatus finalize() = 0; + virtual Status init(TabletSharedPtr tablet, BinaryFile* file) = 0; + virtual Status finalize() = 0; - virtual OLAPStatus next(RowCursor* row) = 0; + virtual Status next(RowCursor* row) = 0; virtual bool eof() = 0; @@ -142,10 +142,10 @@ public: explicit BinaryReader(); virtual ~BinaryReader() { finalize(); } - virtual OLAPStatus init(TabletSharedPtr tablet, BinaryFile* file); - virtual OLAPStatus finalize(); + virtual Status init(TabletSharedPtr tablet, BinaryFile* file); + virtual Status finalize(); - virtual OLAPStatus next(RowCursor* row); + virtual Status next(RowCursor* row); virtual bool eof() { return _curr >= _content_len; } @@ -159,15 +159,15 @@ public: explicit LzoBinaryReader(); virtual ~LzoBinaryReader() { finalize(); } - virtual OLAPStatus init(TabletSharedPtr tablet, BinaryFile* file); - virtual OLAPStatus finalize(); + virtual Status init(TabletSharedPtr tablet, BinaryFile* file); + virtual Status finalize(); - virtual OLAPStatus next(RowCursor* row); + virtual Status next(RowCursor* row); virtual bool eof() { return _curr >= _content_len && _row_num == 0; } private: - OLAPStatus _next_block(); + Status _next_block(); typedef uint32_t RowNumType; typedef uint64_t CompressedSizeType; @@ -187,21 +187,21 @@ public: PushBrokerReader() : _ready(false), _eof(false), _fill_tuple(false) {} ~PushBrokerReader() {} - OLAPStatus init(const Schema* schema, const TBrokerScanRange& t_scan_range, + Status init(const Schema* schema, const TBrokerScanRange& t_scan_range, const TDescriptorTable& t_desc_tbl); - OLAPStatus next(ContiguousRow* row); + Status next(ContiguousRow* row); void print_profile(); - OLAPStatus close() { + Status close() { _ready = false; - return OLAP_SUCCESS; + return Status::OK(); } bool eof() { return _eof; } bool is_fill_tuple() { return _fill_tuple; } MemPool* mem_pool() { return _mem_pool.get(); } private: - OLAPStatus fill_field_row(RowCursorCell* dst, const char* src, bool src_null, MemPool* mem_pool, + Status fill_field_row(RowCursorCell* dst, const char* src, bool src_null, MemPool* mem_pool, FieldType type); bool _ready; bool _eof; diff --git a/be/src/olap/reader.cpp b/be/src/olap/reader.cpp index ddab183de4..05a1104c77 100644 --- a/be/src/olap/reader.cpp +++ b/be/src/olap/reader.cpp @@ -105,11 +105,11 @@ TabletReader::~TabletReader() { } } -OLAPStatus TabletReader::init(const ReaderParams& read_params) { +Status TabletReader::init(const ReaderParams& read_params) { _predicate_mem_pool.reset(new MemPool("TabletReader:" + read_params.tablet->full_name())); - OLAPStatus res = _init_params(read_params); - if (res != OLAP_SUCCESS) { + Status res = _init_params(read_params); + if (!res.ok()) { LOG(WARNING) << "fail to init reader when init params. res:" << res << ", tablet_id:" << read_params.tablet->tablet_id() << ", schema_hash:" << read_params.tablet->schema_hash() @@ -144,12 +144,12 @@ bool TabletReader::_optimize_for_single_rowset( return !has_overlapping && nonoverlapping_count == 1 && !has_delete_rowset; } -OLAPStatus TabletReader::_capture_rs_readers(const ReaderParams& read_params, - std::vector* valid_rs_readers) { +Status TabletReader::_capture_rs_readers(const ReaderParams& read_params, + std::vector* valid_rs_readers) { const std::vector* rs_readers = &read_params.rs_readers; if (rs_readers->empty()) { LOG(WARNING) << "fail to acquire data sources. tablet=" << _tablet->full_name(); - return OLAP_ERR_VERSION_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_WRITE_PROTOBUF_ERROR); } bool eof = false; @@ -184,7 +184,7 @@ OLAPStatus TabletReader::_capture_rs_readers(const ReaderParams& read_params, } if (eof) { - return OLAP_SUCCESS; + return Status::OK(); } bool need_ordered_result = true; @@ -224,10 +224,10 @@ OLAPStatus TabletReader::_capture_rs_readers(const ReaderParams& read_params, *valid_rs_readers = *rs_readers; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus TabletReader::_init_params(const ReaderParams& read_params) { +Status TabletReader::_init_params(const ReaderParams& read_params) { read_params.check_validation(); _direct_mode = read_params.direct_mode; @@ -239,20 +239,20 @@ OLAPStatus TabletReader::_init_params(const ReaderParams& read_params) { _init_conditions_param(read_params); _init_load_bf_columns(read_params); - OLAPStatus res = _init_delete_condition(read_params); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("fail to init delete param. [res=%d]", res); + Status res = _init_delete_condition(read_params); + if (!res.ok()) { + LOG(WARNING) << "fail to init delete param. res = " << res; return res; } res = _init_return_columns(read_params); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("fail to init return columns. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to init return columns. res = " << res; return res; } res = _init_keys_param(read_params); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to init keys param. res=" << res; return res; } @@ -276,7 +276,7 @@ OLAPStatus TabletReader::_init_params(const ReaderParams& read_params) { return res; } -OLAPStatus TabletReader::_init_return_columns(const ReaderParams& read_params) { +Status TabletReader::_init_return_columns(const ReaderParams& read_params) { if (read_params.reader_type == READER_QUERY) { _return_columns = read_params.return_columns; _tablet_columns_convert_to_null_set = read_params.tablet_columns_convert_to_null_set; @@ -322,12 +322,12 @@ OLAPStatus TabletReader::_init_return_columns(const ReaderParams& read_params) { } else { OLAP_LOG_WARNING("fail to init return columns. [reader_type=%d return_columns_size=%u]", read_params.reader_type, read_params.return_columns.size()); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } std::sort(_key_cids.begin(), _key_cids.end(), std::greater()); - return OLAP_SUCCESS; + return Status::OK(); } void TabletReader::_init_seek_columns() { @@ -350,9 +350,9 @@ void TabletReader::_init_seek_columns() { } } -OLAPStatus TabletReader::_init_keys_param(const ReaderParams& read_params) { +Status TabletReader::_init_keys_param(const ReaderParams& read_params) { if (read_params.start_key.empty()) { - return OLAP_SUCCESS; + return Status::OK(); } _keys_param.start_key_include = read_params.start_key_include; @@ -368,7 +368,7 @@ OLAPStatus TabletReader::_init_keys_param(const ReaderParams& read_params) { << "Input param are invalid. Column count is bigger than num_columns of schema. " << "column_count=" << scan_key_size << ", schema.num_columns=" << _tablet->tablet_schema().num_columns(); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } std::vector columns(scan_key_size); @@ -381,19 +381,19 @@ OLAPStatus TabletReader::_init_keys_param(const ReaderParams& read_params) { if (read_params.start_key[i].size() != scan_key_size) { OLAP_LOG_WARNING("The start_key.at(%ld).size == %ld, not equals the %ld", i, read_params.start_key[i].size(), scan_key_size); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } - OLAPStatus res = _keys_param.start_keys[i].init_scan_key( + Status res = _keys_param.start_keys[i].init_scan_key( _tablet->tablet_schema(), read_params.start_key[i].values(), schema); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("fail to init row cursor. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to init row cursor. res = " << res; return res; } res = _keys_param.start_keys[i].from_tuple(read_params.start_key[i]); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("fail to init row cursor from Keys. [res=%d key_index=%ld]", res, i); + if (!res.ok()) { + LOG(WARNING) << "fail to init row cursor from Keys. res=" << res << "key_index=" << i; return res; } } @@ -405,26 +405,26 @@ OLAPStatus TabletReader::_init_keys_param(const ReaderParams& read_params) { if (read_params.end_key[i].size() != scan_key_size) { OLAP_LOG_WARNING("The end_key.at(%ld).size == %ld, not equals the %ld", i, read_params.end_key[i].size(), scan_key_size); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } - OLAPStatus res = _keys_param.end_keys[i].init_scan_key( + Status res = _keys_param.end_keys[i].init_scan_key( _tablet->tablet_schema(), read_params.end_key[i].values(), schema); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("fail to init row cursor. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to init row cursor. res = " << res; return res; } res = _keys_param.end_keys[i].from_tuple(read_params.end_key[i]); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("fail to init row cursor from Keys. [res=%d key_index=%ld]", res, i); + if (!res.ok()) { + LOG(WARNING) << "fail to init row cursor from Keys. res=" << res << " key_index=" << i; return res; } } //TODO:check the valid of start_key and end_key.(eg. start_key <= end_key) - return OLAP_SUCCESS; + return Status::OK(); } void TabletReader::_init_conditions_param(const ReaderParams& read_params) { @@ -439,11 +439,11 @@ void TabletReader::_init_conditions_param(const ReaderParams& read_params) { _value_col_predicates.push_back(predicate); } else { _col_predicates.push_back(predicate); - OLAPStatus status = _conditions.append_condition(condition); - DCHECK_EQ(OLAP_SUCCESS, status); + Status status = _conditions.append_condition(condition); + DCHECK_EQ(Status::OK(), status); } - OLAPStatus status = _all_conditions.append_condition(condition); - DCHECK_EQ(OLAP_SUCCESS, status); + Status status = _all_conditions.append_condition(condition); + DCHECK_EQ(Status::OK(), status); } } @@ -816,11 +816,11 @@ void TabletReader::_init_load_bf_columns(const ReaderParams& read_params, Condit } } -OLAPStatus TabletReader::_init_delete_condition(const ReaderParams& read_params) { +Status TabletReader::_init_delete_condition(const ReaderParams& read_params) { if (read_params.reader_type == READER_CUMULATIVE_COMPACTION) { - return OLAP_SUCCESS; + return Status::OK(); } - OLAPStatus ret; + Status ret; { std::shared_lock rdlock(_tablet->get_header_lock()); ret = _delete_handler.init(_tablet->tablet_schema(), _tablet->delete_predicates(), diff --git a/be/src/olap/reader.h b/be/src/olap/reader.h index 6b9ab40135..1c68834349 100644 --- a/be/src/olap/reader.h +++ b/be/src/olap/reader.h @@ -108,13 +108,13 @@ public: virtual ~TabletReader(); // Initialize TabletReader with tablet, data version and fetch range. - virtual OLAPStatus init(const ReaderParams& read_params); + virtual Status init(const ReaderParams& read_params); // Read next row with aggregation. // Return OLAP_SUCCESS and set `*eof` to false when next row is read into `row_cursor`. // Return OLAP_SUCCESS and set `*eof` to true when no more rows can be read. // Return others when unexpected error happens. - virtual OLAPStatus next_row_with_aggregation(RowCursor* row_cursor, MemPool* mem_pool, + virtual Status next_row_with_aggregation(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof) = 0; // Read next block with aggregation. @@ -122,9 +122,9 @@ public: // Return OLAP_SUCCESS and set `*eof` to true when no more rows can be read. // Return others when unexpected error happens. // TODO: Rethink here we still need mem_pool and agg_pool? - virtual OLAPStatus next_block_with_aggregation(vectorized::Block* block, MemPool* mem_pool, + virtual Status next_block_with_aggregation(vectorized::Block* block, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof) { - return OLAP_ERR_READER_INITIALIZE_ERROR; + return Status::OLAPInternalError(OLAP_ERR_READER_INITIALIZE_ERROR); } uint64_t merged_rows() const { return _merged_rows; } @@ -146,14 +146,14 @@ protected: friend class vectorized::VCollectIterator; friend class DeleteHandler; - OLAPStatus _init_params(const ReaderParams& read_params); + Status _init_params(const ReaderParams& read_params); - OLAPStatus _capture_rs_readers(const ReaderParams& read_params, + Status _capture_rs_readers(const ReaderParams& read_params, std::vector* valid_rs_readers); bool _optimize_for_single_rowset(const std::vector& rs_readers); - OLAPStatus _init_keys_param(const ReaderParams& read_params); + Status _init_keys_param(const ReaderParams& read_params); void _init_conditions_param(const ReaderParams& read_params); @@ -175,9 +175,9 @@ protected: ColumnPredicate* _parse_to_predicate( const std::pair>& bloom_filter); - OLAPStatus _init_delete_condition(const ReaderParams& read_params); + Status _init_delete_condition(const ReaderParams& read_params); - OLAPStatus _init_return_columns(const ReaderParams& read_params); + Status _init_return_columns(const ReaderParams& read_params); void _init_seek_columns(); void _init_load_bf_columns(const ReaderParams& read_params); diff --git a/be/src/olap/row_block.cpp b/be/src/olap/row_block.cpp index 92c95cbd12..84b43d3f0e 100644 --- a/be/src/olap/row_block.cpp +++ b/be/src/olap/row_block.cpp @@ -53,16 +53,16 @@ void RowBlock::init(const RowBlockInfo& block_info) { _mem_buf = new char[_mem_buf_bytes]; } -OLAPStatus RowBlock::finalize(uint32_t row_num) { +Status RowBlock::finalize(uint32_t row_num) { if (row_num > _capacity) { OLAP_LOG_WARNING( "Input row num is larger than internal row num." "[row_num=%u; _info.row_num=%u]", row_num, _info.row_num); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } _info.row_num = row_num; - return OLAP_SUCCESS; + return Status::OK(); } void RowBlock::clear() { diff --git a/be/src/olap/row_block.h b/be/src/olap/row_block.h index 122ee01b8a..bc7cb28164 100644 --- a/be/src/olap/row_block.h +++ b/be/src/olap/row_block.h @@ -79,7 +79,7 @@ public: } // called when finished fill this row_block - OLAPStatus finalize(uint32_t row_num); + Status finalize(uint32_t row_num); const uint32_t row_num() const { return _info.row_num; } const RowBlockInfo& row_block_info() const { return _info; } diff --git a/be/src/olap/row_cursor.cpp b/be/src/olap/row_cursor.cpp index 808aff3980..b451355fc2 100644 --- a/be/src/olap/row_cursor.cpp +++ b/be/src/olap/row_cursor.cpp @@ -42,12 +42,12 @@ RowCursor::~RowCursor() { } } -OLAPStatus RowCursor::_init(const std::vector& columns) { +Status RowCursor::_init(const std::vector& columns) { _variable_len = 0; for (auto cid : columns) { if (_schema->column(cid) == nullptr) { LOG(WARNING) << "Fail to create field."; - return OLAP_ERR_INIT_FAILED; + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } _variable_len += column_schema(cid)->get_variable_len(); if (_schema->column(cid)->type() == OLAP_FIELD_TYPE_STRING) { @@ -59,26 +59,26 @@ OLAPStatus RowCursor::_init(const std::vector& columns) { _fixed_buf = new (nothrow) char[_fixed_len](); if (_fixed_buf == nullptr) { LOG(WARNING) << "Fail to malloc _fixed_buf."; - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } _owned_fixed_buf = _fixed_buf; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus RowCursor::_init(const std::shared_ptr& shared_schema, +Status RowCursor::_init(const std::shared_ptr& shared_schema, const std::vector& columns) { _schema.reset(new Schema(*shared_schema.get())); return _init(columns); } -OLAPStatus RowCursor::_init(const std::vector& schema, +Status RowCursor::_init(const std::vector& schema, const std::vector& columns) { _schema.reset(new Schema(schema, columns)); return _init(columns); } -OLAPStatus RowCursor::_init_scan_key(const TabletSchema& schema, +Status RowCursor::_init_scan_key(const TabletSchema& schema, const std::vector& scan_keys) { // NOTE: cid equal with column index // Hyperloglog cannot be key, no need to handle it @@ -123,24 +123,24 @@ OLAPStatus RowCursor::_init_scan_key(const TabletSchema& schema, } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus RowCursor::init(const TabletSchema& schema) { +Status RowCursor::init(const TabletSchema& schema) { return init(schema.columns(), schema.num_columns()); } -OLAPStatus RowCursor::init(const std::vector& schema) { +Status RowCursor::init(const std::vector& schema) { return init(schema, schema.size()); } -OLAPStatus RowCursor::init(const TabletSchema& schema, size_t column_count) { +Status RowCursor::init(const TabletSchema& schema, size_t column_count) { if (column_count > schema.num_columns()) { LOG(WARNING) << "Input param are invalid. Column count is bigger than num_columns of schema. " << "column_count=" << column_count << ", schema.num_columns=" << schema.num_columns(); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } std::vector columns; @@ -148,15 +148,15 @@ OLAPStatus RowCursor::init(const TabletSchema& schema, size_t column_count) { columns.push_back(i); } RETURN_NOT_OK(_init(schema.columns(), columns)); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus RowCursor::init(const std::vector& schema, size_t column_count) { +Status RowCursor::init(const std::vector& schema, size_t column_count) { if (column_count > schema.size()) { LOG(WARNING) << "Input param are invalid. Column count is bigger than num_columns of schema. " << "column_count=" << column_count << ", schema.num_columns=" << schema.size(); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } std::vector columns; @@ -164,15 +164,15 @@ OLAPStatus RowCursor::init(const std::vector& schema, size_t colum columns.push_back(i); } RETURN_NOT_OK(_init(schema, columns)); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus RowCursor::init(const TabletSchema& schema, const std::vector& columns) { +Status RowCursor::init(const TabletSchema& schema, const std::vector& columns) { RETURN_NOT_OK(_init(schema.columns(), columns)); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus RowCursor::init_scan_key(const TabletSchema& schema, +Status RowCursor::init_scan_key(const TabletSchema& schema, const std::vector& scan_keys) { size_t scan_key_size = scan_keys.size(); if (scan_key_size > schema.num_columns()) { @@ -180,7 +180,7 @@ OLAPStatus RowCursor::init_scan_key(const TabletSchema& schema, << "Input param are invalid. Column count is bigger than num_columns of schema. " << "column_count=" << scan_key_size << ", schema.num_columns=" << schema.num_columns(); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } std::vector columns(scan_key_size); @@ -191,7 +191,7 @@ OLAPStatus RowCursor::init_scan_key(const TabletSchema& schema, return _init_scan_key(schema, scan_keys); } -OLAPStatus RowCursor::init_scan_key(const TabletSchema& schema, +Status RowCursor::init_scan_key(const TabletSchema& schema, const std::vector& scan_keys, const std::shared_ptr& shared_schema) { size_t scan_key_size = scan_keys.size(); @@ -207,11 +207,11 @@ OLAPStatus RowCursor::init_scan_key(const TabletSchema& schema, } // TODO(yingchun): parameter 'const TabletSchema& schema' is not used -OLAPStatus RowCursor::allocate_memory_for_string_type(const TabletSchema& schema) { +Status RowCursor::allocate_memory_for_string_type(const TabletSchema& schema) { // allocate memory for string type(char, varchar, hll, array) // The memory allocated in this function is used in aggregate and copy function if (_variable_len == 0 && _string_field_count == 0) { - return OLAP_SUCCESS; + return Status::OK(); } DCHECK(_variable_buf == nullptr) << "allocate memory twice"; RETURN_NOT_OK(_alloc_buf()); @@ -231,20 +231,20 @@ OLAPStatus RowCursor::allocate_memory_for_string_type(const TabletSchema& schema variable_ptr = column_schema(cid)->allocate_memory(fixed_ptr + 1, variable_ptr); } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus RowCursor::build_max_key() { +Status RowCursor::build_max_key() { for (auto cid : _schema->column_ids()) { const Field* field = column_schema(cid); char* dest = cell_ptr(cid); field->set_to_max(dest); set_not_null(cid); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus RowCursor::build_min_key() { +Status RowCursor::build_min_key() { for (auto cid : _schema->column_ids()) { const Field* field = column_schema(cid); char* dest = cell_ptr(cid); @@ -252,14 +252,14 @@ OLAPStatus RowCursor::build_min_key() { set_null(cid); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus RowCursor::from_tuple(const OlapTuple& tuple) { +Status RowCursor::from_tuple(const OlapTuple& tuple) { if (tuple.size() != _schema->num_column_ids()) { LOG(WARNING) << "column count does not match. tuple_size=" << tuple.size() << ", field_count=" << _schema->num_column_ids(); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } for (size_t i = 0; i < tuple.size(); ++i) { @@ -271,15 +271,15 @@ OLAPStatus RowCursor::from_tuple(const OlapTuple& tuple) { } set_not_null(cid); char* buf = cell_ptr(cid); - OLAPStatus res = field->from_string(buf, tuple.get_value(i)); - if (res != OLAP_SUCCESS) { + Status res = field->from_string(buf, tuple.get_value(i)); + if (!res.ok()) { LOG(WARNING) << "fail to convert field from string. string=" << tuple.get_value(i) << ", res=" << res; return res; } } - return OLAP_SUCCESS; + return Status::OK(); } OlapTuple RowCursor::to_tuple() const { @@ -323,28 +323,28 @@ std::string RowCursor::to_string() const { return result; } -OLAPStatus RowCursor::_alloc_buf() { +Status RowCursor::_alloc_buf() { // variable_len for null bytes _variable_buf = new (nothrow) char[_variable_len](); if (_variable_buf == nullptr) { OLAP_LOG_WARNING("Fail to malloc _variable_buf."); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } if (_string_field_count > 0) { _long_text_buf = (char**)malloc(_string_field_count * sizeof(char*)); if (_long_text_buf == nullptr) { OLAP_LOG_WARNING("Fail to malloc _long_text_buf."); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } for (int i = 0; i < _string_field_count; ++i) { _long_text_buf[i] = (char*)malloc(DEFAULT_TEXT_LENGTH * sizeof(char)); if (_long_text_buf[i] == nullptr) { OLAP_LOG_WARNING("Fail to malloc _long_text_buf."); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } } } - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/row_cursor.h b/be/src/olap/row_cursor.h index 6c2deab233..8f018eef1a 100644 --- a/be/src/olap/row_cursor.h +++ b/be/src/olap/row_cursor.h @@ -42,26 +42,26 @@ public: ~RowCursor(); // Create a RowCursor based on the schema - OLAPStatus init(const TabletSchema& schema); - OLAPStatus init(const std::vector& schema); + Status init(const TabletSchema& schema); + Status init(const std::vector& schema); // Create a RowCursor based on the first n columns of the schema - OLAPStatus init(const std::vector& schema, size_t column_count); - OLAPStatus init(const TabletSchema& schema, size_t column_count); + Status init(const std::vector& schema, size_t column_count); + Status init(const TabletSchema& schema, size_t column_count); // Create a RowCursor based on the schema and column id list // which is used for the calculation process only uses some discontinuous prefix columns - OLAPStatus init(const TabletSchema& schema, const std::vector& columns); + Status init(const TabletSchema& schema, const std::vector& columns); // Initialize with the size of the key, currently only used when splitting the range of key - OLAPStatus init_scan_key(const TabletSchema& schema, const std::vector& keys); + Status init_scan_key(const TabletSchema& schema, const std::vector& keys); - OLAPStatus init_scan_key(const TabletSchema& schema, + Status init_scan_key(const TabletSchema& schema, const std::vector& keys, const std::shared_ptr& shared_schema); //allocate memory for string type, which include char, varchar, hyperloglog - OLAPStatus allocate_memory_for_string_type(const TabletSchema& schema); + Status allocate_memory_for_string_type(const TabletSchema& schema); RowCursorCell cell(uint32_t cid) const { return RowCursorCell(nullable_cell_ptr(cid)); } @@ -86,7 +86,7 @@ public: column_schema(index)->shallow_copy_content(dst_cell, buf); } // convert and deep copy field content - OLAPStatus convert_from(size_t index, const char* src, const TypeInfo* src_type, + Status convert_from(size_t index, const char* src, const TypeInfo* src_type, MemPool* mem_pool) { char* dest = cell_ptr(index); return column_schema(index)->convert_from(dest, src, src_type, mem_pool); @@ -95,7 +95,7 @@ public: // Deserialize the value of each field from the string array, // Each array item must be a \0 terminated string // and the input string and line cursor need the same number of columns - OLAPStatus from_tuple(const OlapTuple& tuple); + Status from_tuple(const OlapTuple& tuple); // Returns the number of columns in the current row cursor size_t field_count() const { return _schema->column_ids().size(); } @@ -115,8 +115,8 @@ public: } // set max/min for key field in _field_array - OLAPStatus build_max_key(); - OLAPStatus build_min_key(); + Status build_max_key(); + Status build_min_key(); char* get_buf() const { return _fixed_buf; } @@ -148,14 +148,14 @@ public: char* row_ptr() const { return _fixed_buf; } private: - OLAPStatus _init(const std::vector& columns); - OLAPStatus _init(const std::shared_ptr& shared_schema, + Status _init(const std::vector& columns); + Status _init(const std::shared_ptr& shared_schema, const std::vector& columns); // common init function - OLAPStatus _init(const std::vector& schema, const std::vector& columns); - OLAPStatus _alloc_buf(); + Status _init(const std::vector& schema, const std::vector& columns); + Status _alloc_buf(); - OLAPStatus _init_scan_key(const TabletSchema& schema, const std::vector& scan_keys); + Status _init_scan_key(const TabletSchema& schema, const std::vector& scan_keys); std::unique_ptr _schema; diff --git a/be/src/olap/rowset/CMakeLists.txt b/be/src/olap/rowset/CMakeLists.txt index c5e0e39e15..208ff212ea 100644 --- a/be/src/olap/rowset/CMakeLists.txt +++ b/be/src/olap/rowset/CMakeLists.txt @@ -46,3 +46,5 @@ add_library(Rowset STATIC beta_rowset.cpp beta_rowset_reader.cpp beta_rowset_writer.cpp) + +target_compile_options(Rowset PUBLIC "-Wno-error=maybe-uninitialized") diff --git a/be/src/olap/rowset/alpha_rowset.cpp b/be/src/olap/rowset/alpha_rowset.cpp index 9e3ff54092..80a0a5eebf 100644 --- a/be/src/olap/rowset/alpha_rowset.cpp +++ b/be/src/olap/rowset/alpha_rowset.cpp @@ -30,32 +30,32 @@ AlphaRowset::AlphaRowset(const TabletSchema* schema, const FilePathDesc& rowset_ RowsetMetaSharedPtr rowset_meta) : Rowset(schema, rowset_path_desc, std::move(rowset_meta)) {} -OLAPStatus AlphaRowset::do_load(bool use_cache) { +Status AlphaRowset::do_load(bool use_cache) { for (auto& segment_group : _segment_groups) { // validate segment group - if (segment_group->validate() != OLAP_SUCCESS) { + if (segment_group->validate() != Status::OK()) { LOG(WARNING) << "fail to validate segment_group. [version=" << start_version() << "-" << end_version(); // if load segment group failed, rowset init failed - return OLAP_ERR_TABLE_INDEX_VALIDATE_ERROR; + return Status::OLAPInternalError(OLAP_ERR_TABLE_INDEX_VALIDATE_ERROR); } - OLAPStatus res = segment_group->load(use_cache); - if (res != OLAP_SUCCESS) { + Status res = segment_group->load(use_cache); + if (!res.ok()) { LOG(WARNING) << "fail to load segment_group. res=" << res << ", " << "version=" << start_version() << "-" << end_version(); return res; } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus AlphaRowset::create_reader(std::shared_ptr* result) { +Status AlphaRowset::create_reader(std::shared_ptr* result) { result->reset(new AlphaRowsetReader(_schema->num_rows_per_row_block(), std::static_pointer_cast(shared_from_this()))); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus AlphaRowset::remove() { +Status AlphaRowset::remove() { VLOG_NOTICE << "begin to remove files in rowset " << unique_id() << ", version:" << start_version() << "-" << end_version() << ", tabletid:" << _rowset_meta->tablet_id(); for (auto segment_group : _segment_groups) { @@ -64,10 +64,10 @@ OLAPStatus AlphaRowset::remove() { LOG(WARNING) << "delete segment group files failed." << " tablet id:" << segment_group->get_tablet_id() << ", rowset path:" << segment_group->rowset_path_prefix(); - return OLAP_ERR_ROWSET_DELETE_FILE_FAILED; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_DELETE_FILE_FAILED); } } - return OLAP_SUCCESS; + return Status::OK(); } void AlphaRowset::make_visible_extra(Version version) { @@ -88,70 +88,70 @@ void AlphaRowset::make_visible_extra(Version version) { } } -OLAPStatus AlphaRowset::link_files_to(const FilePathDesc& dir_desc, RowsetId new_rowset_id) { +Status AlphaRowset::link_files_to(const FilePathDesc& dir_desc, RowsetId new_rowset_id) { for (auto& segment_group : _segment_groups) { auto status = segment_group->link_segments_to_path(dir_desc.filepath, new_rowset_id); - if (status != OLAP_SUCCESS) { + if (!status.ok()) { LOG(WARNING) << "create hard links failed for segment group:" << segment_group->segment_group_id(); return status; } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus AlphaRowset::copy_files_to(const std::string& dir) { +Status AlphaRowset::copy_files_to(const std::string& dir) { for (auto& segment_group : _segment_groups) { - OLAPStatus status = segment_group->copy_files_to(dir); - if (status != OLAP_SUCCESS) { + Status status = segment_group->copy_files_to(dir); + if (!status.ok()) { LOG(WARNING) << "copy files failed for segment group." << " segment_group_id:" << segment_group->segment_group_id() << ", dest_path:" << dir; return status; } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus AlphaRowset::convert_from_old_files(const std::string& snapshot_path, +Status AlphaRowset::convert_from_old_files(const std::string& snapshot_path, std::vector* success_files) { for (auto& segment_group : _segment_groups) { - OLAPStatus status = segment_group->convert_from_old_files(snapshot_path, success_files); - if (status != OLAP_SUCCESS) { + Status status = segment_group->convert_from_old_files(snapshot_path, success_files); + if (!status.ok()) { LOG(WARNING) << "create hard links failed for segment group:" << segment_group->segment_group_id(); return status; } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus AlphaRowset::convert_to_old_files(const std::string& snapshot_path, +Status AlphaRowset::convert_to_old_files(const std::string& snapshot_path, std::vector* success_files) { for (auto& segment_group : _segment_groups) { - OLAPStatus status = segment_group->convert_to_old_files(snapshot_path, success_files); - if (status != OLAP_SUCCESS) { + Status status = segment_group->convert_to_old_files(snapshot_path, success_files); + if (!status.ok()) { LOG(WARNING) << "create hard links failed for segment group:" << segment_group->segment_group_id(); return status; } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus AlphaRowset::remove_old_files(std::vector* files_to_remove) { +Status AlphaRowset::remove_old_files(std::vector* files_to_remove) { for (auto& segment_group : _segment_groups) { - OLAPStatus status = segment_group->remove_old_files(files_to_remove); - if (status != OLAP_SUCCESS) { + Status status = segment_group->remove_old_files(files_to_remove); + if (!status.ok()) { LOG(WARNING) << "remove old files failed for segment group:" << segment_group->segment_group_id(); return status; } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus AlphaRowset::split_range(const RowCursor& start_key, const RowCursor& end_key, +Status AlphaRowset::split_range(const RowCursor& start_key, const RowCursor& end_key, uint64_t request_block_row_count, size_t key_num, std::vector* ranges) { if (key_num > _schema->num_short_key_columns()) { @@ -160,7 +160,7 @@ OLAPStatus AlphaRowset::split_range(const RowCursor& start_key, const RowCursor& // just use VLOG to avoid too many warning logs. VLOG_NOTICE << "key num " << key_num << " should less than or equal to short key column number: " << _schema->num_short_key_columns(); - return OLAP_ERR_INVALID_SCHEMA; + return Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA); } EntrySlice entry; RowBlockPosition start_pos; @@ -175,27 +175,26 @@ OLAPStatus AlphaRowset::split_range(const RowCursor& start_key, const RowCursor& << "-" << end_version() << ". tablet: " << rowset_meta()->tablet_id(); ranges->emplace_back(start_key.to_tuple()); ranges->emplace_back(end_key.to_tuple()); - return OLAP_SUCCESS; + return Status::OK(); } uint64_t expected_rows = request_block_row_count / largest_segment_group->current_num_rows_per_row_block(); if (expected_rows == 0) { LOG(WARNING) << "expected_rows less than 1. [request_block_row_count = " << request_block_row_count << "]"; - return OLAP_ERR_INVALID_SCHEMA; + return Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA); } // find the start position of start key RowCursor helper_cursor; - if (helper_cursor.init(*_schema, key_num) != OLAP_SUCCESS) { + if (helper_cursor.init(*_schema, key_num) != Status::OK()) { LOG(WARNING) << "fail to parse strings to key with RowCursor type."; - return OLAP_ERR_INVALID_SCHEMA; + return Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA); } - if (largest_segment_group->find_short_key(start_key, &helper_cursor, false, &start_pos) != - OLAP_SUCCESS) { - if (largest_segment_group->find_first_row_block(&start_pos) != OLAP_SUCCESS) { + if (!largest_segment_group->find_short_key(start_key, &helper_cursor, false, &start_pos)) { + if (!largest_segment_group->find_first_row_block(&start_pos)) { LOG(WARNING) << "fail to get first block pos"; - return OLAP_ERR_TABLE_INDEX_FIND_ERROR; + return Status::OLAPInternalError(OLAP_ERR_TABLE_INDEX_FIND_ERROR); } } @@ -203,25 +202,24 @@ OLAPStatus AlphaRowset::split_range(const RowCursor& start_key, const RowCursor& VLOG_NOTICE << "start_pos=" << start_pos.segment << ", " << start_pos.index_offset; //find last row_block is end_key is given, or using last_row_block - if (largest_segment_group->find_short_key(end_key, &helper_cursor, false, &end_pos) != - OLAP_SUCCESS) { - if (largest_segment_group->find_last_row_block(&end_pos) != OLAP_SUCCESS) { + if (!largest_segment_group->find_short_key(end_key, &helper_cursor, false, &end_pos)) { + if (!largest_segment_group->find_last_row_block(&end_pos)) { LOG(WARNING) << "fail find last row block."; - return OLAP_ERR_TABLE_INDEX_FIND_ERROR; + return Status::OLAPInternalError(OLAP_ERR_TABLE_INDEX_FIND_ERROR); } } VLOG_NOTICE << "end_pos=" << end_pos.segment << ", " << end_pos.index_offset; //get rows between first and last - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); RowCursor cur_start_key; RowCursor last_start_key; - if (cur_start_key.init(*_schema, key_num) != OLAP_SUCCESS || - last_start_key.init(*_schema, key_num) != OLAP_SUCCESS) { + if (cur_start_key.init(*_schema, key_num) != Status::OK() || + last_start_key.init(*_schema, key_num) != Status::OK()) { LOG(WARNING) << "fail to init cursor"; - return OLAP_ERR_INIT_FAILED; + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } std::vector cids; @@ -229,9 +227,9 @@ OLAPStatus AlphaRowset::split_range(const RowCursor& start_key, const RowCursor& cids.push_back(cid); } - if (largest_segment_group->get_row_block_entry(start_pos, &entry) != OLAP_SUCCESS) { + if (largest_segment_group->get_row_block_entry(start_pos, &entry) != Status::OK()) { LOG(WARNING) << "get block entry failed."; - return OLAP_ERR_ROWBLOCK_FIND_ROW_EXCEPTION; + return Status::OLAPInternalError(OLAP_ERR_ROWBLOCK_FIND_ROW_EXCEPTION); } cur_start_key.attach(entry.data); @@ -242,16 +240,16 @@ OLAPStatus AlphaRowset::split_range(const RowCursor& start_key, const RowCursor& while (end_pos > step_pos) { res = largest_segment_group->advance_row_block(expected_rows, &step_pos); - if (res == OLAP_ERR_INDEX_EOF || !(end_pos > step_pos)) { + if (res == Status::OLAPInternalError(OLAP_ERR_INDEX_EOF) || !(end_pos > step_pos)) { break; - } else if (res != OLAP_SUCCESS) { + } else if (!res.ok()) { LOG(WARNING) << "advance_row_block failed."; - return OLAP_ERR_ROWBLOCK_FIND_ROW_EXCEPTION; + return Status::OLAPInternalError(OLAP_ERR_ROWBLOCK_FIND_ROW_EXCEPTION); } - if (largest_segment_group->get_row_block_entry(step_pos, &entry) != OLAP_SUCCESS) { + if (largest_segment_group->get_row_block_entry(step_pos, &entry) != Status::OK()) { LOG(WARNING) << "get block entry failed."; - return OLAP_ERR_ROWBLOCK_FIND_ROW_EXCEPTION; + return Status::OLAPInternalError(OLAP_ERR_ROWBLOCK_FIND_ROW_EXCEPTION); } cur_start_key.attach(entry.data); @@ -263,7 +261,7 @@ OLAPStatus AlphaRowset::split_range(const RowCursor& start_key, const RowCursor& } ranges->emplace_back(end_key.to_tuple()); - return OLAP_SUCCESS; + return Status::OK(); } bool AlphaRowset::check_path(const std::string& path) { @@ -297,7 +295,7 @@ bool AlphaRowset::check_file_exist() { return true; } -OLAPStatus AlphaRowset::init() { +Status AlphaRowset::init() { std::vector segment_group_metas; AlphaRowsetMetaSharedPtr _alpha_rowset_meta = std::dynamic_pointer_cast(_rowset_meta); @@ -318,7 +316,7 @@ OLAPStatus AlphaRowset::init() { if (segment_group == nullptr) { LOG(WARNING) << "fail to create olap segment_group. rowset_id='" << _rowset_meta->rowset_id(); - return OLAP_ERR_CREATE_FILE_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CREATE_FILE_ERROR); } if (segment_group_meta.has_empty()) { segment_group->set_empty(segment_group_meta.empty()); @@ -340,7 +338,7 @@ OLAPStatus AlphaRowset::init() { << "zone_maps_size=" << zone_maps_size << ", " << "num_key_columns=" << _schema->num_key_columns() << ", " << "num_columns=" << _schema->num_columns(); - return OLAP_ERR_TABLE_INDEX_VALIDATE_ERROR; + return Status::OLAPInternalError(OLAP_ERR_TABLE_INDEX_VALIDATE_ERROR); } // Before 0.12.10, the zone map columns number in duplicate/unique table is the same with the key column numbers, // but after 0.12.10 we build zone map for duplicate table value column, after 0.14 we build zone map for unique @@ -364,8 +362,8 @@ OLAPStatus AlphaRowset::init() { null_vec[j] = false; } } - OLAPStatus status = segment_group->add_zone_maps(zone_map_strings, null_vec); - if (status != OLAP_SUCCESS) { + Status status = segment_group->add_zone_maps(zone_map_strings, null_vec); + if (!status.ok()) { LOG(WARNING) << "segment group add column statistics failed, status:" << status; return status; } @@ -375,9 +373,9 @@ OLAPStatus AlphaRowset::init() { if (_is_cumulative && _segment_groups.size() > 1) { LOG(WARNING) << "invalid segment group meta for cumulative rowset. segment group size:" << _segment_groups.size(); - return OLAP_ERR_ENGINE_LOAD_INDEX_TABLE_ERROR; + return Status::OLAPInternalError(OLAP_ERR_ENGINE_LOAD_INDEX_TABLE_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } std::shared_ptr AlphaRowset::_segment_group_with_largest_size() { diff --git a/be/src/olap/rowset/alpha_rowset.h b/be/src/olap/rowset/alpha_rowset.h index 8a5b4d9dc5..d902e0ca97 100644 --- a/be/src/olap/rowset/alpha_rowset.h +++ b/be/src/olap/rowset/alpha_rowset.h @@ -39,25 +39,25 @@ class AlphaRowset : public Rowset { public: virtual ~AlphaRowset() {} - OLAPStatus create_reader(std::shared_ptr* result) override; + Status create_reader(std::shared_ptr* result) override; - OLAPStatus split_range(const RowCursor& start_key, const RowCursor& end_key, + Status split_range(const RowCursor& start_key, const RowCursor& end_key, uint64_t request_block_row_count, size_t key_num, std::vector* ranges) override; - OLAPStatus remove() override; + Status remove() override; - OLAPStatus link_files_to(const FilePathDesc& dir_desc, RowsetId new_rowset_id) override; + Status link_files_to(const FilePathDesc& dir_desc, RowsetId new_rowset_id) override; - OLAPStatus copy_files_to(const std::string& dir) override; + Status copy_files_to(const std::string& dir) override; - OLAPStatus convert_from_old_files(const std::string& snapshot_path, + Status convert_from_old_files(const std::string& snapshot_path, std::vector* success_files); - OLAPStatus convert_to_old_files(const std::string& snapshot_path, + Status convert_to_old_files(const std::string& snapshot_path, std::vector* success_files); - OLAPStatus remove_old_files(std::vector* files_to_remove) override; + Status remove_old_files(std::vector* files_to_remove) override; bool check_path(const std::string& path) override; @@ -70,9 +70,9 @@ protected: RowsetMetaSharedPtr rowset_meta); // init segment groups - OLAPStatus init() override; + Status init() override; - OLAPStatus do_load(bool use_cache) override; + Status do_load(bool use_cache) override; void do_close() override {} diff --git a/be/src/olap/rowset/alpha_rowset_reader.cpp b/be/src/olap/rowset/alpha_rowset_reader.cpp index e883680f50..57aa9c0758 100644 --- a/be/src/olap/rowset/alpha_rowset_reader.cpp +++ b/be/src/olap/rowset/alpha_rowset_reader.cpp @@ -46,10 +46,10 @@ AlphaRowsetReader::~AlphaRowsetReader() { _sequential_ctxs.clear(); } -OLAPStatus AlphaRowsetReader::init(RowsetReaderContext* read_context) { +Status AlphaRowsetReader::init(RowsetReaderContext* read_context) { RETURN_NOT_OK(_rowset->load()); if (read_context == nullptr) { - return OLAP_ERR_INIT_FAILED; + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } _current_read_context = read_context; if (_current_read_context->stats != nullptr) { @@ -69,7 +69,7 @@ OLAPStatus AlphaRowsetReader::init(RowsetReaderContext* read_context) { _read_block.reset(new (std::nothrow) RowBlock(_current_read_context->tablet_schema)); if (_read_block == nullptr) { LOG(WARNING) << "new row block failed in reader"; - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } RowBlockInfo block_info; block_info.row_num = _current_read_context->tablet_schema->num_rows_per_row_block(); @@ -78,7 +78,7 @@ OLAPStatus AlphaRowsetReader::init(RowsetReaderContext* read_context) { _dst_cursor = new (std::nothrow) RowCursor(); if (_dst_cursor == nullptr) { LOG(WARNING) << "allocate memory for row cursor failed"; - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } if (_current_read_context->reader_type == READER_ALTER_TABLE) { // Upon rollup/alter table, seek_columns is nullptr. @@ -102,10 +102,10 @@ OLAPStatus AlphaRowsetReader::init(RowsetReaderContext* read_context) { _next_block = &AlphaRowsetReader::_union_block; _cur_ctx = *(_sequential_ctxs.begin()); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus AlphaRowsetReader::next_block(RowBlock** block) { +Status AlphaRowsetReader::next_block(RowBlock** block) { return (this->*_next_block)(block); } @@ -121,46 +121,46 @@ int64_t AlphaRowsetReader::filtered_rows() { return _stats->rows_del_filtered; } -OLAPStatus AlphaRowsetReader::_union_block(RowBlock** block) { +Status AlphaRowsetReader::_union_block(RowBlock** block) { while (_cur_ctx != nullptr) { // union block only use one block to store - OLAPStatus status = _pull_next_block(_cur_ctx); - if (status == OLAP_ERR_DATA_EOF) { + Status status = _pull_next_block(_cur_ctx); + if (status == Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { delete _cur_ctx; _cur_ctx = nullptr; _sequential_ctxs.pop_front(); if (!_sequential_ctxs.empty()) { _cur_ctx = *(_sequential_ctxs.begin()); } - } else if (status != OLAP_SUCCESS) { + } else if (!status.ok()) { return status; } else { (*block) = _cur_ctx->row_block; - return OLAP_SUCCESS; + return Status::OK(); } } if (_sequential_ctxs.empty()) { *block = nullptr; - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus AlphaRowsetReader::_merge_block(RowBlock** block) { +Status AlphaRowsetReader::_merge_block(RowBlock** block) { // Row among different segment groups may overlap with each other. // Iterate all row_blocks to fetch min row each round. - OLAPStatus status = OLAP_SUCCESS; + Status status = Status::OK(); _read_block->clear(); size_t num_rows_in_block = 0; while (_read_block->pos() < _num_rows_per_row_block) { // 1. Read one row from heap RowCursor* row_cursor = nullptr; status = _pull_next_row_for_merge_rowset_v2(&row_cursor); - if (status == OLAP_ERR_DATA_EOF && _read_block->pos() > 0) { - status = OLAP_SUCCESS; + if (status == Status::OLAPInternalError(OLAP_ERR_DATA_EOF) && _read_block->pos() > 0) { + status = Status::OK(); break; - } else if (status != OLAP_SUCCESS) { + } else if (!status.ok()) { return status; } @@ -193,31 +193,31 @@ OLAPStatus AlphaRowsetReader::_merge_block(RowBlock** block) { return status; } -OLAPStatus AlphaRowsetReader::_init_merge_heap() { +Status AlphaRowsetReader::_init_merge_heap() { DCHECK(_merge_heap.empty()); DCHECK(!_sequential_ctxs.empty()); for (auto merge_ctx : _sequential_ctxs) { RETURN_NOT_OK(_update_merge_ctx_and_build_merge_heap(merge_ctx)); } _sequential_ctxs.clear(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus AlphaRowsetReader::_update_merge_ctx_and_build_merge_heap(AlphaMergeContext* merge_ctx) { +Status AlphaRowsetReader::_update_merge_ctx_and_build_merge_heap(AlphaMergeContext* merge_ctx) { if (OLAP_UNLIKELY(merge_ctx->is_eof)) { // nothing in this merge ctx, release and return delete merge_ctx; - return OLAP_SUCCESS; + return Status::OK(); } // get next row block of this merge ctx if (merge_ctx->row_block == nullptr || !merge_ctx->row_block->has_remaining()) { - OLAPStatus status = _pull_next_block(merge_ctx); - if (status == OLAP_ERR_DATA_EOF) { + Status status = _pull_next_block(merge_ctx); + if (status == Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { // nothing in this merge ctx, release and return delete merge_ctx; - return OLAP_SUCCESS; - } else if (status != OLAP_SUCCESS) { + return Status::OK(); + } else if (!status.ok()) { delete merge_ctx; LOG(WARNING) << "read next row of singleton rowset failed:" << status; return status; @@ -229,10 +229,10 @@ OLAPStatus AlphaRowsetReader::_update_merge_ctx_and_build_merge_heap(AlphaMergeC merge_ctx->row_block->get_row(merge_ctx->row_block->pos(), current_row); _merge_heap.push(merge_ctx); merge_ctx->row_block->pos_inc(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus AlphaRowsetReader::_pull_next_row_for_merge_rowset_v2(RowCursor** row) { +Status AlphaRowsetReader::_pull_next_row_for_merge_rowset_v2(RowCursor** row) { // if _merge_heap is not empty, return the row at top, and insert a new row // from corresponding merge_ctx if (OLAP_LIKELY(!_merge_heap.empty())) { @@ -241,21 +241,21 @@ OLAPStatus AlphaRowsetReader::_pull_next_row_for_merge_rowset_v2(RowCursor** row // Must not rebuild merge_heap in this place. // Because row have not been copied and is a pointer. // If rebuild merge_heap, content in row will be modified. - return OLAP_SUCCESS; + return Status::OK(); } else { // all rows are read - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } } -OLAPStatus AlphaRowsetReader::_pull_next_block(AlphaMergeContext* merge_ctx) { - OLAPStatus status = OLAP_SUCCESS; +Status AlphaRowsetReader::_pull_next_block(AlphaMergeContext* merge_ctx) { + Status status = Status::OK(); if (OLAP_UNLIKELY(merge_ctx->first_read_symbol)) { if (_key_range_size > 0) { status = _pull_first_block(merge_ctx); } else { status = merge_ctx->column_data->get_first_row_block(&(merge_ctx->row_block)); - if (status != OLAP_SUCCESS && status != OLAP_ERR_DATA_EOF) { + if (!status.ok() && status != Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { LOG(WARNING) << "get first row block failed, status:" << status; } } @@ -264,7 +264,7 @@ OLAPStatus AlphaRowsetReader::_pull_next_block(AlphaMergeContext* merge_ctx) { } else { // get next block status = merge_ctx->column_data->get_next_block(&(merge_ctx->row_block)); - if (status == OLAP_ERR_DATA_EOF && _key_range_size > 0) { + if (status == Status::OLAPInternalError(OLAP_ERR_DATA_EOF) && _key_range_size > 0) { // reach the end of one predicate // currently, SegmentReader can only support filter one key range a time // refresh the predicate and continue read @@ -274,8 +274,8 @@ OLAPStatus AlphaRowsetReader::_pull_next_block(AlphaMergeContext* merge_ctx) { return status; } -OLAPStatus AlphaRowsetReader::_pull_first_block(AlphaMergeContext* merge_ctx) { - OLAPStatus status = OLAP_SUCCESS; +Status AlphaRowsetReader::_pull_first_block(AlphaMergeContext* merge_ctx) { + Status status = Status::OK(); merge_ctx->key_range_index++; while (merge_ctx->key_range_index < _key_range_size) { status = merge_ctx->column_data->prepare_block_read( @@ -284,10 +284,10 @@ OLAPStatus AlphaRowsetReader::_pull_first_block(AlphaMergeContext* merge_ctx) { &_current_read_context->upper_bound_keys->at(merge_ctx->key_range_index), _current_read_context->is_upper_keys_included->at(merge_ctx->key_range_index), &(merge_ctx->row_block)); - if (status == OLAP_ERR_DATA_EOF) { + if (status == Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { merge_ctx->key_range_index++; continue; - } else if (status != OLAP_SUCCESS) { + } else if (!status.ok()) { LOG(WARNING) << "prepare block read failed. status=" << status; return status; } else { @@ -296,12 +296,12 @@ OLAPStatus AlphaRowsetReader::_pull_first_block(AlphaMergeContext* merge_ctx) { } if (merge_ctx->key_range_index >= _key_range_size) { merge_ctx->row_block = nullptr; - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } return status; } -OLAPStatus AlphaRowsetReader::_init_merge_ctxs(RowsetReaderContext* read_context) { +Status AlphaRowsetReader::_init_merge_ctxs(RowsetReaderContext* read_context) { if (read_context->reader_type == READER_QUERY) { if (read_context->lower_bound_keys->size() != read_context->is_lower_keys_included->size() || @@ -310,7 +310,7 @@ OLAPStatus AlphaRowsetReader::_init_merge_ctxs(RowsetReaderContext* read_context read_context->is_upper_keys_included->size()) { std::string error_msg = "invalid key range arguments"; LOG(WARNING) << error_msg; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } _key_range_size = read_context->lower_bound_keys->size(); } @@ -320,10 +320,10 @@ OLAPStatus AlphaRowsetReader::_init_merge_ctxs(RowsetReaderContext* read_context for (auto& segment_group : _segment_groups) { std::unique_ptr new_column_data(ColumnData::create(segment_group.get())); - OLAPStatus status = new_column_data->init(); - if (status != OLAP_SUCCESS) { + Status status = new_column_data->init(); + if (!status.ok()) { LOG(WARNING) << "init column data failed"; - return OLAP_ERR_READER_READING_ERROR; + return Status::OLAPInternalError(OLAP_ERR_READER_READING_ERROR); } new_column_data->set_delete_handler(read_context->delete_handler); new_column_data->set_stats(_stats); @@ -382,9 +382,9 @@ OLAPStatus AlphaRowsetReader::_init_merge_ctxs(RowsetReaderContext* read_context if (!_is_segments_overlapping && _sequential_ctxs.size() > 1) { LOG(WARNING) << "invalid column_data for cumulative rowset. column_data size:" << _sequential_ctxs.size(); - return OLAP_ERR_READER_READING_ERROR; + return Status::OLAPInternalError(OLAP_ERR_READER_READING_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } RowsetSharedPtr AlphaRowsetReader::rowset() { diff --git a/be/src/olap/rowset/alpha_rowset_reader.h b/be/src/olap/rowset/alpha_rowset_reader.h index 018d78153c..89e86b404d 100644 --- a/be/src/olap/rowset/alpha_rowset_reader.h +++ b/be/src/olap/rowset/alpha_rowset_reader.h @@ -57,14 +57,14 @@ public: ~AlphaRowsetReader() override; // reader init - OLAPStatus init(RowsetReaderContext* read_context) override; + Status init(RowsetReaderContext* read_context) override; // read next block data // It's ok, because we only get ref here, the block's owner is this reader. - OLAPStatus next_block(RowBlock** block) override; + Status next_block(RowBlock** block) override; - OLAPStatus next_block(vectorized::Block *block) override { - return OLAP_ERR_DATA_EOF; + Status next_block(vectorized::Block *block) override { + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } bool delete_flag() override; @@ -78,26 +78,26 @@ public: RowsetTypePB type() const override { return RowsetTypePB::ALPHA_ROWSET; } private: - OLAPStatus _init_merge_ctxs(RowsetReaderContext* read_context); + Status _init_merge_ctxs(RowsetReaderContext* read_context); - OLAPStatus _union_block(RowBlock** block); - OLAPStatus _merge_block(RowBlock** block); - OLAPStatus _pull_next_block(AlphaMergeContext* merge_ctx); + Status _union_block(RowBlock** block); + Status _merge_block(RowBlock** block); + Status _pull_next_block(AlphaMergeContext* merge_ctx); // Doris will split query predicates to several scan keys // This function is used to fetch block when advancing // current scan key to next scan key. - OLAPStatus _pull_first_block(AlphaMergeContext* merge_ctx); + Status _pull_first_block(AlphaMergeContext* merge_ctx); // merge by priority queue(_merge_heap) - OLAPStatus _pull_next_row_for_merge_rowset_v2(RowCursor** row); + Status _pull_next_row_for_merge_rowset_v2(RowCursor** row); // init the merge heap, this should be call before calling _pull_next_row_for_merge_rowset_v2(); - OLAPStatus _init_merge_heap(); + Status _init_merge_heap(); // update the merge ctx. // 1. get next row block of this ctx, if current row block is empty. // 2. read the current row of the row block and push it to merge heap. // 3. point to the next row of the row block - OLAPStatus _update_merge_ctx_and_build_merge_heap(AlphaMergeContext* merge_ctx); + Status _update_merge_ctx_and_build_merge_heap(AlphaMergeContext* merge_ctx); private: int _num_rows_per_row_block; @@ -111,7 +111,7 @@ private: std::list _sequential_ctxs; std::unique_ptr _read_block; - OLAPStatus (AlphaRowsetReader::*_next_block)(RowBlock** block) = nullptr; + Status (AlphaRowsetReader::*_next_block)(RowBlock** block) = nullptr; RowCursor* _dst_cursor = nullptr; int _key_range_size; diff --git a/be/src/olap/rowset/alpha_rowset_writer.cpp b/be/src/olap/rowset/alpha_rowset_writer.cpp index d3d087bf81..1e0e9c50a8 100644 --- a/be/src/olap/rowset/alpha_rowset_writer.cpp +++ b/be/src/olap/rowset/alpha_rowset_writer.cpp @@ -48,7 +48,7 @@ AlphaRowsetWriter::~AlphaRowsetWriter() { _segment_groups.clear(); } -OLAPStatus AlphaRowsetWriter::init(const RowsetWriterContext& rowset_writer_context) { +Status AlphaRowsetWriter::init(const RowsetWriterContext& rowset_writer_context) { _rowset_writer_context = rowset_writer_context; _current_rowset_meta.reset(new (std::nothrow) AlphaRowsetMeta()); _current_rowset_meta->set_rowset_id(_rowset_writer_context.rowset_id); @@ -70,28 +70,28 @@ OLAPStatus AlphaRowsetWriter::init(const RowsetWriterContext& rowset_writer_cont _current_rowset_meta->set_version(_rowset_writer_context.version); } RETURN_NOT_OK(_init()); - return OLAP_SUCCESS; + return Status::OK(); } template -OLAPStatus AlphaRowsetWriter::_add_row(const RowType& row) { +Status AlphaRowsetWriter::_add_row(const RowType& row) { if (_writer_state != WRITER_INITED) { RETURN_NOT_OK(_init()); } - OLAPStatus status = _column_data_writer->write(row); - if (status != OLAP_SUCCESS) { + Status status = _column_data_writer->write(row); + if (!status.ok()) { std::string error_msg = "add row failed"; LOG(WARNING) << error_msg; return status; } ++_num_rows_written; - return OLAP_SUCCESS; + return Status::OK(); } -template OLAPStatus AlphaRowsetWriter::_add_row(const RowCursor& row); -template OLAPStatus AlphaRowsetWriter::_add_row(const ContiguousRow& row); +template Status AlphaRowsetWriter::_add_row(const RowCursor& row); +template Status AlphaRowsetWriter::_add_row(const ContiguousRow& row); -OLAPStatus AlphaRowsetWriter::add_rowset(RowsetSharedPtr rowset) { +Status AlphaRowsetWriter::add_rowset(RowsetSharedPtr rowset) { _need_column_data_writer = false; // this api is for clone AlphaRowsetSharedPtr alpha_rowset = std::dynamic_pointer_cast(rowset); @@ -109,10 +109,10 @@ OLAPStatus AlphaRowsetWriter::add_rowset(RowsetSharedPtr rowset) { if (rowset->rowset_meta()->has_delete_predicate()) { _current_rowset_meta->set_delete_predicate(rowset->rowset_meta()->delete_predicate()); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus AlphaRowsetWriter::add_rowset_for_linked_schema_change( +Status AlphaRowsetWriter::add_rowset_for_linked_schema_change( RowsetSharedPtr rowset, const SchemaMapping& schema_mapping) { _need_column_data_writer = false; // this api is for LinkedSchemaChange @@ -130,12 +130,12 @@ OLAPStatus AlphaRowsetWriter::add_rowset_for_linked_schema_change( RETURN_NOT_OK(flush()); _num_rows_written += segment_group->num_rows(); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus AlphaRowsetWriter::flush() { +Status AlphaRowsetWriter::flush() { if (_writer_state == WRITER_FLUSHED) { - return OLAP_SUCCESS; + return Status::OK(); } DCHECK(_writer_state == WRITER_INITED); if (_need_column_data_writer) { @@ -144,7 +144,7 @@ OLAPStatus AlphaRowsetWriter::flush() { } SAFE_DELETE(_column_data_writer); _writer_state = WRITER_FLUSHED; - return OLAP_SUCCESS; + return Status::OK(); } RowsetSharedPtr AlphaRowsetWriter::build() { @@ -159,7 +159,7 @@ RowsetSharedPtr AlphaRowsetWriter::build() { } int total_num_segments = 0; for (auto& segment_group : _segment_groups) { - if (segment_group->load() != OLAP_SUCCESS) { + if (segment_group->load() != Status::OK()) { return nullptr; } if (!segment_group->check()) { @@ -223,7 +223,7 @@ RowsetSharedPtr AlphaRowsetWriter::build() { auto status = RowsetFactory::create_rowset(_rowset_writer_context.tablet_schema, _rowset_writer_context.path_desc, _current_rowset_meta, &rowset); - if (status != OLAP_SUCCESS) { + if (!status.ok()) { LOG(WARNING) << "rowset init failed when build new rowset, res=" << status; return nullptr; } @@ -231,22 +231,22 @@ RowsetSharedPtr AlphaRowsetWriter::build() { return rowset; } -OLAPStatus AlphaRowsetWriter::_garbage_collection() { +Status AlphaRowsetWriter::_garbage_collection() { for (auto& segment_group : _segment_groups) { bool ret = segment_group->delete_all_files(); if (!ret) { LOG(WARNING) << "delete segment group files failed." << " tablet id:" << segment_group->get_tablet_id() << ", rowset path:" << segment_group->rowset_path_prefix(); - return OLAP_ERR_ROWSET_DELETE_FILE_FAILED; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_DELETE_FILE_FAILED); } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus AlphaRowsetWriter::_init() { +Status AlphaRowsetWriter::_init() { if (_writer_state == WRITER_INITED) { - return OLAP_SUCCESS; + return Status::OK(); } if (_is_pending_rowset) { _cur_segment_group = new (std::nothrow) SegmentGroup( @@ -270,15 +270,15 @@ OLAPStatus AlphaRowsetWriter::_init() { _cur_segment_group, true, _rowset_writer_context.tablet_schema->compress_kind(), _rowset_writer_context.tablet_schema->bloom_filter_fpp()); DCHECK(_column_data_writer != nullptr) << "memory error occurs when creating writer"; - OLAPStatus res = _column_data_writer->init(); - if (res != OLAP_SUCCESS) { + Status res = _column_data_writer->init(); + if (!res.ok()) { LOG(WARNING) << "column data writer init failed"; return res; } _segment_group_id++; _writer_state = WRITER_INITED; - return OLAP_SUCCESS; + return Status::OK(); } bool AlphaRowsetWriter::_validate_rowset() { diff --git a/be/src/olap/rowset/alpha_rowset_writer.h b/be/src/olap/rowset/alpha_rowset_writer.h index 1fc5ccd1ea..590e7b517e 100644 --- a/be/src/olap/rowset/alpha_rowset_writer.h +++ b/be/src/olap/rowset/alpha_rowset_writer.h @@ -33,17 +33,17 @@ public: AlphaRowsetWriter(); virtual ~AlphaRowsetWriter(); - OLAPStatus init(const RowsetWriterContext& rowset_writer_context) override; + Status init(const RowsetWriterContext& rowset_writer_context) override; - OLAPStatus add_row(const RowCursor& row) override { return _add_row(row); } - OLAPStatus add_row(const ContiguousRow& row) override { return _add_row(row); } + Status add_row(const RowCursor& row) override { return _add_row(row); } + Status add_row(const ContiguousRow& row) override { return _add_row(row); } // add rowset by create hard link - OLAPStatus add_rowset(RowsetSharedPtr rowset) override; - OLAPStatus add_rowset_for_linked_schema_change(RowsetSharedPtr rowset, + Status add_rowset(RowsetSharedPtr rowset) override; + Status add_rowset_for_linked_schema_change(RowsetSharedPtr rowset, const SchemaMapping& schema_mapping) override; - OLAPStatus flush() override; + Status flush() override; // get a rowset RowsetSharedPtr build() override; @@ -57,15 +57,15 @@ public: RowsetTypePB type() const override { return RowsetTypePB::ALPHA_ROWSET; } private: - OLAPStatus _init(); + Status _init(); template - OLAPStatus _add_row(const RowType& row); + Status _add_row(const RowType& row); // validate rowset build arguments before create rowset to make sure correctness bool _validate_rowset(); - OLAPStatus _garbage_collection(); + Status _garbage_collection(); private: int32_t _segment_group_id; diff --git a/be/src/olap/rowset/beta_rowset.cpp b/be/src/olap/rowset/beta_rowset.cpp index a25ff9adf9..b9cd3aee8a 100644 --- a/be/src/olap/rowset/beta_rowset.cpp +++ b/be/src/olap/rowset/beta_rowset.cpp @@ -44,17 +44,17 @@ BetaRowset::BetaRowset(const TabletSchema* schema, const FilePathDesc& rowset_pa BetaRowset::~BetaRowset() {} -OLAPStatus BetaRowset::init() { - return OLAP_SUCCESS; // no op +Status BetaRowset::init() { + return Status::OK(); // no op } -OLAPStatus BetaRowset::do_load(bool /*use_cache*/) { +Status BetaRowset::do_load(bool /*use_cache*/) { // do nothing. // the segments in this rowset will be loaded by calling load_segments() explicitly. - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BetaRowset::load_segments(std::vector* segments) { +Status BetaRowset::load_segments(std::vector* segments) { for (int seg_id = 0; seg_id < num_segments(); ++seg_id) { FilePathDesc seg_path_desc = segment_file_path(_rowset_path_desc, rowset_id(), seg_id); std::shared_ptr segment; @@ -62,28 +62,28 @@ OLAPStatus BetaRowset::load_segments(std::vector* if (!s.ok()) { LOG(WARNING) << "failed to open segment. " << seg_path_desc.debug_string() << " under rowset " << unique_id() << " : " << s.to_string(); - return OLAP_ERR_ROWSET_LOAD_FAILED; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_LOAD_FAILED); } segments->push_back(std::move(segment)); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BetaRowset::create_reader(RowsetReaderSharedPtr* result) { +Status BetaRowset::create_reader(RowsetReaderSharedPtr* result) { // NOTE: We use std::static_pointer_cast for performance result->reset(new BetaRowsetReader(std::static_pointer_cast(shared_from_this()))); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BetaRowset::split_range(const RowCursor& start_key, const RowCursor& end_key, +Status BetaRowset::split_range(const RowCursor& start_key, const RowCursor& end_key, uint64_t request_block_row_count, size_t key_num, std::vector* ranges) { ranges->emplace_back(start_key.to_tuple()); ranges->emplace_back(end_key.to_tuple()); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BetaRowset::remove() { +Status BetaRowset::remove() { // TODO should we close and remove all segment reader first? VLOG_NOTICE << "begin to remove files in rowset " << unique_id() << ", version:" << start_version() << "-" << end_version() @@ -102,22 +102,22 @@ OLAPStatus BetaRowset::remove() { } if (!success) { LOG(WARNING) << "failed to remove files in rowset " << unique_id(); - return OLAP_ERR_ROWSET_DELETE_FILE_FAILED; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_DELETE_FILE_FAILED); } - return OLAP_SUCCESS; + return Status::OK(); } void BetaRowset::do_close() { // do nothing. } -OLAPStatus BetaRowset::link_files_to(const FilePathDesc& dir_desc, RowsetId new_rowset_id) { +Status BetaRowset::link_files_to(const FilePathDesc& dir_desc, RowsetId new_rowset_id) { for (int i = 0; i < num_segments(); ++i) { FilePathDesc dst_link_path_desc = segment_file_path(dir_desc, new_rowset_id, i); // TODO(lingbin): use Env API? or EnvUtil? if (FileUtils::check_exist(dst_link_path_desc.filepath)) { LOG(WARNING) << "failed to create hard link, file already exist: " << dst_link_path_desc.filepath; - return OLAP_ERR_FILE_ALREADY_EXIST; + return Status::OLAPInternalError(OLAP_ERR_FILE_ALREADY_EXIST); } FilePathDesc src_file_path_desc = segment_file_path(_rowset_path_desc, rowset_id(), i); // TODO(lingbin): how external storage support link? @@ -126,63 +126,63 @@ OLAPStatus BetaRowset::link_files_to(const FilePathDesc& dir_desc, RowsetId new_ if (!block_mgr->link_file(src_file_path_desc, dst_link_path_desc).ok()) { LOG(WARNING) << "fail to create hard link. from=" << src_file_path_desc.debug_string() << ", " << "to=" << dst_link_path_desc.debug_string() << ", errno=" << Errno::no(); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BetaRowset::copy_files_to(const std::string& dir) { +Status BetaRowset::copy_files_to(const std::string& dir) { for (int i = 0; i < num_segments(); ++i) { FilePathDesc dst_path_desc = segment_file_path(dir, rowset_id(), i); Status status = Env::Default()->path_exists(dst_path_desc.filepath); if (status.ok()) { LOG(WARNING) << "file already exist: " << dst_path_desc.filepath; - return OLAP_ERR_FILE_ALREADY_EXIST; + return Status::OLAPInternalError(OLAP_ERR_FILE_ALREADY_EXIST); } if (!status.is_not_found()) { LOG(WARNING) << "file check exist error: " << dst_path_desc.filepath; - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } FilePathDesc src_path_desc = segment_file_path(_rowset_path_desc, rowset_id(), i); if (!Env::Default()->copy_path(src_path_desc.filepath, dst_path_desc.filepath).ok()) { LOG(WARNING) << "fail to copy file. from=" << src_path_desc.filepath << ", to=" << dst_path_desc.filepath << ", errno=" << Errno::no(); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BetaRowset::upload_files_to(const FilePathDesc& dir_desc) { +Status BetaRowset::upload_files_to(const FilePathDesc& dir_desc) { std::shared_ptr storage_backend = StorageBackendMgr::instance()-> get_storage_backend(dir_desc.storage_name); if (storage_backend == nullptr) { LOG(WARNING) << "storage_backend is invalid: " << dir_desc.debug_string(); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } for (int i = 0; i < num_segments(); ++i) { FilePathDesc dst_path_desc = segment_file_path(dir_desc, rowset_id(), i); Status status = storage_backend->exist(dst_path_desc.remote_path); if (status.ok()) { LOG(WARNING) << "file already exist: " << dst_path_desc.remote_path; - return OLAP_ERR_FILE_ALREADY_EXIST; + return Status::OLAPInternalError(OLAP_ERR_FILE_ALREADY_EXIST); } if (!status.is_not_found()) { LOG(WARNING) << "file check exist error: " << dst_path_desc.remote_path; - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } FilePathDesc src_path_desc = segment_file_path(_rowset_path_desc, rowset_id(), i); if (!storage_backend->upload(src_path_desc.filepath, dst_path_desc.remote_path).ok()) { LOG(WARNING) << "fail to upload file. from=" << src_path_desc.filepath << ", to=" << dst_path_desc.remote_path << ", errno=" << Errno::no(); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } LOG(INFO) << "succeed to upload file. from " << src_path_desc.filepath << " to " << dst_path_desc.remote_path; } - return OLAP_SUCCESS; + return Status::OK(); } bool BetaRowset::check_path(const std::string& path) { diff --git a/be/src/olap/rowset/beta_rowset.h b/be/src/olap/rowset/beta_rowset.h index 81ad134904..d7e38389bd 100644 --- a/be/src/olap/rowset/beta_rowset.h +++ b/be/src/olap/rowset/beta_rowset.h @@ -37,42 +37,42 @@ class BetaRowset : public Rowset { public: virtual ~BetaRowset(); - OLAPStatus create_reader(RowsetReaderSharedPtr* result) override; + Status create_reader(RowsetReaderSharedPtr* result) override; static FilePathDesc segment_file_path(const FilePathDesc& segment_dir_desc, const RowsetId& rowset_id, int segment_id); - OLAPStatus split_range(const RowCursor& start_key, const RowCursor& end_key, + Status split_range(const RowCursor& start_key, const RowCursor& end_key, uint64_t request_block_row_count, size_t key_num, std::vector* ranges) override; - OLAPStatus remove() override; + Status remove() override; - OLAPStatus link_files_to(const FilePathDesc& dir_desc, RowsetId new_rowset_id) override; + Status link_files_to(const FilePathDesc& dir_desc, RowsetId new_rowset_id) override; - OLAPStatus copy_files_to(const std::string& dir) override; + Status copy_files_to(const std::string& dir) override; - OLAPStatus upload_files_to(const FilePathDesc& dir_desc) override; + Status upload_files_to(const FilePathDesc& dir_desc) override; // only applicable to alpha rowset, no op here - OLAPStatus remove_old_files(std::vector* files_to_remove) override { - return OLAP_SUCCESS; + Status remove_old_files(std::vector* files_to_remove) override { + return Status::OK(); }; bool check_path(const std::string& path) override; bool check_file_exist() override; - OLAPStatus load_segments(std::vector* segments); + Status load_segments(std::vector* segments); protected: BetaRowset(const TabletSchema* schema, const FilePathDesc& rowset_path_desc, RowsetMetaSharedPtr rowset_meta); // init segment groups - OLAPStatus init() override; + Status init() override; - OLAPStatus do_load(bool use_cache) override; + Status do_load(bool use_cache) override; void do_close() override; diff --git a/be/src/olap/rowset/beta_rowset_reader.cpp b/be/src/olap/rowset/beta_rowset_reader.cpp index c0c3bad46c..b4cd2a7bc6 100644 --- a/be/src/olap/rowset/beta_rowset_reader.cpp +++ b/be/src/olap/rowset/beta_rowset_reader.cpp @@ -38,7 +38,7 @@ BetaRowsetReader::BetaRowsetReader(BetaRowsetSharedPtr rowset) _rowset->acquire(); } -OLAPStatus BetaRowsetReader::init(RowsetReaderContext* read_context) { +Status BetaRowsetReader::init(RowsetReaderContext* read_context) { RETURN_NOT_OK(_rowset->load()); _context = read_context; if (_context->stats != nullptr) { @@ -98,7 +98,7 @@ OLAPStatus BetaRowsetReader::init(RowsetReaderContext* read_context) { auto s = seg_ptr->new_iterator(*_schema, read_options, &iter); if (!s.ok()) { LOG(WARNING) << "failed to create iterator[" << seg_ptr->id() << "]: " << s.to_string(); - return OLAP_ERR_ROWSET_READER_INIT; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_READER_INIT); } seg_iterators.push_back(std::move(iter)); } @@ -128,7 +128,7 @@ OLAPStatus BetaRowsetReader::init(RowsetReaderContext* read_context) { auto s = final_iterator->init(read_options); if (!s.ok()) { LOG(WARNING) << "failed to init iterator: " << s.to_string(); - return OLAP_ERR_ROWSET_READER_INIT; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_READER_INIT); } _iterator.reset(final_iterator); @@ -151,10 +151,10 @@ OLAPStatus BetaRowsetReader::init(RowsetReaderContext* read_context) { RETURN_NOT_OK(_row->init(*(read_context->tablet_schema), *(_context->seek_columns))); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BetaRowsetReader::next_block(RowBlock** block) { +Status BetaRowsetReader::next_block(RowBlock** block) { SCOPED_RAW_TIMER(&_stats->block_fetch_ns); // read next input block _input_block->clear(); @@ -163,10 +163,10 @@ OLAPStatus BetaRowsetReader::next_block(RowBlock** block) { if (!s.ok()) { if (s.is_end_of_file()) { *block = nullptr; - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } LOG(WARNING) << "failed to read next block: " << s.to_string(); - return OLAP_ERR_ROWSET_READ_FAILED; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_READ_FAILED); } } @@ -177,19 +177,19 @@ OLAPStatus BetaRowsetReader::next_block(RowBlock** block) { _input_block->convert_to_row_block(_row.get(), _output_block.get()); } *block = _output_block.get(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BetaRowsetReader::next_block(vectorized::Block* block) { +Status BetaRowsetReader::next_block(vectorized::Block* block) { SCOPED_RAW_TIMER(&_stats->block_fetch_ns); if (config::enable_storage_vectorization && _context->is_vec) { auto s = _iterator->next_batch(block); if (!s.ok()) { if (s.is_end_of_file()) { - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } else { LOG(WARNING) << "failed to read next block: " << s.to_string(); - return OLAP_ERR_ROWSET_READ_FAILED; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_READ_FAILED); } } } else { @@ -204,13 +204,13 @@ OLAPStatus BetaRowsetReader::next_block(vectorized::Block* block) { if (!s.ok()) { if (s.is_end_of_file()) { if (is_first) { - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } else { break; } } else { LOG(WARNING) << "failed to read next block: " << s.to_string(); - return OLAP_ERR_ROWSET_READ_FAILED; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_READ_FAILED); } } else if (_input_block->selected_size() == 0) { continue; @@ -223,14 +223,14 @@ OLAPStatus BetaRowsetReader::next_block(vectorized::Block* block) { auto s = _input_block->convert_to_vec_block(block); if (UNLIKELY(!s.ok())) { LOG(WARNING) << "failed to read next block: " << s.to_string(); - return OLAP_ERR_STRING_OVERFLOW_IN_VEC_ENGINE; + return Status::OLAPInternalError(OLAP_ERR_STRING_OVERFLOW_IN_VEC_ENGINE); } } is_first = false; } while (block->rows() < _context->batch_size); // here we should keep block.rows() < batch_size } - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/rowset/beta_rowset_reader.h b/be/src/olap/rowset/beta_rowset_reader.h index eeddef80da..7ba7b6a945 100644 --- a/be/src/olap/rowset/beta_rowset_reader.h +++ b/be/src/olap/rowset/beta_rowset_reader.h @@ -34,11 +34,11 @@ public: ~BetaRowsetReader() override { _rowset->release(); } - OLAPStatus init(RowsetReaderContext* read_context) override; + Status init(RowsetReaderContext* read_context) override; // It's ok, because we only get ref here, the block's owner is this reader. - OLAPStatus next_block(RowBlock** block) override; - OLAPStatus next_block(vectorized::Block* block) override; + Status next_block(RowBlock** block) override; + Status next_block(vectorized::Block* block) override; bool delete_flag() override { return _rowset->delete_flag(); } diff --git a/be/src/olap/rowset/beta_rowset_writer.cpp b/be/src/olap/rowset/beta_rowset_writer.cpp index 74e13a163b..5c6b35c438 100644 --- a/be/src/olap/rowset/beta_rowset_writer.cpp +++ b/be/src/olap/rowset/beta_rowset_writer.cpp @@ -77,7 +77,7 @@ BetaRowsetWriter::~BetaRowsetWriter() { } } -OLAPStatus BetaRowsetWriter::init(const RowsetWriterContext& rowset_writer_context) { +Status BetaRowsetWriter::init(const RowsetWriterContext& rowset_writer_context) { _context = rowset_writer_context; _rowset_meta.reset(new RowsetMeta); _rowset_meta->set_rowset_id(_context.rowset_id); @@ -96,11 +96,11 @@ OLAPStatus BetaRowsetWriter::init(const RowsetWriterContext& rowset_writer_conte } _rowset_meta->set_tablet_uid(_context.tablet_uid); - return OLAP_SUCCESS; + return Status::OK(); } template -OLAPStatus BetaRowsetWriter::_add_row(const RowType& row) { +Status BetaRowsetWriter::_add_row(const RowType& row) { if (PREDICT_FALSE(_segment_writer == nullptr)) { RETURN_NOT_OK(_create_segment_writer(&_segment_writer)); } @@ -108,20 +108,20 @@ OLAPStatus BetaRowsetWriter::_add_row(const RowType& row) { auto s = _segment_writer->append_row(row); if (PREDICT_FALSE(!s.ok())) { LOG(WARNING) << "failed to append row: " << s.to_string(); - return OLAP_ERR_WRITER_DATA_WRITE_ERROR; + return Status::OLAPInternalError(OLAP_ERR_WRITER_DATA_WRITE_ERROR); } if (PREDICT_FALSE(_segment_writer->estimate_segment_size() >= MAX_SEGMENT_SIZE || _segment_writer->num_rows_written() >= _context.max_rows_per_segment)) { RETURN_NOT_OK(_flush_segment_writer(&_segment_writer)); } ++_num_rows_written; - return OLAP_SUCCESS; + return Status::OK(); } -template OLAPStatus BetaRowsetWriter::_add_row(const RowCursor& row); -template OLAPStatus BetaRowsetWriter::_add_row(const ContiguousRow& row); +template Status BetaRowsetWriter::_add_row(const RowCursor& row); +template Status BetaRowsetWriter::_add_row(const ContiguousRow& row); -OLAPStatus BetaRowsetWriter::add_rowset(RowsetSharedPtr rowset) { +Status BetaRowsetWriter::add_rowset(RowsetSharedPtr rowset) { assert(rowset->rowset_meta()->rowset_type() == BETA_ROWSET); RETURN_NOT_OK(rowset->link_files_to(_context.path_desc, _context.rowset_id)); _num_rows_written += rowset->num_rows(); @@ -132,23 +132,23 @@ OLAPStatus BetaRowsetWriter::add_rowset(RowsetSharedPtr rowset) { if (rowset->rowset_meta()->has_delete_predicate()) { _rowset_meta->set_delete_predicate(rowset->rowset_meta()->delete_predicate()); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BetaRowsetWriter::add_rowset_for_linked_schema_change( +Status BetaRowsetWriter::add_rowset_for_linked_schema_change( RowsetSharedPtr rowset, const SchemaMapping& schema_mapping) { // TODO use schema_mapping to transfer zonemap return add_rowset(rowset); } -OLAPStatus BetaRowsetWriter::flush() { +Status BetaRowsetWriter::flush() { if (_segment_writer != nullptr) { RETURN_NOT_OK(_flush_segment_writer(&_segment_writer)); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BetaRowsetWriter::flush_single_memtable(MemTable* memtable, int64_t* flush_size) { +Status BetaRowsetWriter::flush_single_memtable(MemTable* memtable, int64_t* flush_size) { int64_t current_flush_size = _total_data_size + _total_index_size; // Create segment writer for each memtable, so that // all memtables can be flushed in parallel. @@ -163,7 +163,7 @@ OLAPStatus BetaRowsetWriter::flush_single_memtable(MemTable* memtable, int64_t* auto s = writer->append_row(dst_row); if (PREDICT_FALSE(!s.ok())) { LOG(WARNING) << "failed to append row: " << s.to_string(); - return OLAP_ERR_WRITER_DATA_WRITE_ERROR; + return Status::OLAPInternalError(OLAP_ERR_WRITER_DATA_WRITE_ERROR); } if (PREDICT_FALSE(writer->estimate_segment_size() >= MAX_SEGMENT_SIZE || @@ -178,7 +178,7 @@ OLAPStatus BetaRowsetWriter::flush_single_memtable(MemTable* memtable, int64_t* } *flush_size = (_total_data_size + _total_index_size) - current_flush_size; - return OLAP_SUCCESS; + return Status::OK(); } RowsetSharedPtr BetaRowsetWriter::build() { @@ -209,7 +209,7 @@ RowsetSharedPtr BetaRowsetWriter::build() { RowsetSharedPtr rowset; auto status = RowsetFactory::create_rowset(_context.tablet_schema, _context.path_desc, _rowset_meta, &rowset); - if (status != OLAP_SUCCESS) { + if (!status.ok()) { LOG(WARNING) << "rowset init failed when build new rowset, res=" << status; return nullptr; } @@ -217,7 +217,7 @@ RowsetSharedPtr BetaRowsetWriter::build() { return rowset; } -OLAPStatus BetaRowsetWriter::_create_segment_writer(std::unique_ptr* writer) { +Status BetaRowsetWriter::_create_segment_writer(std::unique_ptr* writer) { auto path_desc = BetaRowset::segment_file_path(_context.path_desc, _context.rowset_id, _num_segment++); // TODO(lingbin): should use a more general way to get BlockManager object @@ -230,7 +230,7 @@ OLAPStatus BetaRowsetWriter::_create_segment_writer(std::unique_ptrreset(nullptr); - return OLAP_ERR_INIT_FAILED; + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BetaRowsetWriter::_flush_segment_writer(std::unique_ptr* writer) { +Status BetaRowsetWriter::_flush_segment_writer(std::unique_ptr* writer) { uint64_t segment_size; uint64_t index_size; Status s = (*writer)->finalize(&segment_size, &index_size); if (!s.ok()) { LOG(WARNING) << "failed to finalize segment: " << s.to_string(); - return OLAP_ERR_WRITER_DATA_WRITE_ERROR; + return Status::OLAPInternalError(OLAP_ERR_WRITER_DATA_WRITE_ERROR); } _total_data_size += segment_size; _total_index_size += index_size; writer->reset(); - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/rowset/beta_rowset_writer.h b/be/src/olap/rowset/beta_rowset_writer.h index 343ee2ca96..23f7d207c1 100644 --- a/be/src/olap/rowset/beta_rowset_writer.h +++ b/be/src/olap/rowset/beta_rowset_writer.h @@ -37,22 +37,22 @@ public: ~BetaRowsetWriter() override; - OLAPStatus init(const RowsetWriterContext& rowset_writer_context) override; + Status init(const RowsetWriterContext& rowset_writer_context) override; - OLAPStatus add_row(const RowCursor& row) override { return _add_row(row); } + Status add_row(const RowCursor& row) override { return _add_row(row); } // For Memtable::flush() - OLAPStatus add_row(const ContiguousRow& row) override { return _add_row(row); } + Status add_row(const ContiguousRow& row) override { return _add_row(row); } // add rowset by create hard link - OLAPStatus add_rowset(RowsetSharedPtr rowset) override; + Status add_rowset(RowsetSharedPtr rowset) override; - OLAPStatus add_rowset_for_linked_schema_change(RowsetSharedPtr rowset, + Status add_rowset_for_linked_schema_change(RowsetSharedPtr rowset, const SchemaMapping& schema_mapping) override; - OLAPStatus flush() override; + Status flush() override; // Return the file size flushed to disk in "flush_size" - OLAPStatus flush_single_memtable(MemTable* memtable, int64_t* flush_size) override; + Status flush_single_memtable(MemTable* memtable, int64_t* flush_size) override; RowsetSharedPtr build() override; @@ -66,11 +66,11 @@ public: private: template - OLAPStatus _add_row(const RowType& row); + Status _add_row(const RowType& row); - OLAPStatus _create_segment_writer(std::unique_ptr* writer); + Status _create_segment_writer(std::unique_ptr* writer); - OLAPStatus _flush_segment_writer(std::unique_ptr* writer); + Status _flush_segment_writer(std::unique_ptr* writer); private: RowsetWriterContext _context; diff --git a/be/src/olap/rowset/bit_field_reader.cpp b/be/src/olap/rowset/bit_field_reader.cpp index f809914bb6..c0fbe1d386 100644 --- a/be/src/olap/rowset/bit_field_reader.cpp +++ b/be/src/olap/rowset/bit_field_reader.cpp @@ -30,40 +30,40 @@ BitFieldReader::~BitFieldReader() { SAFE_DELETE(_byte_reader); } -OLAPStatus BitFieldReader::init() { +Status BitFieldReader::init() { if (nullptr == _byte_reader) { _byte_reader = new (std::nothrow) RunLengthByteReader(_input); if (nullptr == _byte_reader) { OLAP_LOG_WARNING("fail to create RunLengthByteReader"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BitFieldReader::_read_byte() { - OLAPStatus res = OLAP_SUCCESS; +Status BitFieldReader::_read_byte() { + Status res = Status::OK(); if (_byte_reader->has_next()) { - if (OLAP_SUCCESS != (res = _byte_reader->next(&_current))) { + if (!(res = _byte_reader->next(&_current))) { return res; } _bits_left = 8; } else { - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BitFieldReader::next(char* value) { - OLAPStatus res = OLAP_SUCCESS; +Status BitFieldReader::next(char* value) { + Status res = Status::OK(); if (0 == _bits_left) { - if (OLAP_SUCCESS != (res = _read_byte())) { + if (!(res = _read_byte())) { return res; } } @@ -72,13 +72,13 @@ OLAPStatus BitFieldReader::next(char* value) { *value = (_current >> _bits_left) & 0x01; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BitFieldReader::seek(PositionProvider* position) { - OLAPStatus res = OLAP_SUCCESS; +Status BitFieldReader::seek(PositionProvider* position) { + Status res = Status::OK(); - if (OLAP_SUCCESS != (res = _byte_reader->seek(position))) { + if (!(res = _byte_reader->seek(position))) { return res; } @@ -86,9 +86,9 @@ OLAPStatus BitFieldReader::seek(PositionProvider* position) { if (consumed > 8) { OLAP_LOG_WARNING("read past end of bit field"); - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } else if (consumed != 0) { - if (OLAP_SUCCESS != (res = _read_byte())) { + if (!(res = _read_byte())) { return res; } @@ -97,11 +97,11 @@ OLAPStatus BitFieldReader::seek(PositionProvider* position) { _bits_left = 0; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BitFieldReader::skip(uint64_t num_values) { - OLAPStatus res = OLAP_SUCCESS; +Status BitFieldReader::skip(uint64_t num_values) { + Status res = Status::OK(); uint64_t total_bits = num_values; @@ -110,18 +110,18 @@ OLAPStatus BitFieldReader::skip(uint64_t num_values) { } else { total_bits -= _bits_left; - if (OLAP_SUCCESS != (res = _byte_reader->skip(total_bits / 8))) { + if (!(res = _byte_reader->skip(total_bits / 8))) { return res; } - if (OLAP_SUCCESS != (res = _byte_reader->next(&_current))) { + if (!(res = _byte_reader->next(&_current))) { return res; } _bits_left = 8 - (total_bits % 8); } - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris \ No newline at end of file diff --git a/be/src/olap/rowset/bit_field_reader.h b/be/src/olap/rowset/bit_field_reader.h index 41afb80d05..6498ae3826 100644 --- a/be/src/olap/rowset/bit_field_reader.h +++ b/be/src/olap/rowset/bit_field_reader.h @@ -30,15 +30,15 @@ class BitFieldReader { public: BitFieldReader(ReadOnlyFileStream* input); ~BitFieldReader(); - OLAPStatus init(); - // 获取下一条数据, 如果没有更多的数据了, 返回OLAP_ERR_DATA_EOF + Status init(); + // 获取下一条数据, 如果没有更多的数据了, 返回Status::OLAPInternalError(OLAP_ERR_DATA_EOF) // 返回的value只可能是0或1 - OLAPStatus next(char* value); - OLAPStatus seek(PositionProvider* position); - OLAPStatus skip(uint64_t num_values); + Status next(char* value); + Status seek(PositionProvider* position); + Status skip(uint64_t num_values); private: - OLAPStatus _read_byte(); + Status _read_byte(); ReadOnlyFileStream* _input; RunLengthByteReader* _byte_reader; diff --git a/be/src/olap/rowset/bit_field_writer.cpp b/be/src/olap/rowset/bit_field_writer.cpp index 99701372fa..ad7c30ebcb 100644 --- a/be/src/olap/rowset/bit_field_writer.cpp +++ b/be/src/olap/rowset/bit_field_writer.cpp @@ -30,21 +30,21 @@ BitFieldWriter::~BitFieldWriter() { SAFE_DELETE(_byte_writer); } -OLAPStatus BitFieldWriter::init() { +Status BitFieldWriter::init() { _byte_writer = new (std::nothrow) RunLengthByteWriter(_output); if (nullptr == _byte_writer) { OLAP_LOG_WARNING("fail to create RunLengthByteWriter"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BitFieldWriter::_write_byte() { - OLAPStatus res = OLAP_SUCCESS; +Status BitFieldWriter::_write_byte() { + Status res = Status::OK(); - if (OLAP_SUCCESS != (res = _byte_writer->write(_current))) { + if (!(res = _byte_writer->write(_current))) { OLAP_LOG_WARNING("fail to write byte to byte writer"); return res; } @@ -54,8 +54,8 @@ OLAPStatus BitFieldWriter::_write_byte() { return res; } -OLAPStatus BitFieldWriter::write(bool bit_value) { - OLAPStatus res = OLAP_SUCCESS; +Status BitFieldWriter::write(bool bit_value) { + Status res = Status::OK(); _bits_left--; @@ -70,11 +70,11 @@ OLAPStatus BitFieldWriter::write(bool bit_value) { return res; } -OLAPStatus BitFieldWriter::flush() { - OLAPStatus res = OLAP_SUCCESS; +Status BitFieldWriter::flush() { + Status res = Status::OK(); if (_bits_left != 8) { - if (OLAP_SUCCESS != (res = _write_byte())) { + if (!(res = _write_byte())) { return res; } } diff --git a/be/src/olap/rowset/bit_field_writer.h b/be/src/olap/rowset/bit_field_writer.h index 6812833e21..87480c51ab 100644 --- a/be/src/olap/rowset/bit_field_writer.h +++ b/be/src/olap/rowset/bit_field_writer.h @@ -30,14 +30,14 @@ class BitFieldWriter { public: explicit BitFieldWriter(OutStream* output); ~BitFieldWriter(); - OLAPStatus init(); + Status init(); // Write a bit, bit_value is true means writing 1, false means writing 0 - OLAPStatus write(bool bit_value); - OLAPStatus flush(); + Status write(bool bit_value); + Status flush(); void get_position(PositionEntryWriter* index_entry) const; private: - OLAPStatus _write_byte(); + Status _write_byte(); OutStream* _output; RunLengthByteWriter* _byte_writer; diff --git a/be/src/olap/rowset/column_data.cpp b/be/src/olap/rowset/column_data.cpp index 178710603b..bf924296da 100644 --- a/be/src/olap/rowset/column_data.cpp +++ b/be/src/olap/rowset/column_data.cpp @@ -54,33 +54,33 @@ ColumnData::~ColumnData() { SAFE_DELETE(_segment_reader); } -OLAPStatus ColumnData::init() { +Status ColumnData::init() { _segment_group->acquire(); auto res = _short_key_cursor.init(_segment_group->short_key_columns()); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "key cursor init failed, res:" << res; return res; } return res; } -OLAPStatus ColumnData::get_next_block(RowBlock** row_block) { +Status ColumnData::get_next_block(RowBlock** row_block) { SCOPED_RAW_TIMER(&_stats->block_fetch_ns); _is_normal_read = true; auto res = _get_block(false); - if (res != OLAP_SUCCESS) { - if (res != OLAP_ERR_DATA_EOF) { + if (!res.ok()) { + if (res != Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { LOG(WARNING) << "Get next block failed."; } *row_block = nullptr; return res; } *row_block = _read_block.get(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus ColumnData::_next_row(const RowCursor** row, bool without_filter) { +Status ColumnData::_next_row(const RowCursor** row, bool without_filter) { _read_block->pos_inc(); do { if (_read_block->has_remaining()) { @@ -89,20 +89,20 @@ OLAPStatus ColumnData::_next_row(const RowCursor** row, bool without_filter) { _read_block->get_row(pos, &_cursor); if (without_filter) { *row = &_cursor; - return OLAP_SUCCESS; + return Status::OK(); } // when without_filter is true, _include_blocks is nullptr if (_read_block->block_status() == DEL_NOT_SATISFIED) { *row = &_cursor; - return OLAP_SUCCESS; + return Status::OK(); } else { DCHECK(_read_block->block_status() == DEL_PARTIAL_SATISFIED); bool row_del_filter = _delete_handler->is_filter_data(_segment_group->version().second, _cursor); if (!row_del_filter) { *row = &_cursor; - return OLAP_SUCCESS; + return Status::OK(); } // This row is filtered, continue to process next row _stats->rows_del_filtered++; @@ -111,23 +111,23 @@ OLAPStatus ColumnData::_next_row(const RowCursor** row, bool without_filter) { } else { // get_next_block auto res = _get_block(without_filter); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { return res; } } } while (true); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus ColumnData::_seek_to_block(const RowBlockPosition& block_pos, bool without_filter) { +Status ColumnData::_seek_to_block(const RowBlockPosition& block_pos, bool without_filter) { // TODO(zc): _segment_readers??? // open segment reader if needed if (_segment_reader == nullptr || block_pos.segment != _current_segment) { if (block_pos.segment >= _segment_group->num_segments() || (_end_key_is_set && block_pos.segment > _end_segment)) { _eof = true; - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } SAFE_DELETE(_segment_reader); std::string file_name; @@ -138,13 +138,13 @@ OLAPStatus ColumnData::_seek_to_block(const RowBlockPosition& block_pos, bool wi _lru_cache, _runtime_state, _stats); if (_segment_reader == nullptr) { OLAP_LOG_WARNING("fail to malloc segment reader."); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } _current_segment = block_pos.segment; auto res = _segment_reader->init(_is_using_cache); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to init segment reader. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to init segment reader. res = " << res; return res; } } @@ -161,52 +161,52 @@ OLAPStatus ColumnData::_seek_to_block(const RowBlockPosition& block_pos, bool wi &_next_block, &_segment_eof); } -OLAPStatus ColumnData::_find_position_by_short_key(const RowCursor& key, bool find_last_key, +Status ColumnData::_find_position_by_short_key(const RowCursor& key, bool find_last_key, RowBlockPosition* position) { RowBlockPosition tmp_pos; auto res = _segment_group->find_short_key(key, &_short_key_cursor, find_last_key, &tmp_pos); - if (res != OLAP_SUCCESS) { - if (res == OLAP_ERR_INDEX_EOF) { - res = OLAP_ERR_DATA_EOF; + if (!res.ok()) { + if (res == Status::OLAPInternalError(OLAP_ERR_INDEX_EOF)) { + res = Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } else { - OLAP_LOG_WARNING("find row block failed. [res=%d]", res); + LOG(WARNING) << "find row block failed. res = " << res; } return res; } res = segment_group()->find_prev_point(tmp_pos, position); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("find prev row block failed. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "find prev row block failed. res = " << res; return res; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus ColumnData::_find_position_by_full_key(const RowCursor& key, bool find_last_key, +Status ColumnData::_find_position_by_full_key(const RowCursor& key, bool find_last_key, RowBlockPosition* position) { RowBlockPosition tmp_pos; auto res = _segment_group->find_short_key(key, &_short_key_cursor, false, &tmp_pos); - if (res != OLAP_SUCCESS) { - if (res == OLAP_ERR_INDEX_EOF) { - res = OLAP_ERR_DATA_EOF; + if (!res.ok()) { + if (res == Status::OLAPInternalError(OLAP_ERR_INDEX_EOF)) { + res = Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } else { - OLAP_LOG_WARNING("find row block failed. [res=%d]", res); + LOG(WARNING) << "find row block failed. res = " << res; } return res; } RowBlockPosition start_position; res = segment_group()->find_prev_point(tmp_pos, &start_position); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("find prev row block failed. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "find prev row block failed. res = " << res; return res; } RowBlockPosition end_position; res = _segment_group->find_short_key(key, &_short_key_cursor, true, &end_position); - if (res != OLAP_SUCCESS) { - if (res == OLAP_ERR_INDEX_EOF) { - res = OLAP_ERR_DATA_EOF; + if (!res.ok()) { + if (res == Status::OLAPInternalError(OLAP_ERR_INDEX_EOF)) { + res = Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } else { - OLAP_LOG_WARNING("find row block failed. [res=%d]", res); + LOG(WARNING) << "find row block failed. res = " << res; } return res; } @@ -221,8 +221,8 @@ OLAPStatus ColumnData::_find_position_by_full_key(const RowCursor& key, bool fin index_offset.segment = _end_segment; index_offset.offset = _end_block; res = segment_group()->get_row_block_position(index_offset, &end_position); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("fail to get row block position. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to get row block position. res = " << res; return res; } } @@ -245,18 +245,16 @@ OLAPStatus ColumnData::_find_position_by_full_key(const RowCursor& key, bool fin << ", start_pos=" << start_position.to_string(); } catch (std::exception& e) { LOG(WARNING) << "exception happens when doing seek. exception=" << e.what(); - return OLAP_ERR_STL_ERROR; + return Status::OLAPInternalError(OLAP_ERR_STL_ERROR); } if (*it_result != *it_start) { it_result -= 1; } - if (OLAP_SUCCESS != (res = segment_group()->advance_row_block(*it_result, &start_position))) { - OLAP_LOG_WARNING( - "fail to advance row_block. [res=%d it_offset=%u " - "start_pos='%s']", - res, *it_result, start_position.to_string().c_str()); + if (!(res = segment_group()->advance_row_block(*it_result, &start_position))) { + LOG(WARNING) << "fail to advance row_block. res=" << res + << " it_offset=" << *it_result << " start_pos=" << start_position.to_string(); return res; } @@ -265,17 +263,17 @@ OLAPStatus ColumnData::_find_position_by_full_key(const RowCursor& key, bool fin end_key_position.segment = _end_segment; end_key_position.data_offset = _end_block; if (end_position > end_key_position) { - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } } *position = start_position; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus ColumnData::_seek_to_row(const RowCursor& key, bool find_last_key, bool is_end_key) { +Status ColumnData::_seek_to_row(const RowCursor& key, bool find_last_key, bool is_end_key) { RowBlockPosition position; - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); const TabletSchema& tablet_schema = _segment_group->get_tablet_schema(); FieldType type = tablet_schema.column(key.field_count() - 1).type(); if (key.field_count() > _segment_group->get_num_short_key_columns() || @@ -284,8 +282,8 @@ OLAPStatus ColumnData::_seek_to_row(const RowCursor& key, bool find_last_key, bo } else { res = _find_position_by_short_key(key, find_last_key, &position); } - if (res != OLAP_SUCCESS) { - if (res != OLAP_ERR_DATA_EOF) { + if (!res.ok()) { + if (res != Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { LOG(WARNING) << "Fail to find the key.[res=" << res << " key=" << key.to_string() << " find_last_key=" << find_last_key << "]"; } @@ -293,17 +291,17 @@ OLAPStatus ColumnData::_seek_to_row(const RowCursor& key, bool find_last_key, bo } bool without_filter = is_end_key; res = _seek_to_block(position, without_filter); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING( - "fail to get row block. " - "[res=%d segment=%d block_size=%d data_offset=%d index_offset=%d]", - res, position.segment, position.block_size, position.data_offset, - position.index_offset); + if (!res.ok()) { + LOG(WARNING) << "fail to get row block. res=" << res + << " segment=" << position.segment + << " block_size=" << position.block_size + << " data_offset=" << position.data_offset + << " index_offset=" << position.index_offset; return res; } res = _get_block(without_filter); - if (res != OLAP_SUCCESS) { - if (res != OLAP_ERR_DATA_EOF) { + if (!res.ok()) { + if (res != Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { LOG(WARNING) << "Fail to find the key.[res=" << res << " key=" << key.to_string() << " find_last_key=" << find_last_key << "]"; } @@ -316,13 +314,13 @@ OLAPStatus ColumnData::_seek_to_row(const RowCursor& key, bool find_last_key, bo // row_cursor >= key // 此处比较2个block的行数，是存在一种极限情况：若未找到满足的block， // Index模块会返回倒数第二个block，此时key可能是最后一个block的最后一行 - while (res == OLAP_SUCCESS && compare_row_key(*row_cursor, key) < 0) { + while (res.ok() && compare_row_key(*row_cursor, key) < 0) { res = _next_row(&row_cursor, without_filter); } } else { // 找last key。返回大于这个key的第一个。也就是 // row_cursor > key - while (res == OLAP_SUCCESS && compare_row_key(*row_cursor, key) <= 0) { + while (res.ok() && compare_row_key(*row_cursor, key) <= 0) { res = _next_row(&row_cursor, without_filter); } } @@ -332,13 +330,13 @@ OLAPStatus ColumnData::_seek_to_row(const RowCursor& key, bool find_last_key, bo const RowCursor* ColumnData::seek_and_get_current_row(const RowBlockPosition& position) { auto res = _seek_to_block(position, true); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "Fail to seek to block in seek_and_get_current_row, res=" << res << ", segment:" << position.segment << ", block:" << position.data_offset; return nullptr; } res = _get_block(true, 1); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "Fail to get block in seek_and_get_current_row, res=" << res << ", segment:" << position.segment << ", block:" << position.data_offset << ", tablet: " << _segment_group->get_tablet_id(); @@ -347,7 +345,7 @@ const RowCursor* ColumnData::seek_and_get_current_row(const RowBlockPosition& po return _current_row(); } -OLAPStatus ColumnData::prepare_block_read(const RowCursor* start_key, bool find_start_key, +Status ColumnData::prepare_block_read(const RowCursor* start_key, bool find_start_key, const RowCursor* end_key, bool find_end_key, RowBlock** first_block) { SCOPED_RAW_TIMER(&_stats->block_fetch_ns); @@ -357,25 +355,25 @@ OLAPStatus ColumnData::prepare_block_read(const RowCursor* start_key, bool find_ // set end position if (end_key != nullptr) { auto res = _seek_to_row(*end_key, find_end_key, true); - if (res == OLAP_SUCCESS) { + if (res.ok()) { // we find a _end_segment = _current_segment; _end_block = _current_block; _end_row_index = _read_block->pos(); _end_key_is_set = true; - } else if (res != OLAP_ERR_DATA_EOF) { + } else if (res != Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { LOG(WARNING) << "Find end key failed.key=" << end_key->to_string(); return res; } - // res == OLAP_ERR_DATA_EOF means there is no end key, then we read to + // res == Status::OLAPInternalError(OLAP_ERR_DATA_EOF) means there is no end key, then we read to // the end of this ColumnData } set_eof(false); if (start_key != nullptr) { auto res = _seek_to_row(*start_key, !find_start_key, false); - if (res == OLAP_SUCCESS) { + if (res.ok()) { *first_block = _read_block.get(); - } else if (res == OLAP_ERR_DATA_EOF) { + } else if (res == Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { _eof = true; *first_block = nullptr; return res; @@ -391,20 +389,20 @@ OLAPStatus ColumnData::prepare_block_read(const RowCursor* start_key, bool find_ pos.segment = 0u; pos.data_offset = 0u; auto res = _seek_to_block(pos, false); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to seek to block in, res=" << res << ", segment:" << pos.segment << ", block:" << pos.data_offset; return res; } res = _get_block(false); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to get block in , res=" << res << ", segment:" << pos.segment << ", block:" << pos.data_offset; return res; } *first_block = _read_block.get(); } - return OLAP_SUCCESS; + return Status::OK(); } // ColumnData向上返回的列至少由几部分组成: @@ -427,7 +425,7 @@ void ColumnData::set_read_params(const std::vector& return_columns, _load_bf_columns = load_bf_columns; auto res = _cursor.init(_segment_group->get_tablet_schema(), _seek_columns); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to init row_cursor"; } @@ -445,16 +443,16 @@ void ColumnData::set_read_params(const std::vector& return_columns, _read_block->init(block_info); } -OLAPStatus ColumnData::get_first_row_block(RowBlock** row_block) { +Status ColumnData::get_first_row_block(RowBlock** row_block) { DCHECK(!_end_key_is_set) << "end key is set while use block interface."; _is_normal_read = true; _eof = false; // to be same with OLAPData, we use segment_group. RowBlockPosition block_pos; - OLAPStatus res = segment_group()->find_first_row_block(&block_pos); - if (res != OLAP_SUCCESS) { - if (res == OLAP_ERR_INDEX_EOF) { + Status res = segment_group()->find_first_row_block(&block_pos); + if (!res.ok()) { + if (res == Status::OLAPInternalError(OLAP_ERR_INDEX_EOF)) { *row_block = nullptr; _eof = true; return res; @@ -464,17 +462,17 @@ OLAPStatus ColumnData::get_first_row_block(RowBlock** row_block) { } res = _seek_to_block(block_pos, false); - if (res != OLAP_SUCCESS) { - if (res != OLAP_ERR_DATA_EOF) { - OLAP_LOG_WARNING("seek to block fail. [res=%d]", res); + if (!res.ok()) { + if (res != Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { + LOG(WARNING) << "seek to block fail. res = " << res; } *row_block = nullptr; return res; } res = _get_block(false); - if (res != OLAP_SUCCESS) { - if (res != OLAP_ERR_DATA_EOF) { + if (!res.ok()) { + if (res != Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { LOG(WARNING) << "fail to load data to row block. res=" << res << ", version=" << version().first << "-" << version().second; } @@ -483,7 +481,7 @@ OLAPStatus ColumnData::get_first_row_block(RowBlock** row_block) { } *row_block = _read_block.get(); - return OLAP_SUCCESS; + return Status::OK(); } bool ColumnData::rowset_pruning_filter() { @@ -558,7 +556,7 @@ uint64_t ColumnData::get_filtered_rows() { return _stats->rows_del_filtered; } -OLAPStatus ColumnData::schema_change_init() { +Status ColumnData::schema_change_init() { _is_using_cache = false; for (int i = 0; i < _segment_group->get_tablet_schema().num_columns(); ++i) { @@ -567,7 +565,7 @@ OLAPStatus ColumnData::schema_change_init() { } auto res = _cursor.init(_segment_group->get_tablet_schema()); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to init row_cursor"); return res; } @@ -581,10 +579,10 @@ OLAPStatus ColumnData::schema_change_init() { block_info.row_num = _num_rows_per_block; block_info.null_supported = true; _read_block->init(block_info); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus ColumnData::_get_block_from_reader(VectorizedRowBatch** got_batch, bool without_filter, +Status ColumnData::_get_block_from_reader(VectorizedRowBatch** got_batch, bool without_filter, int rows_read) { VectorizedRowBatch* vec_batch = nullptr; if (_is_normal_read) { @@ -612,12 +610,12 @@ OLAPStatus ColumnData::_get_block_from_reader(VectorizedRowBatch** got_batch, bo if (!_segment_eof) { _current_block = _next_block; auto res = _segment_reader->get_block(vec_batch, &_next_block, &_segment_eof); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { return res; } // Normal case *got_batch = vec_batch; - return OLAP_SUCCESS; + return Status::OK(); } // When this segment is read over, we reach here. // Seek to next segment @@ -625,19 +623,19 @@ OLAPStatus ColumnData::_get_block_from_reader(VectorizedRowBatch** got_batch, bo block_pos.segment = _current_segment + 1; block_pos.data_offset = 0; auto res = _seek_to_block(block_pos, without_filter); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { return res; } } while (true); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus ColumnData::_get_block(bool without_filter, int rows_read) { +Status ColumnData::_get_block(bool without_filter, int rows_read) { do { VectorizedRowBatch* vec_batch = nullptr; auto res = _get_block_from_reader(&vec_batch, without_filter, rows_read); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { return res; } // evaluate predicates @@ -657,9 +655,9 @@ OLAPStatus ColumnData::_get_block(bool without_filter, int rows_read) { // when reach here, we have already read a block successfully _read_block->clear(); vec_batch->dump_to_row_block(_read_block.get()); - return OLAP_SUCCESS; + return Status::OK(); } while (true); - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/rowset/column_data.h b/be/src/olap/rowset/column_data.h index c5ad741019..7502c77ac4 100644 --- a/be/src/olap/rowset/column_data.h +++ b/be/src/olap/rowset/column_data.h @@ -48,13 +48,13 @@ public: bool delete_flag() const { return _segment_group->delete_flag(); } uint32_t num_segments() const { return _segment_group->num_segments(); } - OLAPStatus init(); + Status init(); - OLAPStatus prepare_block_read(const RowCursor* start_key, bool find_start_key, + Status prepare_block_read(const RowCursor* start_key, bool find_start_key, const RowCursor* end_key, bool find_end_key, RowBlock** first_block); - OLAPStatus get_next_block(RowBlock** row_block); + Status get_next_block(RowBlock** row_block); void set_read_params(const std::vector& return_columns, const std::vector& seek_columns, @@ -62,7 +62,7 @@ public: std::shared_ptr> col_predicates, bool is_using_cache, RuntimeState* runtime_state); - OLAPStatus get_first_row_block(RowBlock** row_block); + Status get_first_row_block(RowBlock** row_block); // Only used to binary search in full-key find row const RowCursor* seek_and_get_current_row(const RowBlockPosition& position); @@ -97,38 +97,38 @@ public: // To compatible with schema change read, use this function to init column data // for schema change read. Only called in get_first_row_block - OLAPStatus schema_change_init(); + Status schema_change_init(); private: DISALLOW_COPY_AND_ASSIGN(ColumnData); // Try to seek to 'key'. If this function returned with OLAP_SUCCESS, current_row() // point to the first row meet the requirement. - // If there is no such row, OLAP_ERR_DATA_EOF will return. + // If there is no such row, Status::OLAPInternalError(OLAP_ERR_DATA_EOF) will return. // If error happened, other code will return - OLAPStatus _seek_to_row(const RowCursor& key, bool find_key, bool is_end_key); + Status _seek_to_row(const RowCursor& key, bool find_key, bool is_end_key); // seek to block_pos without load that block, caller must call _get_block() // to load _read_block with data. If without_filter is false, this will seek to // other block. Because the seeked block may be filtered by condition or delete. - OLAPStatus _seek_to_block(const RowBlockPosition& block_pos, bool without_filter); + Status _seek_to_block(const RowBlockPosition& block_pos, bool without_filter); - OLAPStatus _find_position_by_short_key(const RowCursor& key, bool find_last_key, + Status _find_position_by_short_key(const RowCursor& key, bool find_last_key, RowBlockPosition* position); - OLAPStatus _find_position_by_full_key(const RowCursor& key, bool find_last_key, + Status _find_position_by_full_key(const RowCursor& key, bool find_last_key, RowBlockPosition* position); // Used in _seek_to_row, this function will goto next row that valid for this // ColumnData - OLAPStatus _next_row(const RowCursor** row, bool without_filter); + Status _next_row(const RowCursor** row, bool without_filter); // get block from reader, just read vector batch from _current_segment. // The read batch return by got_batch. - OLAPStatus _get_block_from_reader(VectorizedRowBatch** got_batch, bool without_filter, + Status _get_block_from_reader(VectorizedRowBatch** got_batch, bool without_filter, int rows_read); // get block from segment reader. If this function returns OLAP_SUCCESS - OLAPStatus _get_block(bool without_filter, int rows_read = 0); + Status _get_block(bool without_filter, int rows_read = 0); const RowCursor* _current_row() { _read_block->get_row(_read_block->pos(), &_cursor); @@ -202,9 +202,9 @@ public: private: bool _compare(const iterator_offset_t& index, const RowCursor& key, ComparatorEnum comparator_enum) const { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); RowBlockPosition position = _start_block_position; - if (OLAP_SUCCESS != (res = _segment_group->advance_row_block(index, &position))) { + if (!(res = _segment_group->advance_row_block(index, &position))) { LOG(WARNING) << "fail to advance row block. res=" << res; throw ComparatorException(); } diff --git a/be/src/olap/rowset/column_data_writer.cpp b/be/src/olap/rowset/column_data_writer.cpp index d2b44c863b..e9d31dbbcd 100644 --- a/be/src/olap/rowset/column_data_writer.cpp +++ b/be/src/olap/rowset/column_data_writer.cpp @@ -59,8 +59,8 @@ ColumnDataWriter::~ColumnDataWriter() { SAFE_DELETE(_segment_writer); } -OLAPStatus ColumnDataWriter::init() { - OLAPStatus res = OLAP_SUCCESS; +Status ColumnDataWriter::init() { + Status res = Status::OK(); for (size_t i = 0; i < _zone_maps.size(); ++i) { _zone_maps[i].first = WrapperField::create(_segment_group->get_tablet_schema().column(i)); @@ -81,11 +81,11 @@ OLAPStatus ColumnDataWriter::init() { if (nullptr == _row_block) { LOG(WARNING) << "fail to new RowBlock."; - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } res = _cursor.init(_segment_group->get_tablet_schema()); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { LOG(WARNING) << "fail to initiate row cursor. [res=" << res << "]"; return res; } @@ -96,18 +96,18 @@ OLAPStatus ColumnDataWriter::init() { block_info.null_supported = true; _row_block->init(block_info); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus ColumnDataWriter::_init_segment() { - OLAPStatus res = _add_segment(); - if (OLAP_SUCCESS != res) { +Status ColumnDataWriter::_init_segment() { + Status res = _add_segment(); + if (!res.ok()) { LOG(WARNING) << "fail to add segment. [res=" << res << "]"; return res; } res = _segment_group->add_segment(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { LOG(WARNING) << "fail to add index segment. [res=" << res << "]"; return res; } @@ -117,19 +117,19 @@ OLAPStatus ColumnDataWriter::_init_segment() { } template -OLAPStatus ColumnDataWriter::write(const RowType& row) { +Status ColumnDataWriter::write(const RowType& row) { // copy input row to row block _row_block->get_row(_row_index, &_cursor); copy_row(&_cursor, row, _row_block->mem_pool()); next(row); if (_row_index >= _segment_group->get_num_rows_per_row_block()) { - if (OLAP_SUCCESS != _flush_row_block(false)) { + if (!_flush_row_block(false)) { LOG(WARNING) << "failed to flush data while attaching row cursor."; - return OLAP_ERR_OTHER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OTHER_ERROR); } RETURN_NOT_OK(_flush_segment_with_verification()); } - return OLAP_SUCCESS; + return Status::OK(); } template @@ -150,10 +150,10 @@ void ColumnDataWriter::next(const RowType& row) { ++_row_index; } -OLAPStatus ColumnDataWriter::finalize() { +Status ColumnDataWriter::finalize() { if (_all_num_rows == 0 && _row_index == 0) { _segment_group->set_empty(true); - return OLAP_SUCCESS; + return Status::OK(); } // Segment which size reaches OLAP_MAX_COLUMN_SEGMENT_FILE_SIZE @@ -167,58 +167,58 @@ OLAPStatus ColumnDataWriter::finalize() { // it dedicates that there is no necessity // to generate segment object and file. // Return OLAP_SUCCESS is OK. - return OLAP_SUCCESS; + return Status::OK(); } - OLAPStatus res = _flush_row_block(true); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("failed to flush data while attaching row cursor.[res=%d]", res); + Status res = _flush_row_block(true); + if (!res.ok()) { + LOG(WARNING) << "failed to flush data while attaching row cursor.res = " << res; return res; } res = _finalize_segment(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { LOG(WARNING) << "fail to finalize segment. res=" << res << ", _row_index=" << _row_index << ", _all_num_rows=" << _all_num_rows; return res; } res = _segment_group->add_zone_maps(_zone_maps); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "Fail to set zone_map! res=" << res; return res; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus ColumnDataWriter::_flush_row_block(bool finalize) { +Status ColumnDataWriter::_flush_row_block(bool finalize) { if (!_new_segment_created) { RETURN_NOT_OK(_init_segment()); } if (_row_index < 1) { - return OLAP_SUCCESS; + return Status::OK(); } // 与OLAPDataWriter不同,这里不是真的写RowBlock,所以并不需要finalize RowBlock // 但考虑到兼容Row Block的使用方式,还是调用了finalize - OLAPStatus res = _row_block->finalize(_row_index); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to finalize row block. [num_rows=%u res=%d]", _row_index, res); - return OLAP_ERR_WRITER_ROW_BLOCK_ERROR; + Status res = _row_block->finalize(_row_index); + if (!res.ok()) { + LOG(WARNING) << "fail to finalize row block. num_rows=" << _row_index << "res=" << res; + return Status::OLAPInternalError(OLAP_ERR_WRITER_ROW_BLOCK_ERROR); } // 目标是将自己的block按条写入目标block中。 res = _segment_writer->write_batch(_row_block, &_cursor, finalize); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("fail to write row to segment. [res=%d]", res); - return OLAP_ERR_WRITER_DATA_WRITE_ERROR; + if (!res.ok()) { + LOG(WARNING) << "fail to write row to segment. res = " << res; + return Status::OLAPInternalError(OLAP_ERR_WRITER_DATA_WRITE_ERROR); } // 在SegmentGroup中记录的不是数据文件的偏移,而是block的编号 - if (OLAP_SUCCESS != _segment_group->add_row_block(*_row_block, _block_id++)) { + if (!_segment_group->add_row_block(*_row_block, _block_id++)) { OLAP_LOG_WARNING("fail to update index."); - return OLAP_ERR_WRITER_INDEX_WRITE_ERROR; + return Status::OLAPInternalError(OLAP_ERR_WRITER_INDEX_WRITE_ERROR); } // In order to reuse row_block, clear the row_block after finalize @@ -226,15 +226,15 @@ OLAPStatus ColumnDataWriter::_flush_row_block(bool finalize) { _num_rows += _row_index; _all_num_rows += _row_index; _row_index = 0; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus ColumnDataWriter::_add_segment() { +Status ColumnDataWriter::_add_segment() { std::string file_name; if (nullptr != _segment_writer) { OLAP_LOG_WARNING("previous segment is not finalized before add new segment."); - return OLAP_ERR_WRITER_SEGMENT_NOT_FINALIZED; + return Status::OLAPInternalError(OLAP_ERR_WRITER_SEGMENT_NOT_FINALIZED); } file_name = _segment_group->construct_data_file_path(_segment); @@ -244,55 +244,54 @@ OLAPStatus ColumnDataWriter::_add_segment() { if (nullptr == _segment_writer) { OLAP_LOG_WARNING("fail to allocate SegmentWriter"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); if (_is_push_write) { res = _segment_writer->init(config::push_write_mbytes_per_sec); } else { res = _segment_writer->init(config::base_compaction_write_mbytes_per_sec); } - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to init segment writer"); return res; } ++_segment; _block_id = 0; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus ColumnDataWriter::_flush_segment_with_verification() { +Status ColumnDataWriter::_flush_segment_with_verification() { uint64_t segment_size = _segment_writer->estimate_segment_size(); if (UNLIKELY(segment_size < _max_segment_size)) { - return OLAP_SUCCESS; + return Status::OK(); } - OLAPStatus res = _finalize_segment(); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to finalize segment. [res=%d]", res); + Status res = _finalize_segment(); + if (!res.ok()) { + LOG(WARNING) << "fail to finalize segment. res = " << res; return res; } _new_segment_created = false; _num_rows = 0; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus ColumnDataWriter::_finalize_segment() { - OLAPStatus res = OLAP_SUCCESS; +Status ColumnDataWriter::_finalize_segment() { uint32_t data_segment_size; - - if ((res = _segment_writer->finalize(&data_segment_size)) != OLAP_SUCCESS) { + Status res = _segment_writer->finalize(&data_segment_size); + if (res != Status::OK()) { OLAP_LOG_WARNING("fail to finish segment from olap_data."); return res; } - - if ((res != _segment_group->finalize_segment(data_segment_size, _num_rows)) != OLAP_SUCCESS) { + res = _segment_group->finalize_segment(data_segment_size, _num_rows); + if (res != Status::OK()) { OLAP_LOG_WARNING("fail to finish segment from olap_index."); - return OLAP_ERR_WRITER_INDEX_WRITE_ERROR; + return res; } SAFE_DELETE(_segment_writer); @@ -312,8 +311,8 @@ CompressKind ColumnDataWriter::compress_kind() { return _compress_kind; } -template OLAPStatus ColumnDataWriter::write(const RowCursor& row); -template OLAPStatus ColumnDataWriter::write(const ContiguousRow& row); +template Status ColumnDataWriter::write(const RowCursor& row); +template Status ColumnDataWriter::write(const ContiguousRow& row); template void ColumnDataWriter::next(const RowCursor& row); template void ColumnDataWriter::next(const ContiguousRow& row); diff --git a/be/src/olap/rowset/column_data_writer.h b/be/src/olap/rowset/column_data_writer.h index 32b828e1a1..66b72c69ce 100644 --- a/be/src/olap/rowset/column_data_writer.h +++ b/be/src/olap/rowset/column_data_writer.h @@ -37,25 +37,25 @@ public: ColumnDataWriter(SegmentGroup* segment_group, bool is_push_write, CompressKind compress_kind, double bloom_filter_fpp); ~ColumnDataWriter(); - OLAPStatus init(); + Status init(); template - OLAPStatus write(const RowType& row); + Status write(const RowType& row); template void next(const RowType& row); - OLAPStatus finalize(); + Status finalize(); uint64_t written_bytes(); MemPool* mem_pool(); CompressKind compress_kind(); private: - OLAPStatus _add_segment(); - OLAPStatus _flush_segment_with_verification(); - OLAPStatus _finalize_segment(); - OLAPStatus _flush_row_block(bool finalize); - OLAPStatus _init_segment(); + Status _add_segment(); + Status _flush_segment_with_verification(); + Status _finalize_segment(); + Status _flush_row_block(bool finalize); + Status _init_segment(); private: SegmentGroup* _segment_group; diff --git a/be/src/olap/rowset/column_reader.cpp b/be/src/olap/rowset/column_reader.cpp index d75a7cb652..42f301f521 100644 --- a/be/src/olap/rowset/column_reader.cpp +++ b/be/src/olap/rowset/column_reader.cpp @@ -31,11 +31,11 @@ IntegerColumnReader::~IntegerColumnReader() { SAFE_DELETE(_data_reader); } -OLAPStatus IntegerColumnReader::init(std::map* streams, +Status IntegerColumnReader::init(std::map* streams, bool is_sign) { if (nullptr == streams) { OLAP_LOG_WARNING("input streams is nullptr"); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } // Get data stream according to column id and type @@ -44,29 +44,29 @@ OLAPStatus IntegerColumnReader::init(std::map* if (data_stream == nullptr) { OLAP_LOG_WARNING("specified stream is nullptr"); - return OLAP_ERR_COLUMN_STREAM_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_NOT_EXIST); } _data_reader = new (std::nothrow) RunLengthIntegerReader(data_stream, is_sign); if (nullptr == _data_reader) { OLAP_LOG_WARNING("fail to malloc RunLengthIntegerReader"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } // reset eof flag when init, to support reinit - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus IntegerColumnReader::seek(PositionProvider* position) { +Status IntegerColumnReader::seek(PositionProvider* position) { return _data_reader->seek(position); } -OLAPStatus IntegerColumnReader::skip(uint64_t row_count) { +Status IntegerColumnReader::skip(uint64_t row_count) { return _data_reader->skip(row_count); } -OLAPStatus IntegerColumnReader::next(int64_t* value) { +Status IntegerColumnReader::next(int64_t* value) { return _data_reader->next(value); } @@ -81,11 +81,11 @@ StringColumnDirectReader::~StringColumnDirectReader() { SAFE_DELETE(_length_reader); } -OLAPStatus StringColumnDirectReader::init(std::map* streams, +Status StringColumnDirectReader::init(std::map* streams, int size, MemPool* mem_pool) { if (nullptr == streams) { OLAP_LOG_WARNING("input streams is nullptr"); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } // Get data stream according to column id and type @@ -93,7 +93,7 @@ OLAPStatus StringColumnDirectReader::init(std::map(mem_pool->allocate(size * sizeof(Slice))); @@ -103,47 +103,47 @@ OLAPStatus StringColumnDirectReader::init(std::mapseek(position); +Status StringColumnDirectReader::seek(PositionProvider* position) { + Status res = _data_stream->seek(position); // All strings in segment may be empty, so the data stream is EOF and // and length stream is not EOF. - if (OLAP_SUCCESS == res || OLAP_ERR_COLUMN_STREAM_EOF == res) { + if (res.ok() || Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF) == res) { res = _length_reader->seek(position); } return res; } -OLAPStatus StringColumnDirectReader::skip(uint64_t row_count) { - OLAPStatus res = OLAP_SUCCESS; +Status StringColumnDirectReader::skip(uint64_t row_count) { + Status res = Status::OK(); int64_t skip_length = 0; int64_t tmp_length = 0; for (size_t i = 0; i < row_count; ++i) { res = _length_reader->next(&tmp_length); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } skip_length += tmp_length; } - if (OLAP_SUCCESS == res) { + if (res.ok()) { // TODO: skip function of instream is implemented, but not tested return _data_stream->skip(skip_length); } @@ -152,11 +152,11 @@ OLAPStatus StringColumnDirectReader::skip(uint64_t row_count) { } // Return string field of current row_count -OLAPStatus StringColumnDirectReader::next(char* buffer, uint32_t* length) { +Status StringColumnDirectReader::next(char* buffer, uint32_t* length) { int64_t read_length = 0; - OLAPStatus res = _length_reader->next(&read_length); + Status res = _length_reader->next(&read_length); *length = read_length; - while (OLAP_SUCCESS == res && read_length > 0) { + while (res.ok() && read_length > 0) { uint64_t buf_size = read_length; res = _data_stream->read(buffer, &buf_size); read_length -= buf_size; @@ -166,7 +166,7 @@ OLAPStatus StringColumnDirectReader::next(char* buffer, uint32_t* length) { return res; } -OLAPStatus StringColumnDirectReader::next_vector(ColumnVector* column_vector, uint32_t size, +Status StringColumnDirectReader::next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool, int64_t* read_bytes) { /* * MemPool here is not the same as MemPool in init function @@ -175,7 +175,7 @@ OLAPStatus StringColumnDirectReader::next_vector(ColumnVector* column_vector, ui * 2. MemPool in init function is created by SegmentReader, * and free by SegmentReader deconstruction. */ - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); int64_t length = 0; int64_t string_buffer_size = 0; @@ -183,7 +183,7 @@ OLAPStatus StringColumnDirectReader::next_vector(ColumnVector* column_vector, ui if (column_vector->no_nulls()) { for (int i = 0; i < size; ++i) { res = _length_reader->next(&length); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } _values[i].size = length; @@ -192,7 +192,7 @@ OLAPStatus StringColumnDirectReader::next_vector(ColumnVector* column_vector, ui uint8_t* allocated_mem; res = mem_pool->allocate_safely(string_buffer_size, allocated_mem); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } char* string_buffer = reinterpret_cast(allocated_mem); @@ -207,7 +207,7 @@ OLAPStatus StringColumnDirectReader::next_vector(ColumnVector* column_vector, ui while (length > 0) { uint64_t buf_size = length; res = _data_stream->read(string_buffer, &buf_size); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { return res; } length -= buf_size; @@ -219,7 +219,7 @@ OLAPStatus StringColumnDirectReader::next_vector(ColumnVector* column_vector, ui for (int i = 0; i < size; ++i) { if (!is_null[i]) { res = _length_reader->next(&length); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } _values[i].size = length; @@ -231,7 +231,7 @@ OLAPStatus StringColumnDirectReader::next_vector(ColumnVector* column_vector, ui uint8_t* allocated_mem; res = mem_pool->allocate_safely(string_buffer_size, allocated_mem); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } char* string_buffer = reinterpret_cast(allocated_mem); @@ -247,7 +247,7 @@ OLAPStatus StringColumnDirectReader::next_vector(ColumnVector* column_vector, ui while (length > 0) { uint64_t buf_size = length; res = _data_stream->read(string_buffer, &buf_size); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { return res; } length -= buf_size; @@ -283,14 +283,14 @@ StringColumnDictionaryReader::~StringColumnDictionaryReader() { SAFE_DELETE_ARRAY(_read_buffer); } -OLAPStatus StringColumnDictionaryReader::init(std::map* streams, +Status StringColumnDictionaryReader::init(std::map* streams, int size, MemPool* mem_pool) { ReadOnlyFileStream* dictionary_data_stream = extract_stream(_column_unique_id, StreamInfoMessage::DICTIONARY_DATA, streams); if (nullptr == dictionary_data_stream) { OLAP_LOG_WARNING("dictionary data stream not found. [unique id = %u]", _column_unique_id); - return OLAP_ERR_COLUMN_STREAM_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_NOT_EXIST); } ReadOnlyFileStream* dictionary_length_stream = @@ -298,12 +298,12 @@ OLAPStatus StringColumnDictionaryReader::init(std::map(mem_pool->allocate(size * sizeof(Slice))); int64_t read_buffer_size = 1024; @@ -311,7 +311,7 @@ OLAPStatus StringColumnDictionaryReader::init(std::mapnext(&length); // 理论上应该足够读，读出eof也是不对的。 - if (OLAP_SUCCESS != res || length < 0) { - OLAP_LOG_WARNING("build offset dictionary failed. [res = %d]", res); + if (!res.ok() || length < 0) { + LOG(WARNING) << "build offset dictionary failed. res = " << res; return res; } @@ -332,7 +332,7 @@ OLAPStatus StringColumnDictionaryReader::init(std::map(read_length) != length) { OLAP_LOG_WARNING("read stream fail."); - return OLAP_ERR_COLUMN_READ_STREAM; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_READ_STREAM); } dictionary_item.assign(_read_buffer, length); @@ -354,35 +354,35 @@ OLAPStatus StringColumnDictionaryReader::init(std::mapseek(position); } -OLAPStatus StringColumnDictionaryReader::skip(uint64_t row_count) { +Status StringColumnDictionaryReader::skip(uint64_t row_count) { return _data_reader->skip(row_count); } -OLAPStatus StringColumnDictionaryReader::next(char* buffer, uint32_t* length) { +Status StringColumnDictionaryReader::next(char* buffer, uint32_t* length) { int64_t value; - OLAPStatus res = _data_reader->next(&value); + Status res = _data_reader->next(&value); // 错误或是EOF - if (OLAP_SUCCESS != res) { - if (OLAP_ERR_DATA_EOF == res) { + if (!res.ok()) { + if (Status::OLAPInternalError(OLAP_ERR_DATA_EOF) == res) { _eof = true; } @@ -394,26 +394,26 @@ OLAPStatus StringColumnDictionaryReader::next(char* buffer, uint32_t* length) { "value may indicated an invalid dictionary entry. " "[value = %lu, dictionary_size = %lu]", value, _dictionary.size()); - return OLAP_ERR_BUFFER_OVERFLOW; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } memcpy(buffer, _dictionary[value].c_str(), _dictionary[value].size()); *length = _dictionary[value].size(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus StringColumnDictionaryReader::next_vector(ColumnVector* column_vector, uint32_t size, +Status StringColumnDictionaryReader::next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool, int64_t* read_bytes) { int64_t index[size]; int64_t buffer_size = 0; - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); column_vector->set_col_data(_values); if (column_vector->no_nulls()) { for (int i = 0; i < size; ++i) { res = _data_reader->next(&index[i]); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } if (index[i] >= static_cast(_dictionary.size())) { @@ -421,7 +421,7 @@ OLAPStatus StringColumnDictionaryReader::next_vector(ColumnVector* column_vector "value may indicated an invalid dictionary entry. " "[index = %lu, dictionary_size = %lu]", index[i], _dictionary.size()); - return OLAP_ERR_BUFFER_OVERFLOW; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } _values[i].size = _dictionary[index[i]].size(); buffer_size += _values[i].size; @@ -438,7 +438,7 @@ OLAPStatus StringColumnDictionaryReader::next_vector(ColumnVector* column_vector for (int i = 0; i < size; ++i) { if (!is_null[i]) { res = _data_reader->next(&index[i]); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } if (index[i] >= static_cast(_dictionary.size())) { @@ -446,7 +446,7 @@ OLAPStatus StringColumnDictionaryReader::next_vector(ColumnVector* column_vector "value may indicated an invalid dictionary entry. " "[index = %lu, dictionary_size = %lu]", index[i], _dictionary.size()); - return OLAP_ERR_BUFFER_OVERFLOW; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } _values[i].size = _dictionary[index[i]].size(); buffer_size += _values[i].size; @@ -660,11 +660,11 @@ ColumnReader::~ColumnReader() { SAFE_DELETE(_present_reader); } -OLAPStatus ColumnReader::init(std::map* streams, int size, +Status ColumnReader::init(std::map* streams, int size, MemPool* mem_pool, OlapReaderStatistics* stats) { if (nullptr == streams) { OLAP_LOG_WARNING("null parameters given."); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } _stats = stats; @@ -684,42 +684,42 @@ OLAPStatus ColumnReader::init(std::map* streams if (nullptr == _present_reader) { OLAP_LOG_WARNING("malloc present reader failed."); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } - if (OLAP_SUCCESS != _present_reader->init()) { + if (!_present_reader->init()) { OLAP_LOG_WARNING("fail to init present reader."); - return OLAP_ERR_INIT_FAILED; + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } _value_present = true; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus ColumnReader::seek(PositionProvider* position) { +Status ColumnReader::seek(PositionProvider* position) { if (nullptr != _present_reader) { return _present_reader->seek(position); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus ColumnReader::skip(uint64_t row_count) { - return OLAP_SUCCESS; +Status ColumnReader::skip(uint64_t row_count) { + return Status::OK(); } -OLAPStatus ColumnReader::next_vector(ColumnVector* column_vector, uint32_t size, +Status ColumnReader::next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); column_vector->set_is_null(_is_null); if (nullptr != _present_reader) { column_vector->set_no_nulls(false); for (uint32_t i = 0; i < size; ++i) { bool value = false; res = _present_reader->next((char*)&value); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { break; } _is_null[i] = value; @@ -734,13 +734,13 @@ OLAPStatus ColumnReader::next_vector(ColumnVector* column_vector, uint32_t size, uint64_t ColumnReader::_count_none_nulls(uint64_t rows) { if (_present_reader != nullptr) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); uint64_t result = 0; for (uint64_t counter = 0; counter < rows; ++counter) { res = _present_reader->next(reinterpret_cast(&_value_present)); - if (OLAP_SUCCESS == res && (false == _value_present)) { + if (res.ok() && (false == _value_present)) { result += 1; } else { break; @@ -763,11 +763,11 @@ TinyColumnReader::~TinyColumnReader() { SAFE_DELETE(_data_reader); } -OLAPStatus TinyColumnReader::init(std::map* streams, int size, +Status TinyColumnReader::init(std::map* streams, int size, MemPool* mem_pool, OlapReaderStatistics* stats) { if (nullptr == streams) { OLAP_LOG_WARNING("input streams is nullptr"); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } ColumnReader::init(streams, size, mem_pool, stats); @@ -776,7 +776,7 @@ OLAPStatus TinyColumnReader::init(std::map* str if (nullptr == data_stream) { OLAP_LOG_WARNING("specified stream not exist"); - return OLAP_ERR_COLUMN_STREAM_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_NOT_EXIST); } _values = reinterpret_cast(mem_pool->allocate(size)); @@ -784,44 +784,44 @@ OLAPStatus TinyColumnReader::init(std::map* str if (nullptr == _data_reader) { OLAP_LOG_WARNING("malloc data reader failed"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus TinyColumnReader::seek(PositionProvider* positions) { - OLAPStatus res; +Status TinyColumnReader::seek(PositionProvider* positions) { + Status res; if (nullptr == _present_reader) { res = _data_reader->seek(positions); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } } else { res = ColumnReader::seek(positions); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } res = _data_reader->seek(positions); - if (OLAP_SUCCESS != res && OLAP_ERR_COLUMN_STREAM_EOF != res) { - OLAP_LOG_WARNING("fail to seek tinyint stream. [res=%d]", res); + if (!res.ok() && Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF) != res) { + LOG(WARNING) << "fail to seek tinyint stream. res = " << res; return res; } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus TinyColumnReader::skip(uint64_t row_count) { +Status TinyColumnReader::skip(uint64_t row_count) { // count_none_nulls 其实就是columnReader的跳过函数。 return _data_reader->skip(_count_none_nulls(row_count)); } -OLAPStatus TinyColumnReader::next_vector(ColumnVector* column_vector, uint32_t size, +Status TinyColumnReader::next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) { - OLAPStatus res = ColumnReader::next_vector(column_vector, size, mem_pool); - if (OLAP_SUCCESS != res) { - if (OLAP_ERR_DATA_EOF == res) { + Status res = ColumnReader::next_vector(column_vector, size, mem_pool); + if (!res.ok()) { + if (Status::OLAPInternalError(OLAP_ERR_DATA_EOF) == res) { _eof = true; } return res; @@ -832,7 +832,7 @@ OLAPStatus TinyColumnReader::next_vector(ColumnVector* column_vector, uint32_t s if (column_vector->no_nulls()) { for (uint32_t i = 0; i < size; ++i) { res = _data_reader->next(_values + i); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { break; } } @@ -840,7 +840,7 @@ OLAPStatus TinyColumnReader::next_vector(ColumnVector* column_vector, uint32_t s for (uint32_t i = 0; i < size; ++i) { if (!is_null[i]) { res = _data_reader->next(_values + i); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { break; } } @@ -848,7 +848,7 @@ OLAPStatus TinyColumnReader::next_vector(ColumnVector* column_vector, uint32_t s } _stats->bytes_read += size; - if (OLAP_ERR_DATA_EOF == res) { + if (Status::OLAPInternalError(OLAP_ERR_DATA_EOF) == res) { _eof = true; } @@ -867,11 +867,11 @@ DecimalColumnReader::~DecimalColumnReader() { SAFE_DELETE(_frac_reader); } -OLAPStatus DecimalColumnReader::init(std::map* streams, int size, +Status DecimalColumnReader::init(std::map* streams, int size, MemPool* mem_pool, OlapReaderStatistics* stats) { if (nullptr == streams) { OLAP_LOG_WARNING("input streams is nullptr"); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } // reset stream and reader @@ -885,7 +885,7 @@ OLAPStatus DecimalColumnReader::init(std::map* if (nullptr == int_stream) { OLAP_LOG_WARNING("specified stream not found. [unique_id = %u]", _column_unique_id); - return OLAP_ERR_COLUMN_STREAM_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_NOT_EXIST); } ReadOnlyFileStream* frac_stream = @@ -893,84 +893,84 @@ OLAPStatus DecimalColumnReader::init(std::map* if (nullptr == frac_stream) { OLAP_LOG_WARNING("specified stream not found. [unique_id = %u]", _column_unique_id); - return OLAP_ERR_COLUMN_STREAM_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_NOT_EXIST); } _int_reader = new (std::nothrow) RunLengthIntegerReader(int_stream, true); if (nullptr == _int_reader) { OLAP_LOG_WARNING("fail to malloc RunLengthIntegerReader"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } _frac_reader = new (std::nothrow) RunLengthIntegerReader(frac_stream, true); if (nullptr == _frac_reader) { OLAP_LOG_WARNING("fail to malloc RunLengthIntegerReader"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus DecimalColumnReader::seek(PositionProvider* positions) { - OLAPStatus res; +Status DecimalColumnReader::seek(PositionProvider* positions) { + Status res; if (nullptr == _present_reader) { res = _int_reader->seek(positions); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } res = _frac_reader->seek(positions); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } } else { //all field in the segment can be nullptr, so the data stream is EOF res = ColumnReader::seek(positions); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } res = _int_reader->seek(positions); - if (OLAP_SUCCESS != res && OLAP_ERR_COLUMN_STREAM_EOF != res) { - OLAP_LOG_WARNING("fail to seek int stream of decimal. [res=%d]", res); + if (!res.ok() && Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF) != res) { + LOG(WARNING) << "fail to seek int stream of decimal. res = " << res; return res; } res = _frac_reader->seek(positions); - if (OLAP_SUCCESS != res && OLAP_ERR_COLUMN_STREAM_EOF != res) { - OLAP_LOG_WARNING("fail to seek frac stream of decimal. [res=%d]", res); + if (!res.ok() && Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF) != res) { + LOG(WARNING) << "fail to seek frac stream of decimal. res = " << res; return res; } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus DecimalColumnReader::skip(uint64_t row_count) { - OLAPStatus res = _int_reader->skip(row_count); +Status DecimalColumnReader::skip(uint64_t row_count) { + Status res = _int_reader->skip(row_count); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to create int part reader"); return res; } res = _frac_reader->skip(row_count); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to create frac part reader"); return res; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus DecimalColumnReader::next_vector(ColumnVector* column_vector, uint32_t size, +Status DecimalColumnReader::next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) { - OLAPStatus res = ColumnReader::next_vector(column_vector, size, mem_pool); - if (OLAP_SUCCESS != res) { - if (OLAP_ERR_DATA_EOF == res) { + Status res = ColumnReader::next_vector(column_vector, size, mem_pool); + if (!res.ok()) { + if (Status::OLAPInternalError(OLAP_ERR_DATA_EOF) == res) { _eof = true; } return res; @@ -982,15 +982,15 @@ OLAPStatus DecimalColumnReader::next_vector(ColumnVector* column_vector, uint32_ if (column_vector->no_nulls()) { for (uint32_t i = 0; i < size; ++i) { int64_t value = 0; - OLAPStatus res = _int_reader->next(&value); - if (OLAP_SUCCESS != res) { + Status res = _int_reader->next(&value); + if (!res.ok()) { OLAP_LOG_WARNING("fail to read decimal int part"); break; } _values[i].integer = value; res = _frac_reader->next(&value); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to read decimal frac part"); break; } @@ -1000,15 +1000,15 @@ OLAPStatus DecimalColumnReader::next_vector(ColumnVector* column_vector, uint32_ for (uint32_t i = 0; i < size; ++i) { int64_t value = 0; if (!is_null[i]) { - OLAPStatus res = _int_reader->next(&value); - if (OLAP_SUCCESS != res) { + Status res = _int_reader->next(&value); + if (!res.ok()) { OLAP_LOG_WARNING("fail to read decimal int part"); break; } _values[i].integer = value; res = _frac_reader->next(&value); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to read decimal frac part"); break; } @@ -1033,11 +1033,11 @@ LargeIntColumnReader::~LargeIntColumnReader() { SAFE_DELETE(_low_reader); } -OLAPStatus LargeIntColumnReader::init(std::map* streams, int size, +Status LargeIntColumnReader::init(std::map* streams, int size, MemPool* mem_pool, OlapReaderStatistics* stats) { if (nullptr == streams) { OLAP_LOG_WARNING("input streams is nullptr"); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } // reset stream and reader @@ -1051,88 +1051,88 @@ OLAPStatus LargeIntColumnReader::init(std::map* extract_stream(_column_unique_id, StreamInfoMessage::DATA, streams); if (nullptr == high_stream) { OLAP_LOG_WARNING("specified stream not found. [unique_id = %u]", _column_unique_id); - return OLAP_ERR_COLUMN_STREAM_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_NOT_EXIST); } ReadOnlyFileStream* low_stream = extract_stream(_column_unique_id, StreamInfoMessage::SECONDARY, streams); if (nullptr == low_stream) { OLAP_LOG_WARNING("specified stream not found. [unique_id = %u]", _column_unique_id); - return OLAP_ERR_COLUMN_STREAM_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_NOT_EXIST); } _high_reader = new (std::nothrow) RunLengthIntegerReader(high_stream, true); if (nullptr == _high_reader) { OLAP_LOG_WARNING("fail to malloc RunLengthIntegerReader."); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } _low_reader = new (std::nothrow) RunLengthIntegerReader(low_stream, true); if (nullptr == _low_reader) { OLAP_LOG_WARNING("fail to malloc RunLengthIntegerReader."); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus LargeIntColumnReader::seek(PositionProvider* positions) { - OLAPStatus res; +Status LargeIntColumnReader::seek(PositionProvider* positions) { + Status res; if (nullptr == _present_reader) { res = _high_reader->seek(positions); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } res = _low_reader->seek(positions); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } } else { //all field in the segment can be nullptr, so the data stream is EOF res = ColumnReader::seek(positions); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to seek null stream of largeint"); return res; } res = _high_reader->seek(positions); - if (OLAP_SUCCESS != res && OLAP_ERR_COLUMN_STREAM_EOF != res) { - OLAP_LOG_WARNING("fail to seek high int stream of largeint. [res=%d]", res); + if (!res.ok() && Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF) != res) { + LOG(WARNING) << "fail to seek high int stream of largeint. res = " << res; return res; } res = _low_reader->seek(positions); - if (OLAP_SUCCESS != res && OLAP_ERR_COLUMN_STREAM_EOF != res) { - OLAP_LOG_WARNING("fail to seek low int stream of largeint. [res=%d]", res); + if (!res.ok() && Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF) != res) { + LOG(WARNING) << "fail to seek low int stream of largeint. res = " << res; return res; } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus LargeIntColumnReader::skip(uint64_t row_count) { - OLAPStatus res = _high_reader->skip(row_count); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to skip large int high part. [res=%d]", res); +Status LargeIntColumnReader::skip(uint64_t row_count) { + Status res = _high_reader->skip(row_count); + if (!res.ok()) { + LOG(WARNING) << "fail to skip large int high part. res = " << res; return res; } res = _low_reader->skip(row_count); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to skip large int low part reader. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to skip large int low part reader. res = " << res; return res; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus LargeIntColumnReader::next_vector(ColumnVector* column_vector, uint32_t size, +Status LargeIntColumnReader::next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) { - OLAPStatus res = ColumnReader::next_vector(column_vector, size, mem_pool); - if (OLAP_SUCCESS != res) { - if (OLAP_ERR_DATA_EOF == res) { + Status res = ColumnReader::next_vector(column_vector, size, mem_pool); + if (!res.ok()) { + if (Status::OLAPInternalError(OLAP_ERR_DATA_EOF) == res) { _eof = true; } return res; @@ -1146,13 +1146,13 @@ OLAPStatus LargeIntColumnReader::next_vector(ColumnVector* column_vector, uint32 int64_t* value = nullptr; value = (int64_t*)(_values + i); res = _high_reader->next(value); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to read decimal int part"); break; } res = _low_reader->next(++value); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to read decimal frac part"); break; } @@ -1163,13 +1163,13 @@ OLAPStatus LargeIntColumnReader::next_vector(ColumnVector* column_vector, uint32 if (!is_null[i]) { value = (int64_t*)(_values + i); res = _high_reader->next(value); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to read decimal int part"); break; } res = _low_reader->next(++value); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to read decimal frac part"); break; } diff --git a/be/src/olap/rowset/column_reader.h b/be/src/olap/rowset/column_reader.h index 0303b2e67f..9ea973cca9 100644 --- a/be/src/olap/rowset/column_reader.h +++ b/be/src/olap/rowset/column_reader.h @@ -78,13 +78,13 @@ public: * @param is_sign whether the number read has a sign * @return [description] */ - OLAPStatus init(std::map* streams, bool is_sign); + Status init(std::map* streams, bool is_sign); // Position the internal pointer to positions - OLAPStatus seek(PositionProvider* positions); + Status seek(PositionProvider* positions); // Move the internal pointer back row_count rows - OLAPStatus skip(uint64_t row_count); + Status skip(uint64_t row_count); // Return the data of the current row by moving the internal pointer to the next row - OLAPStatus next(int64_t* value); + Status next(int64_t* value); bool eof() { return _eof; } private: @@ -100,15 +100,15 @@ public: StringColumnDirectReader(uint32_t column_unique_id, uint32_t dictionary_size); ~StringColumnDirectReader(); - OLAPStatus init(std::map* streams, int size, + Status init(std::map* streams, int size, MemPool* mem_pool); - OLAPStatus seek(PositionProvider* positions); - OLAPStatus skip(uint64_t row_count); + Status seek(PositionProvider* positions); + Status skip(uint64_t row_count); // Return the data of the current row and move the internal pointer backward // buffer - the buffer of the returned data // length - the size of the buffer area when input, and the size of the string when returning - OLAPStatus next(char* buffer, uint32_t* length); - OLAPStatus next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool, + Status next(char* buffer, uint32_t* length); + Status next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool, int64_t* read_bytes); size_t get_buffer_size() { return sizeof(RunLengthByteReader); } @@ -132,12 +132,12 @@ class StringColumnDictionaryReader { public: StringColumnDictionaryReader(uint32_t column_unique_id, uint32_t dictionary_size); ~StringColumnDictionaryReader(); - OLAPStatus init(std::map* streams, int size, + Status init(std::map* streams, int size, MemPool* mem_pool); - OLAPStatus seek(PositionProvider* positions); - OLAPStatus skip(uint64_t row_count); - OLAPStatus next(char* buffer, uint32_t* length); - OLAPStatus next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool, + Status seek(PositionProvider* positions); + Status skip(uint64_t row_count); + Status next(char* buffer, uint32_t* length); + Status next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool, int64_t* read_bytes); size_t get_buffer_size() { return sizeof(RunLengthByteReader) + _dictionary_size; } @@ -188,17 +188,17 @@ public: // ColumnReader is initialized only once, and a new object is allocated each time it is used. // Input: // streams-input stream - virtual OLAPStatus init(std::map* streams, int size, + virtual Status init(std::map* streams, int size, MemPool* mem_pool, OlapReaderStatistics* stats); // Set the position of the next returned data // positions are the positions where each column needs to seek, ColumnReader passes (*positions)[_column_unique_id] // Get the seek position of this column - virtual OLAPStatus seek(PositionProvider* positions); + virtual Status seek(PositionProvider* positions); - virtual OLAPStatus skip(uint64_t row_count); + virtual Status skip(uint64_t row_count); - virtual OLAPStatus next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool); + virtual Status next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool); uint32_t column_unique_id() { return _column_unique_id; } @@ -233,7 +233,7 @@ public: virtual ~DefaultValueReader() {} - virtual OLAPStatus init(std::map* streams, int size, + virtual Status init(std::map* streams, int size, MemPool* mem_pool, OlapReaderStatistics* stats) { switch (_type) { case OLAP_FIELD_TYPE_TINYINT: { @@ -364,16 +364,16 @@ public: break; } _stats = stats; - return OLAP_SUCCESS; + return Status::OK(); } - virtual OLAPStatus seek(PositionProvider* positions) { return OLAP_SUCCESS; } - virtual OLAPStatus skip(uint64_t row_count) { return OLAP_SUCCESS; } + virtual Status seek(PositionProvider* positions) { return Status::OK(); } + virtual Status skip(uint64_t row_count) { return Status::OK(); } - virtual OLAPStatus next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) { + virtual Status next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) { column_vector->set_no_nulls(true); column_vector->set_col_data(_values); _stats->bytes_read += _length * size; - return OLAP_SUCCESS; + return Status::OK(); } private: @@ -387,21 +387,21 @@ class NullValueReader : public ColumnReader { public: NullValueReader(uint32_t column_id, uint32_t column_unique_id) : ColumnReader(column_id, column_unique_id) {} - OLAPStatus init(std::map* streams, int size, MemPool* mem_pool, + Status init(std::map* streams, int size, MemPool* mem_pool, OlapReaderStatistics* stats) override { _is_null = reinterpret_cast(mem_pool->allocate(size)); memset(_is_null, 1, size); _stats = stats; - return OLAP_SUCCESS; + return Status::OK(); } - virtual OLAPStatus seek(PositionProvider* positions) override { return OLAP_SUCCESS; } - virtual OLAPStatus skip(uint64_t row_count) override { return OLAP_SUCCESS; } - virtual OLAPStatus next_vector(ColumnVector* column_vector, uint32_t size, + virtual Status seek(PositionProvider* positions) override { return Status::OK(); } + virtual Status skip(uint64_t row_count) override { return Status::OK(); } + virtual Status next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) override { column_vector->set_no_nulls(false); column_vector->set_is_null(_is_null); _stats->bytes_read += size; - return OLAP_SUCCESS; + return Status::OK(); } }; @@ -411,11 +411,11 @@ public: TinyColumnReader(uint32_t column_id, uint32_t column_unique_id); virtual ~TinyColumnReader(); - virtual OLAPStatus init(std::map* streams, int size, + virtual Status init(std::map* streams, int size, MemPool* mem_pool, OlapReaderStatistics* stats); - virtual OLAPStatus seek(PositionProvider* positions); - virtual OLAPStatus skip(uint64_t row_count); - virtual OLAPStatus next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool); + virtual Status seek(PositionProvider* positions); + virtual Status skip(uint64_t row_count); + virtual Status next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool); virtual size_t get_buffer_size() { return sizeof(RunLengthByteReader); } @@ -437,11 +437,11 @@ public: virtual ~IntegerColumnReaderWrapper() {} - virtual OLAPStatus init(std::map* streams, int size, + virtual Status init(std::map* streams, int size, MemPool* mem_pool, OlapReaderStatistics* stats) { - OLAPStatus res = ColumnReader::init(streams, size, mem_pool, stats); + Status res = ColumnReader::init(streams, size, mem_pool, stats); - if (OLAP_SUCCESS == res) { + if (res.ok()) { res = _reader.init(streams, is_sign); } @@ -449,36 +449,36 @@ public: return res; } - virtual OLAPStatus seek(PositionProvider* positions) { - OLAPStatus res; + virtual Status seek(PositionProvider* positions) { + Status res; if (nullptr == _present_reader) { res = _reader.seek(positions); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } } else { //all field in the segment can be nullptr, so the data stream is EOF res = ColumnReader::seek(positions); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } res = _reader.seek(positions); - if (OLAP_SUCCESS != res && OLAP_ERR_COLUMN_STREAM_EOF != res) { - OLAP_LOG_WARNING("fail to seek int stream. [res=%d]", res); + if (!res.ok() && Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF) != res) { + LOG(WARNING) << "fail to seek int stream. res = " << res; return res; } } - return OLAP_SUCCESS; + return Status::OK(); } - virtual OLAPStatus skip(uint64_t row_count) { + virtual Status skip(uint64_t row_count) { return _reader.skip(_count_none_nulls(row_count)); } - virtual OLAPStatus next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) { - OLAPStatus res = ColumnReader::next_vector(column_vector, size, mem_pool); - if (OLAP_SUCCESS != res) { - if (OLAP_ERR_DATA_EOF == res) { + virtual Status next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) { + Status res = ColumnReader::next_vector(column_vector, size, mem_pool); + if (!res.ok()) { + if (Status::OLAPInternalError(OLAP_ERR_DATA_EOF) == res) { _eof = true; } return res; @@ -489,7 +489,7 @@ public: for (uint32_t i = 0; i < size; ++i) { int64_t value = 0; res = _reader.next(&value); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { break; } _values[i] = value; @@ -500,7 +500,7 @@ public: int64_t value = 0; if (!is_null[i]) { res = _reader.next(&value); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { break; } } @@ -509,7 +509,7 @@ public: } _stats->bytes_read += sizeof(T) * size; - if (OLAP_ERR_DATA_EOF == res) { + if (Status::OLAPInternalError(OLAP_ERR_DATA_EOF) == res) { _eof = true; } return res; @@ -537,46 +537,46 @@ public: _string_length(string_length) {} virtual ~FixLengthStringColumnReader() {} - virtual OLAPStatus init(std::map* streams, int size, + virtual Status init(std::map* streams, int size, MemPool* mem_pool, OlapReaderStatistics* stats) { - OLAPStatus res = ColumnReader::init(streams, size, mem_pool, stats); + Status res = ColumnReader::init(streams, size, mem_pool, stats); - if (OLAP_SUCCESS == res) { + if (res.ok()) { res = _reader.init(streams, size, mem_pool); } return res; } - virtual OLAPStatus seek(PositionProvider* positions) { - OLAPStatus res; + virtual Status seek(PositionProvider* positions) { + Status res; if (nullptr == _present_reader) { res = _reader.seek(positions); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } } else { //all field in the segment can be nullptr, so the data stream is EOF res = ColumnReader::seek(positions); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } res = _reader.seek(positions); - if (OLAP_SUCCESS != res && OLAP_ERR_COLUMN_STREAM_EOF != res) { - OLAP_LOG_WARNING("fail to read fixed string stream. [res=%d]", res); + if (!res.ok() && Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF) != res) { + LOG(WARNING) << "fail to read fixed string stream. res = " << res; return res; } } - return OLAP_SUCCESS; + return Status::OK(); } - virtual OLAPStatus skip(uint64_t row_count) { + virtual Status skip(uint64_t row_count) { return _reader.skip(_count_none_nulls(row_count)); } - virtual OLAPStatus next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) { - OLAPStatus res = ColumnReader::next_vector(column_vector, size, mem_pool); - if (OLAP_SUCCESS != res) { - if (OLAP_ERR_DATA_EOF == res) { + virtual Status next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) { + Status res = ColumnReader::next_vector(column_vector, size, mem_pool); + if (!res.ok()) { + if (Status::OLAPInternalError(OLAP_ERR_DATA_EOF) == res) { _eof = true; } return res; @@ -604,46 +604,46 @@ public: _reader(column_unique_id, dictionary_size), _max_length(max_length) {} virtual ~VarStringColumnReader() {} - virtual OLAPStatus init(std::map* streams, int size, + virtual Status init(std::map* streams, int size, MemPool* mem_pool, OlapReaderStatistics* stats) { - OLAPStatus res = ColumnReader::init(streams, size, mem_pool, stats); - if (OLAP_SUCCESS == res) { + Status res = ColumnReader::init(streams, size, mem_pool, stats); + if (res.ok()) { res = _reader.init(streams, size, mem_pool); } return res; } - virtual OLAPStatus seek(PositionProvider* position) { - OLAPStatus res; + virtual Status seek(PositionProvider* position) { + Status res; if (nullptr == _present_reader) { res = _reader.seek(position); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } } else { //all field in the segment can be nullptr, so the data stream is EOF res = ColumnReader::seek(position); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } res = _reader.seek(position); - if (OLAP_SUCCESS != res && OLAP_ERR_COLUMN_STREAM_EOF != res) { - OLAP_LOG_WARNING("fail to seek varchar stream. [res=%d]", res); + if (!res.ok() && Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF) != res) { + LOG(WARNING) << "fail to seek varchar stream. res = " << res; return res; } } - return OLAP_SUCCESS; + return Status::OK(); } - virtual OLAPStatus skip(uint64_t row_count) { + virtual Status skip(uint64_t row_count) { return _reader.skip(_count_none_nulls(row_count)); } - virtual OLAPStatus next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) { - OLAPStatus res = ColumnReader::next_vector(column_vector, size, mem_pool); - if (OLAP_SUCCESS != res) { - if (OLAP_ERR_DATA_EOF == res) { + virtual Status next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) { + Status res = ColumnReader::next_vector(column_vector, size, mem_pool); + if (!res.ok()) { + if (Status::OLAPInternalError(OLAP_ERR_DATA_EOF) == res) { _eof = true; } return res; @@ -671,11 +671,11 @@ public: virtual ~FloatintPointColumnReader() {} - virtual OLAPStatus init(std::map* streams, int size, + virtual Status init(std::map* streams, int size, MemPool* mem_pool, OlapReaderStatistics* stats) { if (nullptr == streams) { OLAP_LOG_WARNING("input streams is nullptr"); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } // reset stream and reader @@ -684,63 +684,63 @@ public: if (nullptr == _data_stream) { OLAP_LOG_WARNING("specified stream not exist"); - return OLAP_ERR_COLUMN_STREAM_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_NOT_EXIST); } _values = reinterpret_cast(mem_pool->allocate(size * sizeof(FLOAT_TYPE))); - return OLAP_SUCCESS; + return Status::OK(); } - virtual OLAPStatus seek(PositionProvider* position) { + virtual Status seek(PositionProvider* position) { if (nullptr == position) { OLAP_LOG_WARNING("input positions is nullptr"); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } if (nullptr == _data_stream) { OLAP_LOG_WARNING("reader not init."); - return OLAP_ERR_NOT_INITED; + return Status::OLAPInternalError(OLAP_ERR_NOT_INITED); } - OLAPStatus res; + Status res; if (nullptr == _present_reader) { res = _data_stream->seek(position); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } } else { //all field in the segment can be nullptr, so the data stream is EOF res = ColumnReader::seek(position); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } res = _data_stream->seek(position); - if (OLAP_SUCCESS != res && OLAP_ERR_COLUMN_STREAM_EOF != res) { - OLAP_LOG_WARNING("fail to seek float stream. [res=%d]", res); + if (!res.ok() && Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF) != res) { + LOG(WARNING) << "fail to seek float stream. res = " << res; return res; } } - return OLAP_SUCCESS; + return Status::OK(); } - virtual OLAPStatus skip(uint64_t row_count) { + virtual Status skip(uint64_t row_count) { if (nullptr == _data_stream) { OLAP_LOG_WARNING("reader not init."); - return OLAP_ERR_NOT_INITED; + return Status::OLAPInternalError(OLAP_ERR_NOT_INITED); } uint64_t skip_values_count = _count_none_nulls(row_count); return _data_stream->skip(skip_values_count * sizeof(FLOAT_TYPE)); } - virtual OLAPStatus next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) { + virtual Status next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) { if (nullptr == _data_stream) { OLAP_LOG_WARNING("reader not init."); - return OLAP_ERR_NOT_INITED; + return Status::OLAPInternalError(OLAP_ERR_NOT_INITED); } - OLAPStatus res = ColumnReader::next_vector(column_vector, size, mem_pool); - if (OLAP_SUCCESS != res) { - if (OLAP_ERR_DATA_EOF == res) { + Status res = ColumnReader::next_vector(column_vector, size, mem_pool); + if (!res.ok()) { + if (Status::OLAPInternalError(OLAP_ERR_DATA_EOF) == res) { _eof = true; } return res; @@ -753,7 +753,7 @@ public: for (uint32_t i = 0; i < size; ++i) { FLOAT_TYPE value = 0.0; res = _data_stream->read(reinterpret_cast(&value), &length); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { break; } _values[i] = value; @@ -763,7 +763,7 @@ public: FLOAT_TYPE value = 0.0; if (!is_null[i]) { res = _data_stream->read(reinterpret_cast(&value), &length); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { break; } } @@ -772,7 +772,7 @@ public: } _stats->bytes_read += sizeof(FLOAT_TYPE) * size; - if (OLAP_ERR_DATA_EOF == res) { + if (Status::OLAPInternalError(OLAP_ERR_DATA_EOF) == res) { _eof = true; } @@ -789,11 +789,11 @@ class DecimalColumnReader : public ColumnReader { public: DecimalColumnReader(uint32_t column_id, uint32_t column_unique_id); virtual ~DecimalColumnReader(); - OLAPStatus init(std::map* streams, int size, MemPool* mem_pool, + Status init(std::map* streams, int size, MemPool* mem_pool, OlapReaderStatistics* stats) override; - virtual OLAPStatus seek(PositionProvider* positions) override; - virtual OLAPStatus skip(uint64_t row_count) override; - virtual OLAPStatus next_vector(ColumnVector* column_vector, uint32_t size, + virtual Status seek(PositionProvider* positions) override; + virtual Status skip(uint64_t row_count) override; + virtual Status next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool) override; virtual size_t get_buffer_size() override { return sizeof(RunLengthByteReader) * 2; } @@ -809,11 +809,11 @@ class LargeIntColumnReader : public ColumnReader { public: LargeIntColumnReader(uint32_t column_id, uint32_t column_unique_id); virtual ~LargeIntColumnReader(); - virtual OLAPStatus init(std::map* streams, int size, + virtual Status init(std::map* streams, int size, MemPool* mem_pool, OlapReaderStatistics* stats); - virtual OLAPStatus seek(PositionProvider* positions); - virtual OLAPStatus skip(uint64_t row_count); - virtual OLAPStatus next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool); + virtual Status seek(PositionProvider* positions); + virtual Status skip(uint64_t row_count); + virtual Status next_vector(ColumnVector* column_vector, uint32_t size, MemPool* mem_pool); virtual size_t get_buffer_size() { return sizeof(RunLengthByteReader) * 2; } diff --git a/be/src/olap/rowset/column_writer.cpp b/be/src/olap/rowset/column_writer.cpp index 5ca0ce94ea..d750db1ec1 100644 --- a/be/src/olap/rowset/column_writer.cpp +++ b/be/src/olap/rowset/column_writer.cpp @@ -151,39 +151,39 @@ ColumnWriter::~ColumnWriter() { } } -OLAPStatus ColumnWriter::init() { +Status ColumnWriter::init() { if (_column.is_nullable()) { _is_present_stream = _stream_factory->create_stream(unique_column_id(), StreamInfoMessage::PRESENT); if (nullptr == _is_present_stream) { OLAP_LOG_WARNING("fail to allocate IS PRESENT STREAM"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } _is_present = new (std::nothrow) BitFieldWriter(_is_present_stream); if (nullptr == _is_present) { OLAP_LOG_WARNING("fail to allocate IS PRESENT Writer"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } - if (OLAP_SUCCESS != _is_present->init()) { + if (!_is_present->init()) { OLAP_LOG_WARNING("fail to init IS PRESENT Writer"); - return OLAP_ERR_INIT_FAILED; + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } } - OLAPStatus res = _block_statistics.init(_column.type(), true); + Status res = _block_statistics.init(_column.type(), true); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("init block statistic failed"); return res; } res = _segment_statistics.init(_column.type(), true); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("init segment statistic failed"); return res; } @@ -193,7 +193,7 @@ OLAPStatus ColumnWriter::init() { if (nullptr == _index_stream) { OLAP_LOG_WARNING("fail to allocate Index STREAM"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } // bloom filter index @@ -202,27 +202,27 @@ OLAPStatus ColumnWriter::init() { _stream_factory->create_stream(unique_column_id(), StreamInfoMessage::BLOOM_FILTER); if (nullptr == _bf_index_stream) { OLAP_LOG_WARNING("fail to allocate bloom filter index stream"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } _bf = new (std::nothrow) BloomFilter(); if (nullptr == _bf) { OLAP_LOG_WARNING("fail to allocate bloom filter"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } if (!_bf->init(_num_rows_per_row_block, _bf_fpp)) { OLAP_LOG_WARNING("fail to init bloom filter. num rows: %u, fpp: %g", _num_rows_per_row_block, _bf_fpp); - return OLAP_ERR_INIT_FAILED; + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus ColumnWriter::write(RowCursor* row_cursor) { - OLAPStatus res = OLAP_SUCCESS; +Status ColumnWriter::write(RowCursor* row_cursor) { + Status res = Status::OK(); bool is_null = row_cursor->is_null(_column_id); char* buf = row_cursor->cell_ptr(_column_id); @@ -252,12 +252,12 @@ OLAPStatus ColumnWriter::write(RowCursor* row_cursor) { return res; } -OLAPStatus ColumnWriter::flush() { +Status ColumnWriter::flush() { return _is_present->flush(); } -OLAPStatus ColumnWriter::create_row_index_entry() { - OLAPStatus res = OLAP_SUCCESS; +Status ColumnWriter::create_row_index_entry() { + Status res = Status::OK(); segment_statistics()->merge(&_block_statistics); _index_entry.set_statistic(&_block_statistics); _index.add_index_entry(_index_entry); @@ -271,19 +271,19 @@ OLAPStatus ColumnWriter::create_row_index_entry() { _bf = new (std::nothrow) BloomFilter(); if (nullptr == _bf) { OLAP_LOG_WARNING("fail to allocate bloom filter"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } if (!_bf->init(_num_rows_per_row_block, _bf_fpp)) { OLAP_LOG_WARNING("fail to init bloom filter. num rows: %u, fpp: %g", _num_rows_per_row_block, _bf_fpp); - return OLAP_ERR_INIT_FAILED; + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } } for (std::vector::iterator it = _sub_writers.begin(); it != _sub_writers.end(); ++it) { - if (OLAP_SUCCESS != (res = (*it)->create_row_index_entry())) { + if (!(res = (*it)->create_row_index_entry())) { OLAP_LOG_WARNING("fail to create sub column's index."); return res; } @@ -320,11 +320,11 @@ void ColumnWriter::_remove_is_present_positions() { } } -OLAPStatus ColumnWriter::finalize(ColumnDataHeaderMessage* header) { - OLAPStatus res = OLAP_SUCCESS; +Status ColumnWriter::finalize(ColumnDataHeaderMessage* header) { + Status res = Status::OK(); if (nullptr != _is_present) { - if (OLAP_SUCCESS != (res = _is_present->flush())) { + if (!(res = _is_present->flush())) { return res; } @@ -341,22 +341,22 @@ OLAPStatus ColumnWriter::finalize(ColumnDataHeaderMessage* header) { index_buf = new (std::nothrow) char[pb_size]; ColumnMessage* column = nullptr; - if (OLAP_SUCCESS != _index.write_to_buffer(index_buf, pb_size)) { + if (!_index.write_to_buffer(index_buf, pb_size)) { OLAP_LOG_WARNING("fail to serialize index"); - res = OLAP_ERR_SERIALIZE_PROTOBUF_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_SERIALIZE_PROTOBUF_ERROR); goto FINALIZE_EXIT; } res = _index_stream->write(index_buf, pb_size); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write index to stream"); goto FINALIZE_EXIT; } res = _index_stream->flush(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to flush index stream"); goto FINALIZE_EXIT; } @@ -364,13 +364,13 @@ OLAPStatus ColumnWriter::finalize(ColumnDataHeaderMessage* header) { // write bloom filter index if (is_bf_column()) { res = _bf_index.write_to_buffer(_bf_index_stream); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write bloom filter stream"); OLAP_GOTO(FINALIZE_EXIT); } res = _bf_index_stream->flush(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to flush bloom filter stream"); OLAP_GOTO(FINALIZE_EXIT); } @@ -437,10 +437,10 @@ ByteColumnWriter::~ByteColumnWriter() { SAFE_DELETE(_writer); } -OLAPStatus ByteColumnWriter::init() { - OLAPStatus res = OLAP_SUCCESS; +Status ByteColumnWriter::init() { + Status res = Status::OK(); - if (OLAP_SUCCESS != (res = ColumnWriter::init())) { + if (!(res = ColumnWriter::init())) { return res; } @@ -449,34 +449,34 @@ OLAPStatus ByteColumnWriter::init() { if (nullptr == stream) { OLAP_LOG_WARNING("fail to allocate DATA STREAM"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } _writer = new (std::nothrow) RunLengthByteWriter(stream); if (nullptr == _writer) { OLAP_LOG_WARNING("fail to allocate RunLengthByteWriter"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } record_position(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus ByteColumnWriter::finalize(ColumnDataHeaderMessage* header) { - OLAPStatus res = OLAP_SUCCESS; +Status ByteColumnWriter::finalize(ColumnDataHeaderMessage* header) { + Status res = Status::OK(); - if (OLAP_SUCCESS != (res = ColumnWriter::finalize(header))) { + if (!(res = ColumnWriter::finalize(header))) { OLAP_LOG_WARNING("fail to finalize ColumnWriter."); return res; } - if (OLAP_SUCCESS != (res = _writer->flush())) { + if (!(res = _writer->flush())) { OLAP_LOG_WARNING("fail to flush."); return res; } - return OLAP_SUCCESS; + return Status::OK(); } void ByteColumnWriter::record_position() { @@ -498,22 +498,22 @@ IntegerColumnWriter::~IntegerColumnWriter() { SAFE_DELETE(_writer); } -OLAPStatus IntegerColumnWriter::init() { +Status IntegerColumnWriter::init() { OutStream* stream = _stream_factory->create_stream(_unique_column_id, StreamInfoMessage::DATA); if (nullptr == stream) { OLAP_LOG_WARNING("fail to allocate DATA STREAM"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } _writer = new (std::nothrow) RunLengthIntegerWriter(stream, _is_signed); if (nullptr == _writer) { OLAP_LOG_WARNING("fail to allocate RunLengthIntegerWriter"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } //////////////////////////////////////////////////////////////////////////////// @@ -534,10 +534,10 @@ VarStringColumnWriter::~VarStringColumnWriter() { SAFE_DELETE(_id_writer); } -OLAPStatus VarStringColumnWriter::init() { - OLAPStatus res = OLAP_SUCCESS; +Status VarStringColumnWriter::init() { + Status res = Status::OK(); - if (OLAP_SUCCESS != (res = ColumnWriter::init())) { + if (!(res = ColumnWriter::init())) { return res; } @@ -549,7 +549,7 @@ OLAPStatus VarStringColumnWriter::init() { if (nullptr == _dict_stream || nullptr == length_stream || nullptr == _data_stream) { OLAP_LOG_WARNING("fail to create stream."); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } _length_writer = new (std::nothrow) RunLengthIntegerWriter(length_stream, false); @@ -557,29 +557,29 @@ OLAPStatus VarStringColumnWriter::init() { if (nullptr == _length_writer || nullptr == _id_writer) { OLAP_LOG_WARNING("fail to create writer."); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } record_position(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus VarStringColumnWriter::write(const char* str, uint32_t len) { - OLAPStatus res = OLAP_SUCCESS; +Status VarStringColumnWriter::write(const char* str, uint32_t len) { + Status res = Status::OK(); // zdb shield the dictionary coding //std::string key(str, len); - if (OLAP_SUCCESS != (res = _data_stream->write(str, len))) { + if (!(res = _data_stream->write(str, len))) { OLAP_LOG_WARNING("fail to write string content."); return res; } - if (OLAP_SUCCESS != (res = _length_writer->write(len))) { + if (!(res = _length_writer->write(len))) { OLAP_LOG_WARNING("fail to write string length."); return res; } - return OLAP_SUCCESS; + return Status::OK(); } uint64_t VarStringColumnWriter::estimate_buffered_memory() { @@ -587,8 +587,8 @@ uint64_t VarStringColumnWriter::estimate_buffered_memory() { return _dict_total_size; } -OLAPStatus VarStringColumnWriter::_finalize_dict_encoding() { - OLAPStatus res = OLAP_SUCCESS; +Status VarStringColumnWriter::_finalize_dict_encoding() { + Status res = Status::OK(); std::vector dump_order; uint32_t current_id = 0; @@ -600,12 +600,12 @@ OLAPStatus VarStringColumnWriter::_finalize_dict_encoding() { const std::string& key = it->first.get(); res = _dict_stream->write(key.c_str(), key.length()); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write string dict to stream."); return res; } - if (OLAP_SUCCESS != (res = _length_writer->write(key.length()))) { + if (!(res = _length_writer->write(key.length()))) { OLAP_LOG_WARNING("fail to write string length to stream."); return res; } @@ -623,26 +623,26 @@ OLAPStatus VarStringColumnWriter::_finalize_dict_encoding() { if (i != _string_id.size()) { res = _id_writer->write(dump_order[_string_id[i]]); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write string id to stream."); return res; } } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus VarStringColumnWriter::_finalize_direct_encoding() { - //OLAPStatus res = OLAP_SUCCESS; +Status VarStringColumnWriter::_finalize_direct_encoding() { + //Status res = Status::OK(); //uint32_t block_id = 0; _dict_stream->suppress(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus VarStringColumnWriter::finalize(ColumnDataHeaderMessage* header) { - OLAPStatus res = OLAP_SUCCESS; +Status VarStringColumnWriter::finalize(ColumnDataHeaderMessage* header) { + Status res = Status::OK(); uint64_t ratio_threshold = config::column_dictionary_key_ratio_threshold; uint64_t size_threshold = config::column_dictionary_key_size_threshold; @@ -652,13 +652,13 @@ OLAPStatus VarStringColumnWriter::finalize(ColumnDataHeaderMessage* header) { if (_use_dictionary_encoding) { res = _finalize_dict_encoding(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to finalize dict encoding."); return res; } } else { res = _finalize_direct_encoding(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to finalize direct encoding."); return res; } @@ -666,16 +666,16 @@ OLAPStatus VarStringColumnWriter::finalize(ColumnDataHeaderMessage* header) { // The index's supplementary writing has been completed, ColumnWriter::finalize will write the header res = ColumnWriter::finalize(header); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to finalize ColumnWriter."); return res; } // id_writer is practical to data_stream, it doesn't matter if you repeat flush - if (OLAP_SUCCESS != _length_writer->flush() || OLAP_SUCCESS != _id_writer->flush() || - OLAP_SUCCESS != _dict_stream->flush() || OLAP_SUCCESS != _data_stream->flush()) { + if (!_length_writer->flush() || !_id_writer->flush() || + !_dict_stream->flush() || !_data_stream->flush()) { OLAP_LOG_WARNING("fail to flush stream."); - return OLAP_ERR_WRITER_DATA_WRITE_ERROR; + return Status::OLAPInternalError(OLAP_ERR_WRITER_DATA_WRITE_ERROR); } _string_keys.clear(); @@ -683,7 +683,7 @@ OLAPStatus VarStringColumnWriter::finalize(ColumnDataHeaderMessage* header) { _string_id.clear(); _block_row_count.clear(); _dict_total_size = 0; - return OLAP_SUCCESS; + return Status::OK(); } void VarStringColumnWriter::save_encoding(ColumnEncodingMessage* encoding) { @@ -732,11 +732,11 @@ DecimalColumnWriter::~DecimalColumnWriter() { SAFE_DELETE(_frac_writer); } -OLAPStatus DecimalColumnWriter::init() { - OLAPStatus res = OLAP_SUCCESS; +Status DecimalColumnWriter::init() { + Status res = Status::OK(); res = ColumnWriter::init(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } @@ -747,7 +747,7 @@ OLAPStatus DecimalColumnWriter::init() { if (nullptr == int_stream || nullptr == frac_stream) { OLAP_LOG_WARNING("fail to create stream."); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } _int_writer = new (std::nothrow) RunLengthIntegerWriter(int_stream, true); @@ -755,35 +755,35 @@ OLAPStatus DecimalColumnWriter::init() { if (nullptr == _int_writer || nullptr == _frac_writer) { OLAP_LOG_WARNING("fail to create writer."); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } record_position(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus DecimalColumnWriter::finalize(ColumnDataHeaderMessage* header) { - OLAPStatus res; +Status DecimalColumnWriter::finalize(ColumnDataHeaderMessage* header) { + Status res; res = ColumnWriter::finalize(header); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to finalize ColumnWriter."); return res; } res = _int_writer->flush(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to flush integer writer."); return res; } res = _frac_writer->flush(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to flush fraction writer."); return res; } - return OLAP_SUCCESS; + return Status::OK(); } void DecimalColumnWriter::record_position() { @@ -806,11 +806,11 @@ LargeIntColumnWriter::~LargeIntColumnWriter() { SAFE_DELETE(_low_writer); } -OLAPStatus LargeIntColumnWriter::init() { - OLAPStatus res = OLAP_SUCCESS; +Status LargeIntColumnWriter::init() { + Status res = Status::OK(); res = ColumnWriter::init(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } @@ -821,7 +821,7 @@ OLAPStatus LargeIntColumnWriter::init() { if (nullptr == high_stream || nullptr == low_stream) { OLAP_LOG_WARNING("fail to create stream."); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } _high_writer = new (std::nothrow) RunLengthIntegerWriter(high_stream, true); @@ -829,35 +829,35 @@ OLAPStatus LargeIntColumnWriter::init() { if (nullptr == _high_writer || nullptr == _low_writer) { OLAP_LOG_WARNING("fail to create writer."); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } record_position(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus LargeIntColumnWriter::finalize(ColumnDataHeaderMessage* header) { - OLAPStatus res; +Status LargeIntColumnWriter::finalize(ColumnDataHeaderMessage* header) { + Status res; res = ColumnWriter::finalize(header); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to finalize ColumnWriter."); return res; } res = _high_writer->flush(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to flush integer writer."); return res; } res = _low_writer->flush(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to flush fraction writer."); return res; } - return OLAP_SUCCESS; + return Status::OK(); } void LargeIntColumnWriter::record_position() { diff --git a/be/src/olap/rowset/column_writer.h b/be/src/olap/rowset/column_writer.h index 42bc54caa2..9fe2d60f2a 100644 --- a/be/src/olap/rowset/column_writer.h +++ b/be/src/olap/rowset/column_writer.h @@ -56,23 +56,23 @@ public: double bf_fpp); virtual ~ColumnWriter(); - virtual OLAPStatus init(); + virtual Status init(); - OLAPStatus write(RowCursor* cursor); + Status write(RowCursor* cursor); - virtual OLAPStatus write_batch(RowBlock* block, RowCursor* cursor) = 0; + virtual Status write_batch(RowBlock* block, RowCursor* cursor) = 0; // Write the previously recorded block location information and current statistical information into a new index entry - OLAPStatus create_row_index_entry(); + Status create_row_index_entry(); // Estimate the current cache memory size, excluding the memory that has been output to OutStream virtual uint64_t estimate_buffered_memory(); - virtual OLAPStatus flush(); + virtual Status flush(); // End the segment, flush stream and update the header: // * column_unique_id // * column_type // * column_encoding // * zone_maps - virtual OLAPStatus finalize(ColumnDataHeaderMessage* header); + virtual Status finalize(ColumnDataHeaderMessage* header); virtual void save_encoding(ColumnEncodingMessage* encoding); uint32_t column_id() const { return _column_id; } @@ -128,14 +128,14 @@ public: ByteColumnWriter(uint32_t column_id, OutStreamFactory* stream_factory, const TabletColumn& column, size_t num_rows_per_row_block, double bf_fpp); virtual ~ByteColumnWriter(); - virtual OLAPStatus init() override; + virtual Status init() override; - OLAPStatus write_batch(RowBlock* block, RowCursor* cursor) override { + Status write_batch(RowBlock* block, RowCursor* cursor) override { for (uint32_t i = 0; i < block->row_block_info().row_num; i++) { block->get_row(i, cursor); - OLAPStatus res = ColumnWriter::write(cursor); - if (OLAP_UNLIKELY(res != OLAP_SUCCESS)) { + Status res = ColumnWriter::write(cursor); + if (OLAP_UNLIKELY(!res.ok())) { OLAP_LOG_WARNING("fail to write ColumnWriter."); return res; } @@ -145,18 +145,18 @@ public: if (!cell.is_null()) { char value = *reinterpret_cast(cell.cell_ptr()); res = _writer->write(value); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to write double, res=" << res; return res; } } } - return OLAP_SUCCESS; + return Status::OK(); } - virtual OLAPStatus finalize(ColumnDataHeaderMessage* header) override; + virtual Status finalize(ColumnDataHeaderMessage* header) override; virtual void record_position() override; - virtual OLAPStatus flush() override { return OLAP_SUCCESS; } + virtual Status flush() override { return Status::OK(); } private: RunLengthByteWriter* _writer; @@ -170,13 +170,13 @@ public: IntegerColumnWriter(uint32_t column_id, uint32_t unique_column_id, OutStreamFactory* stream_factory, bool is_singed); ~IntegerColumnWriter(); - OLAPStatus init(); - OLAPStatus write(int64_t data) { return _writer->write(data); } - OLAPStatus finalize(ColumnDataHeaderMessage* header) { return _writer->flush(); } + Status init(); + Status write(int64_t data) { return _writer->write(data); } + Status finalize(ColumnDataHeaderMessage* header) { return _writer->flush(); } void record_position(PositionEntryWriter* index_entry) { _writer->get_position(index_entry, false); } - OLAPStatus flush() { return _writer->flush(); } + Status flush() { return _writer->flush(); } private: uint32_t _column_id; @@ -199,31 +199,31 @@ public: virtual ~IntegerColumnWriterWrapper() {} - virtual OLAPStatus init() override { - OLAPStatus res = OLAP_SUCCESS; + virtual Status init() override { + Status res = Status::OK(); res = ColumnWriter::init(); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to init ColumnWriter. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to init ColumnWriter. res = " << res; return res; } res = _writer.init(); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to init IntegerColumnWriter. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to init IntegerColumnWriter. res = " << res; return res; } record_position(); - return OLAP_SUCCESS; + return Status::OK(); } - OLAPStatus write_batch(RowBlock* block, RowCursor* cursor) override { + Status write_batch(RowBlock* block, RowCursor* cursor) override { for (uint32_t i = 0; i < block->row_block_info().row_num; i++) { block->get_row(i, cursor); - OLAPStatus res = ColumnWriter::write(cursor); - if (OLAP_UNLIKELY(OLAP_SUCCESS != res)) { - OLAP_LOG_WARNING("fail to write ColumnWriter. [res=%d]", res); + Status res = ColumnWriter::write(cursor); + if (OLAP_UNLIKELY(!res.ok())) { + LOG(WARNING) << "fail to write ColumnWriter. res = " << res; return res; } @@ -232,38 +232,38 @@ public: if (!cell.is_null()) { T value = *reinterpret_cast(cell.cell_ptr()); res = _writer.write(static_cast(value)); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to write integer, res=" << res; return res; } } } - return OLAP_SUCCESS; + return Status::OK(); } - virtual OLAPStatus flush() override { - OLAPStatus res = ColumnWriter::flush(); + virtual Status flush() override { + Status res = ColumnWriter::flush(); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to flush column_writer. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to flush column_writer. res = " << res; return res; } res = _writer.flush(); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to flush integer_writer. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to flush integer_writer. res = " << res; return res; } return res; } - virtual OLAPStatus finalize(ColumnDataHeaderMessage* header) override { - OLAPStatus res = ColumnWriter::finalize(header); + virtual Status finalize(ColumnDataHeaderMessage* header) override { + Status res = ColumnWriter::finalize(header); - if (OLAP_UNLIKELY(OLAP_SUCCESS != res)) { - OLAP_LOG_WARNING("fail to finalize ColumnWriter. [res=%d]", res); + if (OLAP_UNLIKELY(!res.ok())) { + LOG(WARNING) << "fail to finalize ColumnWriter. res = " << res; return res; } @@ -291,11 +291,11 @@ public: virtual ~DoubleColumnWriterBase() {} - virtual OLAPStatus init() override { - OLAPStatus res = OLAP_SUCCESS; + virtual Status init() override { + Status res = Status::OK(); res = ColumnWriter::init(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } @@ -303,22 +303,22 @@ public: _stream = factory->create_stream(unique_column_id(), StreamInfoMessage::DATA); if (nullptr == _stream) { - OLAP_LOG_WARNING("fail to allocate DATA STREAM"); - return OLAP_ERR_MALLOC_ERROR; + LOG(WARNING) << "fail to allocate DATA STREAM"; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } record_position(); - return OLAP_SUCCESS; + return Status::OK(); } - virtual OLAPStatus flush() override { return OLAP_SUCCESS; } + virtual Status flush() override { return Status::OK(); } - OLAPStatus write_batch(RowBlock* block, RowCursor* cursor) override { + Status write_batch(RowBlock* block, RowCursor* cursor) override { for (uint32_t i = 0; i < block->row_block_info().row_num; i++) { block->get_row(i, cursor); - OLAPStatus res = ColumnWriter::write(cursor); - if (OLAP_UNLIKELY(res != OLAP_SUCCESS)) { - OLAP_LOG_WARNING("fail to write ColumnWriter. [res=%d]", res); + Status res = ColumnWriter::write(cursor); + if (OLAP_UNLIKELY(!res.ok())) { + LOG(WARNING) << "fail to write ColumnWriter. res = " << res; return res; } @@ -327,31 +327,31 @@ public: if (!cell.is_null()) { const T* value = reinterpret_cast(cell.cell_ptr()); res = _stream->write(reinterpret_cast(value), sizeof(T)); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to write double, res=" << res; return res; } } } - return OLAP_SUCCESS; + return Status::OK(); } - virtual OLAPStatus finalize(ColumnDataHeaderMessage* header) override { - OLAPStatus res = OLAP_SUCCESS; + virtual Status finalize(ColumnDataHeaderMessage* header) override { + Status res = Status::OK(); res = ColumnWriter::finalize(header); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to finalize ColumnWriter. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to finalize ColumnWriter. res = " << res; return res; } res = _stream->flush(); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to flush. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to flush. res = " << res; return res; } - return OLAP_SUCCESS; + return Status::OK(); } virtual void record_position() override { @@ -375,13 +375,13 @@ public: VarStringColumnWriter(uint32_t column_id, OutStreamFactory* stream_factory, const TabletColumn& column, size_t num_rows_per_row_block, double bf_fpp); virtual ~VarStringColumnWriter(); - virtual OLAPStatus init() override; + virtual Status init() override; - OLAPStatus write_batch(RowBlock* block, RowCursor* cursor) override { + Status write_batch(RowBlock* block, RowCursor* cursor) override { for (uint32_t i = 0; i < block->row_block_info().row_num; i++) { block->get_row(i, cursor); - OLAPStatus res = ColumnWriter::write(cursor); - if (OLAP_UNLIKELY(res != OLAP_SUCCESS)) { + Status res = ColumnWriter::write(cursor); + if (OLAP_UNLIKELY(!res.ok())) { OLAP_LOG_WARNING("fail to write ColumnWriter."); return res; } @@ -390,24 +390,24 @@ public: char* buf = cursor->cell_ptr(column_id()); Slice* slice = reinterpret_cast(buf); res = write(slice->data, slice->size); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to write varchar, res=" << res; return res; } } } - return OLAP_SUCCESS; + return Status::OK(); } virtual uint64_t estimate_buffered_memory() override; - virtual OLAPStatus finalize(ColumnDataHeaderMessage* header) override; + virtual Status finalize(ColumnDataHeaderMessage* header) override; virtual void save_encoding(ColumnEncodingMessage* encoding) override; virtual void record_position() override; - virtual OLAPStatus flush() override { return OLAP_SUCCESS; } + virtual Status flush() override { return Status::OK(); } protected: //Write a piece of data directly without using cursor - OLAPStatus write(const char* str, uint32_t length); + Status write(const char* str, uint32_t length); private: // You can use references as keys in the map @@ -424,8 +424,8 @@ private: typedef std::map StringDict; private: - OLAPStatus _finalize_dict_encoding(); - OLAPStatus _finalize_direct_encoding(); + Status _finalize_dict_encoding(); + Status _finalize_direct_encoding(); private: bool _use_dictionary_encoding; @@ -450,12 +450,12 @@ public: double bf_fpp); virtual ~FixLengthStringColumnWriter(); - OLAPStatus write_batch(RowBlock* block, RowCursor* cursor) override { + Status write_batch(RowBlock* block, RowCursor* cursor) override { for (uint32_t i = 0; i < block->row_block_info().row_num; i++) { block->get_row(i, cursor); - OLAPStatus res = ColumnWriter::write(cursor); - if (OLAP_UNLIKELY(res != OLAP_SUCCESS)) { + Status res = ColumnWriter::write(cursor); + if (OLAP_UNLIKELY(!res.ok())) { OLAP_LOG_WARNING("fail to write ColumnWriter."); return res; } @@ -467,16 +467,16 @@ public: //const char* str = reinterpret_cast(buf); Slice* slice = reinterpret_cast(buf); res = VarStringColumnWriter::write(slice->data, slice->size); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to write fix-length string, res=" << res; return res; } } } - return OLAP_SUCCESS; + return Status::OK(); } - virtual OLAPStatus flush() override { return OLAP_SUCCESS; } + virtual Status flush() override { return Status::OK(); } private: uint32_t _length; @@ -495,13 +495,13 @@ public: DecimalColumnWriter(uint32_t column_id, OutStreamFactory* stream_factory, const TabletColumn& column, size_t num_rows_per_row_block, double bf_fpp); virtual ~DecimalColumnWriter(); - virtual OLAPStatus init() override; + virtual Status init() override; - OLAPStatus write_batch(RowBlock* block, RowCursor* cursor) override { + Status write_batch(RowBlock* block, RowCursor* cursor) override { for (uint32_t i = 0; i < block->row_block_info().row_num; i++) { block->get_row(i, cursor); - OLAPStatus res = ColumnWriter::write(cursor); - if (OLAP_UNLIKELY(res != OLAP_SUCCESS)) { + Status res = ColumnWriter::write(cursor); + if (OLAP_UNLIKELY(!res.ok())) { OLAP_LOG_WARNING("fail to write ColumnWriter."); return res; } @@ -511,23 +511,23 @@ public: if (!cell.is_null()) { decimal12_t value = *reinterpret_cast(cell.cell_ptr()); res = _int_writer->write(value.integer); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write integer of Decimal."); return res; } res = _frac_writer->write(value.fraction); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write fraction of Decimal."); return res; } } } - return OLAP_SUCCESS; + return Status::OK(); } - virtual OLAPStatus finalize(ColumnDataHeaderMessage* header) override; + virtual Status finalize(ColumnDataHeaderMessage* header) override; virtual void record_position() override; - virtual OLAPStatus flush() override { return OLAP_SUCCESS; } + virtual Status flush() override { return Status::OK(); } private: RunLengthIntegerWriter* _int_writer; @@ -541,13 +541,13 @@ public: LargeIntColumnWriter(uint32_t column_id, OutStreamFactory* stream_factory, const TabletColumn& column, size_t num_rows_per_row_block, double bf_fpp); virtual ~LargeIntColumnWriter(); - virtual OLAPStatus init() override; + virtual Status init() override; - OLAPStatus write_batch(RowBlock* block, RowCursor* cursor) override { + Status write_batch(RowBlock* block, RowCursor* cursor) override { for (uint32_t i = 0; i < block->row_block_info().row_num; i++) { block->get_row(i, cursor); - OLAPStatus res = ColumnWriter::write(cursor); - if (OLAP_UNLIKELY(res != OLAP_SUCCESS)) { + Status res = ColumnWriter::write(cursor); + if (OLAP_UNLIKELY(!res.ok())) { OLAP_LOG_WARNING("fail to write ColumnWriter."); return res; } @@ -556,23 +556,23 @@ public: if (!cell.is_null()) { const int64_t* value = reinterpret_cast(cell.cell_ptr()); res = _high_writer->write(*value); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write integer of LargeInt."); return res; } res = _low_writer->write(*(++value)); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write fraction of LargeInt."); return res; } } } - return OLAP_SUCCESS; + return Status::OK(); } - virtual OLAPStatus finalize(ColumnDataHeaderMessage* header) override; + virtual Status finalize(ColumnDataHeaderMessage* header) override; virtual void record_position() override; - virtual OLAPStatus flush() override { return OLAP_SUCCESS; } + virtual Status flush() override { return Status::OK(); } private: RunLengthIntegerWriter* _high_writer; diff --git a/be/src/olap/rowset/rowset.cpp b/be/src/olap/rowset/rowset.cpp index 1e2dea00b0..c07586349d 100644 --- a/be/src/olap/rowset/rowset.cpp +++ b/be/src/olap/rowset/rowset.cpp @@ -36,11 +36,11 @@ Rowset::Rowset(const TabletSchema* schema, const FilePathDesc& rowset_path_desc, } } -OLAPStatus Rowset::load(bool use_cache) { +Status Rowset::load(bool use_cache) { // if the state is ROWSET_UNLOADING it means close() is called // and the rowset is already loaded, and the resource is not closed yet. if (_rowset_state_machine.rowset_state() == ROWSET_LOADED) { - return OLAP_SUCCESS; + return Status::OK(); } { // before lock, if rowset state is ROWSET_UNLOADING, maybe it is doing do_close in release @@ -56,7 +56,7 @@ OLAPStatus Rowset::load(bool use_cache) { VLOG_CRITICAL << "rowset is loaded. " << rowset_id() << ", rowset version:" << rowset_meta()->version() << ", state from ROWSET_UNLOADED to ROWSET_LOADED. tabletid:" << _rowset_meta->tablet_id(); - return OLAP_SUCCESS; + return Status::OK(); } void Rowset::make_visible(Version version) { diff --git a/be/src/olap/rowset/rowset.h b/be/src/olap/rowset/rowset.h index 61feae841e..5674c3703a 100644 --- a/be/src/olap/rowset/rowset.h +++ b/be/src/olap/rowset/rowset.h @@ -58,19 +58,19 @@ class RowsetStateMachine { public: RowsetStateMachine() : _rowset_state(ROWSET_UNLOADED) {} - OLAPStatus on_load() { + Status on_load() { switch (_rowset_state) { case ROWSET_UNLOADED: _rowset_state = ROWSET_LOADED; break; default: - return OLAP_ERR_ROWSET_INVALID_STATE_TRANSITION; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_INVALID_STATE_TRANSITION); } - return OLAP_SUCCESS; + return Status::OK(); } - OLAPStatus on_close(uint64_t refs_by_reader) { + Status on_close(uint64_t refs_by_reader) { switch (_rowset_state) { case ROWSET_LOADED: if (refs_by_reader == 0) { @@ -81,21 +81,21 @@ public: break; default: - return OLAP_ERR_ROWSET_INVALID_STATE_TRANSITION; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_INVALID_STATE_TRANSITION); } - return OLAP_SUCCESS; + return Status::OK(); } - OLAPStatus on_release() { + Status on_release() { switch (_rowset_state) { case ROWSET_UNLOADING: _rowset_state = ROWSET_UNLOADED; break; default: - return OLAP_ERR_ROWSET_INVALID_STATE_TRANSITION; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_INVALID_STATE_TRANSITION); } - return OLAP_SUCCESS; + return Status::OK(); } RowsetState rowset_state() { return _rowset_state; } @@ -113,10 +113,10 @@ public: // // May be called multiple times, subsequent calls will no-op. // Derived class implements the load logic by overriding the `do_load_once()` method. - OLAPStatus load(bool use_cache = true); + Status load(bool use_cache = true); - // returns OLAP_ERR_ROWSET_CREATE_READER when failed to create reader - virtual OLAPStatus create_reader(std::shared_ptr* result) = 0; + // returns Status::OLAPInternalError(OLAP_ERR_ROWSET_CREATE_READER) when failed to create reader + virtual Status create_reader(std::shared_ptr* result) = 0; // Split range denoted by `start_key` and `end_key` into sub-ranges, each contains roughly // `request_block_row_count` rows. Sub-range is represented by pair of OlapTuples and added to `ranges`. @@ -126,7 +126,7 @@ public: // // The first/last tuple must be start_key/end_key.to_tuple(). If we can't divide the input range, // the result `ranges` should be [start_key.to_tuple(), end_key.to_tuple()] - virtual OLAPStatus split_range(const RowCursor& start_key, const RowCursor& end_key, + virtual Status split_range(const RowCursor& start_key, const RowCursor& end_key, uint64_t request_block_row_count, size_t key_num, std::vector* ranges) = 0; @@ -160,7 +160,7 @@ public: // remove all files in this rowset // TODO should we rename the method to remove_files() to be more specific? - virtual OLAPStatus remove() = 0; + virtual Status remove() = 0; // close to clear the resource owned by rowset // including: open files, indexes and so on @@ -170,7 +170,7 @@ public: if (old_state != ROWSET_LOADED) { return; } - OLAPStatus st = OLAP_SUCCESS; + Status st = Status::OK(); { std::lock_guard close_lock(_lock); uint64_t current_refs = _refs_by_reader; @@ -183,7 +183,7 @@ public: } st = _rowset_state_machine.on_close(current_refs); } - if (st != OLAP_SUCCESS) { + if (!st.ok()) { LOG(WARNING) << "state transition failed from:" << _rowset_state_machine.rowset_state(); return; } @@ -193,14 +193,14 @@ public: } // hard link all files in this rowset to `dir` to form a new rowset with id `new_rowset_id`. - virtual OLAPStatus link_files_to(const FilePathDesc& dir_desc, RowsetId new_rowset_id) = 0; + virtual Status link_files_to(const FilePathDesc& dir_desc, RowsetId new_rowset_id) = 0; // copy all files to `dir` - virtual OLAPStatus copy_files_to(const std::string& dir) = 0; + virtual Status copy_files_to(const std::string& dir) = 0; - virtual OLAPStatus upload_files_to(const FilePathDesc& dir_desc) { return OLAP_SUCCESS; } + virtual Status upload_files_to(const FilePathDesc& dir_desc) { return Status::OK(); } - virtual OLAPStatus remove_old_files(std::vector* files_to_remove) = 0; + virtual Status remove_old_files(std::vector* files_to_remove) = 0; // return whether `path` is one of the files in this rowset virtual bool check_path(const std::string& path) = 0; @@ -254,10 +254,10 @@ protected: Rowset(const TabletSchema* schema, const FilePathDesc& rowset_path_desc, RowsetMetaSharedPtr rowset_meta); // this is non-public because all clients should use RowsetFactory to obtain pointer to initialized Rowset - virtual OLAPStatus init() = 0; + virtual Status init() = 0; // The actual implementation of load(). Guaranteed by to called exactly once. - virtual OLAPStatus do_load(bool use_cache) = 0; + virtual Status do_load(bool use_cache) = 0; // release resources in this api virtual void do_close() = 0; diff --git a/be/src/olap/rowset/rowset_factory.cpp b/be/src/olap/rowset/rowset_factory.cpp index 915c56cd5d..077ac7ca6c 100644 --- a/be/src/olap/rowset/rowset_factory.cpp +++ b/be/src/olap/rowset/rowset_factory.cpp @@ -28,7 +28,7 @@ namespace doris { -OLAPStatus RowsetFactory::create_rowset(const TabletSchema* schema, const FilePathDesc& rowset_path_desc, +Status RowsetFactory::create_rowset(const TabletSchema* schema, const FilePathDesc& rowset_path_desc, RowsetMetaSharedPtr rowset_meta, RowsetSharedPtr* rowset) { if (rowset_meta->rowset_type() == ALPHA_ROWSET) { rowset->reset(new AlphaRowset(schema, rowset_path_desc, rowset_meta)); @@ -38,10 +38,10 @@ OLAPStatus RowsetFactory::create_rowset(const TabletSchema* schema, const FilePa rowset->reset(new BetaRowset(schema, rowset_path_desc, rowset_meta)); return (*rowset)->init(); } - return OLAP_ERR_ROWSET_TYPE_NOT_FOUND; // should never happen + return Status::OLAPInternalError(OLAP_ERR_ROWSET_TYPE_NOT_FOUND); // should never happen } -OLAPStatus RowsetFactory::create_rowset_writer(const RowsetWriterContext& context, +Status RowsetFactory::create_rowset_writer(const RowsetWriterContext& context, std::unique_ptr* output) { if (context.rowset_type == ALPHA_ROWSET) { output->reset(new AlphaRowsetWriter); @@ -51,7 +51,7 @@ OLAPStatus RowsetFactory::create_rowset_writer(const RowsetWriterContext& contex output->reset(new BetaRowsetWriter); return (*output)->init(context); } - return OLAP_ERR_ROWSET_TYPE_NOT_FOUND; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_TYPE_NOT_FOUND); } } // namespace doris diff --git a/be/src/olap/rowset/rowset_factory.h b/be/src/olap/rowset/rowset_factory.h index bad3e7efca..42e8f4c8e8 100644 --- a/be/src/olap/rowset/rowset_factory.h +++ b/be/src/olap/rowset/rowset_factory.h @@ -31,14 +31,14 @@ class RowsetFactory { public: // return OLAP_SUCCESS and set inited rowset in `*rowset`. // return others if failed to create or init rowset. - static OLAPStatus create_rowset(const TabletSchema* schema, + static Status create_rowset(const TabletSchema* schema, const FilePathDesc& rowset_path_desc, RowsetMetaSharedPtr rowset_meta, RowsetSharedPtr* rowset); // create and init rowset writer. // return OLAP_SUCCESS and set `*output` to inited rowset writer. // return others if failed - static OLAPStatus create_rowset_writer(const RowsetWriterContext& context, + static Status create_rowset_writer(const RowsetWriterContext& context, std::unique_ptr* output); }; diff --git a/be/src/olap/rowset/rowset_meta_manager.cpp b/be/src/olap/rowset/rowset_meta_manager.cpp index 434b53ef55..25a90986b1 100644 --- a/be/src/olap/rowset/rowset_meta_manager.cpp +++ b/be/src/olap/rowset/rowset_meta_manager.cpp @@ -41,46 +41,46 @@ bool RowsetMetaManager::check_rowset_meta(OlapMeta* meta, TabletUid tablet_uid, return meta->key_may_exist(META_COLUMN_FAMILY_INDEX, key, &value); } -OLAPStatus RowsetMetaManager::get_rowset_meta(OlapMeta* meta, TabletUid tablet_uid, +Status RowsetMetaManager::get_rowset_meta(OlapMeta* meta, TabletUid tablet_uid, const RowsetId& rowset_id, RowsetMetaSharedPtr rowset_meta) { std::string key = ROWSET_PREFIX + tablet_uid.to_string() + "_" + rowset_id.to_string(); std::string value; - OLAPStatus s = meta->get(META_COLUMN_FAMILY_INDEX, key, &value); - if (s == OLAP_ERR_META_KEY_NOT_FOUND) { + Status s = meta->get(META_COLUMN_FAMILY_INDEX, key, &value); + if (s == Status::OLAPInternalError(OLAP_ERR_META_KEY_NOT_FOUND)) { std::string error_msg = "rowset id:" + key + " not found."; LOG(WARNING) << error_msg; - return OLAP_ERR_META_KEY_NOT_FOUND; - } else if (s != OLAP_SUCCESS) { + return Status::OLAPInternalError(OLAP_ERR_META_KEY_NOT_FOUND); + } else if (!s.ok()) { std::string error_msg = "load rowset id:" + key + " failed."; LOG(WARNING) << error_msg; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } bool ret = rowset_meta->init(value); if (!ret) { std::string error_msg = "parse rowset meta failed. rowset id:" + key; - return OLAP_ERR_SERIALIZE_PROTOBUF_ERROR; + return Status::OLAPInternalError(OLAP_ERR_SERIALIZE_PROTOBUF_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus RowsetMetaManager::get_json_rowset_meta(OlapMeta* meta, TabletUid tablet_uid, +Status RowsetMetaManager::get_json_rowset_meta(OlapMeta* meta, TabletUid tablet_uid, const RowsetId& rowset_id, std::string* json_rowset_meta) { RowsetMetaSharedPtr rowset_meta_ptr(new (std::nothrow) RowsetMeta()); - OLAPStatus status = get_rowset_meta(meta, tablet_uid, rowset_id, rowset_meta_ptr); - if (status != OLAP_SUCCESS) { + Status status = get_rowset_meta(meta, tablet_uid, rowset_id, rowset_meta_ptr); + if (!status.ok()) { return status; } bool ret = rowset_meta_ptr->json_rowset_meta(json_rowset_meta); if (!ret) { std::string error_msg = "get json rowset meta failed. rowset id:" + rowset_id.to_string(); - return OLAP_ERR_SERIALIZE_PROTOBUF_ERROR; + return Status::OLAPInternalError(OLAP_ERR_SERIALIZE_PROTOBUF_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus RowsetMetaManager::save(OlapMeta* meta, TabletUid tablet_uid, const RowsetId& rowset_id, +Status RowsetMetaManager::save(OlapMeta* meta, TabletUid tablet_uid, const RowsetId& rowset_id, const RowsetMetaPB& rowset_meta_pb) { std::string key = ROWSET_PREFIX + tablet_uid.to_string() + "_" + rowset_id.to_string(); std::string value; @@ -88,22 +88,22 @@ OLAPStatus RowsetMetaManager::save(OlapMeta* meta, TabletUid tablet_uid, const R if (!ret) { std::string error_msg = "serialize rowset pb failed. rowset id:" + key; LOG(WARNING) << error_msg; - return OLAP_ERR_SERIALIZE_PROTOBUF_ERROR; + return Status::OLAPInternalError(OLAP_ERR_SERIALIZE_PROTOBUF_ERROR); } - OLAPStatus status = meta->put(META_COLUMN_FAMILY_INDEX, key, value); + Status status = meta->put(META_COLUMN_FAMILY_INDEX, key, value); return status; } -OLAPStatus RowsetMetaManager::remove(OlapMeta* meta, TabletUid tablet_uid, +Status RowsetMetaManager::remove(OlapMeta* meta, TabletUid tablet_uid, const RowsetId& rowset_id) { std::string key = ROWSET_PREFIX + tablet_uid.to_string() + "_" + rowset_id.to_string(); VLOG_NOTICE << "start to remove rowset, key:" << key; - OLAPStatus status = meta->remove(META_COLUMN_FAMILY_INDEX, key); + Status status = meta->remove(META_COLUMN_FAMILY_INDEX, key); VLOG_NOTICE << "remove rowset key:" << key << " finished"; return status; } -OLAPStatus RowsetMetaManager::traverse_rowset_metas( +Status RowsetMetaManager::traverse_rowset_metas( OlapMeta* meta, std::function const& func) { auto traverse_rowset_meta_func = [&func](const std::string& key, @@ -122,12 +122,12 @@ OLAPStatus RowsetMetaManager::traverse_rowset_metas( TabletUid tablet_uid(uid_parts[0], uid_parts[1]); return func(tablet_uid, rowset_id, value); }; - OLAPStatus status = + Status status = meta->iterate(META_COLUMN_FAMILY_INDEX, ROWSET_PREFIX, traverse_rowset_meta_func); return status; } -OLAPStatus RowsetMetaManager::load_json_rowset_meta(OlapMeta* meta, +Status RowsetMetaManager::load_json_rowset_meta(OlapMeta* meta, const std::string& rowset_meta_path) { std::ifstream infile(rowset_meta_path); char buffer[1024]; @@ -142,11 +142,11 @@ OLAPStatus RowsetMetaManager::load_json_rowset_meta(OlapMeta* meta, if (!ret) { std::string error_msg = "parse json rowset meta failed."; LOG(WARNING) << error_msg; - return OLAP_ERR_SERIALIZE_PROTOBUF_ERROR; + return Status::OLAPInternalError(OLAP_ERR_SERIALIZE_PROTOBUF_ERROR); } RowsetId rowset_id = rowset_meta.rowset_id(); TabletUid tablet_uid = rowset_meta.tablet_uid(); - OLAPStatus status = save(meta, tablet_uid, rowset_id, rowset_meta.get_rowset_pb()); + Status status = save(meta, tablet_uid, rowset_id, rowset_meta.get_rowset_pb()); return status; } diff --git a/be/src/olap/rowset/rowset_meta_manager.h b/be/src/olap/rowset/rowset_meta_manager.h index 258b30f477..10d3345547 100644 --- a/be/src/olap/rowset/rowset_meta_manager.h +++ b/be/src/olap/rowset/rowset_meta_manager.h @@ -32,23 +32,23 @@ class RowsetMetaManager { public: static bool check_rowset_meta(OlapMeta* meta, TabletUid tablet_uid, const RowsetId& rowset_id); - static OLAPStatus get_rowset_meta(OlapMeta* meta, TabletUid tablet_uid, + static Status get_rowset_meta(OlapMeta* meta, TabletUid tablet_uid, const RowsetId& rowset_id, RowsetMetaSharedPtr rowset_meta); - static OLAPStatus get_json_rowset_meta(OlapMeta* meta, TabletUid tablet_uid, + static Status get_json_rowset_meta(OlapMeta* meta, TabletUid tablet_uid, const RowsetId& rowset_id, std::string* json_rowset_meta); - static OLAPStatus save(OlapMeta* meta, TabletUid tablet_uid, const RowsetId& rowset_id, + static Status save(OlapMeta* meta, TabletUid tablet_uid, const RowsetId& rowset_id, const RowsetMetaPB& rowset_meta_pb); - static OLAPStatus remove(OlapMeta* meta, TabletUid tablet_uid, const RowsetId& rowset_id); + static Status remove(OlapMeta* meta, TabletUid tablet_uid, const RowsetId& rowset_id); - static OLAPStatus traverse_rowset_metas( + static Status traverse_rowset_metas( OlapMeta* meta, std::function const& func); - static OLAPStatus load_json_rowset_meta(OlapMeta* meta, const std::string& rowset_meta_path); + static Status load_json_rowset_meta(OlapMeta* meta, const std::string& rowset_meta_path); }; } // namespace doris diff --git a/be/src/olap/rowset/rowset_reader.h b/be/src/olap/rowset/rowset_reader.h index 542e705f6d..d3026376ff 100644 --- a/be/src/olap/rowset/rowset_reader.h +++ b/be/src/olap/rowset/rowset_reader.h @@ -41,16 +41,16 @@ public: virtual ~RowsetReader() {} // reader init - virtual OLAPStatus init(RowsetReaderContext* read_context) = 0; + virtual Status init(RowsetReaderContext* read_context) = 0; // read next block data into *block. // Returns // OLAP_SUCCESS when read successfully. - // OLAP_ERR_DATA_EOF and set *block to null when there is no more block. + // Status::OLAPInternalError(OLAP_ERR_DATA_EOF) and set *block to null when there is no more block. // Others when error happens. - virtual OLAPStatus next_block(RowBlock** block) = 0; + virtual Status next_block(RowBlock** block) = 0; - virtual OLAPStatus next_block(vectorized::Block* block) = 0; + virtual Status next_block(vectorized::Block* block) = 0; virtual bool delete_flag() = 0; diff --git a/be/src/olap/rowset/rowset_writer.h b/be/src/olap/rowset/rowset_writer.h index a36f0f8ceb..43d1837362 100644 --- a/be/src/olap/rowset/rowset_writer.h +++ b/be/src/olap/rowset/rowset_writer.h @@ -36,26 +36,26 @@ public: RowsetWriter() = default; virtual ~RowsetWriter() = default; - virtual OLAPStatus init(const RowsetWriterContext& rowset_writer_context) = 0; + virtual Status init(const RowsetWriterContext& rowset_writer_context) = 0; // Memory note: input `row` is guaranteed to be copied into writer's internal buffer, including all slice data // referenced by `row`. That means callers are free to de-allocate memory for `row` after this method returns. - virtual OLAPStatus add_row(const RowCursor& row) = 0; - virtual OLAPStatus add_row(const ContiguousRow& row) = 0; + virtual Status add_row(const RowCursor& row) = 0; + virtual Status add_row(const ContiguousRow& row) = 0; // Precondition: the input `rowset` should have the same type of the rowset we're building - virtual OLAPStatus add_rowset(RowsetSharedPtr rowset) = 0; + virtual Status add_rowset(RowsetSharedPtr rowset) = 0; // Precondition: the input `rowset` should have the same type of the rowset we're building - virtual OLAPStatus add_rowset_for_linked_schema_change(RowsetSharedPtr rowset, + virtual Status add_rowset_for_linked_schema_change(RowsetSharedPtr rowset, const SchemaMapping& schema_mapping) = 0; // explicit flush all buffered rows into segment file. // note that `add_row` could also trigger flush when certain conditions are met - virtual OLAPStatus flush() = 0; + virtual Status flush() = 0; - virtual OLAPStatus flush_single_memtable(MemTable* memtable, int64_t* flush_size) { - return OLAP_ERR_FUNC_NOT_IMPLEMENTED; + virtual Status flush_single_memtable(MemTable* memtable, int64_t* flush_size) { + return Status::OLAPInternalError(OLAP_ERR_FUNC_NOT_IMPLEMENTED); } // finish building and return pointer to the built rowset (guaranteed to be inited). diff --git a/be/src/olap/rowset/run_length_byte_reader.cpp b/be/src/olap/rowset/run_length_byte_reader.cpp index 61c1ea3d9b..b29f921de7 100644 --- a/be/src/olap/rowset/run_length_byte_reader.cpp +++ b/be/src/olap/rowset/run_length_byte_reader.cpp @@ -25,14 +25,14 @@ namespace doris { RunLengthByteReader::RunLengthByteReader(ReadOnlyFileStream* input) : _input(input), _num_literals(0), _used(0), _repeat(false) {} -OLAPStatus RunLengthByteReader::_read_values() { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthByteReader::_read_values() { + Status res = Status::OK(); _used = 0; char control_byte = 0; res = _input->read(&control_byte); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read control byte.[res = %d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to read control byte.res = " << res; return res; } @@ -41,8 +41,8 @@ OLAPStatus RunLengthByteReader::_read_values() { _num_literals = control_byte + RunLengthByteWriter::MIN_REPEAT_SIZE; res = _input->read(&_literals[0]); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read value byte.[res = %d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to read value byte.res = " << res; return res; } } else { @@ -54,8 +54,8 @@ OLAPStatus RunLengthByteReader::_read_values() { uint64_t to_read = _num_literals - bytes; res = _input->read(&_literals[bytes], &to_read); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read value byte.[res = %d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to read value byte.res = " << res; return res; } @@ -70,13 +70,13 @@ bool RunLengthByteReader::has_next() const { return _used != _num_literals || !_input->eof(); } -OLAPStatus RunLengthByteReader::next(char* value) { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthByteReader::next(char* value) { + Status res = Status::OK(); if (_used == _num_literals) { res = _read_values(); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read values.[res = %d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to read values.res = " << res; return res; } } @@ -91,11 +91,11 @@ OLAPStatus RunLengthByteReader::next(char* value) { return res; } -OLAPStatus RunLengthByteReader::seek(PositionProvider* position) { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthByteReader::seek(PositionProvider* position) { + Status res = Status::OK(); res = _input->seek(position); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { VLOG_TRACE << "fail to ReadOnlyFileStream seek. res = " << res; return res; } @@ -106,8 +106,8 @@ OLAPStatus RunLengthByteReader::seek(PositionProvider* position) { // a loop is required for cases where we break the run into two parts while (consumed > 0) { res = _read_values(); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read values.[res = %d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to read values.res = " << res; break; } @@ -122,14 +122,14 @@ OLAPStatus RunLengthByteReader::seek(PositionProvider* position) { return res; } -OLAPStatus RunLengthByteReader::skip(uint64_t num_values) { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthByteReader::skip(uint64_t num_values) { + Status res = Status::OK(); while (num_values > 0) { if (_used == _num_literals) { res = _read_values(); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read values.[res = %d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to read values.res = " << res; break; } } diff --git a/be/src/olap/rowset/run_length_byte_reader.h b/be/src/olap/rowset/run_length_byte_reader.h index 906c778413..f80bd1b451 100644 --- a/be/src/olap/rowset/run_length_byte_reader.h +++ b/be/src/olap/rowset/run_length_byte_reader.h @@ -35,13 +35,13 @@ public: explicit RunLengthByteReader(ReadOnlyFileStream* input); ~RunLengthByteReader() {} bool has_next() const; - // Gets the next piece of data, or if there is no more, returns OLAP_ERR_DATA_EOF - OLAPStatus next(char* value); - OLAPStatus seek(PositionProvider* position); - OLAPStatus skip(uint64_t num_values); + // Gets the next piece of data, or if there is no more, returns Status::OLAPInternalError(OLAP_ERR_DATA_EOF) + Status next(char* value); + Status seek(PositionProvider* position); + Status skip(uint64_t num_values); private: - OLAPStatus _read_values(); + Status _read_values(); ReadOnlyFileStream* _input; char _literals[RunLengthByteWriter::MAX_LITERAL_SIZE]; diff --git a/be/src/olap/rowset/run_length_byte_writer.cpp b/be/src/olap/rowset/run_length_byte_writer.cpp index 450f2a18ce..8955d9b84a 100644 --- a/be/src/olap/rowset/run_length_byte_writer.cpp +++ b/be/src/olap/rowset/run_length_byte_writer.cpp @@ -28,31 +28,31 @@ const int32_t RunLengthByteWriter::MAX_REPEAT_SIZE; RunLengthByteWriter::RunLengthByteWriter(OutStream* output) : _output(output), _num_literals(0), _repeat(false), _tail_run_length(0) {} -OLAPStatus RunLengthByteWriter::_write_values() { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthByteWriter::_write_values() { + Status res = Status::OK(); if (_num_literals != 0) { if (_repeat) { res = _output->write(_num_literals - MIN_REPEAT_SIZE); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write control byte."); return res; } res = _output->write(_literals[0]); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write repeat byte"); return res; } } else { res = _output->write(-_num_literals); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write control byte."); return res; } res = _output->write(_literals, _num_literals); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write literals bytes."); return res; } @@ -66,8 +66,8 @@ OLAPStatus RunLengthByteWriter::_write_values() { return res; } -OLAPStatus RunLengthByteWriter::write(char value) { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthByteWriter::write(char value) { + Status res = Status::OK(); if (0 == _num_literals) { _literals[0] = value; @@ -83,7 +83,7 @@ OLAPStatus RunLengthByteWriter::write(char value) { } else { res = _write_values(); - if (OLAP_SUCCESS == res) { + if (res.ok()) { _literals[0] = value; _num_literals = 1; _tail_run_length = 1; @@ -104,7 +104,7 @@ OLAPStatus RunLengthByteWriter::write(char value) { _num_literals -= MIN_REPEAT_SIZE - 1; res = _write_values(); - if (OLAP_SUCCESS == res) { + if (res.ok()) { _literals[0] = value; _repeat = true; _num_literals = MIN_REPEAT_SIZE; @@ -123,11 +123,11 @@ OLAPStatus RunLengthByteWriter::write(char value) { return res; } -OLAPStatus RunLengthByteWriter::flush() { - OLAPStatus res; +Status RunLengthByteWriter::flush() { + Status res; res = _write_values(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } diff --git a/be/src/olap/rowset/run_length_byte_writer.h b/be/src/olap/rowset/run_length_byte_writer.h index 7184d478ef..90d5046d83 100644 --- a/be/src/olap/rowset/run_length_byte_writer.h +++ b/be/src/olap/rowset/run_length_byte_writer.h @@ -33,15 +33,15 @@ class RunLengthByteWriter { public: explicit RunLengthByteWriter(OutStream* output); ~RunLengthByteWriter() {} - OLAPStatus write(char byte); - OLAPStatus flush(); + Status write(char byte); + Status flush(); void get_position(PositionEntryWriter* index_entry) const; static const int32_t MIN_REPEAT_SIZE = 3; static const int32_t MAX_LITERAL_SIZE = 128; static const int32_t MAX_REPEAT_SIZE = 127 + MIN_REPEAT_SIZE; private: - OLAPStatus _write_values(); + Status _write_values(); OutStream* _output; char _literals[MAX_LITERAL_SIZE]; diff --git a/be/src/olap/rowset/run_length_integer_reader.cpp b/be/src/olap/rowset/run_length_integer_reader.cpp index dffa8b07ab..47cd9d755f 100644 --- a/be/src/olap/rowset/run_length_integer_reader.cpp +++ b/be/src/olap/rowset/run_length_integer_reader.cpp @@ -26,15 +26,15 @@ namespace doris { RunLengthIntegerReader::RunLengthIntegerReader(ReadOnlyFileStream* input, bool is_singed) : _input(input), _signed(is_singed), _num_literals(0), _used(0) {} -OLAPStatus RunLengthIntegerReader::_read_values() { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthIntegerReader::_read_values() { + Status res = Status::OK(); // read the first 2 bits and determine the encoding type uint8_t first_byte; res = _input->read((char*)&first_byte); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read first byte.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to read first byte.res = " << res; return res; } else { int enc = (first_byte >> 6) & 0x03; @@ -53,8 +53,8 @@ OLAPStatus RunLengthIntegerReader::_read_values() { return res; } -OLAPStatus RunLengthIntegerReader::_read_delta_values(uint8_t first_byte) { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthIntegerReader::_read_delta_values(uint8_t first_byte) { + Status res = Status::OK(); // extract the number of fixed bits uint32_t fb = (first_byte >> 1) & 0x1f; @@ -65,11 +65,10 @@ OLAPStatus RunLengthIntegerReader::_read_delta_values(uint8_t first_byte) { // extract the blob run length int32_t len = (first_byte & 0x01) << 8; - uint8_t byte; + uint8_t byte = 0; res = _input->read((char*)&byte); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read byte from instream.[res=%d]", res); + if (!res.ok()) { return res; } @@ -80,14 +79,14 @@ OLAPStatus RunLengthIntegerReader::_read_delta_values(uint8_t first_byte) { if (_signed) { res = ser::read_var_signed(_input, &first_val); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read var signed.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to read var signed.res = " << res; return res; } } else { res = ser::read_var_unsigned(_input, &first_val); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read var unsigned.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to read var unsigned.res = " << res; return res; } } @@ -103,8 +102,8 @@ OLAPStatus RunLengthIntegerReader::_read_delta_values(uint8_t first_byte) { int64_t fd = 0; res = ser::read_var_signed(_input, &fd); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read var signed.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to read var signed.res = " << res; return res; } @@ -118,8 +117,8 @@ OLAPStatus RunLengthIntegerReader::_read_delta_values(uint8_t first_byte) { int64_t delta_base = 0; res = ser::read_var_signed(_input, &delta_base); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read var signed.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to read var signed.res = " << res; return res; } @@ -132,8 +131,8 @@ OLAPStatus RunLengthIntegerReader::_read_delta_values(uint8_t first_byte) { // value to result buffer. if the delta base value is negative then it // is a decreasing sequence else an increasing sequence res = ser::read_ints(_input, &_literals[_num_literals], len, fb); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read ints.[res = %d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to read ints.res = " << res; return res; } @@ -153,8 +152,8 @@ OLAPStatus RunLengthIntegerReader::_read_delta_values(uint8_t first_byte) { return res; } -OLAPStatus RunLengthIntegerReader::_read_patched_base_values(uint8_t first_byte) { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthIntegerReader::_read_patched_base_values(uint8_t first_byte) { + Status res = Status::OK(); // extract the number of fixed bits int32_t fbo = (first_byte >> 1) & 0x1f; @@ -162,11 +161,10 @@ OLAPStatus RunLengthIntegerReader::_read_patched_base_values(uint8_t first_byte) // extract the run length of data blob int32_t len = (first_byte & 0x01) << 8; - uint8_t byte; + uint8_t byte = 0; res = _input->read((char*)&byte); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read byte from in_straem.[res=%d]", res); + if (!res.ok()) { return res; } @@ -178,8 +176,8 @@ OLAPStatus RunLengthIntegerReader::_read_patched_base_values(uint8_t first_byte) char third_byte = '\0'; res = _input->read(&third_byte); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read byte from in_stream.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to read byte from in_stream.res = " << res; return res; } @@ -195,8 +193,8 @@ OLAPStatus RunLengthIntegerReader::_read_patched_base_values(uint8_t first_byte) char four_byte = '\0'; res = _input->read(&four_byte); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read byte from in_straem.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to read byte from in_straem.res = " << res; return res; } @@ -211,8 +209,8 @@ OLAPStatus RunLengthIntegerReader::_read_patched_base_values(uint8_t first_byte) int64_t base = 0; res = ser::bytes_to_long_be(_input, bw, &base); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to bytes to long be.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to bytes to long be.res = " << res; return res; } @@ -229,7 +227,7 @@ OLAPStatus RunLengthIntegerReader::_read_patched_base_values(uint8_t first_byte) int64_t unpacked[len]; res = ser::read_ints(_input, unpacked, len, fb); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } @@ -238,7 +236,7 @@ OLAPStatus RunLengthIntegerReader::_read_patched_base_values(uint8_t first_byte) uint32_t bit_width = ser::get_closet_fixed_bits(pw + pgw); res = ser::read_ints(_input, unpacked_patch, pl, bit_width); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } @@ -304,8 +302,8 @@ OLAPStatus RunLengthIntegerReader::_read_patched_base_values(uint8_t first_byte) return res; } -OLAPStatus RunLengthIntegerReader::_read_direct_values(uint8_t first_byte) { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthIntegerReader::_read_direct_values(uint8_t first_byte) { + Status res = Status::OK(); // extract the number of fixed bits uint32_t fbo = (first_byte >> 1) & 0x1f; @@ -316,7 +314,7 @@ OLAPStatus RunLengthIntegerReader::_read_direct_values(uint8_t first_byte) { uint8_t byte; res = _input->read((char*)&byte); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } @@ -326,7 +324,7 @@ OLAPStatus RunLengthIntegerReader::_read_direct_values(uint8_t first_byte) { // write the unpacked values and zigzag decode to result buffer res = ser::read_ints(_input, _literals, len, fb); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } @@ -342,8 +340,8 @@ OLAPStatus RunLengthIntegerReader::_read_direct_values(uint8_t first_byte) { return res; } -OLAPStatus RunLengthIntegerReader::_read_short_repeat_values(uint8_t first_byte) { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthIntegerReader::_read_short_repeat_values(uint8_t first_byte) { + Status res = Status::OK(); // read the number of bytes occupied by the value int32_t size = (first_byte >> 3) & 0x07; @@ -359,7 +357,7 @@ OLAPStatus RunLengthIntegerReader::_read_short_repeat_values(uint8_t first_byte) int64_t val = 0; res = ser::bytes_to_long_be(_input, size, &val); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } @@ -375,10 +373,10 @@ OLAPStatus RunLengthIntegerReader::_read_short_repeat_values(uint8_t first_byte) return res; } -OLAPStatus RunLengthIntegerReader::seek(PositionProvider* position) { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthIntegerReader::seek(PositionProvider* position) { + Status res = Status::OK(); - if (OLAP_SUCCESS != (res = _input->seek(position))) { + if (!(res = _input->seek(position))) { return res; } @@ -390,7 +388,7 @@ OLAPStatus RunLengthIntegerReader::seek(PositionProvider* position) { _num_literals = 0; res = _read_values(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } @@ -405,8 +403,8 @@ OLAPStatus RunLengthIntegerReader::seek(PositionProvider* position) { return res; } -OLAPStatus RunLengthIntegerReader::skip(uint64_t num_values) { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthIntegerReader::skip(uint64_t num_values) { + Status res = Status::OK(); while (num_values > 0) { if (_used == _num_literals) { @@ -414,8 +412,8 @@ OLAPStatus RunLengthIntegerReader::skip(uint64_t num_values) { _used = 0; res = _read_values(); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to read values.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to read values.res = " << res; return res; } } diff --git a/be/src/olap/rowset/run_length_integer_reader.h b/be/src/olap/rowset/run_length_integer_reader.h index 1b94c961b7..95f1c9429d 100644 --- a/be/src/olap/rowset/run_length_integer_reader.h +++ b/be/src/olap/rowset/run_length_integer_reader.h @@ -34,16 +34,16 @@ public: explicit RunLengthIntegerReader(ReadOnlyFileStream* input, bool is_singed); ~RunLengthIntegerReader() {} bool has_next() const { return _used != _num_literals || !_input->eof(); } - // 获取下一条数据, 如果没有更多的数据了, 返回OLAP_ERR_DATA_EOF - OLAPStatus next(int64_t* value) { - OLAPStatus res = OLAP_SUCCESS; + // 获取下一条数据, 如果没有更多的数据了, 返回Status::OLAPInternalError(OLAP_ERR_DATA_EOF) + Status next(int64_t* value) { + Status res = Status::OK(); if (OLAP_UNLIKELY(_used == _num_literals)) { _num_literals = 0; _used = 0; res = _read_values(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { return res; } } @@ -51,15 +51,15 @@ public: *value = _literals[_used++]; return res; } - OLAPStatus seek(PositionProvider* position); - OLAPStatus skip(uint64_t num_values); + Status seek(PositionProvider* position); + Status skip(uint64_t num_values); private: - OLAPStatus _read_values(); - OLAPStatus _read_delta_values(uint8_t first_byte); - OLAPStatus _read_patched_base_values(uint8_t first_byte); - OLAPStatus _read_direct_values(uint8_t first_byte); - OLAPStatus _read_short_repeat_values(uint8_t first_byte); + Status _read_values(); + Status _read_delta_values(uint8_t first_byte); + Status _read_patched_base_values(uint8_t first_byte); + Status _read_direct_values(uint8_t first_byte); + Status _read_short_repeat_values(uint8_t first_byte); ReadOnlyFileStream* _input; bool _signed; diff --git a/be/src/olap/rowset/run_length_integer_writer.cpp b/be/src/olap/rowset/run_length_integer_writer.cpp index 2cd2b7c527..89ad60bcc9 100644 --- a/be/src/olap/rowset/run_length_integer_writer.cpp +++ b/be/src/olap/rowset/run_length_integer_writer.cpp @@ -313,8 +313,8 @@ void RunLengthIntegerWriter::_prepare_patched_blob() { } } -OLAPStatus RunLengthIntegerWriter::_write_short_repeat_values() { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthIntegerWriter::_write_short_repeat_values() { + Status res = Status::OK(); int64_t repeat_value; repeat_value = _is_signed ? ser::zig_zag_encode(_literals[0]) : _literals[0]; @@ -330,7 +330,7 @@ OLAPStatus RunLengthIntegerWriter::_write_short_repeat_values() { head.run_length = _fixed_run_length - MIN_REPEAT; res = _output->write((char*)&head, sizeof(head)); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write SHORT_REPEAT head."); return res; } @@ -339,18 +339,18 @@ OLAPStatus RunLengthIntegerWriter::_write_short_repeat_values() { for (int32_t i = num_bytes_repeat_value - 1; i >= 0; i--) { char byte = (char)(((uint64_t)repeat_value >> (i * 8)) & 0xff); - if (OLAP_SUCCESS != (res = _output->write(byte))) { + if (!(res = _output->write(byte))) { OLAP_LOG_WARNING("fail to write SHORT_REPEAT data."); return res; } } _fixed_run_length = 0; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus RunLengthIntegerWriter::_write_direct_values() { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthIntegerWriter::_write_direct_values() { + Status res = Status::OK(); DirectHead head; head.type = DIRECT; @@ -358,23 +358,23 @@ OLAPStatus RunLengthIntegerWriter::_write_direct_values() { head.set_length(_var_run_length - 1); res = _output->write((char*)&head, sizeof(head)); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write DIRECT head."); return res; } res = ser::write_ints(_output, _zig_zag_literals, _num_literals, _zz_bits_100p); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to write DIRECT data."); return res; } _var_run_length = 0; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus RunLengthIntegerWriter::_write_patched_base_values() { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthIntegerWriter::_write_patched_base_values() { + Status res = Status::OK(); uint32_t bit_width = 0; PatchedBaseHead head; @@ -409,8 +409,8 @@ OLAPStatus RunLengthIntegerWriter::_write_patched_base_values() { // write header res = _output->write((char*)&head, sizeof(head)); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to write data.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to write data.res = " << res; return res; } @@ -419,8 +419,8 @@ OLAPStatus RunLengthIntegerWriter::_write_patched_base_values() { char byte = ((uint64_t)_min >> (i * 8)) & 0xff; res = _output->write(byte); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to write data.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to write data.res = " << res; return res; } } @@ -429,8 +429,8 @@ OLAPStatus RunLengthIntegerWriter::_write_patched_base_values() { bit_width = ser::get_closet_fixed_bits(_br_bits_95p); res = ser::write_ints(_output, _base_reduced_literals, _num_literals, bit_width); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to write data.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to write data.res = " << res; return res; } @@ -438,17 +438,17 @@ OLAPStatus RunLengthIntegerWriter::_write_patched_base_values() { bit_width = ser::get_closet_fixed_bits(_patch_gap_width + _patch_width); res = ser::write_ints(_output, _gap_vs_patch_list, _patch_length, bit_width); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to write data.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to write data.res = " << res; return res; } _var_run_length = 0; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus RunLengthIntegerWriter::_write_delta_values() { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthIntegerWriter::_write_delta_values() { + Status res = Status::OK(); uint32_t len = 0; uint32_t bit_width = _bits_delta_max; uint32_t encoded_bit_width = 0; @@ -486,8 +486,8 @@ OLAPStatus RunLengthIntegerWriter::_write_delta_values() { // write header res = _output->write((char*)&head, sizeof(head)); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to write data.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to write data.res = " << res; return res; } @@ -498,8 +498,8 @@ OLAPStatus RunLengthIntegerWriter::_write_delta_values() { res = ser::write_var_unsigned(_output, _literals[0]); } - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to write data.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to write data.res = " << res; return res; } @@ -507,81 +507,81 @@ OLAPStatus RunLengthIntegerWriter::_write_delta_values() { // if delta is fixed then we don't need to store delta blob res = ser::write_var_signed(_output, _fixed_delta); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to write data.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to write data.res = " << res; return res; } } else { // store the first value as delta value using zigzag encoding res = ser::write_var_signed(_output, _adj_deltas[0]); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to write data.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to write data.res = " << res; return res; } // adjacent delta values are bit packed res = ser::write_ints(_output, &_adj_deltas[1], _num_literals - 2, bit_width); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to write data.[res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to write data.res = " << res; return res; } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus RunLengthIntegerWriter::_write_values() { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthIntegerWriter::_write_values() { + Status res = Status::OK(); if (_num_literals > 0) { switch (_encoding) { case SHORT_REPEAT: - if (OLAP_SUCCESS != (res = _write_short_repeat_values())) { - OLAP_LOG_WARNING("fail to write short repeat value.[res=%d]", res); + if (!(res = _write_short_repeat_values())) { + LOG(WARNING) << "fail to write short repeat value.res = " << res; return res; } break; case DIRECT: - if (OLAP_SUCCESS != (res = _write_direct_values())) { - OLAP_LOG_WARNING("fail to write direct value.[res=%d]", res); + if (!(res = _write_direct_values())) { + LOG(WARNING) << "fail to write direct value.res = " << res; return res; } break; case PATCHED_BASE: - if (OLAP_SUCCESS != (res = _write_patched_base_values())) { - OLAP_LOG_WARNING("fail to write patched base value.[res=%d]", res); + if (!(res = _write_patched_base_values())) { + LOG(WARNING) << "fail to write patched base value.res = " << res; return res; } break; case DELTA: - if (OLAP_SUCCESS != (res = _write_delta_values())) { - OLAP_LOG_WARNING("fail to write delta value.[res=%d]", res); + if (!(res = _write_delta_values())) { + LOG(WARNING) << "fail to write delta value.res = " << res; return res; } break; default: - OLAP_LOG_WARNING("Unknown encoding [encoding=%d]", _encoding); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + LOG(WARNING) << "Unknown encoding encoding=" << _encoding; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } _clear(); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus RunLengthIntegerWriter::write(int64_t value) { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthIntegerWriter::write(int64_t value) { + Status res = Status::OK(); if (_num_literals == 0) { _init_literals(value); @@ -622,7 +622,7 @@ OLAPStatus RunLengthIntegerWriter::write(int64_t value) { uint32_t tail_pos = _num_literals; _determined_encoding(); - if (OLAP_SUCCESS != (res = _write_values())) { + if (!(res = _write_values())) { OLAP_LOG_WARNING("fail to write values."); return res; } @@ -636,7 +636,7 @@ OLAPStatus RunLengthIntegerWriter::write(int64_t value) { if (_fixed_run_length == MAX_SCOPE) { _determined_encoding(); - if (OLAP_SUCCESS != (res = _write_values())) { + if (!(res = _write_values())) { OLAP_LOG_WARNING("fail to write values."); return res; } @@ -655,7 +655,7 @@ OLAPStatus RunLengthIntegerWriter::write(int64_t value) { _is_fixed_delta = true; } - if (OLAP_SUCCESS != (res = _write_values())) { + if (!(res = _write_values())) { OLAP_LOG_WARNING("fail to write values."); return res; } @@ -678,7 +678,7 @@ OLAPStatus RunLengthIntegerWriter::write(int64_t value) { if (_var_run_length == MAX_SCOPE) { _determined_encoding(); - if (OLAP_SUCCESS != (res = _write_values())) { + if (!(res = _write_values())) { OLAP_LOG_WARNING("fail to write values."); return res; } @@ -690,8 +690,8 @@ OLAPStatus RunLengthIntegerWriter::write(int64_t value) { return res; } -OLAPStatus RunLengthIntegerWriter::flush() { - OLAPStatus res = OLAP_SUCCESS; +Status RunLengthIntegerWriter::flush() { + Status res = Status::OK(); if (_num_literals != 0) { if (_var_run_length != 0) { @@ -709,7 +709,7 @@ OLAPStatus RunLengthIntegerWriter::flush() { } } - if (OLAP_SUCCESS != (res = _write_values())) { + if (!(res = _write_values())) { OLAP_LOG_WARNING("fail to write values."); return res; } diff --git a/be/src/olap/rowset/run_length_integer_writer.h b/be/src/olap/rowset/run_length_integer_writer.h index c95b627ea3..a8f544f793 100644 --- a/be/src/olap/rowset/run_length_integer_writer.h +++ b/be/src/olap/rowset/run_length_integer_writer.h @@ -108,8 +108,8 @@ public: // 编码以减少存储负数时使用的比特数 explicit RunLengthIntegerWriter(OutStream* output, bool is_signed); ~RunLengthIntegerWriter() {} - OLAPStatus write(int64_t value); - OLAPStatus flush(); + Status write(int64_t value); + Status flush(); void get_position(PositionEntryWriter* index_entry, bool print) const; void print_position_debug_info() { @@ -239,11 +239,11 @@ private: void _determined_encoding(); void _init_literals(int64_t value); void _prepare_patched_blob(); - OLAPStatus _write_values(); - OLAPStatus _write_short_repeat_values(); - OLAPStatus _write_direct_values(); - OLAPStatus _write_patched_base_values(); - OLAPStatus _write_delta_values(); + Status _write_values(); + Status _write_short_repeat_values(); + Status _write_direct_values(); + Status _write_patched_base_values(); + Status _write_delta_values(); static const uint16_t MAX_SCOPE = 512; static const uint16_t MIN_REPEAT = 3; // NOTE 不要修改这个值, 否则程序出错 diff --git a/be/src/olap/rowset/segment_group.cpp b/be/src/olap/rowset/segment_group.cpp index 0dc2f51c38..e83eea429c 100644 --- a/be/src/olap/rowset/segment_group.cpp +++ b/be/src/olap/rowset/segment_group.cpp @@ -46,7 +46,7 @@ namespace doris { if (!_index_loaded) { \ OLAP_LOG_WARNING("fail to find, index is not loaded. [segment_group_id=%d]", \ _segment_group_id); \ - return OLAP_ERR_NOT_INITED; \ + return Status::OLAPInternalError(OLAP_ERR_NOT_INITED); \ } \ } while (0); @@ -54,7 +54,7 @@ namespace doris { do { \ if (nullptr == pos) { \ OLAP_LOG_WARNING("fail to find, nullptr position parameter."); \ - return OLAP_ERR_INPUT_PARAMETER_ERROR; \ + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); \ } \ } while (0); @@ -62,7 +62,7 @@ namespace doris { do { \ if (nullptr == slice) { \ OLAP_LOG_WARNING("fail to find, nullptr slice parameter."); \ - return OLAP_ERR_INPUT_PARAMETER_ERROR; \ + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); \ } \ } while (0); @@ -246,12 +246,12 @@ bool SegmentGroup::delete_all_files() { return success; } -OLAPStatus SegmentGroup::add_zone_maps_for_linked_schema_change( +Status SegmentGroup::add_zone_maps_for_linked_schema_change( const std::vector>& zone_map_fields, const SchemaMapping& schema_mapping) { //When add rollup tablet, the base tablet index maybe empty if (zone_map_fields.size() == 0) { - return OLAP_SUCCESS; + return Status::OK(); } // 1. rollup tablet get_num_zone_map_columns() will less than base tablet zone_map_fields.size(). @@ -311,10 +311,10 @@ OLAPStatus SegmentGroup::add_zone_maps_for_linked_schema_change( _zone_maps.push_back(std::make_pair(first, second)); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentGroup::add_zone_maps( +Status SegmentGroup::add_zone_maps( const std::vector>& zone_map_fields) { DCHECK(_empty || zone_map_fields.size() == get_num_zone_map_columns()); for (size_t i = 0; i < zone_map_fields.size(); ++i) { @@ -329,10 +329,10 @@ OLAPStatus SegmentGroup::add_zone_maps( _zone_maps.push_back(std::make_pair(first, second)); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentGroup::add_zone_maps( +Status SegmentGroup::add_zone_maps( std::vector>& zone_map_strings, std::vector& null_vec) { DCHECK(_empty || zone_map_strings.size() <= get_num_zone_map_columns()); @@ -350,19 +350,19 @@ OLAPStatus SegmentGroup::add_zone_maps( RETURN_NOT_OK(second->from_string(zone_map_strings[i].second)); _zone_maps.push_back(std::make_pair(first, second)); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentGroup::load(bool use_cache) { +Status SegmentGroup::load(bool use_cache) { if (_empty) { _index_loaded = true; - return OLAP_SUCCESS; + return Status::OK(); } - OLAPStatus res = OLAP_ERR_INDEX_LOAD_ERROR; + Status res = Status::OLAPInternalError(OLAP_ERR_INDEX_LOAD_ERROR); std::lock_guard guard(_index_load_lock); if (_index_loaded) { - return OLAP_SUCCESS; + return Status::OK(); } if (_num_segments == 0) { @@ -371,7 +371,7 @@ OLAPStatus SegmentGroup::load(bool use_cache) { } if (_index.init(_short_key_length, _new_short_key_length, _schema->num_short_key_columns(), - &_short_key_columns) != OLAP_SUCCESS) { + &_short_key_columns) != Status::OK()) { LOG(WARNING) << "fail to create MemIndex. num_segment=" << _num_segments; return res; } @@ -379,7 +379,7 @@ OLAPStatus SegmentGroup::load(bool use_cache) { // for each segment for (uint32_t seg_id = 0; seg_id < _num_segments; ++seg_id) { string seg_path = construct_data_file_path(seg_id); - if (OLAP_SUCCESS != (res = load_pb(seg_path.c_str(), seg_id))) { + if (!(res = load_pb(seg_path.c_str(), seg_id))) { LOG(WARNING) << "failed to load pb structures. [seg_path='" << seg_path << "']"; return res; @@ -388,7 +388,7 @@ OLAPStatus SegmentGroup::load(bool use_cache) { // get full path for one segment std::string path = construct_index_file_path(seg_id); if ((res = _index.load_segment(path.c_str(), &_current_num_rows_per_row_block, - use_cache)) != OLAP_SUCCESS) { + use_cache)) != Status::OK()) { LOG(WARNING) << "fail to load segment. [path='" << path << "']"; return res; @@ -398,42 +398,44 @@ OLAPStatus SegmentGroup::load(bool use_cache) { _delete_flag = _index.delete_flag(); _index_loaded = true; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentGroup::load_pb(const char* file, uint32_t seg_id) { - OLAPStatus res = OLAP_SUCCESS; +Status SegmentGroup::load_pb(const char* file, uint32_t seg_id) { + Status res = Status::OK(); FileHeader seg_file_header; FileHandler seg_file_handler; res = seg_file_handler.open(file, O_RDONLY); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("failed to open segment file. [err=%d, file=%s]", res, file); + if (!res.ok()) { + LOG(WARNING) << "failed to open segment file. err=" << res + << ", file=" << file; return res; } res = seg_file_header.unserialize(&seg_file_handler); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { seg_file_handler.close(); - OLAP_LOG_WARNING("fail to unserialize header. [err=%d, path='%s']", res, file); + LOG(WARNING) << "fail to unserialize header. err=" << res + << ", path=" << file; return res; } _seg_pb_map[seg_id] = seg_file_header; seg_file_handler.close(); - return OLAP_SUCCESS; + return Status::OK(); } bool SegmentGroup::index_loaded() { return _index_loaded; } -OLAPStatus SegmentGroup::validate() { +Status SegmentGroup::validate() { if (_empty) { - return OLAP_SUCCESS; + return Status::OK(); } - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); for (uint32_t seg_id = 0; seg_id < _num_segments; ++seg_id) { FileHeader index_file_header; FileHeader data_file_header; @@ -443,19 +445,19 @@ OLAPStatus SegmentGroup::validate() { string data_path = construct_data_file_path(seg_id); // 检查index文件头 - if ((res = index_file_header.validate(index_path)) != OLAP_SUCCESS) { + if ((res = index_file_header.validate(index_path)) != Status::OK()) { LOG(WARNING) << "validate index file error. [file='" << index_path << "']"; return res; } // 检查data文件头 - if ((res = data_file_header.validate(data_path)) != OLAP_SUCCESS) { + if ((res = data_file_header.validate(data_path)) != Status::OK()) { LOG(WARNING) << "validate data file error. [file='" << data_path << "']"; return res; } } - return OLAP_SUCCESS; + return Status::OK(); } bool SegmentGroup::check() { @@ -468,7 +470,7 @@ bool SegmentGroup::check() { return true; } -OLAPStatus SegmentGroup::find_short_key(const RowCursor& key, RowCursor* helper_cursor, +Status SegmentGroup::find_short_key(const RowCursor& key, RowCursor* helper_cursor, bool find_last, RowBlockPosition* pos) const { SEGMENT_GROUP_PARAM_VALIDATE(); POS_PARAM_VALIDATE(pos); @@ -489,28 +491,28 @@ OLAPStatus SegmentGroup::find_short_key(const RowCursor& key, RowCursor* helper_ return _index.get_row_block_position(offset, pos); } -OLAPStatus SegmentGroup::get_row_block_entry(const RowBlockPosition& pos, EntrySlice* entry) const { +Status SegmentGroup::get_row_block_entry(const RowBlockPosition& pos, EntrySlice* entry) const { SEGMENT_GROUP_PARAM_VALIDATE(); SLICE_PARAM_VALIDATE(entry); return _index.get_entry(_index.get_offset(pos), entry); } -OLAPStatus SegmentGroup::find_first_row_block(RowBlockPosition* position) const { +Status SegmentGroup::find_first_row_block(RowBlockPosition* position) const { SEGMENT_GROUP_PARAM_VALIDATE(); POS_PARAM_VALIDATE(position); return _index.get_row_block_position(_index.find_first(), position); } -OLAPStatus SegmentGroup::find_last_row_block(RowBlockPosition* position) const { +Status SegmentGroup::find_last_row_block(RowBlockPosition* position) const { SEGMENT_GROUP_PARAM_VALIDATE(); POS_PARAM_VALIDATE(position); return _index.get_row_block_position(_index.find_last(), position); } -OLAPStatus SegmentGroup::find_next_row_block(RowBlockPosition* pos, bool* eof) const { +Status SegmentGroup::find_next_row_block(RowBlockPosition* pos, bool* eof) const { SEGMENT_GROUP_PARAM_VALIDATE(); POS_PARAM_VALIDATE(pos); POS_PARAM_VALIDATE(eof); @@ -521,28 +523,28 @@ OLAPStatus SegmentGroup::find_next_row_block(RowBlockPosition* pos, bool* eof) c OLAPIndexOffset next = _index.next(current); if (next == _index.end()) { *eof = true; - return OLAP_ERR_INDEX_EOF; + return Status::OLAPInternalError(OLAP_ERR_INDEX_EOF); } return _index.get_row_block_position(next, pos); } -OLAPStatus SegmentGroup::find_mid_point(const RowBlockPosition& low, const RowBlockPosition& high, +Status SegmentGroup::find_mid_point(const RowBlockPosition& low, const RowBlockPosition& high, RowBlockPosition* output, uint32_t* dis) const { *dis = compute_distance(low, high); if (*dis >= _index.count()) { - return OLAP_ERR_INDEX_EOF; + return Status::OLAPInternalError(OLAP_ERR_INDEX_EOF); } else { *output = low; - if (advance_row_block(*dis / 2, output) != OLAP_SUCCESS) { - return OLAP_ERR_INDEX_EOF; + if (advance_row_block(*dis / 2, output) != Status::OK()) { + return Status::OLAPInternalError(OLAP_ERR_INDEX_EOF); } - return OLAP_SUCCESS; + return Status::OK(); } } -OLAPStatus SegmentGroup::find_prev_point(const RowBlockPosition& current, +Status SegmentGroup::find_prev_point(const RowBlockPosition& current, RowBlockPosition* prev) const { OLAPIndexOffset current_offset = _index.get_offset(current); OLAPIndexOffset prev_offset = _index.prev(current_offset); @@ -550,7 +552,7 @@ OLAPStatus SegmentGroup::find_prev_point(const RowBlockPosition& current, return _index.get_row_block_position(prev_offset, prev); } -OLAPStatus SegmentGroup::advance_row_block(int64_t num_row_blocks, +Status SegmentGroup::advance_row_block(int64_t num_row_blocks, RowBlockPosition* position) const { SEGMENT_GROUP_PARAM_VALIDATE(); POS_PARAM_VALIDATE(position); @@ -558,7 +560,7 @@ OLAPStatus SegmentGroup::advance_row_block(int64_t num_row_blocks, OLAPIndexOffset off = _index.get_offset(*position); iterator_offset_t absolute_offset = _index.get_absolute_offset(off) + num_row_blocks; if (absolute_offset >= _index.count()) { - return OLAP_ERR_INDEX_EOF; + return Status::OLAPInternalError(OLAP_ERR_INDEX_EOF); } return _index.get_row_block_position(_index.get_relative_offset(absolute_offset), position); @@ -573,7 +575,7 @@ uint32_t SegmentGroup::compute_distance(const RowBlockPosition& position1, return offset2 > offset1 ? offset2 - offset1 : 0; } -OLAPStatus SegmentGroup::add_segment() { +Status SegmentGroup::add_segment() { // 打开文件 ++_num_segments; @@ -594,29 +596,29 @@ OLAPStatus SegmentGroup::add_segment() { _short_key_buf = new (std::nothrow) char[_short_key_length]; if (_short_key_buf == nullptr) { OLAP_LOG_WARNING("malloc short_key_buf error."); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } memset(_short_key_buf, 0, _short_key_length); - if (_current_index_row.init(*_schema) != OLAP_SUCCESS) { + if (_current_index_row.init(*_schema) != Status::OK()) { OLAP_LOG_WARNING("init _current_index_row fail."); - return OLAP_ERR_INIT_FAILED; + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } } // 初始化checksum _checksum = ADLER32_INIT; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentGroup::add_row_block(const RowBlock& row_block, const uint32_t data_offset) { +Status SegmentGroup::add_row_block(const RowBlock& row_block, const uint32_t data_offset) { // get first row of the row_block to distill index item. row_block.get_row(0, &_current_index_row); return add_short_key(_current_index_row, data_offset); } -OLAPStatus SegmentGroup::add_short_key(const RowCursor& short_key, const uint32_t data_offset) { - OLAPStatus res = OLAP_SUCCESS; +Status SegmentGroup::add_short_key(const RowCursor& short_key, const uint32_t data_offset) { + Status res = Status::OK(); if (!_new_segment_created) { string file_path = construct_index_file_path(_num_segments - 1); StorageEngine* engine = StorageEngine::instance(); @@ -630,7 +632,7 @@ OLAPStatus SegmentGroup::add_short_key(const RowCursor& short_key, const uint32_ } res = _current_file_handler.open_with_mode(file_path.c_str(), O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { char errmsg[64]; LOG(WARNING) << "can not create file. file_path=" << file_path << ", err='" << strerror_r(errno, errmsg, 64); @@ -639,7 +641,7 @@ OLAPStatus SegmentGroup::add_short_key(const RowCursor& short_key, const uint32_ _new_segment_created = true; // 准备FileHeader - if ((res = _file_header.prepare(&_current_file_handler)) != OLAP_SUCCESS) { + if ((res = _file_header.prepare(&_current_file_handler)) != Status::OK()) { OLAP_LOG_WARNING("write file header error. [err=%m]"); return res; } @@ -647,7 +649,7 @@ OLAPStatus SegmentGroup::add_short_key(const RowCursor& short_key, const uint32_ // 跳过FileHeader if (_current_file_handler.seek(_file_header.size(), SEEK_SET) == -1) { OLAP_LOG_WARNING("lseek header file error. [err=%m]"); - res = OLAP_ERR_IO_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_IO_ERROR); return res; } } @@ -663,14 +665,14 @@ OLAPStatus SegmentGroup::add_short_key(const RowCursor& short_key, const uint32_ } // 写入Short Key对应的数据 - if ((res = _current_file_handler.write(_short_key_buf, _short_key_length)) != OLAP_SUCCESS) { + if ((res = _current_file_handler.write(_short_key_buf, _short_key_length)) != Status::OK()) { OLAP_LOG_WARNING("write short key failed. [err=%m]"); return res; } // 写入对应的数据文件偏移量 - if ((res = _current_file_handler.write(&data_offset, sizeof(data_offset))) != OLAP_SUCCESS) { + if ((res = _current_file_handler.write(&data_offset, sizeof(data_offset))) != Status::OK()) { OLAP_LOG_WARNING("write data_offset failed. [err=%m]"); return res; } @@ -678,18 +680,18 @@ OLAPStatus SegmentGroup::add_short_key(const RowCursor& short_key, const uint32_ _checksum = olap_adler32(_checksum, _short_key_buf, _short_key_length); _checksum = olap_adler32(_checksum, reinterpret_cast(&data_offset), sizeof(data_offset)); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentGroup::finalize_segment(uint32_t data_segment_size, int64_t num_rows) { +Status SegmentGroup::finalize_segment(uint32_t data_segment_size, int64_t num_rows) { // 准备FileHeader - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); int file_length = _current_file_handler.tell(); if (file_length == -1) { LOG(WARNING) << "get file_length error. err=" << Errno::no() << ", _new_segment_created=" << _new_segment_created; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } _file_header.set_file_length(file_length); @@ -698,7 +700,7 @@ OLAPStatus SegmentGroup::finalize_segment(uint32_t data_segment_size, int64_t nu _file_header.mutable_extra()->num_rows = num_rows; // 写入更新之后的FileHeader - if ((res = _file_header.serialize(&_current_file_handler)) != OLAP_SUCCESS) { + if ((res = _file_header.serialize(&_current_file_handler)) != Status::OK()) { OLAP_LOG_WARNING("write file header error. [err=%m]"); return res; @@ -707,14 +709,14 @@ OLAPStatus SegmentGroup::finalize_segment(uint32_t data_segment_size, int64_t nu VLOG_NOTICE << "finalize_segment. file_name=" << _current_file_handler.file_name() << ", file_length=" << file_length; - if ((res = _current_file_handler.close()) != OLAP_SUCCESS) { + if ((res = _current_file_handler.close()) != Status::OK()) { OLAP_LOG_WARNING("close file error. [err=%m]"); return res; } _new_segment_created = false; - return OLAP_SUCCESS; + return Status::OK(); } uint64_t SegmentGroup::num_index_entries() const { @@ -753,46 +755,46 @@ int64_t SegmentGroup::get_tablet_id() { return _tablet_id; } -OLAPStatus SegmentGroup::copy_files_to(const std::string& dir) { +Status SegmentGroup::copy_files_to(const std::string& dir) { if (_empty) { - return OLAP_SUCCESS; + return Status::OK(); } for (int segment_id = 0; segment_id < _num_segments; segment_id++) { std::string dest_data_file = construct_data_file_path(dir, segment_id); if (FileUtils::check_exist(dest_data_file)) { LOG(WARNING) << "file already exists:" << dest_data_file; - return OLAP_ERR_FILE_ALREADY_EXIST; + return Status::OLAPInternalError(OLAP_ERR_FILE_ALREADY_EXIST); } std::string data_file_to_copy = construct_data_file_path(segment_id); if (!FileUtils::copy_file(data_file_to_copy, dest_data_file).ok()) { LOG(WARNING) << "fail to copy data file. from=" << data_file_to_copy << ", to=" << dest_data_file << ", errno=" << Errno::no(); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } std::string dest_index_file = construct_index_file_path(dir, segment_id); if (FileUtils::check_exist(dest_index_file)) { LOG(WARNING) << "file already exists:" << dest_index_file; - return OLAP_ERR_FILE_ALREADY_EXIST; + return Status::OLAPInternalError(OLAP_ERR_FILE_ALREADY_EXIST); } std::string index_file_to_copy = construct_index_file_path(segment_id); if (!FileUtils::copy_file(index_file_to_copy, dest_index_file).ok()) { LOG(WARNING) << "fail to copy index file. from=" << index_file_to_copy << ", to=" << dest_index_file << ", errno=" << Errno::no(); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } } - return OLAP_SUCCESS; + return Status::OK(); } // when convert from old files, remove existing files // convert from old files in 2 cases: // case 1: clone from old version be // case 2: upgrade to new version be -OLAPStatus SegmentGroup::convert_from_old_files(const std::string& snapshot_path, +Status SegmentGroup::convert_from_old_files(const std::string& snapshot_path, std::vector* success_links) { if (_empty) { // the segment group is empty, it does not have files, just return - return OLAP_SUCCESS; + return Status::OK(); } for (int segment_id = 0; segment_id < _num_segments; segment_id++) { std::string new_data_file_name = construct_data_file_path(_rowset_path_prefix, segment_id); @@ -800,14 +802,14 @@ OLAPStatus SegmentGroup::convert_from_old_files(const std::string& snapshot_path if (FileUtils::check_exist(new_data_file_name)) { LOG(INFO) << "file already exist, remove it. file=" << new_data_file_name; RETURN_WITH_WARN_IF_ERROR(FileUtils::remove(new_data_file_name), - OLAP_ERR_CANNOT_CREATE_DIR, + Status::OLAPInternalError(OLAP_ERR_CANNOT_CREATE_DIR), "remove path failed. path=" + new_data_file_name); } std::string old_data_file_name = construct_old_data_file_path(snapshot_path, segment_id); if (link(old_data_file_name.c_str(), new_data_file_name.c_str()) != 0) { LOG(WARNING) << "fail to create hard link. from=" << old_data_file_name << ", to=" << new_data_file_name << ", errno=" << Errno::no(); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } else { VLOG_NOTICE << "link data file from " << old_data_file_name << " to " << new_data_file_name << " successfully"; @@ -819,27 +821,27 @@ OLAPStatus SegmentGroup::convert_from_old_files(const std::string& snapshot_path LOG(INFO) << "file already exist, remove it. file=" << new_index_file_name; RETURN_WITH_WARN_IF_ERROR(FileUtils::remove(new_index_file_name), - OLAP_ERR_CANNOT_CREATE_DIR, + Status::OLAPInternalError(OLAP_ERR_CANNOT_CREATE_DIR), "remove path failed. path=" + new_index_file_name); } std::string old_index_file_name = construct_old_index_file_path(snapshot_path, segment_id); if (link(old_index_file_name.c_str(), new_index_file_name.c_str()) != 0) { LOG(WARNING) << "fail to create hard link. from=" << old_index_file_name << ", to=" << new_index_file_name << ", errno=" << Errno::no(); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } else { VLOG_NOTICE << "link index file from " << old_index_file_name << " to " << new_index_file_name << " successfully"; } success_links->push_back(new_index_file_name); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentGroup::convert_to_old_files(const std::string& snapshot_path, +Status SegmentGroup::convert_to_old_files(const std::string& snapshot_path, std::vector* success_links) { if (_empty) { - return OLAP_SUCCESS; + return Status::OK(); } for (int segment_id = 0; segment_id < _num_segments; segment_id++) { std::string new_data_file_name = construct_data_file_path(_rowset_path_prefix, segment_id); @@ -849,7 +851,7 @@ OLAPStatus SegmentGroup::convert_to_old_files(const std::string& snapshot_path, LOG(WARNING) << "fail to create hard link. from=" << new_data_file_name << ", " << "to=" << old_data_file_name << ", " << "errno=" << Errno::no(); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } success_links->push_back(old_data_file_name); } @@ -863,23 +865,23 @@ OLAPStatus SegmentGroup::convert_to_old_files(const std::string& snapshot_path, LOG(WARNING) << "fail to create hard link. from=" << new_index_file_name << ", " << "to=" << old_index_file_name << ", " << "errno=" << Errno::no(); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } success_links->push_back(old_index_file_name); } VLOG_NOTICE << "create hard link. from=" << new_index_file_name << ", " << "to=" << old_index_file_name; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentGroup::remove_old_files(std::vector* links_to_remove) { +Status SegmentGroup::remove_old_files(std::vector* links_to_remove) { for (int segment_id = 0; segment_id < _num_segments; segment_id++) { std::string old_data_file_name = construct_old_data_file_path(_rowset_path_prefix, segment_id); if (FileUtils::check_exist(old_data_file_name)) { RETURN_WITH_WARN_IF_ERROR(FileUtils::remove(old_data_file_name), - OLAP_ERR_CANNOT_CREATE_DIR, + Status::OLAPInternalError(OLAP_ERR_CANNOT_CREATE_DIR), "remove path failed. path" + old_data_file_name); links_to_remove->push_back(old_data_file_name); @@ -888,7 +890,7 @@ OLAPStatus SegmentGroup::remove_old_files(std::vector* links_to_rem construct_old_index_file_path(_rowset_path_prefix, segment_id); if (FileUtils::check_exist(old_index_file_name)) { RETURN_WITH_WARN_IF_ERROR(FileUtils::remove(old_index_file_name), - OLAP_ERR_CANNOT_CREATE_DIR, + Status::OLAPInternalError(OLAP_ERR_CANNOT_CREATE_DIR), "remove path failed. path" + old_index_file_name); links_to_remove->push_back(old_index_file_name); @@ -898,7 +900,7 @@ OLAPStatus SegmentGroup::remove_old_files(std::vector* links_to_rem old_data_file_name = _construct_err_sg_data_file_path(_rowset_path_prefix, segment_id); if (FileUtils::check_exist(old_data_file_name)) { RETURN_WITH_WARN_IF_ERROR(FileUtils::remove(old_data_file_name), - OLAP_ERR_CANNOT_CREATE_DIR, + Status::OLAPInternalError(OLAP_ERR_CANNOT_CREATE_DIR), "remove path failed. path" + old_data_file_name); links_to_remove->push_back(old_data_file_name); } @@ -906,7 +908,7 @@ OLAPStatus SegmentGroup::remove_old_files(std::vector* links_to_rem _construct_err_sg_index_file_path(_rowset_path_prefix, segment_id); if (FileUtils::check_exist(old_index_file_name)) { RETURN_WITH_WARN_IF_ERROR(FileUtils::remove(old_index_file_name), - OLAP_ERR_CANNOT_CREATE_DIR, + Status::OLAPInternalError(OLAP_ERR_CANNOT_CREATE_DIR), "remove path failed. path" + old_index_file_name); links_to_remove->push_back(old_index_file_name); @@ -917,17 +919,17 @@ OLAPStatus SegmentGroup::remove_old_files(std::vector* links_to_rem if (FileUtils::check_exist(pending_delta_path)) { LOG(INFO) << "remove pending delta path:" << pending_delta_path; RETURN_WITH_WARN_IF_ERROR(FileUtils::remove_all(pending_delta_path), - OLAP_ERR_CANNOT_CREATE_DIR, + Status::OLAPInternalError(OLAP_ERR_CANNOT_CREATE_DIR), "remove path failed. path" + pending_delta_path); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentGroup::link_segments_to_path(const std::string& dest_path, +Status SegmentGroup::link_segments_to_path(const std::string& dest_path, const RowsetId& rowset_id) { if (dest_path.empty()) { LOG(WARNING) << "dest path is empty, return error"; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } for (int segment_id = 0; segment_id < _num_segments; segment_id++) { std::string data_file_name = _construct_file_name(rowset_id, segment_id, ".dat"); @@ -938,7 +940,7 @@ OLAPStatus SegmentGroup::link_segments_to_path(const std::string& dest_path, if (link(origin_data_file_path.c_str(), new_data_file_path.c_str()) != 0) { LOG(WARNING) << "fail to create hard link. from=" << origin_data_file_path << ", to=" << new_data_file_path << ", error=" << strerror(errno); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } } std::string index_file_name = _construct_file_name(rowset_id, segment_id, ".idx"); @@ -949,11 +951,11 @@ OLAPStatus SegmentGroup::link_segments_to_path(const std::string& dest_path, if (link(origin_idx_file_path.c_str(), new_index_file_path.c_str()) != 0) { LOG(WARNING) << "fail to create hard link. from=" << origin_idx_file_path << ", to=" << new_index_file_path << ", error=" << strerror(errno); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } } } - return OLAP_SUCCESS; + return Status::OK(); } std::string SegmentGroup::construct_old_index_file_path(const std::string& path_prefix, diff --git a/be/src/olap/rowset/segment_group.h b/be/src/olap/rowset/segment_group.h index de84ef030a..8ea2ce3cd5 100644 --- a/be/src/olap/rowset/segment_group.h +++ b/be/src/olap/rowset/segment_group.h @@ -60,20 +60,20 @@ public: virtual ~SegmentGroup(); // Load the index into memory. - OLAPStatus load(bool use_cache = true); + Status load(bool use_cache = true); bool index_loaded(); - OLAPStatus load_pb(const char* file, uint32_t seg_id); + Status load_pb(const char* file, uint32_t seg_id); bool has_zone_maps() { return _zone_maps.size() != 0; } - OLAPStatus add_zone_maps_for_linked_schema_change( + Status add_zone_maps_for_linked_schema_change( const std::vector>& zone_map_fields, const SchemaMapping& schema_mapping); - OLAPStatus add_zone_maps( + Status add_zone_maps( const std::vector>& zone_map_fields); - OLAPStatus add_zone_maps(std::vector>& zone_map_strings, + Status add_zone_maps(std::vector>& zone_map_strings, std::vector& null_vec); const std::vector>& get_zone_maps() { @@ -81,42 +81,42 @@ public: } // 检查index文件和data文件的有效性 - OLAPStatus validate(); + Status validate(); // this function should be called after load bool check(); // Finds position of first row block contain the smallest key equal // to or greater than 'key'. Returns true on success. - OLAPStatus find_short_key(const RowCursor& key, RowCursor* helper_cursor, bool find_last, + Status find_short_key(const RowCursor& key, RowCursor* helper_cursor, bool find_last, RowBlockPosition* position) const; // Returns position of the first row block in the index. - OLAPStatus find_first_row_block(RowBlockPosition* position) const; + Status find_first_row_block(RowBlockPosition* position) const; // Returns position of the last row block in the index. - OLAPStatus find_last_row_block(RowBlockPosition* position) const; + Status find_last_row_block(RowBlockPosition* position) const; // Given the position of a row block, finds position of the next block. // Sets eof to tru if there are no more blocks to go through, and // returns false. Returns true on success. - OLAPStatus find_next_row_block(RowBlockPosition* position, bool* eof) const; + Status find_next_row_block(RowBlockPosition* position, bool* eof) const; // Given two positions in an index, low and high, set output to be // the midpoint between those two positions. Returns the distance // between low and high as computed by ComputeDistance. - OLAPStatus find_mid_point(const RowBlockPosition& low, const RowBlockPosition& high, + Status find_mid_point(const RowBlockPosition& low, const RowBlockPosition& high, RowBlockPosition* output, uint32_t* dis) const; - OLAPStatus find_prev_point(const RowBlockPosition& current, RowBlockPosition* prev) const; + Status find_prev_point(const RowBlockPosition& current, RowBlockPosition* prev) const; - OLAPStatus get_row_block_entry(const RowBlockPosition& pos, EntrySlice* entry) const; + Status get_row_block_entry(const RowBlockPosition& pos, EntrySlice* entry) const; // Given a starting row block position, advances the position by // num_row_blocks, then stores back the new position through the // pointer. Returns true on success, false on attempt to seek past // the last block. - OLAPStatus advance_row_block(int64_t num_row_blocks, RowBlockPosition* position) const; + Status advance_row_block(int64_t num_row_blocks, RowBlockPosition* position) const; // Computes the distance between two positions, in row blocks. uint32_t compute_distance(const RowBlockPosition& position1, @@ -126,10 +126,10 @@ public: // files. AddSegment() and FinalizeSegment() start and end a new // segment respectively, while IndexRowBlock() and IndexShortKey() // add a new index entry to the current segment. - OLAPStatus add_segment(); - OLAPStatus add_short_key(const RowCursor& short_key, const uint32_t data_offset); - OLAPStatus add_row_block(const RowBlock& row_block, const uint32_t data_offset); - OLAPStatus finalize_segment(uint32_t data_segment_size, int64_t num_rows); + Status add_segment(); + Status add_short_key(const RowCursor& short_key, const uint32_t data_offset); + Status add_row_block(const RowBlock& row_block, const uint32_t data_offset); + Status finalize_segment(uint32_t data_segment_size, int64_t num_rows); // reference count void acquire(); @@ -187,7 +187,7 @@ public: // return count of entries in MemIndex uint64_t num_index_entries() const; - OLAPStatus get_row_block_position(const OLAPIndexOffset& pos, RowBlockPosition* rbp) const { + Status get_row_block_position(const OLAPIndexOffset& pos, RowBlockPosition* rbp) const { return _index.get_row_block_position(pos, rbp); } @@ -231,17 +231,17 @@ public: const RowsetId& rowset_id() { return _rowset_id; } - OLAPStatus convert_from_old_files(const std::string& snapshot_path, + Status convert_from_old_files(const std::string& snapshot_path, std::vector* success_links); - OLAPStatus convert_to_old_files(const std::string& snapshot_path, + Status convert_to_old_files(const std::string& snapshot_path, std::vector* success_links); - OLAPStatus remove_old_files(std::vector* links_to_remove); + Status remove_old_files(std::vector* links_to_remove); - OLAPStatus copy_files_to(const std::string& dir); + Status copy_files_to(const std::string& dir); - OLAPStatus link_segments_to_path(const std::string& dest_path, const RowsetId& rowset_id); + Status link_segments_to_path(const std::string& dest_path, const RowsetId& rowset_id); private: std::string _construct_file_name(int32_t segment_id, const std::string& suffix) const; diff --git a/be/src/olap/rowset/segment_reader.cpp b/be/src/olap/rowset/segment_reader.cpp index 897dd5e022..7126d272d7 100644 --- a/be/src/olap/rowset/segment_reader.cpp +++ b/be/src/olap/rowset/segment_reader.cpp @@ -97,11 +97,11 @@ SegmentReader::~SegmentReader() { } } -OLAPStatus SegmentReader::_check_file_version() { +Status SegmentReader::_check_file_version() { if (_header_message().magic_string().compare("COLUMN DATA") != 0) { OLAP_LOG_WARNING("not valid column data file, [magic_string = %s]", _header_message().magic_string().c_str()); - return OLAP_ERR_FILE_FORMAT_ERROR; + return Status::OLAPInternalError(OLAP_ERR_FILE_FORMAT_ERROR); } if (_header_message().version() > CURRENT_COLUMN_DATA_VERSION) { @@ -111,14 +111,14 @@ OLAPStatus SegmentReader::_check_file_version() { _header_message().version()); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentReader::_load_segment_file() { - OLAPStatus res = OLAP_SUCCESS; +Status SegmentReader::_load_segment_file() { + Status res = Status::OK(); res = _file_handler.open_with_cache(_file_name, O_RDONLY); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { LOG(WARNING) << "fail to open segment file. [file='" << _file_name << "']"; return res; } @@ -130,7 +130,7 @@ OLAPStatus SegmentReader::_load_segment_file() { _header_length = _file_header->size(); res = _check_file_version(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("file header corrupted or generated by higher version olap/ngine."); return res; } @@ -141,14 +141,14 @@ OLAPStatus SegmentReader::_load_segment_file() { if (nullptr == _mmap_buffer) { OLAP_LOG_WARNING("fail to call mmap, using default mode"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentReader::_set_decompressor() { +Status SegmentReader::_set_decompressor() { switch (_header_message().compress_kind()) { case COMPRESS_NONE: { _decompressor = nullptr; @@ -166,39 +166,39 @@ OLAPStatus SegmentReader::_set_decompressor() { } default: { OLAP_LOG_WARNING("unknown decompressor"); - return OLAP_ERR_PARSE_PROTOBUF_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PARSE_PROTOBUF_ERROR); } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentReader::_set_segment_info() { +Status SegmentReader::_set_segment_info() { _num_rows_in_block = _header_message().num_rows_per_block(); if (_num_rows_in_block == 0) { _num_rows_in_block = _segment_group->get_num_rows_per_row_block(); } _set_column_map(); - OLAPStatus res = _set_decompressor(); - if (OLAP_SUCCESS != res) { + Status res = _set_decompressor(); + if (!res.ok()) { OLAP_LOG_WARNING("fail to get decompressor."); return res; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentReader::init(bool is_using_cache) { +Status SegmentReader::init(bool is_using_cache) { SCOPED_RAW_TIMER(&_stats->index_load_ns); - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); res = _load_segment_file(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to load segment file. "); return res; } // File header res = _set_segment_info(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to set segment info. "); return res; } @@ -207,38 +207,38 @@ OLAPStatus SegmentReader::init(bool is_using_cache) { StorageByteBuffer::create(_header_message().stream_buffer_size() + sizeof(StreamHead)); if (_shared_buffer == nullptr) { OLAP_LOG_WARNING("fail to create shared buffer. [size=%lu]", sizeof(StorageByteBuffer)); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } res = _pick_columns(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to pick columns"); return res; } res = _load_index(is_using_cache); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to load index stream"); return res; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentReader::seek_to_block(uint32_t first_block, uint32_t last_block, +Status SegmentReader::seek_to_block(uint32_t first_block, uint32_t last_block, bool without_filter, uint32_t* next_block_id, bool* eof) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); if (!_is_data_loaded) { _reset_readers(); res = _read_all_data_streams(&_buffer_size); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to read data stream"); return res; } - OLAPStatus res = _create_reader(&_buffer_size); - if (res != OLAP_SUCCESS) { + Status res = _create_reader(&_buffer_size); + if (!res.ok()) { OLAP_LOG_WARNING("fail to create reader"); return res; } @@ -260,7 +260,7 @@ OLAPStatus SegmentReader::seek_to_block(uint32_t first_block, uint32_t last_bloc */ _remain_block = last_block - first_block + 1; res = _pick_row_groups(first_block, last_block); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to pick row groups"); return res; } @@ -278,13 +278,13 @@ OLAPStatus SegmentReader::seek_to_block(uint32_t first_block, uint32_t last_bloc // of prefix shortkey columns is wrong. _need_to_seek_block = true; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentReader::get_block(VectorizedRowBatch* batch, uint32_t* next_block_id, bool* eof) { +Status SegmentReader::get_block(VectorizedRowBatch* batch, uint32_t* next_block_id, bool* eof) { if (_eof) { *eof = true; - return OLAP_SUCCESS; + return Status::OK(); } // lazy seek @@ -298,7 +298,7 @@ OLAPStatus SegmentReader::get_block(VectorizedRowBatch* batch, uint32_t* next_bl } auto res = _load_to_vectorized_row_batch(batch, num_rows_load); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to load block to vectorized_row_batch. res:" << res; return res; } @@ -307,7 +307,7 @@ OLAPStatus SegmentReader::get_block(VectorizedRowBatch* batch, uint32_t* next_bl *next_block_id = _next_block_id; *eof = _eof; - return OLAP_SUCCESS; + return Status::OK(); } void SegmentReader::_set_column_map() { @@ -342,7 +342,7 @@ void SegmentReader::_set_column_map() { } } -OLAPStatus SegmentReader::_pick_columns() { +Status SegmentReader::_pick_columns() { for (uint32_t i : _used_columns) { ColumnId unique_column_id = _tablet_id_to_unique_id_map[i]; _include_columns.insert(unique_column_id); @@ -353,19 +353,19 @@ OLAPStatus SegmentReader::_pick_columns() { _include_bf_columns.insert(unique_column_id); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentReader::_pick_delete_row_groups(uint32_t first_block, uint32_t last_block) { +Status SegmentReader::_pick_delete_row_groups(uint32_t first_block, uint32_t last_block) { VLOG_TRACE << "pick for " << first_block << " to " << last_block << " for delete_condition"; if (_delete_handler->empty()) { - return OLAP_SUCCESS; + return Status::OK(); } if (DEL_NOT_SATISFIED == _delete_status) { VLOG_TRACE << "the segment not satisfy the delete_conditions"; - return OLAP_SUCCESS; + return Status::OK(); } for (auto& delete_condition : _delete_handler->get_delete_conditions()) { @@ -424,42 +424,42 @@ OLAPStatus SegmentReader::_pick_delete_row_groups(uint32_t first_block, uint32_t } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentReader::_init_include_blocks(uint32_t first_block, uint32_t last_block) { +Status SegmentReader::_init_include_blocks(uint32_t first_block, uint32_t last_block) { if (nullptr == _include_blocks) { _include_blocks = new (std::nothrow) uint8_t[_block_count]; if (nullptr == _include_blocks) { OLAP_LOG_WARNING("fail to malloc include block array"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } } memset(_include_blocks, 0, _block_count); memset(_include_blocks + first_block, 1, _remain_block); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentReader::_pick_row_groups(uint32_t first_block, uint32_t last_block) { +Status SegmentReader::_pick_row_groups(uint32_t first_block, uint32_t last_block) { VLOG_TRACE << "pick from " << first_block << " to " << last_block; if (first_block > last_block) { OLAP_LOG_WARNING("invalid block offset. [first_block=%u last_block=%u]", first_block, last_block); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } - OLAPStatus res = _init_include_blocks(first_block, last_block); - if (OLAP_SUCCESS != res) { + Status res = _init_include_blocks(first_block, last_block); + if (!res.ok()) { return res; } _pick_delete_row_groups(first_block, last_block); if (nullptr == _conditions || _conditions->columns().size() == 0) { - return OLAP_SUCCESS; + return Status::OK(); } OlapStopWatch timer; @@ -501,7 +501,7 @@ OLAPStatus SegmentReader::_pick_row_groups(uint32_t first_block, uint32_t last_b VLOG_TRACE << "bloom filter is ignored for too few block remained. " << "remain_block=" << _remain_block << ", const_time=" << timer.get_elapse_time_us(); - return OLAP_SUCCESS; + return Status::OK(); } for (uint32_t i : _load_bf_columns) { @@ -537,7 +537,7 @@ OLAPStatus SegmentReader::_pick_row_groups(uint32_t first_block, uint32_t last_b VLOG_TRACE << "pick row groups finished. remain_block=" << _remain_block << ", const_time=" << timer.get_elapse_time_us(); - return OLAP_SUCCESS; + return Status::OK(); } CacheKey SegmentReader::_construct_index_stream_key(char* buf, size_t len, @@ -558,8 +558,8 @@ void SegmentReader::_delete_cached_index_stream(const CacheKey& key, void* value SAFE_DELETE_ARRAY(buffer); } -OLAPStatus SegmentReader::_load_index(bool is_using_cache) { - OLAPStatus res = OLAP_SUCCESS; +Status SegmentReader::_load_index(bool is_using_cache) { + Status res = Status::OK(); int32_t handle_num = _get_included_row_index_stream_num(); _cache_handle.resize(handle_num, nullptr); @@ -567,8 +567,8 @@ OLAPStatus SegmentReader::_load_index(bool is_using_cache) { ReadOnlyFileStream stream(&_file_handler, &_shared_buffer, _decompressor, _header_message().stream_buffer_size(), _stats); res = stream.init(); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to init stream. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to init stream. res = " << res; return res; } @@ -623,15 +623,15 @@ OLAPStatus SegmentReader::_load_index(bool is_using_cache) { "fail to malloc index stream. " "[column_unique_id = %u, offset = %lu]", unique_column_id, stream_offset); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } size_t read_length = stream_length; stream.reset(stream_offset, stream_length); res = stream.read_all(stream_buffer, &read_length); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("read index fail"); - return OLAP_ERR_FILE_FORMAT_ERROR; + return Status::OLAPInternalError(OLAP_ERR_FILE_FORMAT_ERROR); } if (is_using_cache) { @@ -650,12 +650,12 @@ OLAPStatus SegmentReader::_load_index(bool is_using_cache) { StreamIndexReader* index_message = new (std::nothrow) StreamIndexReader; if (index_message == nullptr) { OLAP_LOG_WARNING("fail to malloc memory. [size=%lu]", sizeof(StreamIndexReader)); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } res = index_message->init(stream_buffer, stream_length, type, is_using_cache, _null_supported); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("init index from cache fail"); return res; } @@ -669,14 +669,14 @@ OLAPStatus SegmentReader::_load_index(bool is_using_cache) { if (bf_message == nullptr) { OLAP_LOG_WARNING("fail to malloc memory. [size=%lu]", sizeof(BloomFilterIndexReader)); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } res = bf_message->init(stream_buffer, stream_length, is_using_cache, _header_message().bf_hash_function_num(), _header_message().bf_bit_num()); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("fail to init bloom filter reader. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to init bloom filter reader. res = " << res; return res; } @@ -696,15 +696,15 @@ OLAPStatus SegmentReader::_load_index(bool is_using_cache) { << ", tablet_id=" << _segment_group->get_tablet_id() << ", version='" << _segment_group->version().first << "-" << _segment_group->version().second << "'"; - return OLAP_ERR_FILE_FORMAT_ERROR; + return Status::OLAPInternalError(OLAP_ERR_FILE_FORMAT_ERROR); } } VLOG_TRACE << "found index entry count: " << _block_count; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentReader::_read_all_data_streams(size_t* buffer_size) { +Status SegmentReader::_read_all_data_streams(size_t* buffer_size) { int64_t stream_offset = _header_length; uint64_t stream_length = 0; @@ -735,11 +735,11 @@ OLAPStatus SegmentReader::_read_all_data_streams(size_t* buffer_size) { _header_message().stream_buffer_size(), _stats)); if (stream == nullptr) { OLAP_LOG_WARNING("fail to create stream"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } - OLAPStatus res = stream->init(); - if (OLAP_SUCCESS != res) { + Status res = stream->init(); + if (!res.ok()) { OLAP_LOG_WARNING("fail to init stream"); return res; } @@ -748,10 +748,10 @@ OLAPStatus SegmentReader::_read_all_data_streams(size_t* buffer_size) { _streams[name] = stream.release(); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentReader::_create_reader(size_t* buffer_size) { +Status SegmentReader::_create_reader(size_t* buffer_size) { _column_readers.resize(_segment_group->get_tablet_schema().num_columns(), nullptr); _column_indices.resize(_segment_group->get_tablet_schema().num_columns(), nullptr); for (auto table_column_id : _used_columns) { @@ -762,11 +762,11 @@ OLAPStatus SegmentReader::_create_reader(size_t* buffer_size) { _unique_id_to_segment_id_map, _encodings_map)); if (reader == nullptr) { OLAP_LOG_WARNING("fail to create reader"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } auto res = reader->init(&_streams, _num_rows_in_block, _mem_pool.get(), _stats); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to init reader"); return res; } @@ -778,14 +778,14 @@ OLAPStatus SegmentReader::_create_reader(size_t* buffer_size) { } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentReader::_seek_to_block_directly(int64_t block_id, +Status SegmentReader::_seek_to_block_directly(int64_t block_id, const std::vector& cids) { if (!_need_to_seek_block && block_id == _current_block_id) { // no need to execute seek - return OLAP_SUCCESS; + return Status::OK(); } SCOPED_RAW_TIMER(&_stats->block_seek_ns); for (auto cid : cids) { @@ -795,30 +795,30 @@ OLAPStatus SegmentReader::_seek_to_block_directly(int64_t block_id, continue; } - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); PositionProvider position(&_column_indices[cid]->entry(block_id)); - if (OLAP_SUCCESS != (res = _column_readers[cid]->seek(&position))) { - if (OLAP_ERR_COLUMN_STREAM_EOF == res) { + if (!(res = _column_readers[cid]->seek(&position))) { + if (Status::OLAPInternalError(OLAP_ERR_COLUMN_STREAM_EOF) == res) { VLOG_TRACE << "Stream EOF. tablet_id=" << _segment_group->get_tablet_id() << ", column_id=" << _column_readers[cid]->column_unique_id() << ", block_id=" << block_id; - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } else { OLAP_LOG_WARNING( "fail to seek to block. " "[tablet_id=%ld column_id=%u block_id=%lu]", _segment_group->get_tablet_id(), _column_readers[cid]->column_unique_id(), block_id); - return OLAP_ERR_COLUMN_SEEK_ERROR; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_SEEK_ERROR); } } } _current_block_id = block_id; _need_to_seek_block = false; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentReader::_reset_readers() { +Status SegmentReader::_reset_readers() { VLOG_TRACE << _streams.size() << " stream in total."; for (std::map::iterator it = _streams.begin(); @@ -838,7 +838,7 @@ OLAPStatus SegmentReader::_reset_readers() { _column_readers.clear(); _eof = false; - return OLAP_SUCCESS; + return Status::OK(); } void SegmentReader::_seek_to_block(int64_t block_id, bool without_filter) { @@ -853,13 +853,13 @@ void SegmentReader::_seek_to_block(int64_t block_id, bool without_filter) { _next_block_id = block_id; } -OLAPStatus SegmentReader::_load_to_vectorized_row_batch(VectorizedRowBatch* batch, size_t size) { +Status SegmentReader::_load_to_vectorized_row_batch(VectorizedRowBatch* batch, size_t size) { SCOPED_RAW_TIMER(&_stats->block_load_ns); MemPool* mem_pool = batch->mem_pool(); for (auto cid : batch->columns()) { auto reader = _column_readers[cid]; auto res = reader->next_vector(batch->column(cid), size, mem_pool); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to read next, res=" << res << ", column=" << reader->column_unique_id() << ", size=" << size; return res; @@ -882,7 +882,7 @@ OLAPStatus SegmentReader::_load_to_vectorized_row_batch(VectorizedRowBatch* batc _stats->blocks_load++; _stats->raw_rows_read += size; - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/rowset/segment_reader.h b/be/src/olap/rowset/segment_reader.h index 148f8f3e6b..d6cc119aba 100644 --- a/be/src/olap/rowset/segment_reader.h +++ b/be/src/olap/rowset/segment_reader.h @@ -60,11 +60,11 @@ public: // 2. Check the file version // 3. Get the decompressor // @return [description] - OLAPStatus init(bool is_using_cache); + Status init(bool is_using_cache); // Must called before seek to block. // TODO(zc) - OLAPStatus prepare(const std::vector& columns); + Status prepare(const std::vector& columns); // Specify the first block and the last block to read, and initialize the column reader // seek_to_block supports being called multiple times @@ -79,7 +79,7 @@ public: // next_block_id: // block with next_block_id would read if get_block called again. // this field is used to set batch's limit when client found logical end is reach - OLAPStatus seek_to_block(uint32_t first_block, uint32_t last_block, bool without_filter, + Status seek_to_block(uint32_t first_block, uint32_t last_block, bool without_filter, uint32_t* next_block_id, bool* eof); // get vector batch from this segment. @@ -87,7 +87,7 @@ public: // block with next_block_id would read if get_block called again. // this field is used to set batch's limit when client found logical end is reach // ATTN: If you change batch to contain more columns, you must call seek_to_block again. - OLAPStatus get_block(VectorizedRowBatch* batch, uint32_t* next_block_id, bool* eof); + Status get_block(VectorizedRowBatch* batch, uint32_t* next_block_id, bool* eof); bool eof() const { return _eof; } @@ -136,43 +136,43 @@ private: } // Load files and necessary file information - OLAPStatus _load_segment_file(); + Status _load_segment_file(); // Set the encoding map and use it when creating columns void _set_column_map(); //Get the current file compression format from the header and generate a decompressor, which can be called by _decompressor // @return Return OLAP_SUCCESS on behalf of the version check passed - OLAPStatus _set_decompressor(); + Status _set_decompressor(); // Set segment related information, decompressor, column, encoding, etc. - OLAPStatus _set_segment_info(); + Status _set_segment_info(); // Check the listed file version // @return Return OLAP_SUCCESS on behalf of the version check passed - OLAPStatus _check_file_version(); + Status _check_file_version(); // Select the column to be read - OLAPStatus _pick_columns(); + Status _pick_columns(); // Select the range to be read according to the conditions, and use the conditions to mark the appropriate block between the first block and the last block // NOTE. Note that the range is [first_block, last_block], closed interval // @param first_block : Starting block number // @param last_block : End block number // @return - OLAPStatus _pick_row_groups(uint32_t first_block, uint32_t last_block); - OLAPStatus _pick_delete_row_groups(uint32_t first_block, uint32_t last_block); + Status _pick_row_groups(uint32_t first_block, uint32_t last_block); + Status _pick_delete_row_groups(uint32_t first_block, uint32_t last_block); // Load the index, read the index of the required column into memory - OLAPStatus _load_index(bool is_using_cache); + Status _load_index(bool is_using_cache); // Read all the columns, the complete stream, (here just create the stream, because there is no mmap in the orc file, // it means the actual data is read, but there is no actual read here, just circle the required range) - OLAPStatus _read_all_data_streams(size_t* buffer_size); + Status _read_all_data_streams(size_t* buffer_size); // Filter and read, (like _read_all_data_streams, there is no actual read data) // Create reader - OLAPStatus _create_reader(size_t* buffer_size); + Status _create_reader(size_t* buffer_size); // we implement seek to block in two phase. first, we just only move _next_block_id // to the position that we want goto; second, we seek the column streams to the @@ -181,19 +181,19 @@ private: // seek to block id without check. only seek in cids's read stream. // because some columns may not be read - OLAPStatus _seek_to_block_directly(int64_t block_id, const std::vector& cids); + Status _seek_to_block_directly(int64_t block_id, const std::vector& cids); // Jump to a row entry - OLAPStatus _seek_to_row_entry(int64_t block_id); + Status _seek_to_row_entry(int64_t block_id); - OLAPStatus _reset_readers(); + Status _reset_readers(); // Get the current table-level schema. const TabletSchema& tablet_schema() { return _segment_group->get_tablet_schema(); } const ColumnDataHeaderMessage& _header_message() { return _file_header->message(); } - OLAPStatus _init_include_blocks(uint32_t first_block, uint32_t last_block); + Status _init_include_blocks(uint32_t first_block, uint32_t last_block); const int32_t _get_included_row_index_stream_num() { int32_t included_row_index_stream_num = 0; @@ -214,7 +214,7 @@ private: return included_row_index_stream_num; } - OLAPStatus _load_to_vectorized_row_batch(VectorizedRowBatch* batch, size_t size); + Status _load_to_vectorized_row_batch(VectorizedRowBatch* batch, size_t size); FieldAggregationMethod _get_aggregation_by_index(uint32_t index) { const TabletSchema& tablet_schema = _segment_group->get_tablet_schema(); diff --git a/be/src/olap/rowset/segment_v2/column_reader.cpp b/be/src/olap/rowset/segment_v2/column_reader.cpp index 761140852a..90c0a57e28 100644 --- a/be/src/olap/rowset/segment_v2/column_reader.cpp +++ b/be/src/olap/rowset/segment_v2/column_reader.cpp @@ -717,7 +717,7 @@ Status DefaultValueColumnIterator::init(const ColumnIteratorOptions& opts) { } else { _type_size = _type_info->size(); _mem_value = reinterpret_cast(_pool->allocate(_type_size)); - OLAPStatus s = OLAP_SUCCESS; + Status s = Status::OK(); if (_type_info->type() == OLAP_FIELD_TYPE_CHAR) { int32_t length = _schema_length; char* string_buffer = reinterpret_cast(_pool->allocate(length)); @@ -740,9 +740,8 @@ Status DefaultValueColumnIterator::init(const ColumnIteratorOptions& opts) { } else { s = _type_info->from_string(_mem_value, _default_value); } - if (s != OLAP_SUCCESS) { - return Status::InternalError(strings::Substitute( - "get value of type from default value failed. status:$0", s)); + if (!s.ok()) { + return s; } } } else if (_is_nullable) { diff --git a/be/src/olap/rowset/segment_writer.cpp b/be/src/olap/rowset/segment_writer.cpp index 6aaceb91ec..be71be2115 100644 --- a/be/src/olap/rowset/segment_writer.cpp +++ b/be/src/olap/rowset/segment_writer.cpp @@ -47,14 +47,14 @@ SegmentWriter::~SegmentWriter() { } } -OLAPStatus SegmentWriter::init(uint32_t write_mbytes_per_sec) { - OLAPStatus res = OLAP_SUCCESS; +Status SegmentWriter::init(uint32_t write_mbytes_per_sec) { + Status res = Status::OK(); // 创建factory _stream_factory = new (std::nothrow) OutStreamFactory(_compress_kind, _stream_buffer_size); if (nullptr == _stream_factory) { OLAP_LOG_WARNING("fail to allocate out stream factory"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } // 创建writer @@ -65,38 +65,38 @@ OLAPStatus SegmentWriter::init(uint32_t write_mbytes_per_sec) { if (nullptr == writer) { OLAP_LOG_WARNING("fail to create writer"); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } else { _root_writers.push_back(writer); } res = writer->init(); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to initialize ColumnWriter. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to initialize ColumnWriter. res = " << res; return res; } } _write_mbytes_per_sec = write_mbytes_per_sec; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentWriter::write_batch(RowBlock* block, RowCursor* cursor, bool is_finalize) { +Status SegmentWriter::write_batch(RowBlock* block, RowCursor* cursor, bool is_finalize) { DCHECK(block->row_block_info().row_num == _segment_group->get_num_rows_per_row_block() || is_finalize) << "write block not empty, num_rows=" << block->row_block_info().row_num << ", table_num_rows=" << _segment_group->get_num_rows_per_row_block(); - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); for (auto col_writer : _root_writers) { res = col_writer->write_batch(block, cursor); - if (OLAP_UNLIKELY(res != OLAP_SUCCESS)) { - OLAP_LOG_WARNING("fail to write row. [res=%d]", res); + if (OLAP_UNLIKELY(!res.ok())) { + LOG(WARNING) << "fail to write row. res = " << res; return res; } res = col_writer->create_row_index_entry(); - if (OLAP_UNLIKELY(res != OLAP_SUCCESS)) { - OLAP_LOG_WARNING("fail to create row index. [res=%d]", res); + if (OLAP_UNLIKELY(!res.ok())) { + LOG(WARNING) << "fail to create row index. res = " << res; return res; } } @@ -121,8 +121,8 @@ uint64_t SegmentWriter::estimate_segment_size() { return result; } -OLAPStatus SegmentWriter::_make_file_header(ColumnDataHeaderMessage* file_header) { - OLAPStatus res = OLAP_SUCCESS; +Status SegmentWriter::_make_file_header(ColumnDataHeaderMessage* file_header) { + Status res = Status::OK(); file_header->set_number_of_rows(_row_count); file_header->set_compress_kind(_compress_kind); file_header->set_stream_buffer_size(_stream_buffer_size); @@ -154,8 +154,8 @@ OLAPStatus SegmentWriter::_make_file_header(ColumnDataHeaderMessage* file_header // * zone_maps res = (*it)->finalize(file_header); - if (OLAP_UNLIKELY(OLAP_SUCCESS != res)) { - OLAP_LOG_WARNING("fail to finalize row writer. [res=%d]", res); + if (OLAP_UNLIKELY(!res.ok())) { + LOG(WARNING) << "fail to finalize row writer. res = " << res; return res; } } @@ -169,8 +169,8 @@ OLAPStatus SegmentWriter::_make_file_header(ColumnDataHeaderMessage* file_header // 如果这个流没有被终止，flush if (!stream->is_suppressed()) { - if (OLAP_SUCCESS != (res = stream->flush())) { - OLAP_LOG_WARNING("fail to flush out stream. [res=%d]", res); + if (!(res = stream->flush())) { + LOG(WARNING) << "fail to flush out stream. res = " << res; return res; } } else { @@ -200,8 +200,8 @@ OLAPStatus SegmentWriter::_make_file_header(ColumnDataHeaderMessage* file_header } // 之前所有的数据都缓存在内存里, 现在创建文件, 写入数据 -OLAPStatus SegmentWriter::finalize(uint32_t* segment_file_size) { - OLAPStatus res = OLAP_SUCCESS; +Status SegmentWriter::finalize(uint32_t* segment_file_size) { + Status res = Status::OK(); FileHandler file_handle; FileHeader file_header; StorageEngine* engine = StorageEngine::instance(); @@ -216,34 +216,34 @@ OLAPStatus SegmentWriter::finalize(uint32_t* segment_file_size) { data_dir->add_pending_ids(ROWSET_ID_PREFIX + _segment_group->rowset_id().to_string()); } else { LOG(WARNING) << "data dir not found. [data_dir=" << data_dir_string << "]"; - return OLAP_ERR_CANNOT_CREATE_DIR; + return Status::OLAPInternalError(OLAP_ERR_CANNOT_CREATE_DIR); } } - if (OLAP_SUCCESS != (res = file_handle.open_with_mode(_file_name, O_CREAT | O_EXCL | O_WRONLY, + if (!(res = file_handle.open_with_mode(_file_name, O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR))) { LOG(WARNING) << "fail to open file. [file_name=" << _file_name << "]"; return res; } res = _make_file_header(file_header.mutable_message()); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to make file header. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to make file header. res = " << res; return res; } // check disk capacity if (data_dir != nullptr && data_dir->reach_capacity_limit((int64_t)file_header.file_length())) { - return OLAP_ERR_DISK_REACH_CAPACITY_LIMIT; + return Status::OLAPInternalError(OLAP_ERR_DISK_REACH_CAPACITY_LIMIT); } - if (OLAP_SUCCESS != (res = file_handle.open_with_mode(_file_name, O_CREAT | O_EXCL | O_WRONLY, + if (!(res = file_handle.open_with_mode(_file_name, O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR))) { LOG(WARNING) << "fail to open file. [file_name=" << _file_name << "]"; return res; } res = file_header.prepare(&file_handle); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("write file header error. [err=%m]"); return res; } @@ -251,7 +251,7 @@ OLAPStatus SegmentWriter::finalize(uint32_t* segment_file_size) { // 跳过FileHeader if (-1 == file_handle.seek(file_header.size(), SEEK_SET)) { OLAP_LOG_WARNING("lseek header file error. [err=%m]"); - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } uint32_t checksum = CRC32_INIT; @@ -267,8 +267,8 @@ OLAPStatus SegmentWriter::finalize(uint32_t* segment_file_size) { VLOG_TRACE << "stream id=" << it->first.unique_column_id() << ", type=" << it->first.kind(); res = stream->write_to_file(&file_handle, _write_mbytes_per_sec); - if (OLAP_SUCCESS != res) { - OLAP_LOG_WARNING("fail to write stream to file. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "fail to write stream to file. res = " << res; return res; } } @@ -281,13 +281,13 @@ OLAPStatus SegmentWriter::finalize(uint32_t* segment_file_size) { // 写入更新之后的FileHeader res = file_header.serialize(&file_handle); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("write file header error. [err=%m]"); return res; } res = file_handle.close(); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to close file. [err=%m]"); return res; } diff --git a/be/src/olap/rowset/segment_writer.h b/be/src/olap/rowset/segment_writer.h index 2441be2b5c..53d6767005 100644 --- a/be/src/olap/rowset/segment_writer.h +++ b/be/src/olap/rowset/segment_writer.h @@ -33,16 +33,16 @@ public: uint32_t stream_buffer_size, CompressKind compress_kind, double bloom_filter_fpp); ~SegmentWriter(); - OLAPStatus init(uint32_t write_mbytes_per_sec); - OLAPStatus write_batch(RowBlock* block, RowCursor* cursor, bool is_finalize); + Status init(uint32_t write_mbytes_per_sec); + Status write_batch(RowBlock* block, RowCursor* cursor, bool is_finalize); // 通过对缓存的使用,预估最终segment的大小 uint64_t estimate_segment_size(); // 生成文件并写入缓存的数据 - OLAPStatus finalize(uint32_t* segment_file_size); + Status finalize(uint32_t* segment_file_size); private: // Helper: 生成最终的PB文件头 - OLAPStatus _make_file_header(ColumnDataHeaderMessage* file_header); + Status _make_file_header(ColumnDataHeaderMessage* file_header); private: std::string _file_name; diff --git a/be/src/olap/schema_change.cpp b/be/src/olap/schema_change.cpp index ebe69f8b75..31b7a3dc60 100644 --- a/be/src/olap/schema_change.cpp +++ b/be/src/olap/schema_change.cpp @@ -178,7 +178,7 @@ ColumnMapping* RowBlockChanger::get_mutable_column_mapping(size_t column_index) << " origin_type=" \ << ref_block->tablet_schema().column(ref_column).type() \ << ", alter_type=" << mutable_block->tablet_schema().column(i).type(); \ - return OLAP_ERR_SCHEMA_CHANGE_INFO_INVALID; \ + return Status::OLAPInternalError(OLAP_ERR_SCHEMA_CHANGE_INFO_INVALID); \ } \ break; \ } @@ -430,38 +430,38 @@ bool count_field(RowCursor* read_helper, RowCursor* write_helper, const TabletCo return true; } -OLAPStatus RowBlockChanger::change_row_block(const RowBlock* ref_block, int32_t data_version, +Status RowBlockChanger::change_row_block(const RowBlock* ref_block, int32_t data_version, RowBlock* mutable_block, uint64_t* filtered_rows) const { if (mutable_block == nullptr) { LOG(FATAL) << "mutable block is uninitialized."; - return OLAP_ERR_NOT_INITED; + return Status::OLAPInternalError(OLAP_ERR_NOT_INITED); } else if (mutable_block->tablet_schema().num_columns() != _schema_mapping.size()) { LOG(WARNING) << "mutable block does not match with schema mapping rules. " << "block_schema_size=" << mutable_block->tablet_schema().num_columns() << ", mapping_schema_size=" << _schema_mapping.size(); - return OLAP_ERR_NOT_INITED; + return Status::OLAPInternalError(OLAP_ERR_NOT_INITED); } if (mutable_block->capacity() < ref_block->row_block_info().row_num) { LOG(WARNING) << "mutable block is not large enough for storing the changed block. " << "mutable_block_size=" << mutable_block->capacity() << ", ref_block_row_num=" << ref_block->row_block_info().row_num; - return OLAP_ERR_NOT_INITED; + return Status::OLAPInternalError(OLAP_ERR_NOT_INITED); } mutable_block->clear(); RowCursor write_helper; - if (write_helper.init(mutable_block->tablet_schema()) != OLAP_SUCCESS) { + if (write_helper.init(mutable_block->tablet_schema()) != Status::OK()) { LOG(WARNING) << "fail to init rowcursor."; - return OLAP_ERR_NOT_INITED; + return Status::OLAPInternalError(OLAP_ERR_NOT_INITED); } RowCursor read_helper; - if (read_helper.init(ref_block->tablet_schema()) != OLAP_SUCCESS) { + if (read_helper.init(ref_block->tablet_schema()) != Status::OK()) { LOG(WARNING) << "fail to init rowcursor."; - return OLAP_ERR_NOT_INITED; + return Status::OLAPInternalError(OLAP_ERR_NOT_INITED); } // a.1 First determine whether the data needs to be filtered, and finally only those marked as 1 are left as needed @@ -508,7 +508,7 @@ OLAPStatus RowBlockChanger::change_row_block(const RowBlock* ref_block, int32_t } else { LOG(WARNING) << "error materialized view function : " << _schema_mapping[i].materialized_function; - return OLAP_ERR_SCHEMA_CHANGE_INFO_INVALID; + return Status::OLAPInternalError(OLAP_ERR_SCHEMA_CHANGE_INFO_INVALID); } VLOG_NOTICE << "_schema_mapping[" << i << "].materialized_function : " << _schema_mapping[i].materialized_function; @@ -524,7 +524,7 @@ OLAPStatus RowBlockChanger::change_row_block(const RowBlock* ref_block, int32_t if (!_do_materialized_transform(&read_helper, &write_helper, ref_block->tablet_schema().column(ref_column), i, _schema_mapping[i].ref_column, mem_pool)) { - return OLAP_ERR_DATA_QUALITY_ERR; + return Status::OLAPInternalError(OLAP_ERR_DATA_QUALITY_ERR); } } continue; @@ -584,12 +584,11 @@ OLAPStatus RowBlockChanger::change_row_block(const RowBlock* ref_block, int32_t write_helper.set_not_null(i); const Field* ref_field = read_helper.column_schema(ref_column); char* ref_value = read_helper.cell_ptr(ref_column); - OLAPStatus st = write_helper.convert_from(i, ref_value, - ref_field->type_info(), mem_pool); - if (st != OLAPStatus::OLAP_SUCCESS) { + Status st = write_helper.convert_from(i, ref_value, ref_field->type_info(), mem_pool); + if (!st) { LOG(WARNING) << "the column type which was altered from was unsupported." - << "status:" << st << ", from_type=" << reftype + << "status:" << st.to_string() << ", from_type=" << reftype << ", to_type=" << newtype; return st; } @@ -622,7 +621,7 @@ OLAPStatus RowBlockChanger::change_row_block(const RowBlock* ref_block, int32_t LOG(WARNING) << "the column type which was altered from was unsupported." << " from_type=" << ref_block->tablet_schema().column(ref_column).type(); - return OLAP_ERR_SCHEMA_CHANGE_INFO_INVALID; + return Status::OLAPInternalError(OLAP_ERR_SCHEMA_CHANGE_INFO_INVALID); } if (newtype < reftype) { @@ -660,7 +659,7 @@ OLAPStatus RowBlockChanger::change_row_block(const RowBlock* ref_block, int32_t // (Actually, you can re-init into less when init, the new_row_num left by the filter) // In split_table, there may be no data due to filtering mutable_block->finalize(new_row_num); - return OLAP_SUCCESS; + return Status::OK(); } #undef CONVERT_FROM_TYPE @@ -687,8 +686,7 @@ bool RowBlockSorter::sort(RowBlock** row_block) { _swap_row_block = nullptr; } - if (_row_block_allocator->allocate(&_swap_row_block, row_num, null_supported) != - OLAP_SUCCESS) { + if (!_row_block_allocator->allocate(&_swap_row_block, row_num, null_supported)) { LOG(WARNING) << "fail to allocate memory."; return false; } @@ -696,7 +694,7 @@ bool RowBlockSorter::sort(RowBlock** row_block) { RowCursor helper_row; auto res = helper_row.init(_swap_row_block->tablet_schema()); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "row cursor init failed.res:" << res; return false; } @@ -711,7 +709,7 @@ bool RowBlockSorter::sort(RowBlock** row_block) { return false; } - if (row_cursor_list[i]->init((*row_block)->tablet_schema()) != OLAP_SUCCESS) { + if (row_cursor_list[i]->init((*row_block)->tablet_schema()) != Status::OK()) { return false; } @@ -751,7 +749,7 @@ RowBlockAllocator::~RowBlockAllocator() { } } -OLAPStatus RowBlockAllocator::allocate(RowBlock** row_block, size_t num_rows, bool null_supported) { +Status RowBlockAllocator::allocate(RowBlock** row_block, size_t num_rows, bool null_supported) { size_t row_block_size = _row_len * num_rows; if (_memory_limitation > 0 && @@ -763,7 +761,7 @@ OLAPStatus RowBlockAllocator::allocate(RowBlock** row_block, size_t num_rows, bo << "You can increase the memory " << "by changing the Config.memory_limitation_per_thread_for_schema_change_bytes"; *row_block = nullptr; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } // TODO(lijiao) : Why abandon the original m_row_block_buffer @@ -771,7 +769,7 @@ OLAPStatus RowBlockAllocator::allocate(RowBlock** row_block, size_t num_rows, bo if (*row_block == nullptr) { LOG(WARNING) << "failed to malloc RowBlock. size=" << sizeof(RowBlock); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } RowBlockInfo row_block_info(0U, num_rows); @@ -782,7 +780,7 @@ OLAPStatus RowBlockAllocator::allocate(RowBlock** row_block, size_t num_rows, bo VLOG_NOTICE << "RowBlockAllocator::allocate() this=" << this << ", num_rows=" << num_rows << ", m_memory_allocated=" << _mem_tracker->consumption() << ", row_block_addr=" << *row_block; - return OLAP_SUCCESS; + return Status::OK(); } void RowBlockAllocator::release(RowBlock* row_block) { @@ -818,7 +816,7 @@ bool RowBlockMerger::merge(const std::vector& row_block_arr, RowsetWr RowCursor row_cursor; std::unique_ptr mem_pool(new MemPool("RowBlockMerger")); std::unique_ptr agg_object_pool(new ObjectPool()); - if (row_cursor.init(_tablet->tablet_schema()) != OLAP_SUCCESS) { + if (row_cursor.init(_tablet->tablet_schema()) != Status::OK()) { LOG(WARNING) << "fail to init row cursor."; goto MERGE_ERR; } @@ -836,7 +834,7 @@ bool RowBlockMerger::merge(const std::vector& row_block_arr, RowsetWr _pop_heap(); if (KeysType::DUP_KEYS == _tablet->keys_type()) { - if (rowset_writer->add_row(row_cursor) != OLAP_SUCCESS) { + if (rowset_writer->add_row(row_cursor) != Status::OK()) { LOG(WARNING) << "fail to add row to rowset writer."; goto MERGE_ERR; } @@ -851,7 +849,7 @@ bool RowBlockMerger::merge(const std::vector& row_block_arr, RowsetWr _pop_heap(); } agg_finalize_row(&row_cursor, mem_pool.get()); - if (rowset_writer->add_row(row_cursor) != OLAP_SUCCESS) { + if (rowset_writer->add_row(row_cursor) != Status::OK()) { LOG(WARNING) << "fail to add row to rowset writer."; goto MERGE_ERR; } @@ -861,7 +859,7 @@ bool RowBlockMerger::merge(const std::vector& row_block_arr, RowsetWr mem_pool->clear(); agg_object_pool.reset(new ObjectPool()); } - if (rowset_writer->flush() != OLAP_SUCCESS) { + if (rowset_writer->flush() != Status::OK()) { LOG(WARNING) << "failed to finalizing writer."; goto MERGE_ERR; } @@ -891,7 +889,7 @@ bool RowBlockMerger::_make_heap(const std::vector& row_block_arr) { return false; } - if (element.row_cursor->init(element.row_block->tablet_schema()) != OLAP_SUCCESS) { + if (element.row_cursor->init(element.row_block->tablet_schema()) != Status::OK()) { LOG(WARNING) << "failed to init row cursor."; SAFE_DELETE(element.row_cursor); return false; @@ -920,7 +918,7 @@ void RowBlockMerger::_pop_heap() { return; } -OLAPStatus LinkedSchemaChange::process(RowsetReaderSharedPtr rowset_reader, +Status LinkedSchemaChange::process(RowsetReaderSharedPtr rowset_reader, RowsetWriter* new_rowset_writer, TabletSharedPtr new_tablet, TabletSharedPtr base_tablet) { // In some cases, there may be more than one type of rowset in a tablet, @@ -933,9 +931,9 @@ OLAPStatus LinkedSchemaChange::process(RowsetReaderSharedPtr rowset_reader, SchemaChangeDirectly scd(_row_block_changer); return scd.process(rowset_reader, new_rowset_writer, new_tablet, base_tablet); } else { - OLAPStatus status = new_rowset_writer->add_rowset_for_linked_schema_change( + Status status = new_rowset_writer->add_rowset_for_linked_schema_change( rowset_reader->rowset(), _row_block_changer.get_schema_mapping()); - if (status != OLAP_SUCCESS) { + if (!status.ok()) { LOG(WARNING) << "fail to convert rowset." << ", new_tablet=" << new_tablet->full_name() << ", base_tablet=" << base_tablet->full_name() @@ -961,7 +959,7 @@ SchemaChangeDirectly::~SchemaChangeDirectly() { bool SchemaChangeDirectly::_write_row_block(RowsetWriter* rowset_writer, RowBlock* row_block) { for (uint32_t i = 0; i < row_block->row_block_info().row_num; i++) { row_block->get_row(i, _cursor); - if (OLAP_SUCCESS != rowset_writer->add_row(*_cursor)) { + if (!rowset_writer->add_row(*_cursor)) { LOG(WARNING) << "fail to write to new rowset for direct schema change"; return false; } @@ -970,7 +968,7 @@ bool SchemaChangeDirectly::_write_row_block(RowsetWriter* rowset_writer, RowBloc return true; } -OLAPStatus reserve_block(std::unique_ptr* block_handle_ptr, int row_num, +Status reserve_block(std::unique_ptr* block_handle_ptr, int row_num, RowBlockAllocator* allocator) { auto& block_handle = *block_handle_ptr; if (block_handle == nullptr || block_handle->capacity() < row_num) { @@ -985,17 +983,17 @@ OLAPStatus reserve_block(std::unique_ptr* block_handl } else { block_handle->clear(); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SchemaChangeDirectly::process(RowsetReaderSharedPtr rowset_reader, +Status SchemaChangeDirectly::process(RowsetReaderSharedPtr rowset_reader, RowsetWriter* rowset_writer, TabletSharedPtr new_tablet, TabletSharedPtr base_tablet) { if (_row_block_allocator == nullptr) { _row_block_allocator = new RowBlockAllocator(new_tablet->tablet_schema(), 0); if (_row_block_allocator == nullptr) { LOG(FATAL) << "failed to malloc RowBlockAllocator. size=" << sizeof(RowBlockAllocator); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } } @@ -1003,25 +1001,25 @@ OLAPStatus SchemaChangeDirectly::process(RowsetReaderSharedPtr rowset_reader, _cursor = new (nothrow) RowCursor(); if (nullptr == _cursor) { LOG(WARNING) << "fail to allocate row cursor."; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } - if (OLAP_SUCCESS != _cursor->init(new_tablet->tablet_schema())) { + if (!_cursor->init(new_tablet->tablet_schema())) { LOG(WARNING) << "fail to init row cursor."; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } } - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); if (rowset_reader->rowset()->empty() || rowset_reader->rowset()->num_rows() == 0) { res = rowset_writer->flush(); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "create empty version for schema change failed." << "version=" << rowset_writer->version().first << "-" << rowset_writer->version().second; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } VLOG_NOTICE << "init writer. new_tablet=" << new_tablet->full_name() @@ -1055,7 +1053,7 @@ OLAPStatus SchemaChangeDirectly::process(RowsetReaderSharedPtr rowset_reader, add_filtered_rows(filtered_rows); if (!_write_row_block(rowset_writer, new_row_block.get())) { - res = OLAP_ERR_SCHEMA_CHANGE_INFO_INVALID; + res = Status::OLAPInternalError(OLAP_ERR_SCHEMA_CHANGE_INFO_INVALID); LOG(WARNING) << "failed to write row block."; return res; } @@ -1064,8 +1062,8 @@ OLAPStatus SchemaChangeDirectly::process(RowsetReaderSharedPtr rowset_reader, rowset_reader->next_block(&ref_row_block); } - if (OLAP_SUCCESS != rowset_writer->flush()) { - return OLAP_ERR_ALTER_STATUS_ERR; + if (!rowset_writer->flush()) { + return Status::OLAPInternalError(OLAP_ERR_ALTER_STATUS_ERR); } // rows filtered by zone map against delete handler @@ -1080,7 +1078,7 @@ OLAPStatus SchemaChangeDirectly::process(RowsetReaderSharedPtr rowset_reader, << ", merged_rows=" << merged_rows() << ", filtered_rows=" << filtered_rows() << ", new_index_rows=" << rowset_writer->num_rows(); - res = OLAP_ERR_ALTER_STATUS_ERR; + res = Status::OLAPInternalError(OLAP_ERR_ALTER_STATUS_ERR); } } LOG(INFO) << "all row nums. source_rows=" << rowset_reader->rowset()->num_rows() @@ -1107,7 +1105,7 @@ SchemaChangeWithSorting::~SchemaChangeWithSorting() { SAFE_DELETE(_row_block_allocator); } -OLAPStatus SchemaChangeWithSorting::process(RowsetReaderSharedPtr rowset_reader, +Status SchemaChangeWithSorting::process(RowsetReaderSharedPtr rowset_reader, RowsetWriter* new_rowset_writer, TabletSharedPtr new_tablet, TabletSharedPtr base_tablet) { @@ -1116,22 +1114,22 @@ OLAPStatus SchemaChangeWithSorting::process(RowsetReaderSharedPtr rowset_reader, new (nothrow) RowBlockAllocator(new_tablet->tablet_schema(), _memory_limitation); if (_row_block_allocator == nullptr) { LOG(FATAL) << "failed to malloc RowBlockAllocator. size=" << sizeof(RowBlockAllocator); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } } - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); RowsetSharedPtr rowset = rowset_reader->rowset(); if (rowset->empty() || rowset->num_rows() == 0) { res = new_rowset_writer->flush(); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "create empty version for schema change failed." << " version=" << new_rowset_writer->version().first << "-" << new_rowset_writer->version().second; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } RowBlockSorter row_block_sorter(_row_block_allocator); @@ -1169,11 +1167,11 @@ OLAPStatus SchemaChangeWithSorting::process(RowsetReaderSharedPtr rowset_reader, RowBlock* ref_row_block = nullptr; rowset_reader->next_block(&ref_row_block); while (ref_row_block != nullptr && ref_row_block->has_remaining()) { - if (OLAP_SUCCESS != _row_block_allocator->allocate(&new_row_block, + if (!_row_block_allocator->allocate(&new_row_block, ref_row_block->row_block_info().row_num, true)) { LOG(WARNING) << "failed to allocate RowBlock."; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } else { // do memory check for sorting, in case schema change task fail at row block sorting because of // not doing internal sorting first @@ -1190,7 +1188,7 @@ OLAPStatus SchemaChangeWithSorting::process(RowsetReaderSharedPtr rowset_reader, if (row_block_arr.size() < 1) { LOG(WARNING) << "Memory limitation is too small for Schema Change." << "memory_limitation=" << _memory_limitation; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } // enter here while memory limitation is reached. @@ -1204,7 +1202,7 @@ OLAPStatus SchemaChangeWithSorting::process(RowsetReaderSharedPtr rowset_reader, Version(_temp_delta_versions.second, _temp_delta_versions.second), new_tablet, new_rowset_type, segments_overlap, &rowset)) { LOG(WARNING) << "failed to sorting internally."; - return OLAP_ERR_ALTER_STATUS_ERR; + return Status::OLAPInternalError(OLAP_ERR_ALTER_STATUS_ERR); } src_rowsets.push_back(rowset); @@ -1223,7 +1221,7 @@ OLAPStatus SchemaChangeWithSorting::process(RowsetReaderSharedPtr rowset_reader, uint64_t filtered_rows = 0; res = _row_block_changer.change_row_block(ref_row_block, rowset_reader->version().second, new_row_block, &filtered_rows); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { row_block_arr.push_back(new_row_block); LOG(WARNING) << "failed to change data in row block."; return res; @@ -1234,7 +1232,7 @@ OLAPStatus SchemaChangeWithSorting::process(RowsetReaderSharedPtr rowset_reader, if (!row_block_sorter.sort(&new_row_block)) { row_block_arr.push_back(new_row_block); LOG(WARNING) << "failed to sort row block."; - return OLAP_ERR_ALTER_STATUS_ERR; + return Status::OLAPInternalError(OLAP_ERR_ALTER_STATUS_ERR); } row_block_arr.push_back(new_row_block); } else { @@ -1259,7 +1257,7 @@ OLAPStatus SchemaChangeWithSorting::process(RowsetReaderSharedPtr rowset_reader, Version(_temp_delta_versions.second, _temp_delta_versions.second), new_tablet, new_rowset_type, segments_overlap, &rowset)) { LOG(WARNING) << "failed to sorting internally."; - return OLAP_ERR_ALTER_STATUS_ERR; + return Status::OLAPInternalError(OLAP_ERR_ALTER_STATUS_ERR); } src_rowsets.push_back(rowset); @@ -1276,15 +1274,15 @@ OLAPStatus SchemaChangeWithSorting::process(RowsetReaderSharedPtr rowset_reader, if (src_rowsets.empty()) { res = new_rowset_writer->flush(); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "create empty version for schema change failed." << " version=" << new_rowset_writer->version().first << "-" << new_rowset_writer->version().second; - return OLAP_ERR_ALTER_STATUS_ERR; + return Status::OLAPInternalError(OLAP_ERR_ALTER_STATUS_ERR); } } else if (!_external_sorting(src_rowsets, new_rowset_writer, new_tablet)) { LOG(WARNING) << "failed to sorting externally."; - return OLAP_ERR_ALTER_STATUS_ERR; + return Status::OLAPInternalError(OLAP_ERR_ALTER_STATUS_ERR); } add_filtered_rows(rowset_reader->filtered_rows()); @@ -1298,7 +1296,7 @@ OLAPStatus SchemaChangeWithSorting::process(RowsetReaderSharedPtr rowset_reader, << ", merged_rows=" << merged_rows() << ", filtered_rows=" << filtered_rows() << ", new_index_rows=" << new_rowset_writer->num_rows(); - res = OLAP_ERR_ALTER_STATUS_ERR; + res = Status::OLAPInternalError(OLAP_ERR_ALTER_STATUS_ERR); } } LOG(INFO) << "all row nums. source_rows=" << rowset_reader->rowset()->num_rows() @@ -1333,7 +1331,7 @@ bool SchemaChangeWithSorting::_internal_sorting(const std::vector& ro << ", block_row_size=" << new_tablet->num_rows_per_row_block(); std::unique_ptr rowset_writer; - if (RowsetFactory::create_rowset_writer(context, &rowset_writer) != OLAP_SUCCESS) { + if (RowsetFactory::create_rowset_writer(context, &rowset_writer) != Status::OK()) { return false; } @@ -1357,7 +1355,7 @@ bool SchemaChangeWithSorting::_external_sorting(vector& src_row for (auto& rowset : src_rowsets) { RowsetReaderSharedPtr rs_reader; auto res = rowset->create_reader(&rs_reader); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to create rowset reader."; return false; } @@ -1367,7 +1365,7 @@ bool SchemaChangeWithSorting::_external_sorting(vector& src_row Merger::Statistics stats; auto res = Merger::merge_rowsets(new_tablet, READER_ALTER_TABLE, rs_readers, rowset_writer, &stats); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to merge rowsets. tablet=" << new_tablet->full_name() << ", version=" << rowset_writer->version().first << "-" << rowset_writer->version().second; @@ -1382,7 +1380,7 @@ SchemaChangeHandler::SchemaChangeHandler() {} SchemaChangeHandler::~SchemaChangeHandler() {} -OLAPStatus SchemaChangeHandler::process_alter_tablet_v2(const TAlterTabletReqV2& request) { +Status SchemaChangeHandler::process_alter_tablet_v2(const TAlterTabletReqV2& request) { LOG(INFO) << "begin to do request alter tablet: base_tablet_id=" << request.base_tablet_id << ", new_tablet_id=" << request.new_tablet_id << ", alter_version=" << request.alter_version; @@ -1390,7 +1388,7 @@ OLAPStatus SchemaChangeHandler::process_alter_tablet_v2(const TAlterTabletReqV2& TabletSharedPtr base_tablet = StorageEngine::instance()->tablet_manager()->get_tablet(request.base_tablet_id); if (base_tablet == nullptr) { LOG(WARNING) << "fail to find base tablet. base_tablet=" << request.base_tablet_id; - return OLAP_ERR_TABLE_NOT_FOUND; + return Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); } // Lock schema_change_lock util schema change info is stored in tablet header std::unique_lock schema_change_lock(base_tablet->get_schema_change_lock(), @@ -1398,10 +1396,10 @@ OLAPStatus SchemaChangeHandler::process_alter_tablet_v2(const TAlterTabletReqV2& if (!schema_change_lock.owns_lock()) { LOG(WARNING) << "failed to obtain schema change lock. " << "base_tablet=" << request.base_tablet_id; - return OLAP_ERR_TRY_LOCK_FAILED; + return Status::OLAPInternalError(OLAP_ERR_TRY_LOCK_FAILED); } - OLAPStatus res = _do_process_alter_tablet_v2(request); + Status res = _do_process_alter_tablet_v2(request); LOG(INFO) << "finished alter tablet process, res=" << res; return res; } @@ -1411,12 +1409,12 @@ OLAPStatus SchemaChangeHandler::process_alter_tablet_v2(const TAlterTabletReqV2& // In alter task v2, FE will call BE to create tablet and send an alter task to BE to convert historical data. // The admin should upgrade all BE and then upgrade FE. // Should delete the old code after upgrade finished. -OLAPStatus SchemaChangeHandler::_do_process_alter_tablet_v2(const TAlterTabletReqV2& request) { - OLAPStatus res = OLAP_SUCCESS; +Status SchemaChangeHandler::_do_process_alter_tablet_v2(const TAlterTabletReqV2& request) { + Status res = Status::OK(); TabletSharedPtr base_tablet = StorageEngine::instance()->tablet_manager()->get_tablet(request.base_tablet_id); if (base_tablet == nullptr) { LOG(WARNING) << "fail to find base tablet. base_tablet=" << request.base_tablet_id; - return OLAP_ERR_TABLE_NOT_FOUND; + return Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); } // new tablet has to exist @@ -1424,7 +1422,7 @@ OLAPStatus SchemaChangeHandler::_do_process_alter_tablet_v2(const TAlterTabletRe if (new_tablet == nullptr) { LOG(WARNING) << "fail to find new tablet." << " new_tablet=" << request.new_tablet_id; - return OLAP_ERR_TABLE_NOT_FOUND; + return Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); } // check if tablet's state is not_ready, if it is ready, it means the tablet already finished @@ -1444,11 +1442,11 @@ OLAPStatus SchemaChangeHandler::_do_process_alter_tablet_v2(const TAlterTabletRe std::shared_lock base_migration_rlock(base_tablet->get_migration_lock(), std::try_to_lock); if (!base_migration_rlock.owns_lock()) { - return OLAP_ERR_RWLOCK_ERROR; + return Status::OLAPInternalError(OLAP_ERR_RWLOCK_ERROR); } std::shared_lock new_migration_rlock(new_tablet->get_migration_lock(), std::try_to_lock); if (!new_migration_rlock.owns_lock()) { - return OLAP_ERR_RWLOCK_ERROR; + return Status::OLAPInternalError(OLAP_ERR_RWLOCK_ERROR); } std::vector versions_to_be_changed; @@ -1487,7 +1485,7 @@ OLAPStatus SchemaChangeHandler::_do_process_alter_tablet_v2(const TAlterTabletRe do { // get history data to be converted and it will check if there is hold in base tablet res = _get_versions_to_be_changed(base_tablet, &versions_to_be_changed); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to get version to be changed. res=" << res; break; } @@ -1498,7 +1496,7 @@ OLAPStatus SchemaChangeHandler::_do_process_alter_tablet_v2(const TAlterTabletRe LOG(WARNING) << "base tablet's max version=" << (max_rowset == nullptr ? 0 : max_rowset->end_version()) << " is less than request version=" << request.alter_version; - res = OLAP_ERR_VERSION_NOT_EXIST; + res = Status::OLAPInternalError(OLAP_ERR_WRITE_PROTOBUF_ERROR); break; } // before calculating version_to_be_changed, @@ -1533,11 +1531,11 @@ OLAPStatus SchemaChangeHandler::_do_process_alter_tablet_v2(const TAlterTabletRe } } - res = delete_handler.init(base_tablet->tablet_schema(), - base_tablet->delete_predicates(), end_version); - if (res != OLAP_SUCCESS) { - LOG(WARNING) << "init delete handler failed. base_tablet=" - << base_tablet->full_name() << ", end_version=" << end_version; + res = delete_handler.init(base_tablet->tablet_schema(), base_tablet->delete_predicates(), + end_version); + if (!res.ok()) { + LOG(WARNING) << "init delete handler failed. base_tablet=" << base_tablet->full_name() + << ", end_version=" << end_version; // release delete handlers which have been inited successfully. delete_handler.finalize(); @@ -1550,13 +1548,13 @@ OLAPStatus SchemaChangeHandler::_do_process_alter_tablet_v2(const TAlterTabletRe LOG(WARNING) << "fail to acquire all data sources. " << "version_num=" << versions_to_be_changed.size() << ", data_source_num=" << rs_readers.size(); - res = OLAP_ERR_ALTER_DELTA_DOES_NOT_EXISTS; + res = Status::OLAPInternalError(OLAP_ERR_ALTER_DELTA_DOES_NOT_EXISTS); break; } for (auto& rs_reader : rs_readers) { res = rs_reader->init(&reader_context); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to init rowset reader: " << base_tablet->full_name(); break; } @@ -1566,7 +1564,7 @@ OLAPStatus SchemaChangeHandler::_do_process_alter_tablet_v2(const TAlterTabletRe } do { - if (res != OLAP_SUCCESS) { + if (!res.ok()) { break; } SchemaChangeParams sc_params; @@ -1607,26 +1605,26 @@ OLAPStatus SchemaChangeHandler::_do_process_alter_tablet_v2(const TAlterTabletRe } res = _convert_historical_rowsets(sc_params); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { break; } // set state to ready std::lock_guard new_wlock(new_tablet->get_header_lock()); res = new_tablet->set_tablet_state(TabletState::TABLET_RUNNING); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { break; } new_tablet->save_meta(); } while (0); - if (res == OLAP_SUCCESS) { + if (res.ok()) { // _validate_alter_result should be outside the above while loop. // to avoid requiring the header lock twice. res = _validate_alter_result(new_tablet, request); } // if failed convert history data, then just remove the new tablet - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to alter tablet. base_tablet=" << base_tablet->full_name() << ", drop new_tablet=" << new_tablet->full_name(); // do not drop the new tablet and its data. GC thread will @@ -1635,11 +1633,11 @@ OLAPStatus SchemaChangeHandler::_do_process_alter_tablet_v2(const TAlterTabletRe return res; } -OLAPStatus SchemaChangeHandler::schema_version_convert(TabletSharedPtr base_tablet, +Status SchemaChangeHandler::schema_version_convert(TabletSharedPtr base_tablet, TabletSharedPtr new_tablet, RowsetSharedPtr* base_rowset, RowsetSharedPtr* new_rowset) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); LOG(INFO) << "begin to convert delta version for schema changing. " << "base_tablet=" << base_tablet->full_name() << ", new_tablet=" << new_tablet->full_name(); @@ -1651,7 +1649,7 @@ OLAPStatus SchemaChangeHandler::schema_version_convert(TabletSharedPtr base_tabl bool sc_directly = false; const std::unordered_map materialized_function_map; - if (OLAP_SUCCESS != (res = _parse_request(base_tablet, new_tablet, &rb_changer, &sc_sorting, + if (!(res = _parse_request(base_tablet, new_tablet, &rb_changer, &sc_sorting, &sc_directly, materialized_function_map))) { LOG(WARNING) << "failed to parse the request. res=" << res; return res; @@ -1676,7 +1674,7 @@ OLAPStatus SchemaChangeHandler::schema_version_convert(TabletSharedPtr base_tabl if (sc_procedure == nullptr) { LOG(FATAL) << "failed to malloc SchemaChange. size=" << sizeof(SchemaChangeWithSorting); - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } // c. Convert data @@ -1724,7 +1722,7 @@ OLAPStatus SchemaChangeHandler::schema_version_convert(TabletSharedPtr base_tabl RowsetFactory::create_rowset_writer(writer_context, &rowset_writer); if ((res = sc_procedure->process(rowset_reader, rowset_writer.get(), new_tablet, - base_tablet)) != OLAP_SUCCESS) { + base_tablet)) != Status::OK()) { if ((*base_rowset)->is_pending()) { LOG(WARNING) << "failed to process the transaction when schema change. " << "tablet=" << new_tablet->full_name() << "'" @@ -1743,7 +1741,7 @@ OLAPStatus SchemaChangeHandler::schema_version_convert(TabletSharedPtr base_tabl rowset_writer->rowset_id().to_string()); if (*new_rowset == nullptr) { LOG(WARNING) << "build rowset failed."; - res = OLAP_ERR_MALLOC_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); goto SCHEMA_VERSION_CONVERT_ERR; } @@ -1765,12 +1763,12 @@ SCHEMA_VERSION_CONVERT_ERR: return res; } -OLAPStatus SchemaChangeHandler::_get_versions_to_be_changed( +Status SchemaChangeHandler::_get_versions_to_be_changed( TabletSharedPtr base_tablet, std::vector* versions_to_be_changed) { RowsetSharedPtr rowset = base_tablet->rowset_with_max_version(); if (rowset == nullptr) { LOG(WARNING) << "Tablet has no version. base_tablet=" << base_tablet->full_name(); - return OLAP_ERR_ALTER_DELTA_DOES_NOT_EXISTS; + return Status::OLAPInternalError(OLAP_ERR_ALTER_DELTA_DOES_NOT_EXISTS); } std::vector span_versions; @@ -1779,10 +1777,10 @@ OLAPStatus SchemaChangeHandler::_get_versions_to_be_changed( versions_to_be_changed->insert(versions_to_be_changed->end(), span_versions.begin(), span_versions.end()); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SchemaChangeHandler::_convert_historical_rowsets(const SchemaChangeParams& sc_params) { +Status SchemaChangeHandler::_convert_historical_rowsets(const SchemaChangeParams& sc_params) { LOG(INFO) << "begin to convert historical rowsets for new_tablet from base_tablet." << " base_tablet=" << sc_params.base_tablet->full_name() << ", new_tablet=" << sc_params.new_tablet->full_name(); @@ -1804,9 +1802,9 @@ OLAPStatus SchemaChangeHandler::_convert_historical_rowsets(const SchemaChangePa SchemaChange* sc_procedure = nullptr; // a.Parse the Alter request and convert it into an internal representation - OLAPStatus res = _parse_request(sc_params.base_tablet, sc_params.new_tablet, &rb_changer, + Status res = _parse_request(sc_params.base_tablet, sc_params.new_tablet, &rb_changer, &sc_sorting, &sc_directly, sc_params.materialized_params_map); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to parse the request. res=" << res; goto PROCESS_ALTER_EXIT; } @@ -1830,7 +1828,7 @@ OLAPStatus SchemaChangeHandler::_convert_historical_rowsets(const SchemaChangePa if (sc_procedure == nullptr) { LOG(WARNING) << "failed to malloc SchemaChange. " << "malloc_size=" << sizeof(SchemaChangeWithSorting); - res = OLAP_ERR_MALLOC_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); goto PROCESS_ALTER_EXIT; } @@ -1865,14 +1863,14 @@ OLAPStatus SchemaChangeHandler::_convert_historical_rowsets(const SchemaChangePa writer_context.segments_overlap = rs_reader->rowset()->rowset_meta()->segments_overlap(); std::unique_ptr rowset_writer; - OLAPStatus status = RowsetFactory::create_rowset_writer(writer_context, &rowset_writer); - if (status != OLAP_SUCCESS) { - res = OLAP_ERR_ROWSET_BUILDER_INIT; + Status status = RowsetFactory::create_rowset_writer(writer_context, &rowset_writer); + if (!status.ok()) { + res = Status::OLAPInternalError(OLAP_ERR_ROWSET_BUILDER_INIT); goto PROCESS_ALTER_EXIT; } if ((res = sc_procedure->process(rs_reader, rowset_writer.get(), sc_params.new_tablet, - sc_params.base_tablet)) != OLAP_SUCCESS) { + sc_params.base_tablet)) != Status::OK()) { LOG(WARNING) << "failed to process the version." << " version=" << rs_reader->version().first << "-" << rs_reader->version().second; @@ -1891,13 +1889,13 @@ OLAPStatus SchemaChangeHandler::_convert_historical_rowsets(const SchemaChangePa goto PROCESS_ALTER_EXIT; } res = sc_params.new_tablet->add_rowset(new_rowset, false); - if (res == OLAP_ERR_PUSH_VERSION_ALREADY_EXIST) { + if (res == Status::OLAPInternalError(OLAP_ERR_PUSH_VERSION_ALREADY_EXIST)) { LOG(WARNING) << "version already exist, version revert occurred. " << "tablet=" << sc_params.new_tablet->full_name() << ", version='" << rs_reader->version().first << "-" << rs_reader->version().second; StorageEngine::instance()->add_unused_rowset(new_rowset); - res = OLAP_SUCCESS; - } else if (res != OLAP_SUCCESS) { + res = Status::OK(); + } else if (!res.ok()) { LOG(WARNING) << "failed to register new version. " << " tablet=" << sc_params.new_tablet->full_name() << ", version=" << rs_reader->version().first << "-" @@ -1920,7 +1918,7 @@ PROCESS_ALTER_EXIT : { std::lock_guard new_wlock(sc_params.new_tablet->get_header_lock()); sc_params.new_tablet->save_meta(); } - if (res == OLAP_SUCCESS) { + if (res.ok()) { Version test_version(0, end_version); res = sc_params.new_tablet->check_version_integrity(test_version); } @@ -1934,12 +1932,12 @@ PROCESS_ALTER_EXIT : { // @static // Analyze the mapping of the column and the mapping of the filter key -OLAPStatus SchemaChangeHandler::_parse_request( +Status SchemaChangeHandler::_parse_request( TabletSharedPtr base_tablet, TabletSharedPtr new_tablet, RowBlockChanger* rb_changer, bool* sc_sorting, bool* sc_directly, const std::unordered_map& materialized_function_map) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); // set column mapping for (int i = 0, new_schema_size = new_tablet->tablet_schema().num_columns(); @@ -1955,7 +1953,7 @@ OLAPStatus SchemaChangeHandler::_parse_request( LOG(WARNING) << "referenced column was missing. " << "[column=" << column_name << " referenced_column=" << column_index << "]"; - return OLAP_ERR_CE_CMD_PARAMS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CE_CMD_PARAMS_ERROR); } column_mapping->ref_column = column_index; @@ -1977,7 +1975,7 @@ OLAPStatus SchemaChangeHandler::_parse_request( LOG(WARNING) << "referenced column was missing. " << "[column=" << column_name << " referenced_column=" << column_index << "]"; - return OLAP_ERR_CE_CMD_PARAMS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CE_CMD_PARAMS_ERROR); } } @@ -1993,10 +1991,9 @@ OLAPStatus SchemaChangeHandler::_parse_request( if (i < base_tablet->num_short_key_columns()) { *sc_directly = true; } - - if (OLAP_SUCCESS != - (res = _init_column_mapping(column_mapping, new_column, new_column.default_value()))) { - return res; + res = _init_column_mapping(column_mapping, new_column, new_column.default_value()); + if (!res) { + return res; } VLOG_TRACE << "A column with default value will be added after schema changing. " @@ -2018,7 +2015,7 @@ OLAPStatus SchemaChangeHandler::_parse_request( if (column_mapping->ref_column != i - num_default_value) { *sc_sorting = true; - return OLAP_SUCCESS; + return Status::OK(); } } @@ -2028,7 +2025,7 @@ OLAPStatus SchemaChangeHandler::_parse_request( // only when base table is dup and mv is agg // the rollup job must be reagg. *sc_sorting = true; - return OLAP_SUCCESS; + return Status::OK(); } // If the sort of key has not been changed but the new keys num is less then base's, @@ -2044,13 +2041,13 @@ OLAPStatus SchemaChangeHandler::_parse_request( // is less, which means the data in new tablet should be more aggregated. // so we use sorting schema change to sort and merge the data. *sc_sorting = true; - return OLAP_SUCCESS; + return Status::OK(); } if (base_tablet->num_short_key_columns() != new_tablet->num_short_key_columns()) { // the number of short_keys changed, can't do linked schema change *sc_directly = true; - return OLAP_SUCCESS; + return Status::OK(); } for (size_t i = 0; i < new_tablet->num_columns(); ++i) { @@ -2061,22 +2058,22 @@ OLAPStatus SchemaChangeHandler::_parse_request( if (new_tablet_schema.column(i).type() != ref_tablet_schema.column(column_mapping->ref_column).type()) { *sc_directly = true; - return OLAP_SUCCESS; + return Status::OK(); } else if ((new_tablet_schema.column(i).type() == ref_tablet_schema.column(column_mapping->ref_column).type()) && (new_tablet_schema.column(i).length() != ref_tablet_schema.column(column_mapping->ref_column).length())) { *sc_directly = true; - return OLAP_SUCCESS; + return Status::OK(); } else if (new_tablet_schema.column(i).is_bf_column() != ref_tablet_schema.column(column_mapping->ref_column).is_bf_column()) { *sc_directly = true; - return OLAP_SUCCESS; + return Status::OK(); } else if (new_tablet_schema.column(i).has_bitmap_index() != ref_tablet_schema.column(column_mapping->ref_column).has_bitmap_index()) { *sc_directly = true; - return OLAP_SUCCESS; + return Status::OK(); } } } @@ -2092,16 +2089,16 @@ OLAPStatus SchemaChangeHandler::_parse_request( *sc_directly = true; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SchemaChangeHandler::_init_column_mapping(ColumnMapping* column_mapping, +Status SchemaChangeHandler::_init_column_mapping(ColumnMapping* column_mapping, const TabletColumn& column_schema, const std::string& value) { column_mapping->default_value = WrapperField::create(column_schema); if (column_mapping->default_value == nullptr) { - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } if (column_schema.is_nullable() && value.length() == 0) { @@ -2110,10 +2107,10 @@ OLAPStatus SchemaChangeHandler::_init_column_mapping(ColumnMapping* column_mappi column_mapping->default_value->from_string(value); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SchemaChangeHandler::_validate_alter_result(TabletSharedPtr new_tablet, +Status SchemaChangeHandler::_validate_alter_result(TabletSharedPtr new_tablet, const TAlterTabletReqV2& request) { Version max_continuous_version = {-1, 0}; new_tablet->max_continuous_version_from_beginning(&max_continuous_version); @@ -2121,7 +2118,7 @@ OLAPStatus SchemaChangeHandler::_validate_alter_result(TabletSharedPtr new_table << ", start_version=" << max_continuous_version.first << ", end_version=" << max_continuous_version.second; if (max_continuous_version.second < request.alter_version) { - return OLAP_ERR_VERSION_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_WRITE_PROTOBUF_ERROR); } std::vector> version_rowsets; @@ -2132,10 +2129,10 @@ OLAPStatus SchemaChangeHandler::_validate_alter_result(TabletSharedPtr new_table for (auto& pair : version_rowsets) { RowsetSharedPtr rowset = pair.second; if (!rowset->check_file_exist()) { - return OLAP_ERR_FILE_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_FILE_NOT_EXIST); } } - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/schema_change.h b/be/src/olap/schema_change.h index 9b699bb35e..d5c1f39b77 100644 --- a/be/src/olap/schema_change.h +++ b/be/src/olap/schema_change.h @@ -61,7 +61,7 @@ public: const SchemaMapping& get_schema_mapping() const { return _schema_mapping; } - OLAPStatus change_row_block(const RowBlock* ref_block, int32_t data_version, + Status change_row_block(const RowBlock* ref_block, int32_t data_version, RowBlock* mutable_block, uint64_t* filtered_rows) const; private: @@ -79,7 +79,7 @@ public: RowBlockAllocator(const TabletSchema& tablet_schema, size_t memory_limitation); virtual ~RowBlockAllocator(); - OLAPStatus allocate(RowBlock** row_block, size_t num_rows, bool null_supported); + Status allocate(RowBlock** row_block, size_t num_rows, bool null_supported); void release(RowBlock* row_block); bool is_memory_enough_for_sorting(size_t num_rows, size_t allocated_rows); @@ -95,7 +95,7 @@ public: SchemaChange() : _filtered_rows(0), _merged_rows(0) {} virtual ~SchemaChange() = default; - virtual OLAPStatus process(RowsetReaderSharedPtr rowset_reader, + virtual Status process(RowsetReaderSharedPtr rowset_reader, RowsetWriter* new_rowset_builder, TabletSharedPtr tablet, TabletSharedPtr base_tablet) = 0; @@ -122,7 +122,7 @@ public: : SchemaChange(), _row_block_changer(row_block_changer) {} ~LinkedSchemaChange() {} - virtual OLAPStatus process(RowsetReaderSharedPtr rowset_reader, RowsetWriter* new_rowset_writer, + virtual Status process(RowsetReaderSharedPtr rowset_reader, RowsetWriter* new_rowset_writer, TabletSharedPtr new_tablet, TabletSharedPtr base_tablet) override; private: @@ -138,7 +138,7 @@ public: explicit SchemaChangeDirectly(const RowBlockChanger& row_block_changer); virtual ~SchemaChangeDirectly(); - virtual OLAPStatus process(RowsetReaderSharedPtr rowset_reader, RowsetWriter* new_rowset_writer, + virtual Status process(RowsetReaderSharedPtr rowset_reader, RowsetWriter* new_rowset_writer, TabletSharedPtr new_tablet, TabletSharedPtr base_tablet) override; private: @@ -158,7 +158,7 @@ public: size_t memory_limitation); virtual ~SchemaChangeWithSorting(); - virtual OLAPStatus process(RowsetReaderSharedPtr rowset_reader, + virtual Status process(RowsetReaderSharedPtr rowset_reader, RowsetWriter* new_rowset_builder, TabletSharedPtr new_tablet, TabletSharedPtr base_tablet) override; @@ -186,11 +186,11 @@ public: return &instance; } - OLAPStatus schema_version_convert(TabletSharedPtr base_tablet, TabletSharedPtr new_tablet, + Status schema_version_convert(TabletSharedPtr base_tablet, TabletSharedPtr new_tablet, RowsetSharedPtr* base_rowset, RowsetSharedPtr* new_rowset); // schema change v2, it will not set alter task in base tablet - OLAPStatus process_alter_tablet_v2(const TAlterTabletReqV2& request); + Status process_alter_tablet_v2(const TAlterTabletReqV2& request); private: @@ -199,10 +199,10 @@ private: // Returns: // Success: If there is historical information, then clear it if there is no problem; or no historical information // Failure: otherwise, if there is history information and it cannot be emptied (version has not been completed) - OLAPStatus _check_and_clear_schema_change_info(TabletSharedPtr tablet, + Status _check_and_clear_schema_change_info(TabletSharedPtr tablet, const TAlterTabletReq& request); - OLAPStatus _get_versions_to_be_changed(TabletSharedPtr base_tablet, + Status _get_versions_to_be_changed(TabletSharedPtr base_tablet, std::vector* versions_to_be_changed); struct AlterMaterializedViewParam { @@ -220,20 +220,20 @@ private: std::unordered_map materialized_params_map; }; - OLAPStatus _do_process_alter_tablet_v2(const TAlterTabletReqV2& request); + Status _do_process_alter_tablet_v2(const TAlterTabletReqV2& request); - OLAPStatus _validate_alter_result(TabletSharedPtr new_tablet, const TAlterTabletReqV2& request); + Status _validate_alter_result(TabletSharedPtr new_tablet, const TAlterTabletReqV2& request); - OLAPStatus _convert_historical_rowsets(const SchemaChangeParams& sc_params); + Status _convert_historical_rowsets(const SchemaChangeParams& sc_params); - static OLAPStatus _parse_request( + static Status _parse_request( TabletSharedPtr base_tablet, TabletSharedPtr new_tablet, RowBlockChanger* rb_changer, bool* sc_sorting, bool* sc_directly, const std::unordered_map& materialized_function_map); // Initialization Settings for creating a default value - static OLAPStatus _init_column_mapping(ColumnMapping* column_mapping, + static Status _init_column_mapping(ColumnMapping* column_mapping, const TabletColumn& column_schema, const std::string& value); diff --git a/be/src/olap/segment_loader.cpp b/be/src/olap/segment_loader.cpp index 2c3a95689b..609159bdb5 100644 --- a/be/src/olap/segment_loader.cpp +++ b/be/src/olap/segment_loader.cpp @@ -57,12 +57,12 @@ void SegmentLoader::_insert(const SegmentLoader::CacheKey& key, SegmentLoader::C *handle = SegmentCacheHandle(_cache.get(), lru_handle); } -OLAPStatus SegmentLoader::load_segments(const BetaRowsetSharedPtr& rowset, +Status SegmentLoader::load_segments(const BetaRowsetSharedPtr& rowset, SegmentCacheHandle* cache_handle, bool use_cache) { SegmentLoader::CacheKey cache_key(rowset->rowset_id()); if (_lookup(cache_key, cache_handle)) { cache_handle->owned = false; - return OLAP_SUCCESS; + return Status::OK(); } cache_handle->owned = !use_cache; @@ -78,10 +78,10 @@ OLAPStatus SegmentLoader::load_segments(const BetaRowsetSharedPtr& rowset, cache_handle->segments = std::move(segments); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SegmentLoader::prune() { +Status SegmentLoader::prune() { const int64_t curtime = UnixMillis(); auto pred = [curtime](const void* value) -> bool { SegmentLoader::CacheValue* cache_value = (SegmentLoader::CacheValue*)value; @@ -94,7 +94,7 @@ OLAPStatus SegmentLoader::prune() { int64_t prune_num = _cache->prune_if(pred); LOG(INFO) << "prune " << prune_num << " entries in segment cache. cost(ms): " << watch.elapsed_time() / 1000 / 1000; - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/segment_loader.h b/be/src/olap/segment_loader.h index 30cfce304d..c155209614 100644 --- a/be/src/olap/segment_loader.h +++ b/be/src/olap/segment_loader.h @@ -84,10 +84,10 @@ public: // Load segments of "rowset", return the "cache_handle" which contains segments. // If use_cache is true, it will be loaded from _cache. - OLAPStatus load_segments(const BetaRowsetSharedPtr& rowset, SegmentCacheHandle* cache_handle, bool use_cache = false); + Status load_segments(const BetaRowsetSharedPtr& rowset, SegmentCacheHandle* cache_handle, bool use_cache = false); // Try to prune the segment cache if expired. - OLAPStatus prune(); + Status prune(); private: SegmentLoader(); diff --git a/be/src/olap/serialize.cpp b/be/src/olap/serialize.cpp index 6807e3ed1b..fa436dd54b 100644 --- a/be/src/olap/serialize.cpp +++ b/be/src/olap/serialize.cpp @@ -23,10 +23,10 @@ namespace doris { namespace ser { -OLAPStatus write_var_unsigned(OutStream* stream, int64_t value) { - OLAPStatus res = OLAP_SUCCESS; +Status write_var_unsigned(OutStream* stream, int64_t value) { + Status res = Status::OK(); - while (res == OLAP_SUCCESS) { + while (res.ok()) { if ((value & ~0x7f) == 0) { return stream->write((char)value); } else { @@ -38,8 +38,8 @@ OLAPStatus write_var_unsigned(OutStream* stream, int64_t value) { return res; } -OLAPStatus read_var_unsigned(ReadOnlyFileStream* stream, int64_t* value) { - OLAPStatus res; +Status read_var_unsigned(ReadOnlyFileStream* stream, int64_t* value) { + Status res; int64_t result = 0; uint32_t offset = 0; char byte = 0; @@ -47,9 +47,9 @@ OLAPStatus read_var_unsigned(ReadOnlyFileStream* stream, int64_t* value) { do { res = stream->read(&byte); - if (OLAP_UNLIKELY(res != OLAP_SUCCESS)) { - OLAP_LOG_WARNING("fail to read stream. [res=%d]", res); - return OLAP_ERR_COLUMN_DATA_READ_VAR_INT; + if (OLAP_UNLIKELY(!res.ok())) { + LOG(WARNING) << "fail to read stream. res = " << res; + return Status::OLAPInternalError(OLAP_ERR_COLUMN_DATA_READ_VAR_INT); } result |= ((int64_t)(0x7f & byte)) << offset; @@ -57,7 +57,7 @@ OLAPStatus read_var_unsigned(ReadOnlyFileStream* stream, int64_t* value) { } while (byte & 0x80); *value = result; - return OLAP_SUCCESS; + return Status::OK(); } uint32_t find_closet_num_bits(int64_t value) { @@ -70,19 +70,19 @@ uint32_t find_closet_num_bits(int64_t value) { return get_closet_fixed_bits(count); } -OLAPStatus bytes_to_long_be(ReadOnlyFileStream* stream, int32_t n, int64_t* value) { - OLAPStatus res = OLAP_SUCCESS; +Status bytes_to_long_be(ReadOnlyFileStream* stream, int32_t n, int64_t* value) { + Status res = Status::OK(); int64_t out = 0; // TODO(lijiao) : 为什么不直接用switch-case(会更快) while (n > 0) { --n; // store it in a long and then shift else integer overflow will occur - uint8_t byte; + // TODO(yiguolei): why not init it before + uint8_t byte = 0; res = stream->read((char*)&byte); - if (OLAP_UNLIKELY(res != OLAP_SUCCESS)) { - OLAP_LOG_WARNING("fail to read stream. [res=%d]", res); + if (OLAP_UNLIKELY(!res.ok())) { return res; } @@ -91,7 +91,7 @@ OLAPStatus bytes_to_long_be(ReadOnlyFileStream* stream, int32_t n, int64_t* valu } *value = out; - return OLAP_SUCCESS; + return Status::OK(); } uint32_t encode_bit_width(uint32_t n) { @@ -208,8 +208,8 @@ uint32_t percentile_bits(int64_t* data, uint16_t count, double p) { return 0; } -OLAPStatus write_ints(OutStream* output, int64_t* data, uint32_t count, uint32_t bit_width) { - OLAPStatus res = OLAP_SUCCESS; +Status write_ints(OutStream* output, int64_t* data, uint32_t count, uint32_t bit_width) { + Status res = Status::OK(); uint32_t bits_left = 8; char current = 0; @@ -226,8 +226,8 @@ OLAPStatus write_ints(OutStream* output, int64_t* data, uint32_t count, uint32_t value &= (1UL << bits_to_write) - 1; res = output->write(current); - if (OLAP_UNLIKELY(res != OLAP_SUCCESS)) { - OLAP_LOG_WARNING("fail to write byte to stream.[res=%d]", res); + if (OLAP_UNLIKELY(!res.ok())) { + LOG(WARNING) << "fail to write byte to stream.res = " << res; return res; } @@ -241,8 +241,8 @@ OLAPStatus write_ints(OutStream* output, int64_t* data, uint32_t count, uint32_t if (bits_left == 0) { res = output->write(current); - if (OLAP_UNLIKELY(res != OLAP_SUCCESS)) { - OLAP_LOG_WARNING("fail to write byte to stream.[res=%d]", res); + if (OLAP_UNLIKELY(!res.ok())) { + LOG(WARNING) << "fail to write byte to stream.res = " << res; return res; } @@ -254,17 +254,17 @@ OLAPStatus write_ints(OutStream* output, int64_t* data, uint32_t count, uint32_t if (bits_left != 8) { res = output->write(current); - if (OLAP_UNLIKELY(res != OLAP_SUCCESS)) { - OLAP_LOG_WARNING("fail to write byte to stream.[res=%d]", res); + if (OLAP_UNLIKELY(!res.ok())) { + LOG(WARNING) << "fail to write byte to stream.res = " << res; return res; } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus read_ints(ReadOnlyFileStream* input, int64_t* data, uint32_t count, uint32_t bit_width) { - OLAPStatus res = OLAP_SUCCESS; +Status read_ints(ReadOnlyFileStream* input, int64_t* data, uint32_t count, uint32_t bit_width) { + Status res = Status::OK(); uint32_t bits_left = 0; char current = '\0'; @@ -308,8 +308,8 @@ OLAPStatus read_ints(ReadOnlyFileStream* input, int64_t* data, uint32_t count, u bits_left_to_read -= bits_left; res = input->read(¤t); - if (OLAP_UNLIKELY(OLAP_SUCCESS != res)) { - OLAP_LOG_WARNING("fail to write byte to stream.[res=%d]", res); + if (OLAP_UNLIKELY(!res.ok())) { + LOG(WARNING) << "fail to write byte to stream.res = " << res; return res; } diff --git a/be/src/olap/serialize.h b/be/src/olap/serialize.h index be8fc51bb0..5a796b0b40 100644 --- a/be/src/olap/serialize.h +++ b/be/src/olap/serialize.h @@ -44,21 +44,21 @@ inline int64_t zig_zag_decode(int64_t value) { // The so-called unsigned data means that the data is not easy to appear. The sign bit is 1, and the subsequent consecutive 0; or from the sign bit // 1 Continuous occurrence. This situation is prone to occur when the signature data represents a negative number. under these circumstances, // Variable length coding cannot effectively reduce the code length, for this, please use write_var_signed. -OLAPStatus write_var_unsigned(OutStream* stream, int64_t value); +Status write_var_unsigned(OutStream* stream, int64_t value); // Write signed data with variable length encoding, in order to avoid the problem of continuous 1s in the high bits of negative numbers, the data is ZigZag transformed -inline OLAPStatus write_var_signed(OutStream* stream, int64_t value) { +inline Status write_var_signed(OutStream* stream, int64_t value) { return write_var_unsigned(stream, zig_zag_encode(value)); } // Read in write_var_unsigned encoded data -OLAPStatus read_var_unsigned(ReadOnlyFileStream* stream, int64_t* value); +Status read_var_unsigned(ReadOnlyFileStream* stream, int64_t* value); // Read in write_var_signed encoded data -inline OLAPStatus read_var_signed(ReadOnlyFileStream* stream, int64_t* value) { - OLAPStatus res = read_var_unsigned(stream, value); +inline Status read_var_signed(ReadOnlyFileStream* stream, int64_t* value) { + Status res = read_var_unsigned(stream, value); - if (OLAP_SUCCESS == res) { + if (res.ok()) { *value = zig_zag_decode(*value); } @@ -155,7 +155,7 @@ inline uint32_t percentile_bits_with_hist(uint16_t hists[65], uint16_t count, do uint32_t find_closet_num_bits(int64_t value); // Read n bytes in big endian order and convert to long -OLAPStatus bytes_to_long_be(ReadOnlyFileStream* stream, int32_t n, int64_t* value); +Status bytes_to_long_be(ReadOnlyFileStream* stream, int32_t n, int64_t* value); // Encode the bit length as one of 32 fixed-length bits, and the return value is between 0 and 31 uint32_t encode_bit_width(uint32_t n); @@ -170,10 +170,10 @@ uint32_t decode_bit_width(uint32_t n); uint32_t percentile_bits(int64_t* data, uint16_t count, double p); // Output a set of integers to output in a compact manner -OLAPStatus write_ints(OutStream* output, int64_t* data, uint32_t count, uint32_t bit_width); +Status write_ints(OutStream* output, int64_t* data, uint32_t count, uint32_t bit_width); // Read the data output by write_ints -OLAPStatus read_ints(ReadOnlyFileStream* input, int64_t* data, uint32_t count, uint32_t bit_width); +Status read_ints(ReadOnlyFileStream* input, int64_t* data, uint32_t count, uint32_t bit_width); // Do not want to use Guava LongMath.checkedSubtract() here as it will throw // ArithmeticException in case of overflow diff --git a/be/src/olap/snapshot_manager.cpp b/be/src/olap/snapshot_manager.cpp index da9d8f328f..c1c38ac6bc 100644 --- a/be/src/olap/snapshot_manager.cpp +++ b/be/src/olap/snapshot_manager.cpp @@ -61,13 +61,13 @@ SnapshotManager* SnapshotManager::instance() { return _s_instance; } -OLAPStatus SnapshotManager::make_snapshot(const TSnapshotRequest& request, string* snapshot_path, +Status SnapshotManager::make_snapshot(const TSnapshotRequest& request, string* snapshot_path, bool* allow_incremental_clone) { SCOPED_SWITCH_THREAD_LOCAL_MEM_TRACKER(_mem_tracker); - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); if (snapshot_path == nullptr) { LOG(WARNING) << "output parameter cannot be null"; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } TabletSharedPtr ref_tablet = StorageEngine::instance()->tablet_manager()->get_tablet( @@ -75,12 +75,12 @@ OLAPStatus SnapshotManager::make_snapshot(const TSnapshotRequest& request, strin if (ref_tablet == nullptr) { LOG(WARNING) << "failed to get tablet. tablet=" << request.tablet_id << " schema_hash=" << request.schema_hash; - return OLAP_ERR_TABLE_NOT_FOUND; + return Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); } res = _create_snapshot_files(ref_tablet, request, snapshot_path, allow_incremental_clone); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to make snapshot. res=" << res << " tablet=" << request.tablet_id << " schema_hash=" << request.schema_hash; return res; @@ -90,10 +90,10 @@ OLAPStatus SnapshotManager::make_snapshot(const TSnapshotRequest& request, strin return res; } -OLAPStatus SnapshotManager::release_snapshot(const string& snapshot_path) { - SCOPED_SWITCH_THREAD_LOCAL_MEM_TRACKER(_mem_tracker); +Status SnapshotManager::release_snapshot(const string& snapshot_path) { // 如果请求的snapshot_path位于root/snapshot文件夹下，则认为是合法的，可以删除 // 否则认为是非法请求，返回错误结果 + SCOPED_SWITCH_THREAD_LOCAL_MEM_TRACKER(_mem_tracker); auto stores = StorageEngine::instance()->get_stores(); for (auto store : stores) { if (store->is_remote()) { @@ -101,7 +101,7 @@ OLAPStatus SnapshotManager::release_snapshot(const string& snapshot_path) { } std::string abs_path; RETURN_WITH_WARN_IF_ERROR(Env::Default()->canonicalize(store->path(), &abs_path), - OLAP_ERR_DIR_NOT_EXIST, + Status::OLAPInternalError(OLAP_ERR_DIR_NOT_EXIST), "canonical path " + store->path() + "failed"); if (snapshot_path.compare(0, abs_path.size(), abs_path) == 0 && @@ -109,33 +109,32 @@ OLAPStatus SnapshotManager::release_snapshot(const string& snapshot_path) { Env::Default()->delete_dir(snapshot_path); LOG(INFO) << "success to release snapshot path. [path='" << snapshot_path << "']"; - return OLAP_SUCCESS; + return Status::OK(); } } LOG(WARNING) << "released snapshot path illegal. [path='" << snapshot_path << "']"; - return OLAP_ERR_CE_CMD_PARAMS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CE_CMD_PARAMS_ERROR); } // TODO support beta rowset // For now, alpha and beta rowset meta have same fields, so we can just use // AlphaRowsetMeta here. -OLAPStatus SnapshotManager::convert_rowset_ids(const FilePathDesc& clone_dir_desc, int64_t tablet_id, +Status SnapshotManager::convert_rowset_ids(const FilePathDesc& clone_dir_desc, int64_t tablet_id, const int32_t& schema_hash) { SCOPED_SWITCH_THREAD_LOCAL_MEM_TRACKER(_mem_tracker); - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); // check clone dir existed if (!FileUtils::check_exist(clone_dir_desc.filepath)) { - res = OLAP_ERR_DIR_NOT_EXIST; - LOG(WARNING) << "clone dir not existed when convert rowsetids. clone_dir=" - << clone_dir_desc.debug_string(); + res = Status::OLAPInternalError(OLAP_ERR_DIR_NOT_EXIST); + LOG(WARNING) << "clone dir not existed when convert rowsetids. clone_dir=" << clone_dir_desc.debug_string(); return res; } // load original tablet meta string cloned_meta_file = clone_dir_desc.filepath + "/" + std::to_string(tablet_id) + ".hdr"; TabletMeta cloned_tablet_meta; - if ((res = cloned_tablet_meta.create_from_file(cloned_meta_file)) != OLAP_SUCCESS) { + if ((res = cloned_tablet_meta.create_from_file(cloned_meta_file)) != Status::OK()) { LOG(WARNING) << "fail to load original tablet meta after clone. " << ", cloned_meta_file=" << cloned_meta_file; return res; @@ -184,20 +183,19 @@ OLAPStatus SnapshotManager::convert_rowset_ids(const FilePathDesc& clone_dir_des } res = TabletMeta::save(cloned_meta_file, new_tablet_meta_pb); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to save converted tablet meta to dir='" << clone_dir_desc.filepath; return res; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus SnapshotManager::_rename_rowset_id(const RowsetMetaPB& rs_meta_pb, - const FilePathDesc& new_path_desc, - TabletSchema& tablet_schema, +Status SnapshotManager::_rename_rowset_id(const RowsetMetaPB& rs_meta_pb, + const FilePathDesc& new_path_desc, TabletSchema& tablet_schema, const RowsetId& rowset_id, RowsetMetaPB* new_rs_meta_pb) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); // TODO use factory to obtain RowsetMeta when SnapshotManager::convert_rowset_ids supports beta rowset // TODO(cmy): now we only has AlphaRowsetMeta, and no BetaRowsetMeta. // AlphaRowsetMeta only add some functions about segment group, and no addition fields. @@ -231,7 +229,7 @@ OLAPStatus SnapshotManager::_rename_rowset_id(const RowsetMetaPB& rs_meta_pb, RETURN_NOT_OK(RowsetFactory::create_rowset_writer(context, &rs_writer)); res = rs_writer->add_rowset(org_rowset); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to add rowset " << " id = " << org_rowset->rowset_id() << " to rowset " << rowset_id; return res; @@ -239,27 +237,27 @@ OLAPStatus SnapshotManager::_rename_rowset_id(const RowsetMetaPB& rs_meta_pb, RowsetSharedPtr new_rowset = rs_writer->build(); if (new_rowset == nullptr) { LOG(WARNING) << "failed to build rowset when rename rowset id"; - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } RETURN_NOT_OK(new_rowset->load(false)); new_rowset->rowset_meta()->to_rowset_pb(new_rs_meta_pb); org_rowset->remove(); - return OLAP_SUCCESS; + return Status::OK(); } // get snapshot path: curtime.seq.timeout // eg: 20190819221234.3.86400 -OLAPStatus SnapshotManager::_calc_snapshot_id_path(const TabletSharedPtr& tablet, int64_t timeout_s, +Status SnapshotManager::_calc_snapshot_id_path(const TabletSharedPtr& tablet, int64_t timeout_s, string* out_path) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); if (out_path == nullptr) { LOG(WARNING) << "output parameter cannot be null"; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } // get current timestamp string string time_str; - if ((res = gen_timestamp_string(&time_str)) != OLAP_SUCCESS) { + if ((res = gen_timestamp_string(&time_str)) != Status::OK()) { LOG(WARNING) << "failed to generate time_string when move file to trash." << "err code=" << res; return res; @@ -291,17 +289,17 @@ std::string SnapshotManager::_get_header_full_path(const TabletSharedPtr& ref_ta return header_name_stream.str(); } -OLAPStatus SnapshotManager::_link_index_and_data_files( +Status SnapshotManager::_link_index_and_data_files( const FilePathDesc& schema_hash_path_desc, const TabletSharedPtr& ref_tablet, const std::vector& consistent_rowsets) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); for (auto& rs : consistent_rowsets) { RETURN_NOT_OK(rs->link_files_to(schema_hash_path_desc, rs->rowset_id())); } return res; } -OLAPStatus SnapshotManager::_create_snapshot_files(const TabletSharedPtr& ref_tablet, +Status SnapshotManager::_create_snapshot_files(const TabletSharedPtr& ref_tablet, const TSnapshotRequest& request, string* snapshot_path, bool* allow_incremental_clone) { @@ -309,10 +307,10 @@ OLAPStatus SnapshotManager::_create_snapshot_files(const TabletSharedPtr& ref_ta LOG(INFO) << "receive a make snapshot request" << ", request detail is " << apache::thrift::ThriftDebugString(request) << ", snapshot_version is " << snapshot_version; - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); if (snapshot_path == nullptr) { LOG(WARNING) << "output parameter cannot be null"; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } // snapshot_id_path: @@ -323,7 +321,7 @@ OLAPStatus SnapshotManager::_create_snapshot_files(const TabletSharedPtr& ref_ta timeout_s = request.timeout; } res = _calc_snapshot_id_path(ref_tablet, timeout_s, &snapshot_id_path); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to calc snapshot_id_path, ref tablet=" << ref_tablet->data_dir()->path(); return res; @@ -340,20 +338,19 @@ OLAPStatus SnapshotManager::_create_snapshot_files(const TabletSharedPtr& ref_ta FileUtils::remove_all(schema_full_path_desc.filepath); } - RETURN_WITH_WARN_IF_ERROR(FileUtils::create_dir(schema_full_path_desc.filepath), - OLAP_ERR_CANNOT_CREATE_DIR, + RETURN_WITH_WARN_IF_ERROR(FileUtils::create_dir(schema_full_path_desc.filepath), Status::OLAPInternalError(OLAP_ERR_CANNOT_CREATE_DIR), "create path " + schema_full_path_desc.filepath + " failed"); string snapshot_id; RETURN_WITH_WARN_IF_ERROR(FileUtils::canonicalize(snapshot_id_path, &snapshot_id), - OLAP_ERR_CANNOT_CREATE_DIR, + Status::OLAPInternalError(OLAP_ERR_CANNOT_CREATE_DIR), "canonicalize path " + snapshot_id_path + " failed"); do { TabletMetaSharedPtr new_tablet_meta(new (nothrow) TabletMeta()); if (new_tablet_meta == nullptr) { LOG(WARNING) << "fail to malloc TabletMeta."; - res = OLAP_ERR_MALLOC_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); break; } std::vector consistent_rowsets; @@ -375,15 +372,15 @@ OLAPStatus SnapshotManager::_create_snapshot_files(const TabletSharedPtr& ref_ta << "failed to find missed version when snapshot. " << " tablet=" << request.tablet_id << " schema_hash=" << request.schema_hash << " version=" << version; - res = OLAP_ERR_VERSION_NOT_EXIST; + res = Status::OLAPInternalError(OLAP_ERR_WRITE_PROTOBUF_ERROR); break; } } } - if (res != OLAP_SUCCESS || !request.__isset.missing_version) { + if (!res.ok() || !request.__isset.missing_version) { /// not all missing versions are found, fall back to full snapshot. - res = OLAP_SUCCESS; // reset res + res = Status::OK(); // reset res consistent_rowsets.clear(); // reset vector std::shared_lock rdlock(ref_tablet->get_header_lock()); @@ -392,7 +389,7 @@ OLAPStatus SnapshotManager::_create_snapshot_files(const TabletSharedPtr& ref_ta if (last_version == nullptr) { LOG(WARNING) << "tablet has not any version. path=" << ref_tablet->full_name().c_str(); - res = OLAP_ERR_VERSION_NOT_EXIST; + res = Status::OLAPInternalError(OLAP_ERR_WRITE_PROTOBUF_ERROR); break; } // get snapshot version, use request.version if specified @@ -402,7 +399,7 @@ OLAPStatus SnapshotManager::_create_snapshot_files(const TabletSharedPtr& ref_ta LOG(WARNING) << "invalid make snapshot request. " << " version=" << last_version->end_version() << " req_version=" << request.version; - res = OLAP_ERR_INPUT_PARAMETER_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); break; } version = request.version; @@ -412,7 +409,7 @@ OLAPStatus SnapshotManager::_create_snapshot_files(const TabletSharedPtr& ref_ta // it means 0-version has to be a readable version graph res = ref_tablet->capture_consistent_rowsets(Version(0, version), &consistent_rowsets); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to select versions to span. res=" << res; break; } @@ -422,14 +419,14 @@ OLAPStatus SnapshotManager::_create_snapshot_files(const TabletSharedPtr& ref_ta } // copy the tablet meta to new_tablet_meta inside header lock - CHECK(res == OLAP_SUCCESS) << res; + CHECK(res.ok()) << res; ref_tablet->generate_tablet_meta_copy_unlocked(new_tablet_meta); } std::vector rs_metas; for (auto& rs : consistent_rowsets) { res = rs->link_files_to(schema_full_path_desc, rs->rowset_id()); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { break; } rs_metas.push_back(rs->rowset_meta()); @@ -438,7 +435,7 @@ OLAPStatus SnapshotManager::_create_snapshot_files(const TabletSharedPtr& ref_ta << " end version " << rs->rowset_meta()->end_version() << " empty " << rs->rowset_meta()->empty(); } - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to create hard link. [path=" << snapshot_id_path << "]"; break; } @@ -451,10 +448,10 @@ OLAPStatus SnapshotManager::_create_snapshot_files(const TabletSharedPtr& ref_ta if (snapshot_version == g_Types_constants.TSNAPSHOT_REQ_VERSION2) { res = new_tablet_meta->save(header_path); } else { - res = OLAP_ERR_INVALID_SNAPSHOT_VERSION; + res = Status::OLAPInternalError(OLAP_ERR_INVALID_SNAPSHOT_VERSION); } - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "convert rowset failed, res:" << res << ", tablet:" << new_tablet_meta->tablet_id() << ", schema hash:" << new_tablet_meta->schema_hash() @@ -465,7 +462,7 @@ OLAPStatus SnapshotManager::_create_snapshot_files(const TabletSharedPtr& ref_ta } while (0); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to make snapshot, try to delete the snapshot path. path=" << snapshot_id_path.c_str(); diff --git a/be/src/olap/snapshot_manager.h b/be/src/olap/snapshot_manager.h index 790c3106ec..129008b63e 100644 --- a/be/src/olap/snapshot_manager.h +++ b/be/src/olap/snapshot_manager.h @@ -49,7 +49,7 @@ public: /// Create a snapshot /// snapshot_path: out param, the dir of snapshot /// allow_incremental_clone: out param, true if it is an incremental clone - OLAPStatus make_snapshot(const TSnapshotRequest& request, std::string* snapshot_path, + Status make_snapshot(const TSnapshotRequest& request, std::string* snapshot_path, bool* allow_incremental_clone); FilePathDesc get_schema_hash_full_path(const TabletSharedPtr& ref_tablet, @@ -57,11 +57,11 @@ public: // @brief 释放snapshot // @param snapshot_path [in] 要被释放的snapshot的路径，只包含到ID - OLAPStatus release_snapshot(const std::string& snapshot_path); + Status release_snapshot(const std::string& snapshot_path); static SnapshotManager* instance(); - OLAPStatus convert_rowset_ids(const FilePathDesc& clone_dir_desc, int64_t tablet_id, + Status convert_rowset_ids(const FilePathDesc& clone_dir_desc, int64_t tablet_id, const int32_t& schema_hash); private: @@ -70,24 +70,24 @@ private: MemTrackerLevel::OVERVIEW); } - OLAPStatus _calc_snapshot_id_path(const TabletSharedPtr& tablet, int64_t timeout_s, + Status _calc_snapshot_id_path(const TabletSharedPtr& tablet, int64_t timeout_s, std::string* out_path); std::string _get_header_full_path(const TabletSharedPtr& ref_tablet, const std::string& schema_hash_path) const; - OLAPStatus _link_index_and_data_files(const FilePathDesc& header_path_desc, + Status _link_index_and_data_files(const FilePathDesc& header_path_desc, const TabletSharedPtr& ref_tablet, const std::vector& consistent_rowsets); - OLAPStatus _create_snapshot_files(const TabletSharedPtr& ref_tablet, + Status _create_snapshot_files(const TabletSharedPtr& ref_tablet, const TSnapshotRequest& request, std::string* snapshot_path, bool* allow_incremental_clone); - OLAPStatus _prepare_snapshot_dir(const TabletSharedPtr& ref_tablet, + Status _prepare_snapshot_dir(const TabletSharedPtr& ref_tablet, std::string* snapshot_id_path); - OLAPStatus _rename_rowset_id(const RowsetMetaPB& rs_meta_pb, const FilePathDesc& new_path_desc, + Status _rename_rowset_id(const RowsetMetaPB& rs_meta_pb, const FilePathDesc& new_path_desc, TabletSchema& tablet_schema, const RowsetId& next_id, RowsetMetaPB* new_rs_meta_pb); diff --git a/be/src/olap/storage_engine.cpp b/be/src/olap/storage_engine.cpp index 821f2463e1..65359ea61d 100644 --- a/be/src/olap/storage_engine.cpp +++ b/be/src/olap/storage_engine.cpp @@ -165,7 +165,7 @@ void StorageEngine::load_data_dirs(const std::vector& data_dirs) { for (auto data_dir : data_dirs) { threads.emplace_back([data_dir] { auto res = data_dir->load(); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "io error when init load tables. res=" << res << ", data dir=" << data_dir->path(); // TODO(lingbin): why not exit progress, to force OP to change the conf @@ -340,9 +340,9 @@ std::vector StorageEngine::get_stores() { template std::vector StorageEngine::get_stores(); template std::vector StorageEngine::get_stores(); -OLAPStatus StorageEngine::get_all_data_dir_info(std::vector* data_dir_infos, +Status StorageEngine::get_all_data_dir_info(std::vector* data_dir_infos, bool need_update) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); data_dir_infos->clear(); MonotonicStopWatch timer; @@ -641,8 +641,8 @@ void StorageEngine::_start_clean_cache() { SegmentLoader::instance()->prune(); } -OLAPStatus StorageEngine::start_trash_sweep(double* usage, bool ignore_guard) { - OLAPStatus res = OLAP_SUCCESS; +Status StorageEngine::start_trash_sweep(double* usage, bool ignore_guard) { + Status res = Status::OK(); std::unique_lock l(_trash_sweep_lock, std::defer_lock); if (!l.try_lock()) { @@ -669,7 +669,7 @@ OLAPStatus StorageEngine::start_trash_sweep(double* usage, bool ignore_guard) { local_tm_now.tm_isdst = 0; if (localtime_r(&now, &local_tm_now) == nullptr) { LOG(WARNING) << "fail to localtime_r time. time=" << now; - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } const time_t local_now = mktime(&local_tm_now); //得到当地日历时间 @@ -683,10 +683,10 @@ OLAPStatus StorageEngine::start_trash_sweep(double* usage, bool ignore_guard) { double curr_usage = (double)(info.disk_capacity - info.available) / info.disk_capacity; tmp_usage = std::max(tmp_usage, curr_usage); - OLAPStatus curr_res = OLAP_SUCCESS; + Status curr_res = Status::OK(); string snapshot_path = info.path_desc.filepath + SNAPSHOT_PREFIX; curr_res = _do_sweep(snapshot_path, local_now, snapshot_expire); - if (curr_res != OLAP_SUCCESS) { + if (!curr_res.ok()) { LOG(WARNING) << "failed to sweep snapshot. path=" << snapshot_path << ", err_code=" << curr_res; res = curr_res; @@ -694,7 +694,7 @@ OLAPStatus StorageEngine::start_trash_sweep(double* usage, bool ignore_guard) { string trash_path = info.path_desc.filepath + TRASH_PREFIX; curr_res = _do_sweep(trash_path, local_now, curr_usage > guard_space ? 0 : trash_expire); - if (curr_res != OLAP_SUCCESS) { + if (!curr_res.ok()) { LOG(WARNING) << "failed to sweep trash. [path=%s" << trash_path << ", err_code=" << curr_res; res = curr_res; @@ -804,9 +804,9 @@ void StorageEngine::_clean_unused_txns() { } } -OLAPStatus StorageEngine::_do_sweep(const string& scan_root, const time_t& local_now, +Status StorageEngine::_do_sweep(const string& scan_root, const time_t& local_now, const int32_t expire) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); if (!FileUtils::check_exist(scan_root)) { // dir not existed. no need to sweep trash. return res; @@ -825,7 +825,7 @@ OLAPStatus StorageEngine::_do_sweep(const string& scan_root, const time_t& local local_tm_create.tm_isdst = 0; if (strptime(str_time.c_str(), "%Y%m%d%H%M%S", &local_tm_create) == nullptr) { LOG(WARNING) << "fail to strptime time. [time=" << str_time << "]"; - res = OLAP_ERR_OS_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_OS_ERROR); continue; } @@ -844,7 +844,7 @@ OLAPStatus StorageEngine::_do_sweep(const string& scan_root, const time_t& local if (!ret.ok()) { LOG(WARNING) << "fail to remove file or directory. path=" << path_name << ", error=" << ret.to_string(); - res = OLAP_ERR_OS_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_OS_ERROR); continue; } } else { @@ -854,7 +854,7 @@ OLAPStatus StorageEngine::_do_sweep(const string& scan_root, const time_t& local } } catch (...) { LOG(WARNING) << "Exception occur when scan directory. path=" << scan_root; - res = OLAP_ERR_IO_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } return res; @@ -880,7 +880,7 @@ void StorageEngine::start_delete_unused_rowset() { VLOG_NOTICE << "start to remove rowset:" << it->second->rowset_id() << ", version:" << it->second->version().first << "-" << it->second->version().second; - OLAPStatus status = it->second->remove(); + Status status = it->second->remove(); VLOG_NOTICE << "remove rowset:" << it->second->rowset_id() << " finished. status:" << status; it = _unused_rowsets.erase(it); @@ -910,37 +910,37 @@ void StorageEngine::add_unused_rowset(RowsetSharedPtr rowset) { } // TODO(zc): refactor this funciton -OLAPStatus StorageEngine::create_tablet(const TCreateTabletReq& request) { +Status StorageEngine::create_tablet(const TCreateTabletReq& request) { // Get all available stores, use ref_root_path if the caller specified std::vector stores; stores = get_stores_for_create_tablet(request.storage_medium); if (stores.empty()) { LOG(WARNING) << "there is no available disk that can be used to create tablet."; - return OLAP_ERR_CE_CMD_PARAMS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CE_CMD_PARAMS_ERROR); } TRACE("got data directory for create tablet"); return _tablet_manager->create_tablet(request, stores); } -OLAPStatus StorageEngine::obtain_shard_path(TStorageMedium::type storage_medium, +Status StorageEngine::obtain_shard_path(TStorageMedium::type storage_medium, std::string* shard_path, DataDir** store) { LOG(INFO) << "begin to process obtain root path. storage_medium=" << storage_medium; if (shard_path == nullptr) { LOG(WARNING) << "invalid output parameter which is null pointer."; - return OLAP_ERR_CE_CMD_PARAMS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CE_CMD_PARAMS_ERROR); } auto stores = get_stores_for_create_tablet(storage_medium); if (stores.empty()) { LOG(WARNING) << "no available disk can be used to create tablet."; - return OLAP_ERR_NO_AVAILABLE_ROOT_PATH; + return Status::OLAPInternalError(OLAP_ERR_NO_AVAILABLE_ROOT_PATH); } - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); uint64_t shard = 0; res = stores[0]->get_shard(&shard); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to get root path shard. res=" << res; return res; } @@ -954,11 +954,11 @@ OLAPStatus StorageEngine::obtain_shard_path(TStorageMedium::type storage_medium, return res; } -OLAPStatus StorageEngine::load_header(const string& shard_path, const TCloneReq& request, +Status StorageEngine::load_header(const string& shard_path, const TCloneReq& request, bool restore) { LOG(INFO) << "begin to process load headers." << "tablet_id=" << request.tablet_id << ", schema_hash=" << request.schema_hash; - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); DataDir* store = nullptr; { @@ -969,11 +969,11 @@ OLAPStatus StorageEngine::load_header(const string& shard_path, const TCloneReq& store = get_store(store_path); if (store == nullptr) { LOG(WARNING) << "invalid shard path, path=" << shard_path; - return OLAP_ERR_INVALID_ROOT_PATH; + return Status::OLAPInternalError(OLAP_ERR_INVALID_ROOT_PATH); } } catch (...) { LOG(WARNING) << "invalid shard path, path=" << shard_path; - return OLAP_ERR_INVALID_ROOT_PATH; + return Status::OLAPInternalError(OLAP_ERR_INVALID_ROOT_PATH); } } @@ -985,13 +985,13 @@ OLAPStatus StorageEngine::load_header(const string& shard_path, const TCloneReq& string header_path = TabletMeta::construct_header_file_path(schema_hash_path_stream.str(), request.tablet_id); res = TabletMeta::reset_tablet_uid(header_path); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail reset tablet uid file path = " << header_path << " res=" << res; return res; } res = _tablet_manager->load_tablet_from_dir(store, request.tablet_id, request.schema_hash, schema_hash_path_stream.str(), false, restore); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to process load headers. res=" << res; return res; } @@ -1018,7 +1018,7 @@ void StorageEngine::notify_listeners() { } } -OLAPStatus StorageEngine::execute_task(EngineTask* task) { +Status StorageEngine::execute_task(EngineTask* task) { { std::vector tablet_infos; task->get_related_tablets(&tablet_infos); @@ -1037,15 +1037,15 @@ OLAPStatus StorageEngine::execute_task(EngineTask* task) { } } // add write lock to all related tablets - OLAPStatus prepare_status = task->prepare(); - if (prepare_status != OLAP_SUCCESS) { + Status prepare_status = task->prepare(); + if (prepare_status != Status::OK()) { return prepare_status; } } // do execute work without lock - OLAPStatus exec_status = task->execute(); - if (exec_status != OLAP_SUCCESS) { + Status exec_status = task->execute(); + if (exec_status != Status::OK()) { return exec_status; } @@ -1068,7 +1068,7 @@ OLAPStatus StorageEngine::execute_task(EngineTask* task) { } } // add write lock to all related tablets - OLAPStatus fin_status = task->finish(); + Status fin_status = task->finish(); return fin_status; } } diff --git a/be/src/olap/storage_engine.h b/be/src/olap/storage_engine.h index 5460f198a9..84e955c7b0 100644 --- a/be/src/olap/storage_engine.h +++ b/be/src/olap/storage_engine.h @@ -45,7 +45,6 @@ #include "olap/rowset/rowset_id_generator.h" #include "olap/tablet.h" #include "olap/tablet_manager.h" -#include "olap/tablet_sync_service.h" #include "olap/task/engine_task.h" #include "olap/txn_manager.h" #include "runtime/heartbeat_flags.h" @@ -76,7 +75,7 @@ public: static StorageEngine* instance() { return _s_instance; } - OLAPStatus create_tablet(const TCreateTabletReq& request); + Status create_tablet(const TCreateTabletReq& request); void clear_transaction_task(const TTransactionId transaction_id); void clear_transaction_task(const TTransactionId transaction_id, @@ -97,7 +96,7 @@ public: void set_store_used_flag(const std::string& root_path, bool is_used); // @brief 获取所有root_path信息 - OLAPStatus get_all_data_dir_info(std::vector* data_dir_infos, bool need_update); + Status get_all_data_dir_info(std::vector* data_dir_infos, bool need_update); int64_t get_file_or_directory_size(std::filesystem::path file_path); @@ -118,7 +117,7 @@ public: // // @param [out] shard_path choose an available root_path to clone new tablet // @return error code - OLAPStatus obtain_shard_path(TStorageMedium::type storage_medium, std::string* shared_path, + Status obtain_shard_path(TStorageMedium::type storage_medium, std::string* shared_path, DataDir** store); // Load new tablet to make it effective. @@ -127,14 +126,14 @@ public: // @param [in] request specify new tablet info // @param [in] restore whether we're restoring a tablet from trash // @return OLAP_SUCCESS if load tablet success - OLAPStatus load_header(const std::string& shard_path, const TCloneReq& request, + Status load_header(const std::string& shard_path, const TCloneReq& request, bool restore = false); void register_report_listener(TaskWorkerPool* listener); void deregister_report_listener(TaskWorkerPool* listener); void notify_listeners(); - OLAPStatus execute_task(EngineTask* task); + Status execute_task(EngineTask* task); TabletManager* tablet_manager() { return _tablet_manager.get(); } TxnManager* txn_manager() { return _txn_manager.get(); } @@ -142,9 +141,6 @@ public: bool check_rowset_id_in_unused_rowsets(const RowsetId& rowset_id); - // TODO(ygl) - TabletSyncService* tablet_sync_service() { return nullptr; } - RowsetId next_rowset_id() { return _rowset_id_generator->next_id(); }; bool rowset_id_in_use(const RowsetId& rowset_id) { @@ -171,7 +167,7 @@ public: // clear trash and snapshot file // option: update disk usage after sweep - OLAPStatus start_trash_sweep(double* usage, bool ignore_guard = false); + Status start_trash_sweep(double* usage, bool ignore_guard = false); void stop(); @@ -219,7 +215,7 @@ private: void _clean_unused_rowset_metas(); - OLAPStatus _do_sweep(const std::string& scan_root, const time_t& local_tm_now, + Status _do_sweep(const std::string& scan_root, const time_t& local_tm_now, const int32_t expire); // All these xxx_callback() functions are for Background threads diff --git a/be/src/olap/stream_index_common.cpp b/be/src/olap/stream_index_common.cpp index 7b4caaa4ea..9a9469f755 100644 --- a/be/src/olap/stream_index_common.cpp +++ b/be/src/olap/stream_index_common.cpp @@ -30,7 +30,7 @@ ColumnStatistics::~ColumnStatistics() { SAFE_DELETE(_maximum); } -OLAPStatus ColumnStatistics::init(const FieldType& type, bool null_supported) { +Status ColumnStatistics::init(const FieldType& type, bool null_supported) { SAFE_DELETE(_minimum); SAFE_DELETE(_maximum); @@ -47,7 +47,7 @@ OLAPStatus ColumnStatistics::init(const FieldType& type, bool null_supported) { reset(); } - return OLAP_SUCCESS; + return Status::OK(); } void ColumnStatistics::reset() { @@ -100,13 +100,13 @@ void ColumnStatistics::attach(char* buffer) { } } -OLAPStatus ColumnStatistics::write_to_buffer(char* buffer, size_t size) { +Status ColumnStatistics::write_to_buffer(char* buffer, size_t size) { if (_ignored) { - return OLAP_SUCCESS; + return Status::OK(); } if (size < this->size()) { - return OLAP_ERR_BUFFER_OVERFLOW; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } // TODO(zc): too ugly @@ -120,7 +120,7 @@ OLAPStatus ColumnStatistics::write_to_buffer(char* buffer, size_t size) { memcpy(buffer + copy_size, _maximum->ptr(), copy_size); } - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/stream_index_common.h b/be/src/olap/stream_index_common.h index 4a9b80cf8c..289d7a330a 100644 --- a/be/src/olap/stream_index_common.h +++ b/be/src/olap/stream_index_common.h @@ -47,7 +47,7 @@ public: // Initialization, FieldType needs to be used to initialize the maximum and minimum values // It must be initialized before use, otherwise it will be invalid - OLAPStatus init(const FieldType& type, bool null_supported); + Status init(const FieldType& type, bool null_supported); // Just reset the maximum and minimum values, set the minimum value to MAX, and the maximum value to MIN. void reset(); @@ -72,7 +72,7 @@ public: // Attach the maximum and minimum values to the given buffer void attach(char* buffer); // Output the maximum and minimum values to the buffer - OLAPStatus write_to_buffer(char* buffer, size_t size); + Status write_to_buffer(char* buffer, size_t size); // Attributes const WrapperField* minimum() const { return _minimum; } diff --git a/be/src/olap/stream_index_reader.cpp b/be/src/olap/stream_index_reader.cpp index 02bf1e4880..dd8ecaae2a 100644 --- a/be/src/olap/stream_index_reader.cpp +++ b/be/src/olap/stream_index_reader.cpp @@ -22,19 +22,19 @@ namespace doris { PositionEntryReader::PositionEntryReader() : _positions(nullptr), _positions_count(0), _statistics_offset(0) {} -OLAPStatus PositionEntryReader::init(StreamIndexHeader* header, FieldType type, +Status PositionEntryReader::init(StreamIndexHeader* header, FieldType type, bool null_supported) { if (nullptr == header) { - return OLAP_ERR_INIT_FAILED; + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } set_positions_count(header->position_format); - if (OLAP_SUCCESS != _statistics.init(type, null_supported)) { - return OLAP_ERR_INIT_FAILED; + if (!_statistics.init(type, null_supported)) { + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } - return OLAP_SUCCESS; + return Status::OK(); } void PositionEntryReader::attach(char* buffer) { @@ -83,25 +83,25 @@ StreamIndexReader::~StreamIndexReader() { } } -OLAPStatus StreamIndexReader::init(char* buffer, size_t buffer_size, FieldType type, +Status StreamIndexReader::init(char* buffer, size_t buffer_size, FieldType type, bool is_using_cache, bool null_supported) { if (nullptr == buffer) { OLAP_LOG_WARNING("buffer given is invalid."); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } _buffer = buffer; _buffer_size = buffer_size; _is_using_cache = is_using_cache; _null_supported = null_supported; - OLAPStatus res = _parse_header(type); + Status res = _parse_header(type); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to parse header"); return res; } - return OLAP_SUCCESS; + return Status::OK(); } const PositionEntryReader& StreamIndexReader::entry(uint64_t entry_id) { @@ -113,20 +113,20 @@ size_t StreamIndexReader::entry_count() { return _entry_count; } -OLAPStatus StreamIndexReader::_parse_header(FieldType type) { +Status StreamIndexReader::_parse_header(FieldType type) { if (_buffer_size < sizeof(StreamIndexHeader)) { OLAP_LOG_WARNING("invalid length"); - return OLAP_ERR_OUT_OF_BOUND; + return Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND); } StreamIndexHeader* header = reinterpret_cast(_buffer); - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); res = _entry.init(header, type, _null_supported); - if (OLAP_SUCCESS != res) { + if (!res.ok()) { OLAP_LOG_WARNING("fail to init statistic reader"); - return OLAP_ERR_INIT_FAILED; + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } _start_offset = sizeof(StreamIndexHeader); @@ -137,7 +137,7 @@ OLAPStatus StreamIndexReader::_parse_header(FieldType type) { LOG(WARNING) << "invalid header length, entry_count=" << _entry_count << ", step_size=" << _step_size << ", start_offset=" << _start_offset << ", buffer_size=" << _buffer_size; - return OLAP_ERR_FILE_FORMAT_ERROR; + return Status::OLAPInternalError(OLAP_ERR_FILE_FORMAT_ERROR); } return res; diff --git a/be/src/olap/stream_index_reader.h b/be/src/olap/stream_index_reader.h index 4354c237fb..532121d6fe 100644 --- a/be/src/olap/stream_index_reader.h +++ b/be/src/olap/stream_index_reader.h @@ -28,7 +28,7 @@ public: PositionEntryReader(); ~PositionEntryReader() {} // 使用前需要初始化，需要header来计算每一组position/stat的偏移量 - OLAPStatus init(StreamIndexHeader* header, FieldType type, bool null_supported); + Status init(StreamIndexHeader* header, FieldType type, bool null_supported); // attach到一块内存上读取position和stat void attach(char* buffer); // 返回指定下标的position @@ -70,13 +70,13 @@ public: StreamIndexReader(); ~StreamIndexReader(); - OLAPStatus init(char* buffer, size_t buffer_size, FieldType type, bool is_using_cache, + Status init(char* buffer, size_t buffer_size, FieldType type, bool is_using_cache, bool null_supported); const PositionEntryReader& entry(uint64_t entry_id); size_t entry_count(); protected: - OLAPStatus _parse_header(FieldType type); + Status _parse_header(FieldType type); private: char* _buffer; diff --git a/be/src/olap/stream_index_writer.cpp b/be/src/olap/stream_index_writer.cpp index 76f80f2a01..1ef2a06aed 100644 --- a/be/src/olap/stream_index_writer.cpp +++ b/be/src/olap/stream_index_writer.cpp @@ -33,7 +33,7 @@ int64_t PositionEntryWriter::positions(size_t index) const { return -1; } -OLAPStatus PositionEntryWriter::set_statistic(ColumnStatistics* statistic) { +Status PositionEntryWriter::set_statistic(ColumnStatistics* statistic) { _statistics_size = statistic->size(); return statistic->write_to_buffer(_statistics_buffer, MAX_STATISTIC_LENGTH); } @@ -50,23 +50,23 @@ int32_t PositionEntryWriter::output_size() const { return _positions_count * sizeof(uint32_t) + _statistics_size; } -OLAPStatus PositionEntryWriter::add_position(uint32_t position) { +Status PositionEntryWriter::add_position(uint32_t position) { if (_positions_count < MAX_POSITION_SIZE) { _positions[_positions_count] = position; _positions_count++; - return OLAP_SUCCESS; + return Status::OK(); } - return OLAP_ERR_BUFFER_OVERFLOW; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } void PositionEntryWriter::reset_write_offset() { _positions_count = 0; } -OLAPStatus PositionEntryWriter::remove_written_position(uint32_t from, size_t count) { +Status PositionEntryWriter::remove_written_position(uint32_t from, size_t count) { if (from + count > _positions_count) { - return OLAP_ERR_OUT_OF_BOUND; + return Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND); } for (size_t i = from; i < _positions_count - count; ++i) { @@ -74,7 +74,7 @@ OLAPStatus PositionEntryWriter::remove_written_position(uint32_t from, size_t co } _positions_count -= count; - return OLAP_SUCCESS; + return Status::OK(); } void PositionEntryWriter::write_to_buffer(char* out_buffer) { @@ -93,15 +93,15 @@ StreamIndexWriter::StreamIndexWriter(FieldType field_type) : _field_type(field_t StreamIndexWriter::~StreamIndexWriter() {} -OLAPStatus StreamIndexWriter::add_index_entry(const PositionEntryWriter& entry) { +Status StreamIndexWriter::add_index_entry(const PositionEntryWriter& entry) { try { _index_to_write.push_back(entry); } catch (...) { OLAP_LOG_WARNING("add entry to index vector fail"); - return OLAP_ERR_STL_ERROR; + return Status::OLAPInternalError(OLAP_ERR_STL_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } PositionEntryWriter* StreamIndexWriter::mutable_entry(uint32_t index) { @@ -116,15 +116,15 @@ size_t StreamIndexWriter::entry_size() { return _index_to_write.size(); } -OLAPStatus StreamIndexWriter::reset() { +Status StreamIndexWriter::reset() { try { _index_to_write.clear(); } catch (...) { OLAP_LOG_WARNING("add entry to index vector fail"); - return OLAP_ERR_STL_ERROR; + return Status::OLAPInternalError(OLAP_ERR_STL_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } size_t StreamIndexWriter::output_size() { @@ -135,15 +135,15 @@ size_t StreamIndexWriter::output_size() { } } -OLAPStatus StreamIndexWriter::write_to_buffer(char* buffer, size_t buffer_size) { +Status StreamIndexWriter::write_to_buffer(char* buffer, size_t buffer_size) { if (nullptr == buffer) { OLAP_LOG_WARNING("given buffer is null"); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } if (output_size() > buffer_size) { OLAP_LOG_WARNING("need more buffer, size=%lu, given=%lu", output_size(), buffer_size); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } // write header @@ -172,7 +172,7 @@ OLAPStatus StreamIndexWriter::write_to_buffer(char* buffer, size_t buffer_size) write_offset += entry_size; } - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/stream_index_writer.h b/be/src/olap/stream_index_writer.h index ab98bb324d..451dc70505 100644 --- a/be/src/olap/stream_index_writer.h +++ b/be/src/olap/stream_index_writer.h @@ -35,18 +35,18 @@ public: // 获取position的个数 int32_t positions_count() const; // 设置统计信息 - OLAPStatus set_statistic(ColumnStatistics* statistic); + Status set_statistic(ColumnStatistics* statistic); // 判断当前entry是否写入了统计信息 bool has_statistic() const; // 输出到buffer的大小，用来预先分配内存用 int32_t output_size() const; // 增加一个position, 目前给出的上限是16 // ，目前不会有超出这个数量的位置信息 - OLAPStatus add_position(uint32_t position); + Status add_position(uint32_t position); // 实际上是重置position，便于重写时写入正确的位置 void reset_write_offset(); // 移除从from起，count个已经写入的位置，用于去除present流 - OLAPStatus remove_written_position(uint32_t from, size_t count); + Status remove_written_position(uint32_t from, size_t count); // 将内容输出到outbuffer中。 void write_to_buffer(char* out_buffer); @@ -62,13 +62,13 @@ public: StreamIndexWriter(FieldType field_type = OLAP_FIELD_TYPE_NONE); ~StreamIndexWriter(); - OLAPStatus add_index_entry(const PositionEntryWriter& entry); + Status add_index_entry(const PositionEntryWriter& entry); PositionEntryWriter* mutable_entry(uint32_t index); size_t entry_size(); - OLAPStatus reset(); + Status reset(); size_t output_size(); - OLAPStatus write_to_buffer(char* buffer, size_t buffer_size); + Status write_to_buffer(char* buffer, size_t buffer_size); protected: std::vector _index_to_write; diff --git a/be/src/olap/tablet.cpp b/be/src/olap/tablet.cpp index 35238819a1..31624dee34 100644 --- a/be/src/olap/tablet.cpp +++ b/be/src/olap/tablet.cpp @@ -84,8 +84,8 @@ Tablet::Tablet(TabletMetaSharedPtr tablet_meta, const StorageParamPB& storage_pa INT_COUNTER_METRIC_REGISTER(_metric_entity, flush_count); } -OLAPStatus Tablet::_init_once_action() { - OLAPStatus res = OLAP_SUCCESS; +Status Tablet::_init_once_action() { + Status res = Status::OK(); VLOG_NOTICE << "begin to load tablet. tablet=" << full_name() << ", version_size=" << _tablet_meta->version_count(); @@ -100,7 +100,7 @@ OLAPStatus Tablet::_init_once_action() { Version version = rs_meta->version(); RowsetSharedPtr rowset; res = RowsetFactory::create_rowset(&_schema, _tablet_path_desc, rs_meta, &rowset); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to init rowset. tablet_id=" << tablet_id() << ", schema_hash=" << schema_hash() << ", version=" << version << ", res=" << res; @@ -114,7 +114,7 @@ OLAPStatus Tablet::_init_once_action() { Version version = stale_rs_meta->version(); RowsetSharedPtr rowset; res = RowsetFactory::create_rowset(&_schema, _tablet_path_desc, stale_rs_meta, &rowset); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to init stale rowset. tablet_id:" << tablet_id() << ", schema_hash:" << schema_hash() << ", version=" << version << ", res:" << res; @@ -126,7 +126,7 @@ OLAPStatus Tablet::_init_once_action() { return res; } -OLAPStatus Tablet::init() { +Status Tablet::init() { return _init_once.call([this] { return _init_once_action(); }); } @@ -134,16 +134,16 @@ OLAPStatus Tablet::init() { // if it's a primary replica void Tablet::save_meta() { auto res = _tablet_meta->save_meta(_data_dir); - CHECK_EQ(res, OLAP_SUCCESS) << "fail to save tablet_meta. res=" << res + CHECK_EQ(res, Status::OK()) << "fail to save tablet_meta. res=" << res << ", root=" << _data_dir->path(); } -OLAPStatus Tablet::revise_tablet_meta(const std::vector& rowsets_to_clone, +Status Tablet::revise_tablet_meta(const std::vector& rowsets_to_clone, const std::vector& versions_to_delete) { LOG(INFO) << "begin to revise tablet. tablet=" << full_name() << ", rowsets_to_clone=" << rowsets_to_clone.size() << ", versions_to_delete=" << versions_to_delete.size(); - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); do { // load new local tablet_meta to operate on TabletMetaSharedPtr new_tablet_meta(new (nothrow) TabletMeta(*_tablet_meta)); @@ -166,7 +166,7 @@ OLAPStatus Tablet::revise_tablet_meta(const std::vector& ro << ", added rowset size=" << rowsets_to_clone.size(); // save and reload tablet_meta res = new_tablet_meta->save_meta(_data_dir); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to save new local tablet_meta when clone. res:" << res; break; } @@ -184,7 +184,7 @@ OLAPStatus Tablet::revise_tablet_meta(const std::vector& ro Version version = {rs_meta->start_version(), rs_meta->end_version()}; RowsetSharedPtr rowset; res = RowsetFactory::create_rowset(&_schema, _tablet_path_desc, rs_meta, &rowset); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to init rowset. version=" << version; return res; } @@ -205,13 +205,13 @@ OLAPStatus Tablet::revise_tablet_meta(const std::vector& ro return res; } -OLAPStatus Tablet::add_rowset(RowsetSharedPtr rowset, bool need_persist) { +Status Tablet::add_rowset(RowsetSharedPtr rowset, bool need_persist) { DCHECK(rowset != nullptr); std::lock_guard wrlock(_meta_lock); // If the rowset already exist, just return directly. The rowset_id is an unique-id, // we can use it to check this situation. if (_contains_rowset(rowset->rowset_id())) { - return OLAP_SUCCESS; + return Status::OK(); } // Otherwise, the version should be not contained in any existing rowset. RETURN_NOT_OK(_contains_version(rowset->version())); @@ -236,15 +236,15 @@ OLAPStatus Tablet::add_rowset(RowsetSharedPtr rowset, bool need_persist) { modify_rowsets(empty_vec, rowsets_to_delete); if (need_persist) { - OLAPStatus res = + Status res = RowsetMetaManager::save(data_dir()->get_meta(), tablet_uid(), rowset->rowset_id(), rowset->rowset_meta()->get_rowset_pb()); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(FATAL) << "failed to save rowset to local meta store" << rowset->rowset_id(); } } ++_newly_created_rowset_num; - return OLAP_SUCCESS; + return Status::OK(); } void Tablet::modify_rowsets(std::vector& to_add, @@ -367,11 +367,11 @@ RowsetSharedPtr Tablet::_rowset_with_largest_size() { } // add inc rowset should not persist tablet meta, because it will be persisted when publish txn. -OLAPStatus Tablet::add_inc_rowset(const RowsetSharedPtr& rowset) { +Status Tablet::add_inc_rowset(const RowsetSharedPtr& rowset) { DCHECK(rowset != nullptr); std::lock_guard wrlock(_meta_lock); if (_contains_rowset(rowset->rowset_id())) { - return OLAP_SUCCESS; + return Status::OK(); } RETURN_NOT_OK(_contains_version(rowset->version())); @@ -381,7 +381,7 @@ OLAPStatus Tablet::add_inc_rowset(const RowsetSharedPtr& rowset) { _timestamped_version_tracker.add_version(rowset->version()); ++_newly_created_rowset_num; - return OLAP_SUCCESS; + return Status::OK(); } void Tablet::_delete_stale_rowset_by_version(const Version& version) { @@ -437,9 +437,9 @@ void Tablet::delete_expired_stale_rowset() { Version test_version = Version(0, lastest_delta->end_version()); stale_version_path_map[*path_id_iter] = version_path; - OLAPStatus status = capture_consistent_versions(test_version, nullptr); + Status status = capture_consistent_versions(test_version, nullptr); // 1. When there is no consistent versions, we must reconstruct the tracker. - if (status != OLAP_SUCCESS) { + if (!status.ok()) { // 2. fetch missing version after delete std::vector after_missed_versions; calc_missed_versions_unlocked(lastest_delta->end_version(), &after_missed_versions); @@ -551,12 +551,12 @@ bool Tablet::_reconstruct_version_tracker_if_necessary() { return false; } -OLAPStatus Tablet::capture_consistent_versions(const Version& spec_version, +Status Tablet::capture_consistent_versions(const Version& spec_version, std::vector* version_path, bool quiet) const { - OLAPStatus status = + Status status = _timestamped_version_tracker.capture_consistent_versions(spec_version, version_path); - if (status != OLAP_SUCCESS && !quiet) { + if (!status.ok() && !quiet) { std::vector missed_versions; calc_missed_versions_unlocked(spec_version.second, &missed_versions); if (missed_versions.empty()) { @@ -566,7 +566,7 @@ OLAPStatus Tablet::capture_consistent_versions(const Version& spec_version, LOG(WARNING) << "tablet:" << full_name() << ", version already has been merged. spec_version: " << spec_version; } - status = OLAP_ERR_VERSION_ALREADY_MERGED; + status = Status::OLAPInternalError(OLAP_ERR_VERSION_ALREADY_MERGED); } else { if (version_path != nullptr) { LOG(WARNING) << "status:" << status << ", tablet:" << full_name() @@ -578,7 +578,7 @@ OLAPStatus Tablet::capture_consistent_versions(const Version& spec_version, return status; } -OLAPStatus Tablet::check_version_integrity(const Version& version, bool quiet) { +Status Tablet::check_version_integrity(const Version& version, bool quiet) { std::shared_lock rdlock(_meta_lock); return capture_consistent_versions(version, nullptr, quiet); } @@ -601,15 +601,15 @@ void Tablet::acquire_version_and_rowsets( } } -OLAPStatus Tablet::capture_consistent_rowsets(const Version& spec_version, +Status Tablet::capture_consistent_rowsets(const Version& spec_version, std::vector* rowsets) const { std::vector version_path; RETURN_NOT_OK(capture_consistent_versions(spec_version, &version_path)); RETURN_NOT_OK(_capture_consistent_rowsets_unlocked(version_path, rowsets)); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus Tablet::_capture_consistent_rowsets_unlocked( +Status Tablet::_capture_consistent_rowsets_unlocked( const std::vector& version_path, std::vector* rowsets) const { DCHECK(rowsets != nullptr && rowsets->empty()); rowsets->reserve(version_path.size()); @@ -634,21 +634,21 @@ OLAPStatus Tablet::_capture_consistent_rowsets_unlocked( if (!is_find) { LOG(WARNING) << "fail to find Rowset for version. tablet=" << full_name() << ", version='" << version; - return OLAP_ERR_CAPTURE_ROWSET_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CAPTURE_ROWSET_ERROR); } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus Tablet::capture_rs_readers(const Version& spec_version, +Status Tablet::capture_rs_readers(const Version& spec_version, std::vector* rs_readers) const { std::vector version_path; RETURN_NOT_OK(capture_consistent_versions(spec_version, &version_path)); RETURN_NOT_OK(capture_rs_readers(version_path, rs_readers)); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus Tablet::capture_rs_readers(const std::vector& version_path, +Status Tablet::capture_rs_readers(const std::vector& version_path, std::vector* rs_readers) const { DCHECK(rs_readers != nullptr && rs_readers->empty()); for (auto version : version_path) { @@ -662,18 +662,18 @@ OLAPStatus Tablet::capture_rs_readers(const std::vector& version_path, LOG(WARNING) << "fail to find Rowset in stale_rs_version for version. tablet=" << full_name() << ", version='" << version.first << "-" << version.second; - return OLAP_ERR_CAPTURE_ROWSET_READER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CAPTURE_ROWSET_READER_ERROR); } } RowsetReaderSharedPtr rs_reader; auto res = it->second->create_reader(&rs_reader); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to create reader for rowset:" << it->second->rowset_id(); - return OLAP_ERR_CAPTURE_ROWSET_READER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CAPTURE_ROWSET_READER_ERROR); } rs_readers->push_back(std::move(rs_reader)); } - return OLAP_SUCCESS; + return Status::OK(); } void Tablet::add_delete_predicate(const DeletePredicatePB& delete_predicate, int64_t version) { @@ -712,7 +712,7 @@ bool Tablet::can_do_compaction(size_t path_hash, CompactionType compaction_type) } Version test_version = Version(0, lastest_delta->end_version()); - if (OLAP_SUCCESS != capture_consistent_versions(test_version, nullptr)) { + if (!capture_consistent_versions(test_version, nullptr)) { return false; } } @@ -852,7 +852,7 @@ void Tablet::calculate_cumulative_point() { set_cumulative_layer_point(ret_cumulative_point); } -OLAPStatus Tablet::split_range(const OlapTuple& start_key_strings, const OlapTuple& end_key_strings, +Status Tablet::split_range(const OlapTuple& start_key_strings, const OlapTuple& end_key_strings, uint64_t request_block_row_count, std::vector* ranges) { DCHECK(ranges != nullptr); @@ -860,20 +860,20 @@ OLAPStatus Tablet::split_range(const OlapTuple& start_key_strings, const OlapTup RowCursor start_key; // 如果有startkey，用startkey初始化；反之则用minkey初始化 if (start_key_strings.size() > 0) { - if (start_key.init_scan_key(_schema, start_key_strings.values()) != OLAP_SUCCESS) { + if (start_key.init_scan_key(_schema, start_key_strings.values()) != Status::OK()) { LOG(WARNING) << "fail to initial key strings with RowCursor type."; - return OLAP_ERR_INIT_FAILED; + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } - if (start_key.from_tuple(start_key_strings) != OLAP_SUCCESS) { + if (start_key.from_tuple(start_key_strings) != Status::OK()) { LOG(WARNING) << "init end key failed"; - return OLAP_ERR_INVALID_SCHEMA; + return Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA); } key_num = start_key_strings.size(); } else { - if (start_key.init(_schema, num_short_key_columns()) != OLAP_SUCCESS) { + if (start_key.init(_schema, num_short_key_columns()) != Status::OK()) { LOG(WARNING) << "fail to initial key strings with RowCursor type."; - return OLAP_ERR_INIT_FAILED; + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } start_key.allocate_memory_for_string_type(_schema); @@ -884,19 +884,19 @@ OLAPStatus Tablet::split_range(const OlapTuple& start_key_strings, const OlapTup RowCursor end_key; // 和startkey一样处理，没有则用maxkey初始化 if (end_key_strings.size() > 0) { - if (OLAP_SUCCESS != end_key.init_scan_key(_schema, end_key_strings.values())) { + if (!end_key.init_scan_key(_schema, end_key_strings.values())) { LOG(WARNING) << "fail to parse strings to key with RowCursor type."; - return OLAP_ERR_INVALID_SCHEMA; + return Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA); } - if (end_key.from_tuple(end_key_strings) != OLAP_SUCCESS) { + if (end_key.from_tuple(end_key_strings) != Status::OK()) { LOG(WARNING) << "init end key failed"; - return OLAP_ERR_INVALID_SCHEMA; + return Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA); } } else { - if (end_key.init(_schema, num_short_key_columns()) != OLAP_SUCCESS) { + if (end_key.init(_schema, num_short_key_columns()) != Status::OK()) { LOG(WARNING) << "fail to initial key strings with RowCursor type."; - return OLAP_ERR_INIT_FAILED; + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } end_key.allocate_memory_for_string_type(_schema); @@ -912,7 +912,7 @@ OLAPStatus Tablet::split_range(const OlapTuple& start_key_strings, const OlapTup // it may be right if the tablet is empty, so we return success. ranges->emplace_back(start_key.to_tuple()); ranges->emplace_back(end_key.to_tuple()); - return OLAP_SUCCESS; + return Status::OK(); } return rowset->split_range(start_key, end_key, request_block_row_count, key_num, ranges); } @@ -993,7 +993,7 @@ void Tablet::_print_missed_versions(const std::vector& missed_versions) LOG(WARNING) << ss.str(); } -OLAPStatus Tablet::_contains_version(const Version& version) { +Status Tablet::_contains_version(const Version& version) { // check if there exist a rowset contains the added rowset for (auto& it : _rs_version_map) { if (it.first.contains(version)) { @@ -1004,14 +1004,14 @@ OLAPStatus Tablet::_contains_version(const Version& version) { CHECK(it.second != nullptr) << "there exist a version=" << it.first << " contains the input rs with version=" << version << ", but the related rs is null"; - return OLAP_ERR_PUSH_VERSION_ALREADY_EXIST; + return Status::OLAPInternalError(OLAP_ERR_PUSH_VERSION_ALREADY_EXIST); } } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus Tablet::set_partition_id(int64_t partition_id) { +Status Tablet::set_partition_id(int64_t partition_id) { return _tablet_meta->set_partition_id(partition_id); } @@ -1331,11 +1331,11 @@ Status Tablet::prepare_compaction_and_calculate_permits(CompactionType compactio TRACE("create cumulative compaction"); StorageEngine::instance()->create_cumulative_compaction(tablet, _cumulative_compaction); DorisMetrics::instance()->cumulative_compaction_request_total->increment(1); - OLAPStatus res = _cumulative_compaction->prepare_compact(); - if (res != OLAP_SUCCESS) { + Status res = _cumulative_compaction->prepare_compact(); + if (!res.ok()) { set_last_cumu_compaction_failure_time(UnixMillis()); *permits = 0; - if (res != OLAP_ERR_CUMULATIVE_NO_SUITABLE_VERSION) { + if (res != Status::OLAPInternalError(OLAP_ERR_CUMULATIVE_NO_SUITABLE_VERSION)) { DorisMetrics::instance()->cumulative_compaction_request_failed->increment(1); return Status::InternalError(fmt::format("prepare cumulative compaction with err: {}", res)); } @@ -1360,11 +1360,11 @@ Status Tablet::prepare_compaction_and_calculate_permits(CompactionType compactio TRACE("create base compaction"); StorageEngine::instance()->create_base_compaction(tablet, _base_compaction); DorisMetrics::instance()->base_compaction_request_total->increment(1); - OLAPStatus res = _base_compaction->prepare_compact(); - if (res != OLAP_SUCCESS) { + Status res = _base_compaction->prepare_compact(); + if (!res.ok()) { set_last_base_compaction_failure_time(UnixMillis()); *permits = 0; - if (res != OLAP_ERR_BE_NO_SUITABLE_VERSION) { + if (res != Status::OLAPInternalError(OLAP_ERR_BE_NO_SUITABLE_VERSION)) { DorisMetrics::instance()->base_compaction_request_failed->increment(1); return Status::InternalError(fmt::format("prepare base compaction with err: {}", res)); } @@ -1396,8 +1396,8 @@ void Tablet::execute_compaction(CompactionType compaction_type) { ADOPT_TRACE(trace.get()); TRACE("execute cumulative compaction"); - OLAPStatus res = _cumulative_compaction->execute_compact(); - if (res != OLAP_SUCCESS) { + Status res = _cumulative_compaction->execute_compact(); + if (!res.ok()) { set_last_cumu_compaction_failure_time(UnixMillis()); DorisMetrics::instance()->cumulative_compaction_request_failed->increment(1); LOG(WARNING) << "failed to do cumulative compaction. res=" << res @@ -1419,8 +1419,8 @@ void Tablet::execute_compaction(CompactionType compaction_type) { ADOPT_TRACE(trace.get()); TRACE("create base compaction"); - OLAPStatus res = _base_compaction->execute_compact(); - if (res != OLAP_SUCCESS) { + Status res = _base_compaction->execute_compact(); + if (!res.ok()) { set_last_base_compaction_failure_time(UnixMillis()); DorisMetrics::instance()->base_compaction_request_failed->increment(1); LOG(WARNING) << "failed to do base compaction. res=" << res diff --git a/be/src/olap/tablet.h b/be/src/olap/tablet.h index 75235c96c8..2582da46e3 100644 --- a/be/src/olap/tablet.h +++ b/be/src/olap/tablet.h @@ -58,7 +58,7 @@ public: Tablet(TabletMetaSharedPtr tablet_meta, const StorageParamPB& storage_param, DataDir* data_dir, const std::string& cumulative_compaction_type = ""); - OLAPStatus init(); + Status init(); bool init_succeeded(); bool is_used(); @@ -68,7 +68,7 @@ public: void save_meta(); // Used in clone task, to update local meta when finishing a clone job - OLAPStatus revise_tablet_meta(const std::vector& rowsets_to_clone, + Status revise_tablet_meta(const std::vector& rowsets_to_clone, const std::vector& versions_to_delete); const int64_t cumulative_layer_point() const; @@ -96,7 +96,7 @@ public: int32_t field_index(const std::string& field_name) const; // operation in rowsets - OLAPStatus add_rowset(RowsetSharedPtr rowset, bool need_persist = true); + Status add_rowset(RowsetSharedPtr rowset, bool need_persist = true); void modify_rowsets(std::vector& to_add, std::vector& to_delete); @@ -108,7 +108,7 @@ public: const RowsetSharedPtr rowset_with_max_version() const; - OLAPStatus add_inc_rowset(const RowsetSharedPtr& rowset); + Status add_inc_rowset(const RowsetSharedPtr& rowset); /// Delete stale rowset by timing. This delete policy uses now() minutes /// config::tablet_rowset_expired_stale_sweep_time_sec to compute the deadline of expired rowset /// to delete. When rowset is deleted, it will be added to StorageEngine unused map and record @@ -117,21 +117,21 @@ public: // Given spec_version, find a continuous version path and store it in version_path. // If quiet is true, then only "does this path exist" is returned. - OLAPStatus capture_consistent_versions(const Version& spec_version, + Status capture_consistent_versions(const Version& spec_version, std::vector* version_path, bool quiet = false) const; // if quiet is true, no error log will be printed if there are missing versions - OLAPStatus check_version_integrity(const Version& version, bool quiet = false); + Status check_version_integrity(const Version& version, bool quiet = false); bool check_version_exist(const Version& version) const; void acquire_version_and_rowsets( std::vector>* version_rowsets) const; - OLAPStatus capture_consistent_rowsets(const Version& spec_version, + Status capture_consistent_rowsets(const Version& spec_version, std::vector* rowsets) const; - OLAPStatus capture_rs_readers(const Version& spec_version, + Status capture_rs_readers(const Version& spec_version, std::vector* rs_readers) const; - OLAPStatus capture_rs_readers(const std::vector& version_path, + Status capture_rs_readers(const std::vector& version_path, std::vector* rs_readers) const; DelPredicateArray delete_predicates() { return _tablet_meta->delete_predicates(); } @@ -166,7 +166,7 @@ public: void max_continuous_version_from_beginning(Version* version, Version* max_version = nullptr); // operation for query - OLAPStatus split_range(const OlapTuple& start_key_strings, const OlapTuple& end_key_strings, + Status split_range(const OlapTuple& start_key_strings, const OlapTuple& end_key_strings, uint64_t request_block_row_count, std::vector* ranges); void set_bad(bool is_bad) { _is_bad = is_bad; } @@ -196,7 +196,7 @@ public: bool check_path(const std::string& check_path) const; bool check_rowset_id(const RowsetId& rowset_id); - OLAPStatus set_partition_id(int64_t partition_id); + Status set_partition_id(int64_t partition_id); TabletInfo get_tablet_info() const; @@ -256,10 +256,10 @@ public: } private: - OLAPStatus _init_once_action(); + Status _init_once_action(); void _print_missed_versions(const std::vector& missed_versions) const; bool _contains_rowset(const RowsetId rowset_id); - OLAPStatus _contains_version(const Version& version); + Status _contains_version(const Version& version); // Returns: // version: the max continuous version from beginning @@ -270,7 +270,7 @@ private: /// Delete stale rowset by version. This method not only delete the version in expired rowset map, /// but also delete the version in rowset meta vector. void _delete_stale_rowset_by_version(const Version& version); - OLAPStatus _capture_consistent_rowsets_unlocked(const std::vector& version_path, + Status _capture_consistent_rowsets_unlocked(const std::vector& version_path, std::vector* rowsets) const; const uint32_t _calc_cumulative_compaction_score( @@ -287,7 +287,7 @@ public: private: TimestampedVersionTracker _timestamped_version_tracker; - DorisCallOnce _init_once; + DorisCallOnce _init_once; // meta store lock is used for prevent 2 threads do checkpoint concurrently // it will be used in econ-mode in the future std::shared_mutex _meta_store_lock; @@ -351,7 +351,7 @@ inline CumulativeCompactionPolicy* Tablet::cumulative_compaction_policy() { } inline bool Tablet::init_succeeded() { - return _init_once.has_called() && _init_once.stored_result() == OLAP_SUCCESS; + return _init_once.has_called() && _init_once.stored_result().ok(); } inline bool Tablet::is_used() { diff --git a/be/src/olap/tablet_manager.cpp b/be/src/olap/tablet_manager.cpp index 0d5b9714ab..de1a1f9cc7 100644 --- a/be/src/olap/tablet_manager.cpp +++ b/be/src/olap/tablet_manager.cpp @@ -86,9 +86,9 @@ TabletManager::~TabletManager() { DEREGISTER_HOOK_METRIC(tablet_meta_mem_consumption); } -OLAPStatus TabletManager::_add_tablet_unlocked(TTabletId tablet_id, const TabletSharedPtr& tablet, - bool update_meta, bool force) { - OLAPStatus res = OLAP_SUCCESS; +Status TabletManager::_add_tablet_unlocked(TTabletId tablet_id, const TabletSharedPtr& tablet, + bool update_meta, bool force) { + Status res = Status::OK(); VLOG_NOTICE << "begin to add tablet to TabletManager. " << "tablet_id=" << tablet_id << ", force=" << force; @@ -109,11 +109,11 @@ OLAPStatus TabletManager::_add_tablet_unlocked(TTabletId tablet_id, const Tablet if (existed_tablet->tablet_path_desc().filepath == tablet->tablet_path_desc().filepath) { LOG(WARNING) << "add the same tablet twice! tablet_id=" << tablet_id << ", tablet_path=" << tablet->tablet_path_desc().filepath; - return OLAP_ERR_ENGINE_INSERT_EXISTS_TABLE; + return Status::OLAPInternalError(OLAP_ERR_ENGINE_INSERT_EXISTS_TABLE); } if (existed_tablet->data_dir() == tablet->data_dir()) { LOG(WARNING) << "add tablet with same data dir twice! tablet_id=" << tablet_id; - return OLAP_ERR_ENGINE_INSERT_EXISTS_TABLE; + return Status::OLAPInternalError(OLAP_ERR_ENGINE_INSERT_EXISTS_TABLE); } } @@ -133,7 +133,7 @@ OLAPStatus TabletManager::_add_tablet_unlocked(TTabletId tablet_id, const Tablet // it could prevent error when log level is changed in the future. LOG(FATAL) << "new tablet is empty and old tablet exists. it should not happen." << " tablet_id=" << tablet_id; - return OLAP_ERR_ENGINE_INSERT_EXISTS_TABLE; + return Status::OLAPInternalError(OLAP_ERR_ENGINE_INSERT_EXISTS_TABLE); } old_time = old_rowset == nullptr ? -1 : old_rowset->creation_time(); new_time = new_rowset->creation_time(); @@ -158,7 +158,7 @@ OLAPStatus TabletManager::_add_tablet_unlocked(TTabletId tablet_id, const Tablet res = _add_tablet_to_map_unlocked(tablet_id, tablet, update_meta, keep_files, true /*drop_old*/); } else { - res = OLAP_ERR_ENGINE_INSERT_OLD_TABLET; + res = Status::OLAPInternalError(OLAP_ERR_ENGINE_INSERT_OLD_TABLET); } LOG(WARNING) << "add duplicated tablet. force=" << force << ", res=" << res << ", tablet_id=" << tablet_id << ", old_version=" << old_version @@ -170,12 +170,12 @@ OLAPStatus TabletManager::_add_tablet_unlocked(TTabletId tablet_id, const Tablet return res; } -OLAPStatus TabletManager::_add_tablet_to_map_unlocked(TTabletId tablet_id, +Status TabletManager::_add_tablet_to_map_unlocked(TTabletId tablet_id, const TabletSharedPtr& tablet, bool update_meta, bool keep_files, bool drop_old) { // check if new tablet's meta is in store and add new tablet's meta to meta store - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); if (update_meta) { // call tablet save meta in order to valid the meta tablet->save_meta(); @@ -212,7 +212,7 @@ bool TabletManager::_check_tablet_id_exist_unlocked(TTabletId tablet_id) { return tablet_map.find(tablet_id) != tablet_map.end(); } -OLAPStatus TabletManager::create_tablet(const TCreateTabletReq& request, +Status TabletManager::create_tablet(const TCreateTabletReq& request, std::vector stores) { SCOPED_SWITCH_THREAD_LOCAL_MEM_TRACKER(_mem_tracker); DorisMetrics::instance()->create_tablet_requests_total->increment(1); @@ -231,7 +231,7 @@ OLAPStatus TabletManager::create_tablet(const TCreateTabletReq& request, // eventually trigger its deletion). if (_get_tablet_unlocked(tablet_id) != nullptr) { LOG(INFO) << "success to create tablet. tablet already exist. tablet_id=" << tablet_id; - return OLAP_SUCCESS; + return Status::OK(); } TabletSharedPtr base_tablet = nullptr; @@ -245,7 +245,7 @@ OLAPStatus TabletManager::create_tablet(const TCreateTabletReq& request, << "new_tablet_id=" << tablet_id << ", base_tablet_id=" << request.base_tablet_id; DorisMetrics::instance()->create_tablet_requests_failed->increment(1); - return OLAP_ERR_TABLE_CREATE_META_ERROR; + return Status::OLAPInternalError(OLAP_ERR_TABLE_CREATE_META_ERROR); } // If we are doing schema-change, we should use the same data dir // TODO(lingbin): A litter trick here, the directory should be determined before @@ -260,12 +260,12 @@ OLAPStatus TabletManager::create_tablet(const TCreateTabletReq& request, if (tablet == nullptr) { LOG(WARNING) << "fail to create tablet. tablet_id=" << request.tablet_id; DorisMetrics::instance()->create_tablet_requests_failed->increment(1); - return OLAP_ERR_CE_CMD_PARAMS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CE_CMD_PARAMS_ERROR); } TRACE("succeed to create tablet"); LOG(INFO) << "success to create tablet. tablet_id=" << tablet_id; - return OLAP_SUCCESS; + return Status::OK(); } TabletSharedPtr TabletManager::_internal_create_tablet_unlocked( @@ -294,11 +294,11 @@ TabletSharedPtr TabletManager::_internal_create_tablet_unlocked( // TODO(yiguolei) // the following code is very difficult to understand because it mixed alter tablet v2 // and alter tablet v1 should remove alter tablet v1 code after v0.12 - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); bool is_tablet_added = false; do { res = tablet->init(); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "tablet init failed. tablet:" << tablet->full_name(); break; } @@ -308,7 +308,7 @@ TabletSharedPtr TabletManager::_internal_create_tablet_unlocked( // if (!in_restore_mode && request.__isset.version) { // create initial rowset before add it to storage engine could omit many locks res = _create_initial_rowset_unlocked(request, tablet.get()); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to create initial version for tablet. res=" << res; break; } @@ -338,7 +338,7 @@ TabletSharedPtr TabletManager::_internal_create_tablet_unlocked( } // Add tablet to StorageEngine will make it visible to user res = _add_tablet_unlocked(new_tablet_id, tablet, true, false); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to add tablet to StorageEngine. res=" << res; break; } @@ -348,20 +348,20 @@ TabletSharedPtr TabletManager::_internal_create_tablet_unlocked( // Because if _add_tablet_unlocked() return OK, we must can get it from map. TabletSharedPtr tablet_ptr = _get_tablet_unlocked(new_tablet_id); if (tablet_ptr == nullptr) { - res = OLAP_ERR_TABLE_NOT_FOUND; + res = Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); LOG(WARNING) << "fail to get tablet. res=" << res; break; } TRACE("add tablet to StorageEngine"); } while (0); - if (res == OLAP_SUCCESS) { + if (res.ok()) { return tablet; } // something is wrong, we need clear environment if (is_tablet_added) { - OLAPStatus status = _drop_tablet_unlocked(new_tablet_id, false); - if (status != OLAP_SUCCESS) { + Status status = _drop_tablet_unlocked(new_tablet_id, false); + if (!status.ok()) { LOG(WARNING) << "fail to drop tablet when create tablet failed. res=" << res; } } else { @@ -394,9 +394,9 @@ TabletSharedPtr TabletManager::_create_tablet_meta_and_dir_unlocked( TabletMetaSharedPtr tablet_meta; // if create meta failed, do not need to clean dir, because it is only in memory - OLAPStatus res = _create_tablet_meta_unlocked(request, data_dir, is_schema_change, + Status res = _create_tablet_meta_unlocked(request, data_dir, is_schema_change, base_tablet, &tablet_meta); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to create tablet meta. res=" << res << ", root=" << data_dir->path(); continue; @@ -423,8 +423,8 @@ TabletSharedPtr TabletManager::_create_tablet_meta_and_dir_unlocked( } StorageParamPB storage_param; - OLAPStatus status = _get_storage_param(data_dir, tablet_meta->remote_storage_name(), &storage_param); - if (status != OLAP_SUCCESS) { + Status status = _get_storage_param(data_dir, tablet_meta->remote_storage_name(), &storage_param); + if (!status.ok()) { LOG(WARNING) << "fail to _get_storage_param. storage_name: " << tablet_meta->remote_storage_name(); return nullptr; } @@ -435,7 +435,7 @@ TabletSharedPtr TabletManager::_create_tablet_meta_and_dir_unlocked( return nullptr; } -OLAPStatus TabletManager::drop_tablet(TTabletId tablet_id, bool keep_files) { +Status TabletManager::drop_tablet(TTabletId tablet_id, bool keep_files) { std::lock_guard wrlock(_get_tablets_shard_lock(tablet_id)); SCOPED_SWITCH_THREAD_LOCAL_MEM_TRACKER(_mem_tracker); return _drop_tablet_unlocked(tablet_id, keep_files); @@ -449,7 +449,7 @@ OLAPStatus TabletManager::drop_tablet(TTabletId tablet_id, bool keep_files) { // base-tablet cannot be dropped; // b. other cases: // drop specified tablet directly and clear schema change info. -OLAPStatus TabletManager::_drop_tablet_unlocked(TTabletId tablet_id, bool keep_files) { +Status TabletManager::_drop_tablet_unlocked(TTabletId tablet_id, bool keep_files) { LOG(INFO) << "begin drop tablet. tablet_id=" << tablet_id; DorisMetrics::instance()->drop_tablet_requests_total->increment(1); @@ -458,16 +458,16 @@ OLAPStatus TabletManager::_drop_tablet_unlocked(TTabletId tablet_id, bool keep_f if (to_drop_tablet == nullptr) { LOG(WARNING) << "fail to drop tablet because it does not exist. " << "tablet_id=" << tablet_id; - return OLAP_SUCCESS; + return Status::OK(); } return _drop_tablet_directly_unlocked(tablet_id, keep_files); } -OLAPStatus TabletManager::drop_tablets_on_error_root_path( +Status TabletManager::drop_tablets_on_error_root_path( const std::vector& tablet_info_vec) { SCOPED_SWITCH_THREAD_LOCAL_MEM_TRACKER(_mem_tracker); - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); if (tablet_info_vec.empty()) { // This is a high probability event return res; } @@ -673,18 +673,18 @@ TabletSharedPtr TabletManager::find_best_tablet_to_compaction( return best_tablet; } -OLAPStatus TabletManager::load_tablet_from_meta(DataDir* data_dir, TTabletId tablet_id, +Status TabletManager::load_tablet_from_meta(DataDir* data_dir, TTabletId tablet_id, TSchemaHash schema_hash, const string& meta_binary, bool update_meta, bool force, bool restore, bool check_path) { SCOPED_SWITCH_THREAD_LOCAL_MEM_TRACKER(_mem_tracker); TabletMetaSharedPtr tablet_meta(new TabletMeta()); - OLAPStatus status = tablet_meta->deserialize(meta_binary); - if (status != OLAP_SUCCESS) { + Status status = tablet_meta->deserialize(meta_binary); + if (!status.ok()) { LOG(WARNING) << "fail to load tablet because can not parse meta_binary string. " << "tablet_id=" << tablet_id << ", schema_hash=" << schema_hash << ", path=" << data_dir->path(); - return OLAP_ERR_HEADER_PB_PARSE_FAILED; + return Status::OLAPInternalError(OLAP_ERR_HEADER_PB_PARSE_FAILED); } // check if tablet meta is valid @@ -694,12 +694,12 @@ OLAPStatus TabletManager::load_tablet_from_meta(DataDir* data_dir, TTabletId tab << ", schema_hash=" << schema_hash << ")" << ", but meet tablet=" << tablet_meta->full_name() << ", path=" << data_dir->path(); - return OLAP_ERR_HEADER_PB_PARSE_FAILED; + return Status::OLAPInternalError(OLAP_ERR_HEADER_PB_PARSE_FAILED); } if (tablet_meta->tablet_uid().hi == 0 && tablet_meta->tablet_uid().lo == 0) { LOG(WARNING) << "fail to load tablet because its uid == 0. " << "tablet=" << tablet_meta->full_name() << ", path=" << data_dir->path(); - return OLAP_ERR_HEADER_PB_PARSE_FAILED; + return Status::OLAPInternalError(OLAP_ERR_HEADER_PB_PARSE_FAILED); } if (restore) { @@ -715,7 +715,7 @@ OLAPStatus TabletManager::load_tablet_from_meta(DataDir* data_dir, TTabletId tab if (tablet == nullptr) { LOG(WARNING) << "fail to load tablet. tablet_id=" << tablet_id << ", schema_hash:" << schema_hash; - return OLAP_ERR_TABLE_CREATE_FROM_HEADER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_TABLE_CREATE_FROM_HEADER_ERROR); } // NOTE: method load_tablet_from_meta could be called by two cases as below @@ -729,7 +729,7 @@ OLAPStatus TabletManager::load_tablet_from_meta(DataDir* data_dir, TTabletId tab if (check_path && !Env::Default()->path_exists(tablet->tablet_path_desc().filepath).ok()) { LOG(WARNING) << "tablet path not exists, create tablet failed, path=" << tablet->tablet_path_desc().filepath; - return OLAP_ERR_TABLE_ALREADY_DELETED_ERROR; + return Status::OLAPInternalError(OLAP_ERR_TABLE_ALREADY_DELETED_ERROR); } if (tablet_meta->tablet_state() == TABLET_SHUTDOWN) { @@ -739,7 +739,7 @@ OLAPStatus TabletManager::load_tablet_from_meta(DataDir* data_dir, TTabletId tab std::lock_guard shutdown_tablets_wrlock(_shutdown_tablets_lock); _shutdown_tablets.push_back(tablet); } - return OLAP_ERR_TABLE_ALREADY_DELETED_ERROR; + return Status::OLAPInternalError(OLAP_ERR_TABLE_ALREADY_DELETED_ERROR); } // NOTE: We do not check tablet's initial version here, because if BE restarts when // one tablet is doing schema-change, we may meet empty tablet. @@ -747,7 +747,7 @@ OLAPStatus TabletManager::load_tablet_from_meta(DataDir* data_dir, TTabletId tab LOG(WARNING) << "fail to load tablet. it is in running state but without delta. " << "tablet=" << tablet->full_name() << ", path=" << data_dir->path(); // tablet state is invalid, drop tablet - return OLAP_ERR_TABLE_INDEX_VALIDATE_ERROR; + return Status::OLAPInternalError(OLAP_ERR_TABLE_INDEX_VALIDATE_ERROR); } RETURN_NOT_OK_LOG(tablet->init(), @@ -757,10 +757,10 @@ OLAPStatus TabletManager::load_tablet_from_meta(DataDir* data_dir, TTabletId tab RETURN_NOT_OK_LOG(_add_tablet_unlocked(tablet_id, tablet, update_meta, force), strings::Substitute("fail to add tablet. tablet=$0", tablet->full_name())); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus TabletManager::load_tablet_from_dir(DataDir* store, TTabletId tablet_id, +Status TabletManager::load_tablet_from_dir(DataDir* store, TTabletId tablet_id, SchemaHash schema_hash, const string& schema_hash_path, bool force, bool restore) { @@ -784,13 +784,13 @@ OLAPStatus TabletManager::load_tablet_from_dir(DataDir* store, TTabletId tablet_ if (!Env::Default()->path_exists(header_path).ok()) { LOG(WARNING) << "fail to find header file. [header_path=" << header_path << "]"; - return OLAP_ERR_FILE_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_FILE_NOT_EXIST); } TabletMetaSharedPtr tablet_meta(new TabletMeta()); - if (tablet_meta->create_from_file(header_path) != OLAP_SUCCESS) { + if (tablet_meta->create_from_file(header_path) != Status::OK()) { LOG(WARNING) << "fail to load tablet_meta. file_path=" << header_path; - return OLAP_ERR_ENGINE_LOAD_INDEX_TABLE_ERROR; + return Status::OLAPInternalError(OLAP_ERR_ENGINE_LOAD_INDEX_TABLE_ERROR); } // has to change shard id here, because meta file maybe copied from other source // its shard is different from local shard @@ -801,20 +801,20 @@ OLAPStatus TabletManager::load_tablet_from_dir(DataDir* store, TTabletId tablet_ restore, true), strings::Substitute("fail to load tablet. header_path=$0", header_path)); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus TabletManager::report_tablet_info(TTabletInfo* tablet_info) { +Status TabletManager::report_tablet_info(TTabletInfo* tablet_info) { DorisMetrics::instance()->report_tablet_requests_total->increment(1); LOG(INFO) << "begin to process report tablet info." << "tablet_id=" << tablet_info->tablet_id; - OLAPStatus res = OLAP_SUCCESS; + + Status res = Status::OK(); TabletSharedPtr tablet = get_tablet(tablet_info->tablet_id); if (tablet == nullptr) { - LOG(WARNING) << "can't find tablet. " - << " tablet=" << tablet_info->tablet_id; - return OLAP_ERR_TABLE_NOT_FOUND; + LOG(WARNING) << "can't find tablet=" << tablet_info->tablet_id; + return Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); } tablet->build_tablet_report_info(tablet_info); @@ -822,7 +822,7 @@ OLAPStatus TabletManager::report_tablet_info(TTabletInfo* tablet_info) { return res; } -OLAPStatus TabletManager::build_all_report_tablets_info( +Status TabletManager::build_all_report_tablets_info( std::map* tablets_info) { DCHECK(tablets_info != nullptr); LOG(INFO) << "begin to build all report tablets info"; @@ -868,10 +868,10 @@ OLAPStatus TabletManager::build_all_report_tablets_info( DorisMetrics::instance()->tablet_version_num_distribution->set_histogram( tablet_version_num_hist); LOG(INFO) << "success to build all report tablets info. tablet_count=" << tablets_info->size(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus TabletManager::start_trash_sweep() { +Status TabletManager::start_trash_sweep() { { std::vector all_tablets; // we use this vector to save all tablet ptr for saving lock time. @@ -910,9 +910,9 @@ OLAPStatus TabletManager::start_trash_sweep() { continue; } TabletMetaSharedPtr tablet_meta(new TabletMeta()); - OLAPStatus check_st = TabletMetaManager::get_meta((*it)->data_dir(), (*it)->tablet_id(), + Status check_st = TabletMetaManager::get_meta((*it)->data_dir(), (*it)->tablet_id(), (*it)->schema_hash(), tablet_meta); - if (check_st == OLAP_SUCCESS) { + if (check_st.ok()) { if (tablet_meta->tablet_state() != TABLET_SHUTDOWN || tablet_meta->tablet_uid() != (*it)->tablet_uid()) { LOG(WARNING) << "tablet's state changed to normal, skip remove dirs" @@ -932,10 +932,9 @@ OLAPStatus TabletManager::start_trash_sweep() { tablet_path_desc.filepath, std::to_string((*it)->tablet_id()) + ".hdr"); (*it)->tablet_meta()->save(meta_file_path); LOG(INFO) << "start to move tablet to trash. " << tablet_path_desc.debug_string(); - OLAPStatus rm_st = (*it)->data_dir()->move_to_trash(tablet_path_desc); - if (rm_st != OLAP_SUCCESS) { - LOG(WARNING) - << "fail to move dir to trash. " << tablet_path_desc.debug_string(); + Status rm_st = (*it)->data_dir()->move_to_trash(tablet_path_desc); + if (rm_st != Status::OK()) { + LOG(WARNING) << "fail to move dir to trash. " << tablet_path_desc.debug_string(); ++it; continue; } @@ -974,7 +973,7 @@ OLAPStatus TabletManager::start_trash_sweep() { // >= 200 means there may be more tablets need to be handled // So continue } while (clean_num >= 200); - return OLAP_SUCCESS; + return Status::OK(); } // start_trash_sweep void TabletManager::register_clone_tablet(int64_t tablet_id) { @@ -999,9 +998,9 @@ void TabletManager::try_delete_unused_tablet_path(DataDir* data_dir, TTabletId t // check if meta already exists TabletMetaSharedPtr tablet_meta(new TabletMeta()); - OLAPStatus check_st = + Status check_st = TabletMetaManager::get_meta(data_dir, tablet_id, schema_hash, tablet_meta); - if (check_st == OLAP_SUCCESS) { + if (check_st.ok()) { LOG(INFO) << "tablet meta exist is meta store, skip delete the path " << schema_hash_path; return; } @@ -1015,8 +1014,8 @@ void TabletManager::try_delete_unused_tablet_path(DataDir* data_dir, TTabletId t if (Env::Default()->path_exists(schema_hash_path).ok()) { LOG(INFO) << "start to move tablet to trash. tablet_path = " << schema_hash_path; FilePathDesc segment_desc(schema_hash_path); - OLAPStatus rm_st = data_dir->move_to_trash(segment_desc); - if (rm_st != OLAP_SUCCESS) { + Status rm_st = data_dir->move_to_trash(segment_desc); + if (rm_st != Status::OK()) { LOG(WARNING) << "fail to move dir to trash. dir=" << schema_hash_path; } else { LOG(INFO) << "move path " << schema_hash_path << " to trash successfully"; @@ -1086,12 +1085,12 @@ void TabletManager::do_tablet_meta_checkpoint(DataDir* data_dir) { << ", number: " << counter << ", cost(ms): " << cost; } -OLAPStatus TabletManager::_create_initial_rowset_unlocked(const TCreateTabletReq& request, +Status TabletManager::_create_initial_rowset_unlocked(const TCreateTabletReq& request, Tablet* tablet) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); if (request.version < 1) { LOG(WARNING) << "init version of tablet should at least 1. req.ver=" << request.version; - return OLAP_ERR_CE_CMD_PARAMS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CE_CMD_PARAMS_ERROR); } else { Version version(0, request.version); VLOG_NOTICE << "begin to create init version. version=" << version; @@ -1125,26 +1124,26 @@ OLAPStatus TabletManager::_create_initial_rowset_unlocked(const TCreateTabletReq std::unique_ptr builder; res = RowsetFactory::create_rowset_writer(context, &builder); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to init rowset writer for tablet " << tablet->full_name(); break; } res = builder->flush(); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to flush rowset writer for tablet " << tablet->full_name(); break; } new_rowset = builder->build(); res = tablet->add_rowset(new_rowset, false); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to add rowset for tablet " << tablet->full_name(); break; } } while (0); // Unregister index and delete files(index and data) if failed - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to create initial rowset. res=" << res << " version=" << version; StorageEngine::instance()->add_unused_rowset(new_rowset); return res; @@ -1156,7 +1155,7 @@ OLAPStatus TabletManager::_create_initial_rowset_unlocked(const TCreateTabletReq return res; } -OLAPStatus TabletManager::_create_tablet_meta_unlocked(const TCreateTabletReq& request, +Status TabletManager::_create_tablet_meta_unlocked(const TCreateTabletReq& request, DataDir* store, const bool is_schema_change, const Tablet* base_tablet, TabletMetaSharedPtr* tablet_meta) { @@ -1193,7 +1192,7 @@ OLAPStatus TabletManager::_create_tablet_meta_unlocked(const TCreateTabletReq& r // We generate a new tablet_uid for this new tablet. uint64_t shard_id = 0; RETURN_NOT_OK_LOG(store->get_shard(&shard_id), "fail to get root path shard"); - OLAPStatus res = TabletMeta::create(request, TabletUid::gen_uid(), shard_id, next_unique_id, + Status res = TabletMeta::create(request, TabletUid::gen_uid(), shard_id, next_unique_id, col_idx_to_unique_id, tablet_meta); if (request.__isset.storage_format && request.storage_format != TStorageFormat::V1) { @@ -1204,12 +1203,12 @@ OLAPStatus TabletManager::_create_tablet_meta_unlocked(const TCreateTabletReq& r return res; } -OLAPStatus TabletManager::_drop_tablet_directly_unlocked(TTabletId tablet_id, bool keep_files) { +Status TabletManager::_drop_tablet_directly_unlocked(TTabletId tablet_id, bool keep_files) { TabletSharedPtr dropped_tablet = _get_tablet_unlocked(tablet_id); if (dropped_tablet == nullptr) { LOG(WARNING) << "fail to drop tablet because it does not exist. " << " tablet_id=" << tablet_id; - return OLAP_ERR_TABLE_NOT_FOUND; + return Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); } _remove_tablet_from_partition(dropped_tablet); tablet_map_t& tablet_map = _get_tablet_map(tablet_id); @@ -1234,7 +1233,7 @@ OLAPStatus TabletManager::_drop_tablet_directly_unlocked(TTabletId tablet_id, bo } dropped_tablet->deregister_tablet_from_dir(); - return OLAP_SUCCESS; + return Status::OK(); } TabletSharedPtr TabletManager::_get_tablet_unlocked(TTabletId tablet_id) { @@ -1328,15 +1327,15 @@ void TabletManager::get_tablets_distribution_on_different_disks( } } -OLAPStatus TabletManager::_get_storage_param( +Status TabletManager::_get_storage_param( DataDir* data_dir, const std::string& storage_name, StorageParamPB* storage_param) { if (data_dir->is_remote()) { RETURN_WITH_WARN_IF_ERROR(StorageBackendMgr::instance()->get_storage_param(storage_name, storage_param), - OLAP_ERR_OTHER_ERROR, "get_storage_param failed for storage_name: " + storage_name); + Status::OLAPInternalError(OLAP_ERR_OTHER_ERROR), "get_storage_param failed for storage_name: " + storage_name); } else { storage_param->set_storage_medium(fs::fs_util::get_storage_medium_pb(data_dir->storage_medium())); } - return OLAP_SUCCESS; + return Status::OK(); } } // end namespace doris diff --git a/be/src/olap/tablet_manager.h b/be/src/olap/tablet_manager.h index 327e4977ce..65fd3b4eb5 100644 --- a/be/src/olap/tablet_manager.h +++ b/be/src/olap/tablet_manager.h @@ -60,16 +60,16 @@ public: // TODO(lingbin): Other schema-change type do not need to be on the same disk. Because // there may be insufficient space on the current disk, which will lead the schema-change // task to be fail, even if there is enough space on other disks - OLAPStatus create_tablet(const TCreateTabletReq& request, std::vector stores); + Status create_tablet(const TCreateTabletReq& request, std::vector stores); // Drop a tablet by description // If set keep_files == true, files will NOT be deleted when deconstruction. // Return OLAP_SUCCESS, if run ok // OLAP_ERR_TABLE_DELETE_NOEXIST_ERROR, if tablet not exist - // OLAP_ERR_NOT_INITED, if not inited - OLAPStatus drop_tablet(TTabletId tablet_id, bool keep_files = false); + // Status::OLAPInternalError(OLAP_ERR_NOT_INITED), if not inited + Status drop_tablet(TTabletId tablet_id, bool keep_files = false); - OLAPStatus drop_tablets_on_error_root_path(const std::vector& tablet_info_vec); + Status drop_tablets_on_error_root_path(const std::vector& tablet_info_vec); TabletSharedPtr find_best_tablet_to_compaction( CompactionType compaction_type, DataDir* data_dir, @@ -101,24 +101,24 @@ public: // parse tablet header msg to generate tablet object // - restore: whether the request is from restore tablet action, // where we should change tablet status from shutdown back to running - OLAPStatus load_tablet_from_meta(DataDir* data_dir, TTabletId tablet_id, + Status load_tablet_from_meta(DataDir* data_dir, TTabletId tablet_id, TSchemaHash schema_hash, const std::string& header, bool update_meta, bool force = false, bool restore = false, bool check_path = true); - OLAPStatus load_tablet_from_dir(DataDir* data_dir, TTabletId tablet_id, SchemaHash schema_hash, + Status load_tablet_from_dir(DataDir* data_dir, TTabletId tablet_id, SchemaHash schema_hash, const std::string& schema_hash_path, bool force = false, bool restore = false); // 获取所有tables的名字 // // Return OLAP_SUCCESS, if run ok - // OLAP_ERR_INPUT_PARAMETER_ERROR, if tables is null - OLAPStatus report_tablet_info(TTabletInfo* tablet_info); + // Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), if tables is null + Status report_tablet_info(TTabletInfo* tablet_info); - OLAPStatus build_all_report_tablets_info(std::map* tablets_info); + Status build_all_report_tablets_info(std::map* tablets_info); - OLAPStatus start_trash_sweep(); + Status start_trash_sweep(); void try_delete_unused_tablet_path(DataDir* data_dir, TTabletId tablet_id, SchemaHash schema_hash, const std::string& schema_hash_path); @@ -145,19 +145,19 @@ private: // // Return OLAP_SUCCESS, if run ok // OLAP_ERR_TABLE_INSERT_DUPLICATION_ERROR, if find duplication - // OLAP_ERR_NOT_INITED, if not inited - OLAPStatus _add_tablet_unlocked(TTabletId tablet_id, const TabletSharedPtr& tablet, bool update_meta, bool force); + // Status::OLAPInternalError(OLAP_ERR_NOT_INITED), if not inited + Status _add_tablet_unlocked(TTabletId tablet_id, const TabletSharedPtr& tablet, bool update_meta, bool force); - OLAPStatus _add_tablet_to_map_unlocked(TTabletId tablet_id, + Status _add_tablet_to_map_unlocked(TTabletId tablet_id, const TabletSharedPtr& tablet, bool update_meta, bool keep_files, bool drop_old); bool _check_tablet_id_exist_unlocked(TTabletId tablet_id); - OLAPStatus _create_initial_rowset_unlocked(const TCreateTabletReq& request, Tablet* tablet); + Status _create_initial_rowset_unlocked(const TCreateTabletReq& request, Tablet* tablet); - OLAPStatus _drop_tablet_directly_unlocked(TTabletId tablet_id, bool keep_files = false); + Status _drop_tablet_directly_unlocked(TTabletId tablet_id, bool keep_files = false); - OLAPStatus _drop_tablet_unlocked(TTabletId tablet_id, bool keep_files); + Status _drop_tablet_unlocked(TTabletId tablet_id, bool keep_files); TabletSharedPtr _get_tablet_unlocked(TTabletId tablet_id); TabletSharedPtr _get_tablet_unlocked(TTabletId tablet_id, bool include_deleted, std::string* err); @@ -170,7 +170,7 @@ private: const bool is_schema_change, const Tablet* base_tablet, const std::vector& data_dirs); - OLAPStatus _create_tablet_meta_unlocked(const TCreateTabletReq& request, DataDir* store, + Status _create_tablet_meta_unlocked(const TCreateTabletReq& request, DataDir* store, const bool is_schema_change_tablet, const Tablet* base_tablet, TabletMetaSharedPtr* tablet_meta); @@ -181,7 +181,7 @@ private: std::shared_mutex& _get_tablets_shard_lock(TTabletId tabletId); - OLAPStatus _get_storage_param(DataDir* data_dir, const std::string& storage_name, StorageParamPB* storage_param); + Status _get_storage_param(DataDir* data_dir, const std::string& storage_name, StorageParamPB* storage_param); private: DISALLOW_COPY_AND_ASSIGN(TabletManager); diff --git a/be/src/olap/tablet_meta.cpp b/be/src/olap/tablet_meta.cpp index 71b6940b52..060119cae1 100644 --- a/be/src/olap/tablet_meta.cpp +++ b/be/src/olap/tablet_meta.cpp @@ -34,7 +34,7 @@ using std::vector; namespace doris { -OLAPStatus TabletMeta::create(const TCreateTabletReq& request, const TabletUid& tablet_uid, +Status TabletMeta::create(const TCreateTabletReq& request, const TabletUid& tablet_uid, uint64_t shard_id, uint32_t next_unique_id, const unordered_map& col_ordinal_to_unique_id, TabletMetaSharedPtr* tablet_meta) { @@ -44,7 +44,7 @@ OLAPStatus TabletMeta::create(const TCreateTabletReq& request, const TabletUid& col_ordinal_to_unique_id, tablet_uid, request.__isset.tablet_type ? request.tablet_type : TTabletType::TABLET_TYPE_DISK, request.storage_medium, request.storage_param.storage_name)); - return OLAP_SUCCESS; + return Status::OK(); } TabletMeta::TabletMeta() : _tablet_uid(0, 0), _schema(new TabletSchema) {} @@ -212,19 +212,19 @@ void TabletMeta::_init_column_from_tcolumn(uint32_t unique_id, const TColumn& tc } } -OLAPStatus TabletMeta::create_from_file(const string& file_path) { +Status TabletMeta::create_from_file(const string& file_path) { FileHeader file_header; FileHandler file_handler; - if (file_handler.open(file_path, O_RDONLY) != OLAP_SUCCESS) { + if (file_handler.open(file_path, O_RDONLY) != Status::OK()) { LOG(WARNING) << "fail to open ordinal file. file=" << file_path; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } // In file_header.unserialize(), it validates file length, signature, checksum of protobuf. - if (file_header.unserialize(&file_handler) != OLAP_SUCCESS) { + if (file_header.unserialize(&file_handler) != Status::OK()) { LOG(WARNING) << "fail to unserialize tablet_meta. file='" << file_path; - return OLAP_ERR_PARSE_PROTOBUF_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PARSE_PROTOBUF_ERROR); } TabletMetaPB tablet_meta_pb; @@ -232,17 +232,17 @@ OLAPStatus TabletMeta::create_from_file(const string& file_path) { tablet_meta_pb.CopyFrom(file_header.message()); } catch (...) { LOG(WARNING) << "fail to copy protocol buffer object. file='" << file_path; - return OLAP_ERR_PARSE_PROTOBUF_ERROR; + return Status::OLAPInternalError(OLAP_ERR_PARSE_PROTOBUF_ERROR); } init_from_pb(tablet_meta_pb); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus TabletMeta::reset_tablet_uid(const string& header_file) { - OLAPStatus res = OLAP_SUCCESS; +Status TabletMeta::reset_tablet_uid(const string& header_file) { + Status res = Status::OK(); TabletMeta tmp_tablet_meta; - if ((res = tmp_tablet_meta.create_from_file(header_file)) != OLAP_SUCCESS) { + if ((res = tmp_tablet_meta.create_from_file(header_file)) != Status::OK()) { LOG(WARNING) << "fail to load tablet meta from file" << ", meta_file=" << header_file; return res; @@ -251,7 +251,7 @@ OLAPStatus TabletMeta::reset_tablet_uid(const string& header_file) { tmp_tablet_meta.to_meta_pb(&tmp_tablet_meta_pb); *(tmp_tablet_meta_pb.mutable_tablet_uid()) = TabletUid::gen_uid().to_proto(); res = save(header_file, tmp_tablet_meta_pb); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(FATAL) << "fail to save tablet meta pb to " << " meta_file=" << header_file; return res; @@ -266,46 +266,45 @@ std::string TabletMeta::construct_header_file_path(const string& schema_hash_pat return header_name_stream.str(); } -OLAPStatus TabletMeta::save(const string& file_path) { +Status TabletMeta::save(const string& file_path) { TabletMetaPB tablet_meta_pb; to_meta_pb(&tablet_meta_pb); return TabletMeta::save(file_path, tablet_meta_pb); } -OLAPStatus TabletMeta::save(const string& file_path, const TabletMetaPB& tablet_meta_pb) { +Status TabletMeta::save(const string& file_path, const TabletMetaPB& tablet_meta_pb) { DCHECK(!file_path.empty()); FileHeader file_header; FileHandler file_handler; - if (file_handler.open_with_mode(file_path, O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR) != - OLAP_SUCCESS) { + if (!file_handler.open_with_mode(file_path, O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR)) { LOG(WARNING) << "fail to open header file. file='" << file_path; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } try { file_header.mutable_message()->CopyFrom(tablet_meta_pb); } catch (...) { LOG(WARNING) << "fail to copy protocol buffer object. file='" << file_path; - return OLAP_ERR_OTHER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OTHER_ERROR); } - if (file_header.prepare(&file_handler) != OLAP_SUCCESS || - file_header.serialize(&file_handler) != OLAP_SUCCESS) { + if (file_header.prepare(&file_handler) != Status::OK() || + file_header.serialize(&file_handler) != Status::OK()) { LOG(WARNING) << "fail to serialize to file header. file='" << file_path; - return OLAP_ERR_SERIALIZE_PROTOBUF_ERROR; + return Status::OLAPInternalError(OLAP_ERR_SERIALIZE_PROTOBUF_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus TabletMeta::save_meta(DataDir* data_dir) { +Status TabletMeta::save_meta(DataDir* data_dir) { std::lock_guard wrlock(_meta_lock); return _save_meta(data_dir); } -OLAPStatus TabletMeta::_save_meta(DataDir* data_dir) { +Status TabletMeta::_save_meta(DataDir* data_dir) { // check if tablet uid is valid if (_tablet_uid.hi == 0 && _tablet_uid.lo == 0) { LOG(FATAL) << "tablet_uid is invalid" @@ -313,33 +312,33 @@ OLAPStatus TabletMeta::_save_meta(DataDir* data_dir) { } string meta_binary; RETURN_NOT_OK(serialize(&meta_binary)); - OLAPStatus status = TabletMetaManager::save(data_dir, tablet_id(), schema_hash(), meta_binary); - if (status != OLAP_SUCCESS) { + Status status = TabletMetaManager::save(data_dir, tablet_id(), schema_hash(), meta_binary); + if (!status.ok()) { LOG(FATAL) << "fail to save tablet_meta. status=" << status << ", tablet_id=" << tablet_id() << ", schema_hash=" << schema_hash(); } return status; } -OLAPStatus TabletMeta::serialize(string* meta_binary) { +Status TabletMeta::serialize(string* meta_binary) { TabletMetaPB tablet_meta_pb; to_meta_pb(&tablet_meta_pb); bool serialize_success = tablet_meta_pb.SerializeToString(meta_binary); if (!serialize_success) { LOG(FATAL) << "failed to serialize meta " << full_name(); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus TabletMeta::deserialize(const string& meta_binary) { +Status TabletMeta::deserialize(const string& meta_binary) { TabletMetaPB tablet_meta_pb; bool parsed = tablet_meta_pb.ParseFromString(meta_binary); if (!parsed) { LOG(WARNING) << "parse tablet meta failed"; - return OLAP_ERR_INIT_FAILED; + return Status::OLAPInternalError(OLAP_ERR_INIT_FAILED); } init_from_pb(tablet_meta_pb); - return OLAP_SUCCESS; + return Status::OK(); } void TabletMeta::init_from_pb(const TabletMetaPB& tablet_meta_pb) { @@ -475,17 +474,17 @@ Version TabletMeta::max_version() const { return max_version; } -OLAPStatus TabletMeta::add_rs_meta(const RowsetMetaSharedPtr& rs_meta) { +Status TabletMeta::add_rs_meta(const RowsetMetaSharedPtr& rs_meta) { // check RowsetMeta is valid for (auto& rs : _rs_metas) { if (rs->version() == rs_meta->version()) { if (rs->rowset_id() != rs_meta->rowset_id()) { LOG(WARNING) << "version already exist. rowset_id=" << rs->rowset_id() << " version=" << rs->version() << ", tablet=" << full_name(); - return OLAP_ERR_PUSH_VERSION_ALREADY_EXIST; + return Status::OLAPInternalError(OLAP_ERR_PUSH_VERSION_ALREADY_EXIST); } else { // rowsetid,version is equal, it is a duplicate req, skip it - return OLAP_SUCCESS; + return Status::OK(); } } } @@ -495,7 +494,7 @@ OLAPStatus TabletMeta::add_rs_meta(const RowsetMetaSharedPtr& rs_meta) { add_delete_predicate(rs_meta->delete_predicate(), rs_meta->version().first); } - return OLAP_SUCCESS; + return Status::OK(); } void TabletMeta::delete_rs_meta_by_version(const Version& version, @@ -637,13 +636,13 @@ std::string TabletMeta::full_name() const { return ss.str(); } -OLAPStatus TabletMeta::set_partition_id(int64_t partition_id) { +Status TabletMeta::set_partition_id(int64_t partition_id) { if ((_partition_id > 0 && _partition_id != partition_id) || partition_id < 1) { LOG(FATAL) << "cur partition id=" << _partition_id << " new partition id=" << partition_id << " not equal"; } _partition_id = partition_id; - return OLAP_SUCCESS; + return Status::OK(); } bool operator==(const TabletMeta& a, const TabletMeta& b) { diff --git a/be/src/olap/tablet_meta.h b/be/src/olap/tablet_meta.h index 1829ff44ba..b6071fe593 100644 --- a/be/src/olap/tablet_meta.h +++ b/be/src/olap/tablet_meta.h @@ -72,7 +72,7 @@ using TabletMetaSharedPtr = std::shared_ptr; // The concurrency control is handled in Tablet Class, not in this class. class TabletMeta { public: - static OLAPStatus create(const TCreateTabletReq& request, const TabletUid& tablet_uid, + static Status create(const TCreateTabletReq& request, const TabletUid& tablet_uid, uint64_t shard_id, uint32_t next_unique_id, const std::unordered_map& col_ordinal_to_unique_id, TabletMetaSharedPtr* tablet_meta); @@ -91,16 +91,16 @@ public: // Function create_from_file is used to be compatible with previous tablet_meta. // Previous tablet_meta is a physical file in tablet dir, which is not stored in rocksdb. - OLAPStatus create_from_file(const std::string& file_path); - OLAPStatus save(const std::string& file_path); - static OLAPStatus save(const std::string& file_path, const TabletMetaPB& tablet_meta_pb); - static OLAPStatus reset_tablet_uid(const std::string& file_path); + Status create_from_file(const std::string& file_path); + Status save(const std::string& file_path); + static Status save(const std::string& file_path, const TabletMetaPB& tablet_meta_pb); + static Status reset_tablet_uid(const std::string& file_path); static std::string construct_header_file_path(const std::string& schema_hash_path, int64_t tablet_id); - OLAPStatus save_meta(DataDir* data_dir); + Status save_meta(DataDir* data_dir); - OLAPStatus serialize(std::string* meta_binary); - OLAPStatus deserialize(const std::string& meta_binary); + Status serialize(std::string* meta_binary); + Status deserialize(const std::string& meta_binary); void init_from_pb(const TabletMetaPB& tablet_meta_pb); void to_meta_pb(TabletMetaPB* tablet_meta_pb); @@ -137,7 +137,7 @@ public: TabletSchema* mutable_tablet_schema(); const std::vector& all_rs_metas() const; - OLAPStatus add_rs_meta(const RowsetMetaSharedPtr& rs_meta); + Status add_rs_meta(const RowsetMetaSharedPtr& rs_meta); void delete_rs_meta_by_version(const Version& version, std::vector* deleted_rs_metas); // If same_version is true, the rowset in "to_delete" will not be added @@ -159,7 +159,7 @@ public: std::string full_name() const; - OLAPStatus set_partition_id(int64_t partition_id); + Status set_partition_id(int64_t partition_id); RowsetTypePB preferred_rowset_type() const { return _preferred_rowset_type; } @@ -177,7 +177,7 @@ public: } private: - OLAPStatus _save_meta(DataDir* data_dir); + Status _save_meta(DataDir* data_dir); void _init_column_from_tcolumn(uint32_t unique_id, const TColumn& tcolumn, ColumnPB* column); // _del_pred_array is ignored to compare. diff --git a/be/src/olap/tablet_meta_manager.cpp b/be/src/olap/tablet_meta_manager.cpp index 0d57b5d0c1..4a2e612ff5 100644 --- a/be/src/olap/tablet_meta_manager.cpp +++ b/be/src/olap/tablet_meta_manager.cpp @@ -48,19 +48,19 @@ namespace doris { // should use tablet->generate_tablet_meta_copy() method to get a copy of current tablet meta // there are some rowset meta in local meta store and in in-memory tablet meta // but not in tablet meta in local meta store -OLAPStatus TabletMetaManager::get_meta(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, +Status TabletMetaManager::get_meta(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, TabletMetaSharedPtr tablet_meta) { OlapMeta* meta = store->get_meta(); std::stringstream key_stream; key_stream << HEADER_PREFIX << tablet_id << "_" << schema_hash; std::string key = key_stream.str(); std::string value; - OLAPStatus s = meta->get(META_COLUMN_FAMILY_INDEX, key, &value); - if (s == OLAP_ERR_META_KEY_NOT_FOUND) { + Status s = meta->get(META_COLUMN_FAMILY_INDEX, key, &value); + if (s == Status::OLAPInternalError(OLAP_ERR_META_KEY_NOT_FOUND)) { LOG(WARNING) << "tablet_id:" << tablet_id << ", schema_hash:" << schema_hash << " not found."; - return OLAP_ERR_META_KEY_NOT_FOUND; - } else if (s != OLAP_SUCCESS) { + return Status::OLAPInternalError(OLAP_ERR_META_KEY_NOT_FOUND); + } else if (!s.ok()) { LOG(WARNING) << "load tablet_id:" << tablet_id << ", schema_hash:" << schema_hash << " failed."; return s; @@ -68,23 +68,23 @@ OLAPStatus TabletMetaManager::get_meta(DataDir* store, TTabletId tablet_id, TSch return tablet_meta->deserialize(value); } -OLAPStatus TabletMetaManager::get_json_meta(DataDir* store, TTabletId tablet_id, +Status TabletMetaManager::get_json_meta(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, std::string* json_meta) { TabletMetaSharedPtr tablet_meta(new TabletMeta()); - OLAPStatus s = get_meta(store, tablet_id, schema_hash, tablet_meta); - if (s != OLAP_SUCCESS) { + Status s = get_meta(store, tablet_id, schema_hash, tablet_meta); + if (!s.ok()) { return s; } json2pb::Pb2JsonOptions json_options; json_options.pretty_json = true; tablet_meta->to_json(json_meta, json_options); - return OLAP_SUCCESS; + return Status::OK(); } // TODO(ygl): // 1. if term > 0 then save to remote meta store first using term // 2. save to local meta store -OLAPStatus TabletMetaManager::save(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, +Status TabletMetaManager::save(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, TabletMetaSharedPtr tablet_meta, const string& header_prefix) { std::string key = fmt::format("{}{}_{}", header_prefix, tablet_id, schema_hash); std::string value; @@ -94,7 +94,7 @@ OLAPStatus TabletMetaManager::save(DataDir* store, TTabletId tablet_id, TSchemaH return meta->put(META_COLUMN_FAMILY_INDEX, key, value); } -OLAPStatus TabletMetaManager::save(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, +Status TabletMetaManager::save(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, const std::string& meta_binary, const string& header_prefix) { std::string key = fmt::format("{}{}_{}", header_prefix, tablet_id, schema_hash); OlapMeta* meta = store->get_meta(); @@ -105,16 +105,16 @@ OLAPStatus TabletMetaManager::save(DataDir* store, TTabletId tablet_id, TSchemaH // TODO(ygl): // 1. remove load data first // 2. remove from load meta store using term if term > 0 -OLAPStatus TabletMetaManager::remove(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, +Status TabletMetaManager::remove(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, const string& header_prefix) { std::string key = fmt::format("{}{}_{}", header_prefix, tablet_id, schema_hash); OlapMeta* meta = store->get_meta(); - OLAPStatus res = meta->remove(META_COLUMN_FAMILY_INDEX, key); + Status res = meta->remove(META_COLUMN_FAMILY_INDEX, key); VLOG_NOTICE << "remove tablet_meta, key:" << key << ", res:" << res; return res; } -OLAPStatus TabletMetaManager::traverse_headers( +Status TabletMetaManager::traverse_headers( OlapMeta* meta, std::function const& func, const string& header_prefix) { auto traverse_header_func = [&func](const std::string& key, const std::string& value) -> bool { @@ -130,12 +130,12 @@ OLAPStatus TabletMetaManager::traverse_headers( TSchemaHash schema_hash = std::stol(parts[2].c_str(), nullptr, 10); return func(tablet_id, schema_hash, value); }; - OLAPStatus status = + Status status = meta->iterate(META_COLUMN_FAMILY_INDEX, header_prefix, traverse_header_func); return status; } -OLAPStatus TabletMetaManager::load_json_meta(DataDir* store, const std::string& meta_path) { +Status TabletMetaManager::load_json_meta(DataDir* store, const std::string& meta_path) { std::ifstream infile(meta_path); char buffer[102400]; std::string json_meta; @@ -149,7 +149,7 @@ OLAPStatus TabletMetaManager::load_json_meta(DataDir* store, const std::string& bool ret = json2pb::JsonToProtoMessage(json_meta, &tablet_meta_pb, &error); if (!ret) { LOG(ERROR) << "JSON to protobuf message failed: " << error; - return OLAP_ERR_HEADER_LOAD_JSON_HEADER; + return Status::OLAPInternalError(OLAP_ERR_HEADER_LOAD_JSON_HEADER); } std::string meta_binary; diff --git a/be/src/olap/tablet_meta_manager.h b/be/src/olap/tablet_meta_manager.h index 6d65768c2a..0eb4071545 100644 --- a/be/src/olap/tablet_meta_manager.h +++ b/be/src/olap/tablet_meta_manager.h @@ -33,27 +33,27 @@ const std::string HEADER_PREFIX = "tabletmeta_"; // Helper Class for managing tablet headers of one root path. class TabletMetaManager { public: - static OLAPStatus get_meta(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, + static Status get_meta(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, TabletMetaSharedPtr tablet_meta); - static OLAPStatus get_json_meta(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, + static Status get_json_meta(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, std::string* json_meta); - static OLAPStatus save(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, + static Status save(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, TabletMetaSharedPtr tablet_meta, const string& header_prefix = "tabletmeta_"); - static OLAPStatus save(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, + static Status save(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, const std::string& meta_binary, const string& header_prefix = "tabletmeta_"); - static OLAPStatus remove(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, + static Status remove(DataDir* store, TTabletId tablet_id, TSchemaHash schema_hash, const string& header_prefix = "tabletmeta_"); - static OLAPStatus traverse_headers( + static Status traverse_headers( OlapMeta* meta, std::function const& func, const string& header_prefix = "tabletmeta_"); - static OLAPStatus load_json_meta(DataDir* store, const std::string& meta_path); + static Status load_json_meta(DataDir* store, const std::string& meta_path); }; } // namespace doris diff --git a/be/src/olap/tablet_sync_service.cpp b/be/src/olap/tablet_sync_service.cpp deleted file mode 100644 index e71249c5fc..0000000000 --- a/be/src/olap/tablet_sync_service.cpp +++ /dev/null @@ -1,161 +0,0 @@ -// Licensed to the Apache Software Foundation (ASF) under one -// or more contributor license agreements. See the NOTICE file -// distributed with this work for additional information -// regarding copyright ownership. The ASF licenses this file -// to you under the Apache License, Version 2.0 (the -// "License"); you may not use this file except in compliance -// with the License. You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, -// software distributed under the License is distributed on an -// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -// KIND, either express or implied. See the License for the -// specific language governing permissions and limitations -// under the License. - -#include "olap/tablet_sync_service.h" - -using namespace std; - -namespace doris { - -TabletSyncService::TabletSyncService() { - // TODO(ygl): add new config - _fetch_rowset_pool = new BatchProcessThreadPool( - 3, // thread num - 10000, // queue size - 10, // batch size - std::bind(std::mem_fn(&TabletSyncService::_fetch_rowset_meta_thread), this, - std::placeholders::_1)); - - _push_rowset_pool = new BatchProcessThreadPool( - 3, // thread num - 10000, // queue size - 10, // batch size - std::bind(std::mem_fn(&TabletSyncService::_push_rowset_meta_thread), this, - std::placeholders::_1)); - _fetch_tablet_pool = new BatchProcessThreadPool( - 3, // thread num - 10000, // queue size - 10, // batch size - std::bind(std::mem_fn(&TabletSyncService::_fetch_tablet_meta_thread), this, - std::placeholders::_1)); - _push_tablet_pool = new BatchProcessThreadPool( - 3, // thread num - 10000, // queue size - 10, // batch size - std::bind(std::mem_fn(&TabletSyncService::_push_tablet_meta_thread), this, - std::placeholders::_1)); -} - -TabletSyncService::~TabletSyncService() { - if (_fetch_rowset_pool != nullptr) { - delete _fetch_rowset_pool; - } - if (_push_rowset_pool != nullptr) { - delete _push_rowset_pool; - } - if (_fetch_tablet_pool != nullptr) { - delete _fetch_tablet_pool; - } - if (_push_tablet_pool != nullptr) { - delete _push_tablet_pool; - } -} - -// fetch rowset meta and data to local metastore -// when add a task, should check if the task already exist -// if the rowset meta is not published, should commit it to local meta store -// if it is already visible, then just add it to tablet -// tablet_id + txn_id could find a unique rowset -// return a future object, caller could using it to wait the task to finished -// and check the status -std::future TabletSyncService::fetch_rowset(TabletSharedPtr tablet, int64_t txn_id, - bool load_data) { - auto pro = make_shared>(); - FetchRowsetMetaTask fetch_task; - fetch_task.tablet = tablet; - fetch_task.txn_id = txn_id; - fetch_task.load_data = load_data; - fetch_task.pro = pro; - _fetch_rowset_pool->offer(fetch_task); - return pro->get_future(); -} - -// fetch rowset meta and data using version -std::future TabletSyncService::fetch_rowset(TabletSharedPtr tablet, Version& version, - bool load_data) { - auto pro = make_shared>(); - FetchRowsetMetaTask fetch_task; - fetch_task.tablet = tablet; - fetch_task.txn_id = -1; - fetch_task.load_data = load_data; - fetch_task.version = version; - fetch_task.pro = pro; - _fetch_rowset_pool->offer(fetch_task); - return pro->get_future(); -} - -std::future TabletSyncService::push_rowset_meta(RowsetMetaPB& rowset_meta) { - auto pro = make_shared>(); - PushRowsetMetaTask push_task; - push_task.rowset_meta_pb = rowset_meta; - push_task.op_type = MetaOpType::PUSH_META; - push_task.pro = pro; - _push_rowset_pool->offer(push_task); - return pro->get_future(); -} - -std::future TabletSyncService::delete_rowset_meta(RowsetMetaPB& rowset_meta) { - auto pro = make_shared>(); - PushRowsetMetaTask push_task; - push_task.rowset_meta_pb = rowset_meta; - push_task.op_type = MetaOpType::DELETE_META; - push_task.pro = pro; - _push_rowset_pool->offer(push_task); - return pro->get_future(); -} - -// fetch both tablet meta and all rowset meta -// when create a tablet, if it's eco_mode and term > 1 then should fetch -// all rowset and tablet meta from remote meta store -// Maybe, it's better to add a callback function here -std::future TabletSyncService::fetch_tablet_meta(TabletSharedPtr tablet, - bool load_data) { - auto pro = make_shared>(); - FetchTabletMetaTask fetch_task; - fetch_task.tablet = tablet; - fetch_task.load_data = load_data; - fetch_task.pro = pro; - _fetch_tablet_pool->offer(fetch_task); - return pro->get_future(); -} - -std::future TabletSyncService::push_tablet_meta(TabletMetaPB& tablet_meta) { - auto pro = make_shared>(); - PushTabletMetaTask push_task; - push_task.tablet_meta_pb = tablet_meta; - push_task.pro = pro; - _push_tablet_pool->offer(push_task); - return pro->get_future(); -} - -void TabletSyncService::_fetch_rowset_meta_thread(std::vector tasks) { - return; -} - -void TabletSyncService::_push_rowset_meta_thread(std::vector tasks) { - return; -} - -void TabletSyncService::_fetch_tablet_meta_thread(std::vector tasks) { - return; -} - -void TabletSyncService::_push_tablet_meta_thread(std::vector tasks) { - return; -} - -} // namespace doris diff --git a/be/src/olap/tablet_sync_service.h b/be/src/olap/tablet_sync_service.h deleted file mode 100644 index 0784640796..0000000000 --- a/be/src/olap/tablet_sync_service.h +++ /dev/null @@ -1,142 +0,0 @@ -// Licensed to the Apache Software Foundation (ASF) under one -// or more contributor license agreements. See the NOTICE file -// distributed with this work for additional information -// regarding copyright ownership. The ASF licenses this file -// to you under the Apache License, Version 2.0 (the -// "License"); you may not use this file except in compliance -// with the License. You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, -// software distributed under the License is distributed on an -// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -// KIND, either express or implied. See the License for the -// specific language governing permissions and limitations -// under the License. - -#ifndef DORIS_BE_SRC_OLAP_TABLET_SYNC_SERVICE_H -#define DORIS_BE_SRC_OLAP_TABLET_SYNC_SERVICE_H - -#include - -#include "olap/olap_common.h" -#include "olap/olap_define.h" -#include "olap/tablet.h" -#include "util/batch_process_thread_pool.hpp" - -#define FETCH_DATA true -#define NOT_FETCH_DATA false - -namespace doris { - -enum MetaOpType { PUSH_META, DELETE_META }; - -struct FetchRowsetMetaTask { -public: - int priority; - TabletSharedPtr tablet; - int64_t txn_id; - Version version; - bool load_data; - std::shared_ptr> pro; - bool operator<(const FetchRowsetMetaTask& o) const { return priority < o.priority; } - - FetchRowsetMetaTask& operator++() { - priority += 2; - return *this; - } -}; // FetchRowsetMetaTask - -struct PushRowsetMetaTask { -public: - int priority; - MetaOpType op_type; - RowsetMetaPB rowset_meta_pb; - std::shared_ptr> pro; - bool operator<(const PushRowsetMetaTask& o) const { return priority < o.priority; } - - PushRowsetMetaTask& operator++() { - priority += 2; - return *this; - } -}; // PushRowsetMetaTask - -struct FetchTabletMetaTask { -public: - int priority; - TabletSharedPtr tablet; - bool load_data; - std::shared_ptr> pro; - bool operator<(const FetchTabletMetaTask& o) const { return priority < o.priority; } - - FetchTabletMetaTask& operator++() { - priority += 2; - return *this; - } -}; // FetchTabletMetaTask - -struct PushTabletMetaTask { -public: - int priority; - TabletMetaPB tablet_meta_pb; - std::shared_ptr> pro; - bool operator<(const PushTabletMetaTask& o) const { return priority < o.priority; } - - PushTabletMetaTask& operator++() { - priority += 2; - return *this; - } -}; // PushTabletMetaTask - -// sync meta and data from remote meta store to local meta store -// all method should consider dedup duplicate calls -// for example, thread1 call sync meta and thread2 call sync meta, if they are the same -// should not sync twice -class TabletSyncService { -public: - TabletSyncService(); - ~TabletSyncService(); - // fetch rowset meta and data to local metastore - // when add a task, should check if the task already exist - // if the rowset meta is not published, should commit it to local meta store - // if it is already visible, then just add it to tablet - // tablet_id + txn_id could find a unique rowset - // return a future object, caller could using it to wait the task to finished - // and check the status - std::future fetch_rowset(TabletSharedPtr tablet, int64_t txn_id, bool load_data); - - // fetch rowset meta and data using version - std::future fetch_rowset(TabletSharedPtr tablet, Version& version, bool load_data); - - // save the rowset meta pb to remote meta store - // !!!! the caller should not own tablet map lock or tablet lock because - // this method will call tablet manager to get tablet info - std::future push_rowset_meta(RowsetMetaPB& rowset_meta); - - std::future delete_rowset_meta(RowsetMetaPB& rowset_meta); - - // fetch both tablet meta and all rowset meta - // when create a tablet, if it's eco_mode and term > 1 then should fetch - // all rowset and tablet meta from remote meta store - // Maybe, it's better to add a callback function here - std::future fetch_tablet_meta(TabletSharedPtr tablet, bool load_data); - - // save the tablet meta pb to remote meta store - std::future push_tablet_meta(TabletMetaPB& tablet_meta); - -private: - void _fetch_rowset_meta_thread(std::vector tasks); - void _push_rowset_meta_thread(std::vector tasks); - void _fetch_tablet_meta_thread(std::vector tasks); - void _push_tablet_meta_thread(std::vector tasks); - -private: - BatchProcessThreadPool* _fetch_rowset_pool = nullptr; - BatchProcessThreadPool* _push_rowset_pool = nullptr; - BatchProcessThreadPool* _fetch_tablet_pool = nullptr; - BatchProcessThreadPool* _push_tablet_pool = nullptr; -}; // TabletSyncService - -} // namespace doris -#endif // DORIS_BE_SRC_OLAP_TABLET_SYNC_SERVICE_H \ No newline at end of file diff --git a/be/src/olap/task/engine_alter_tablet_task.cpp b/be/src/olap/task/engine_alter_tablet_task.cpp index 228940975f..f8ffec16a4 100644 --- a/be/src/olap/task/engine_alter_tablet_task.cpp +++ b/be/src/olap/task/engine_alter_tablet_task.cpp @@ -35,14 +35,14 @@ EngineAlterTabletTask::EngineAlterTabletTask(const TAlterTabletReqV2& request) StorageEngine::instance()->schema_change_mem_tracker(), MemTrackerLevel::TASK); } -OLAPStatus EngineAlterTabletTask::execute() { +Status EngineAlterTabletTask::execute() { SCOPED_ATTACH_TASK_THREAD(ThreadContext::TaskType::STORAGE, _mem_tracker); DorisMetrics::instance()->create_rollup_requests_total->increment(1); auto schema_change_handler = SchemaChangeHandler::instance(); - OLAPStatus res = schema_change_handler->process_alter_tablet_v2(_alter_tablet_req); + Status res = schema_change_handler->process_alter_tablet_v2(_alter_tablet_req); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to do alter task. res=" << res << " base_tablet_id=" << _alter_tablet_req.base_tablet_id << ", base_schema_hash=" << _alter_tablet_req.base_schema_hash diff --git a/be/src/olap/task/engine_alter_tablet_task.h b/be/src/olap/task/engine_alter_tablet_task.h index 2e022e9ccc..1a2c0b3efa 100644 --- a/be/src/olap/task/engine_alter_tablet_task.h +++ b/be/src/olap/task/engine_alter_tablet_task.h @@ -28,7 +28,7 @@ namespace doris { // add "Engine" as task prefix to prevent duplicate name with agent task class EngineAlterTabletTask : public EngineTask { public: - virtual OLAPStatus execute(); + virtual Status execute(); public: EngineAlterTabletTask(const TAlterTabletReqV2& alter_tablet_request); diff --git a/be/src/olap/task/engine_batch_load_task.cpp b/be/src/olap/task/engine_batch_load_task.cpp index f0fce81bbd..2aabb9852c 100644 --- a/be/src/olap/task/engine_batch_load_task.cpp +++ b/be/src/olap/task/engine_batch_load_task.cpp @@ -60,7 +60,7 @@ EngineBatchLoadTask::EngineBatchLoadTask(TPushReq& push_req, std::vector* tablet_info_vec) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); LOG(INFO) << "begin to process push. " << " transaction_id=" << request.transaction_id << " tablet_id=" << request.tablet_id << ", version=" << request.version; @@ -287,7 +286,7 @@ OLAPStatus EngineBatchLoadTask::_push(const TPushReq& request, if (tablet_info_vec == nullptr) { LOG(WARNING) << "invalid output parameter which is nullptr pointer."; DorisMetrics::instance()->push_requests_fail_total->increment(1); - return OLAP_ERR_CE_CMD_PARAMS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CE_CMD_PARAMS_ERROR); } TabletSharedPtr tablet = StorageEngine::instance()->tablet_manager()->get_tablet( @@ -296,7 +295,7 @@ OLAPStatus EngineBatchLoadTask::_push(const TPushReq& request, LOG(WARNING) << "false to find tablet. tablet=" << request.tablet_id << ", schema_hash=" << request.schema_hash; DorisMetrics::instance()->push_requests_fail_total->increment(1); - return OLAP_ERR_TABLE_NOT_FOUND; + return Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); } PushType type = PUSH_NORMAL; @@ -316,11 +315,11 @@ OLAPStatus EngineBatchLoadTask::_push(const TPushReq& request, } else { { SCOPED_RAW_TIMER(&duration_ns); - res = OLAP_ERR_PUSH_BATCH_PROCESS_REMOVED; + res = Status::OLAPInternalError(OLAP_ERR_PUSH_BATCH_PROCESS_REMOVED); } } - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to push delta, " << "transaction_id=" << request.transaction_id << " tablet=" << tablet->full_name() @@ -339,16 +338,16 @@ OLAPStatus EngineBatchLoadTask::_push(const TPushReq& request, return res; } -OLAPStatus EngineBatchLoadTask::_delete_data(const TPushReq& request, +Status EngineBatchLoadTask::_delete_data(const TPushReq& request, std::vector* tablet_info_vec) { VLOG_DEBUG << "begin to process delete data. request=" << ThriftDebugString(request); DorisMetrics::instance()->delete_requests_total->increment(1); - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); if (tablet_info_vec == nullptr) { LOG(WARNING) << "invalid tablet info parameter which is nullptr pointer."; - return OLAP_ERR_CE_CMD_PARAMS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CE_CMD_PARAMS_ERROR); } // 1. Get all tablets with same tablet_id @@ -357,7 +356,7 @@ OLAPStatus EngineBatchLoadTask::_delete_data(const TPushReq& request, if (tablet == nullptr) { LOG(WARNING) << "can't find tablet. tablet=" << request.tablet_id << ", schema_hash=" << request.schema_hash; - return OLAP_ERR_TABLE_NOT_FOUND; + return Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); } // 2. Process delete data by push interface @@ -366,14 +365,12 @@ OLAPStatus EngineBatchLoadTask::_delete_data(const TPushReq& request, res = push_handler.process_streaming_ingestion(tablet, request, PUSH_FOR_DELETE, tablet_info_vec); } else { - res = OLAP_ERR_PUSH_BATCH_PROCESS_REMOVED; + res = Status::OLAPInternalError(OLAP_ERR_PUSH_BATCH_PROCESS_REMOVED); } - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING( - "fail to push empty version for delete data. " - "[res=%d tablet='%s']", - res, tablet->full_name().c_str()); + if (!res.ok()) { + LOG(WARNING) << "fail to push empty version for delete data. " + << "res=" << res << "tablet=" << tablet->full_name(); DorisMetrics::instance()->delete_requests_failed->increment(1); return res; } diff --git a/be/src/olap/task/engine_batch_load_task.h b/be/src/olap/task/engine_batch_load_task.h index 04805d670b..1f3b41a619 100644 --- a/be/src/olap/task/engine_batch_load_task.h +++ b/be/src/olap/task/engine_batch_load_task.h @@ -43,7 +43,7 @@ public: int64_t signature, Status* res_status); virtual ~EngineBatchLoadTask(); - virtual OLAPStatus execute(); + virtual Status execute(); private: virtual Status _init(); @@ -62,10 +62,10 @@ private: // @param [out] tablet_info_vec return tablet last status, which // include version info, row count, data size, etc // @return OLAP_SUCCESS if submit delete_data success - virtual OLAPStatus _delete_data(const TPushReq& request, vector* tablet_info_vec); + virtual Status _delete_data(const TPushReq& request, vector* tablet_info_vec); Status _get_tmp_file_dir(const std::string& root_path, std::string* local_path); - OLAPStatus _push(const TPushReq& request, std::vector* tablet_info_vec); + Status _push(const TPushReq& request, std::vector* tablet_info_vec); void _get_file_name_from_path(const std::string& file_path, std::string* file_name); bool _is_init = false; diff --git a/be/src/olap/task/engine_checksum_task.cpp b/be/src/olap/task/engine_checksum_task.cpp index d064906241..ae6d5a82b6 100644 --- a/be/src/olap/task/engine_checksum_task.cpp +++ b/be/src/olap/task/engine_checksum_task.cpp @@ -31,21 +31,20 @@ EngineChecksumTask::EngineChecksumTask(TTabletId tablet_id, TSchemaHash schema_h MemTrackerLevel::TASK); } -OLAPStatus EngineChecksumTask::execute() { +Status EngineChecksumTask::execute() { SCOPED_ATTACH_TASK_THREAD(ThreadContext::TaskType::STORAGE, _mem_tracker); - OLAPStatus res = _compute_checksum(); - return res; + return _compute_checksum(); } // execute -OLAPStatus EngineChecksumTask::_compute_checksum() { +Status EngineChecksumTask::_compute_checksum() { LOG(INFO) << "begin to process compute checksum." << "tablet_id=" << _tablet_id << ", schema_hash=" << _schema_hash << ", version=" << _version; - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); if (_checksum == nullptr) { OLAP_LOG_WARNING("invalid output parameter which is null pointer."); - return OLAP_ERR_CE_CMD_PARAMS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_CE_CMD_PARAMS_ERROR); } TabletSharedPtr tablet = @@ -53,7 +52,7 @@ OLAPStatus EngineChecksumTask::_compute_checksum() { if (nullptr == tablet.get()) { OLAP_LOG_WARNING("can't find tablet. [tablet_id=%ld schema_hash=%d]", _tablet_id, _schema_hash); - return OLAP_ERR_TABLE_NOT_FOUND; + return Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); } TupleReader reader; @@ -67,12 +66,12 @@ OLAPStatus EngineChecksumTask::_compute_checksum() { const RowsetSharedPtr message = tablet->rowset_with_max_version(); if (message == nullptr) { LOG(FATAL) << "fail to get latest version. tablet_id=" << _tablet_id; - return OLAP_ERR_VERSION_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_WRITE_PROTOBUF_ERROR); } - OLAPStatus acquire_reader_st = + Status acquire_reader_st = tablet->capture_rs_readers(reader_params.version, &reader_params.rs_readers); - if (acquire_reader_st != OLAP_SUCCESS) { + if (acquire_reader_st != Status::OK()) { LOG(WARNING) << "fail to init reader. tablet=" << tablet->full_name() << "res=" << acquire_reader_st; return acquire_reader_st; @@ -84,8 +83,8 @@ OLAPStatus EngineChecksumTask::_compute_checksum() { } res = reader.init(reader_params); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("initiate reader fail. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "initiate reader fail. res = " << res; return res; } @@ -93,8 +92,8 @@ OLAPStatus EngineChecksumTask::_compute_checksum() { std::unique_ptr mem_pool(new MemPool("EngineChecksumTask:_compute_checksum")); std::unique_ptr agg_object_pool(new ObjectPool()); res = row.init(tablet->tablet_schema(), reader_params.return_columns); - if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("failed to init row cursor. [res=%d]", res); + if (!res.ok()) { + LOG(WARNING) << "failed to init row cursor. res = " << res; return res; } row.allocate_memory_for_string_type(tablet->tablet_schema()); @@ -102,13 +101,13 @@ OLAPStatus EngineChecksumTask::_compute_checksum() { bool eof = false; uint32_t row_checksum = 0; while (true) { - OLAPStatus res = + Status res = reader.next_row_with_aggregation(&row, mem_pool.get(), agg_object_pool.get(), &eof); - if (res == OLAP_SUCCESS && eof) { + if (res.ok() && eof) { VLOG_NOTICE << "reader reads to the end."; break; - } else if (res != OLAP_SUCCESS) { - OLAP_LOG_WARNING("fail to read in reader. [res=%d]", res); + } else if (!res.ok()) { + LOG(WARNING) << "fail to read in reader. res = " << res; return res; } // The value of checksum is independent of the sorting of data rows. @@ -121,7 +120,7 @@ OLAPStatus EngineChecksumTask::_compute_checksum() { LOG(INFO) << "success to finish compute checksum. checksum=" << row_checksum; *_checksum = row_checksum; - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/task/engine_checksum_task.h b/be/src/olap/task/engine_checksum_task.h index 0430c560e9..b96a4328dc 100644 --- a/be/src/olap/task/engine_checksum_task.h +++ b/be/src/olap/task/engine_checksum_task.h @@ -28,7 +28,7 @@ namespace doris { // add "Engine" as task prefix to prevent duplicate name with agent task class EngineChecksumTask : public EngineTask { public: - virtual OLAPStatus execute(); + virtual Status execute(); public: EngineChecksumTask(TTabletId tablet_id, TSchemaHash schema_hash, TVersion version, @@ -37,7 +37,7 @@ public: ~EngineChecksumTask() {} private: - OLAPStatus _compute_checksum(); + Status _compute_checksum(); private: TTabletId _tablet_id; diff --git a/be/src/olap/task/engine_clone_task.cpp b/be/src/olap/task/engine_clone_task.cpp index 4cca849fa1..19e7c89042 100644 --- a/be/src/olap/task/engine_clone_task.cpp +++ b/be/src/olap/task/engine_clone_task.cpp @@ -62,16 +62,16 @@ EngineCloneTask::EngineCloneTask(const TCloneReq& clone_req, const TMasterInfo& StorageEngine::instance()->clone_mem_tracker(), MemTrackerLevel::TASK); } -OLAPStatus EngineCloneTask::execute() { +Status EngineCloneTask::execute() { // register the tablet to avoid it is deleted by gc thread during clone process SCOPED_ATTACH_TASK_THREAD(ThreadContext::TaskType::STORAGE, _mem_tracker); StorageEngine::instance()->tablet_manager()->register_clone_tablet(_clone_req.tablet_id); - OLAPStatus st = _do_clone(); + Status st = _do_clone(); StorageEngine::instance()->tablet_manager()->unregister_clone_tablet(_clone_req.tablet_id); return st; } -OLAPStatus EngineCloneTask::_do_clone() { +Status EngineCloneTask::_do_clone() { Status status = Status::OK(); string src_file_path; TBackend src_host; @@ -83,7 +83,7 @@ OLAPStatus EngineCloneTask::_do_clone() { if (tablet != nullptr) { std::shared_lock migration_rlock(tablet->get_migration_lock(), std::try_to_lock); if (!migration_rlock.owns_lock()) { - return OLAP_ERR_RWLOCK_ERROR; + return Status::OLAPInternalError(OLAP_ERR_RWLOCK_ERROR); } // get download path @@ -100,7 +100,7 @@ OLAPStatus EngineCloneTask::_do_clone() { LOG(INFO) << "missed version size = 0, skip clone and return success. tablet id=" << _clone_req.tablet_id; _set_tablet_info(Status::OK(), is_new_tablet); - return OLAP_SUCCESS; + return Status::OK(); } // try to download missing version from src backend. @@ -118,10 +118,10 @@ OLAPStatus EngineCloneTask::_do_clone() { << ", download snapshot: " << status; if (status.ok()) { - OLAPStatus olap_status = + Status olap_status = _finish_clone(tablet.get(), local_data_path, _clone_req.committed_version, allow_incremental_clone); - if (olap_status != OLAP_SUCCESS) { + if (!olap_status.ok()) { LOG(WARNING) << "failed to finish clone. [table=" << tablet->full_name() << " res=" << olap_status << "]"; _error_msgs->push_back("clone error."); @@ -138,9 +138,9 @@ OLAPStatus EngineCloneTask::_do_clone() { // Get local disk from olap string local_shard_root_path; DataDir* store = nullptr; - OLAPStatus olap_status = StorageEngine::instance()->obtain_shard_path( + Status olap_status = StorageEngine::instance()->obtain_shard_path( _clone_req.storage_medium, &local_shard_root_path, &store); - if (olap_status != OLAP_SUCCESS) { + if (!olap_status.ok()) { LOG(WARNING) << "clone get local root path failed. signature: " << _signature; _error_msgs->push_back("clone get local root path failed."); status = Status::InternalError("Clone to get local root path failed"); @@ -164,17 +164,17 @@ OLAPStatus EngineCloneTask::_do_clone() { << _clone_req.schema_hash; string header_path = TabletMeta::construct_header_file_path( schema_hash_path_stream.str(), _clone_req.tablet_id); - OLAPStatus reset_id_status = TabletMeta::reset_tablet_uid(header_path); - if (reset_id_status != OLAP_SUCCESS) { + Status reset_id_status = TabletMeta::reset_tablet_uid(header_path); + if (reset_id_status != Status::OK()) { LOG(WARNING) << "errors while set tablet uid: '" << header_path; _error_msgs->push_back("errors while set tablet uid."); status = Status::InternalError("Errors while set tablet uid"); } else { - OLAPStatus load_header_status = + Status load_header_status = StorageEngine::instance()->tablet_manager()->load_tablet_from_dir( store, _clone_req.tablet_id, _clone_req.schema_hash, schema_hash_path_stream.str(), false); - if (load_header_status != OLAP_SUCCESS) { + if (load_header_status != Status::OK()) { LOG(WARNING) << "load header failed. local_shard_root_path: '" << local_shard_root_path << "' schema_hash: " << _clone_req.schema_hash @@ -210,7 +210,7 @@ OLAPStatus EngineCloneTask::_do_clone() { } } _set_tablet_info(status, is_new_tablet); - return OLAP_SUCCESS; + return Status::OK(); } void EngineCloneTask::_set_tablet_info(Status status, bool is_new_tablet) { @@ -219,9 +219,9 @@ void EngineCloneTask::_set_tablet_info(Status status, bool is_new_tablet) { TTabletInfo tablet_info; tablet_info.__set_tablet_id(_clone_req.tablet_id); tablet_info.__set_schema_hash(_clone_req.schema_hash); - OLAPStatus get_tablet_info_status = + Status get_tablet_info_status = StorageEngine::instance()->tablet_manager()->report_tablet_info(&tablet_info); - if (get_tablet_info_status != OLAP_SUCCESS) { + if (get_tablet_info_status != Status::OK()) { LOG(WARNING) << "clone success, but get tablet info failed." << " tablet id: " << _clone_req.tablet_id << " schema hash: " << _clone_req.schema_hash @@ -244,9 +244,9 @@ void EngineCloneTask::_set_tablet_info(Status status, bool is_new_tablet) { << ", schema_hash:" << _clone_req.schema_hash << ", signature:" << _signature << ", version:" << tablet_info.version << ", expected_version: " << _clone_req.committed_version; - OLAPStatus drop_status = StorageEngine::instance()->tablet_manager()->drop_tablet( + Status drop_status = StorageEngine::instance()->tablet_manager()->drop_tablet( _clone_req.tablet_id, _clone_req.schema_hash); - if (drop_status != OLAP_SUCCESS && drop_status != OLAP_ERR_TABLE_NOT_FOUND) { + if (drop_status != Status::OK() && drop_status != Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND)) { // just log LOG(WARNING) << "drop stale cloned table failed! tablet id: " << _clone_req.tablet_id; @@ -332,7 +332,7 @@ Status EngineCloneTask::_make_and_download_snapshots(DataDir& data_dir, // change all rowset ids because they maybe its id same with local rowset auto olap_st = SnapshotManager::instance()->convert_rowset_ids( local_path, _clone_req.tablet_id, _clone_req.schema_hash); - if (olap_st != OLAP_SUCCESS) { + if (olap_st != Status::OK()) { LOG(WARNING) << "fail to convert rowset ids, path=" << local_path << ", tablet_id=" << _clone_req.tablet_id << ", schema_hash=" << _clone_req.schema_hash << ", error=" << olap_st; @@ -521,9 +521,9 @@ Status EngineCloneTask::_download_files(DataDir* data_dir, const std::string& re /// This method will do the following things: /// 1. Linke all files from CLONE dir to tablet dir if file does not exist in tablet dir /// 2. Call _finish_xx_clone() to revise the tablet meta. -OLAPStatus EngineCloneTask::_finish_clone(Tablet* tablet, const string& clone_dir, +Status EngineCloneTask::_finish_clone(Tablet* tablet, const string& clone_dir, int64_t committed_version, bool is_incremental_clone) { - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); std::vector linked_success_files; // clone and compaction operation should be performed sequentially { @@ -536,7 +536,7 @@ OLAPStatus EngineCloneTask::_finish_clone(Tablet* tablet, const string& clone_di do { // check clone dir existed if (!FileUtils::check_exist(clone_dir)) { - res = OLAP_ERR_DIR_NOT_EXIST; + res = Status::OLAPInternalError(OLAP_ERR_DIR_NOT_EXIST); LOG(WARNING) << "clone dir not existed when clone. clone_dir=" << clone_dir.c_str(); break; } @@ -547,8 +547,8 @@ OLAPStatus EngineCloneTask::_finish_clone(Tablet* tablet, const string& clone_di string cloned_tablet_meta_file = clone_dir + "/" + std::to_string(tablet->tablet_id()) + ".hdr"; TabletMeta cloned_tablet_meta; - if ((res = cloned_tablet_meta.create_from_file(cloned_tablet_meta_file)) != - OLAP_SUCCESS) { + res = cloned_tablet_meta.create_from_file(cloned_tablet_meta_file); + if (!res.ok()) { LOG(WARNING) << "fail to load src header when clone. " << ", cloned_tablet_meta_file=" << cloned_tablet_meta_file; break; @@ -564,7 +564,7 @@ OLAPStatus EngineCloneTask::_finish_clone(Tablet* tablet, const string& clone_di LOG(WARNING) << "failed to list clone dir when clone. [clone_dir=" << clone_dir << "]" << " error: " << ret.to_string(); - res = OLAP_ERR_DISK_FAILURE; + res = Status::OLAPInternalError(OLAP_ERR_DISK_FAILURE); break; } @@ -575,7 +575,7 @@ OLAPStatus EngineCloneTask::_finish_clone(Tablet* tablet, const string& clone_di LOG(WARNING) << "failed to list local tablet dir when clone. [tablet_dir=" << tablet_dir << "]" << " error: " << ret.to_string(); - res = OLAP_ERR_DISK_FAILURE; + res = Status::OLAPInternalError(OLAP_ERR_DISK_FAILURE); break; } @@ -596,13 +596,13 @@ OLAPStatus EngineCloneTask::_finish_clone(Tablet* tablet, const string& clone_di if (link(from.c_str(), to.c_str()) != 0) { LOG(WARNING) << "fail to create hard link when clone. " << " from=" << from.c_str() << " to=" << to.c_str(); - res = OLAP_ERR_OS_ERROR; + res = Status::OLAPInternalError(OLAP_ERR_OS_ERROR); break; } linked_success_files.emplace_back(std::move(to)); } - if (res != OLAP_SUCCESS) { + if (!res.ok()) { break; } @@ -613,14 +613,14 @@ OLAPStatus EngineCloneTask::_finish_clone(Tablet* tablet, const string& clone_di } // if full clone success, need to update cumulative layer point - if (!is_incremental_clone && res == OLAP_SUCCESS) { + if (!is_incremental_clone && res.ok()) { tablet->set_cumulative_layer_point(Tablet::K_INVALID_CUMULATIVE_POINT); } } while (0); // clear linked files if errors happen - if (res != OLAP_SUCCESS) { + if (!res.ok()) { FileUtils::remove_paths(linked_success_files); } } @@ -635,7 +635,7 @@ OLAPStatus EngineCloneTask::_finish_clone(Tablet* tablet, const string& clone_di /// This method will do: /// 1. Get missing version from local tablet again and check if they exist in cloned tablet. /// 2. Revise the local tablet meta to add all incremental cloned rowset's meta. -OLAPStatus EngineCloneTask::_finish_incremental_clone(Tablet* tablet, +Status EngineCloneTask::_finish_incremental_clone(Tablet* tablet, const TabletMeta& cloned_tablet_meta, int64_t committed_version) { LOG(INFO) << "begin to finish incremental clone. tablet=" << tablet->full_name() @@ -656,7 +656,7 @@ OLAPStatus EngineCloneTask::_finish_incremental_clone(Tablet* tablet, if (rs_meta == nullptr) { LOG(WARNING) << "missed version is not found in cloned tablet meta." << ", missed_version=" << version.first << "-" << version.second; - return OLAP_ERR_VERSION_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_WRITE_PROTOBUF_ERROR); } rowsets_to_clone.push_back(rs_meta); @@ -666,7 +666,7 @@ OLAPStatus EngineCloneTask::_finish_incremental_clone(Tablet* tablet, /// For incremental clone, nothing will be deleted. /// So versions_to_delete is empty. std::vector versions_to_delete; - OLAPStatus clone_res = tablet->revise_tablet_meta(rowsets_to_clone, versions_to_delete); + Status clone_res = tablet->revise_tablet_meta(rowsets_to_clone, versions_to_delete); LOG(INFO) << "finish to incremental clone. [tablet=" << tablet->full_name() << " res=" << clone_res << "]"; return clone_res; @@ -675,7 +675,7 @@ OLAPStatus EngineCloneTask::_finish_incremental_clone(Tablet* tablet, /// This method will do: /// 1. Compare the version of local tablet and cloned tablet to decide which version to keep /// 2. Revise the local tablet meta -OLAPStatus EngineCloneTask::_finish_full_clone(Tablet* tablet, TabletMeta* cloned_tablet_meta) { +Status EngineCloneTask::_finish_full_clone(Tablet* tablet, TabletMeta* cloned_tablet_meta) { Version cloned_max_version = cloned_tablet_meta->max_version(); LOG(INFO) << "begin to finish full clone. tablet=" << tablet->full_name() << ", cloned_max_version=" << cloned_max_version; @@ -711,7 +711,7 @@ OLAPStatus EngineCloneTask::_finish_full_clone(Tablet* tablet, TabletMeta* clone local_version.second > cloned_max_version.second) { LOG(WARNING) << "stop to full clone, version cross src latest." << "tablet=" << tablet->full_name() << ", local_version=" << local_version; - return OLAP_ERR_TABLE_VERSION_DUPLICATE_ERROR; + return Status::OLAPInternalError(OLAP_ERR_TABLE_VERSION_DUPLICATE_ERROR); } else if (local_version.second <= cloned_max_version.second) { // if local version smaller than src, check if existed in src, will not clone it @@ -756,22 +756,23 @@ OLAPStatus EngineCloneTask::_finish_full_clone(Tablet* tablet, TabletMeta* clone // 2. local tablet has error in push // 3. local tablet cloned rowset from other nodes // 4. if cleared alter task info, then push will not write to new tablet, the report info is error - OLAPStatus clone_res = tablet->revise_tablet_meta(rowsets_to_clone, versions_to_delete); + Status clone_res = tablet->revise_tablet_meta(rowsets_to_clone, versions_to_delete); LOG(INFO) << "finish to full clone. tablet=" << tablet->full_name() << ", res=" << clone_res; // in previous step, copy all files from CLONE_DIR to tablet dir // but some rowset is useless, so that remove them here for (auto& rs_meta_ptr : rs_metas_found_in_src) { RowsetSharedPtr rowset_to_remove; - auto s = RowsetFactory::create_rowset(&(cloned_tablet_meta->tablet_schema()), - tablet->tablet_path_desc().filepath, rs_meta_ptr, - &rowset_to_remove); - if (s != OLAP_SUCCESS) { + auto s = + RowsetFactory::create_rowset(&(cloned_tablet_meta->tablet_schema()), + tablet->tablet_path_desc().filepath, rs_meta_ptr, + &rowset_to_remove); + if (!s.ok()) { LOG(WARNING) << "failed to init rowset to remove: " << rs_meta_ptr->rowset_id().to_string(); continue; } s = rowset_to_remove->remove(); - if (s != OLAP_SUCCESS) { + if (!s.ok()) { LOG(WARNING) << "failed to remove rowset " << rs_meta_ptr->rowset_id().to_string() << ", res=" << s; } diff --git a/be/src/olap/task/engine_clone_task.h b/be/src/olap/task/engine_clone_task.h index ecfd0a91ff..dbe0f30611 100644 --- a/be/src/olap/task/engine_clone_task.h +++ b/be/src/olap/task/engine_clone_task.h @@ -32,7 +32,7 @@ namespace doris { // add "Engine" as task prefix to prevent duplicate name with agent task class EngineCloneTask : public EngineTask { public: - virtual OLAPStatus execute(); + virtual Status execute(); public: EngineCloneTask(const TCloneReq& _clone_req, const TMasterInfo& _master_info, @@ -41,15 +41,15 @@ public: ~EngineCloneTask() {} private: - OLAPStatus _do_clone(); + Status _do_clone(); - virtual OLAPStatus _finish_clone(Tablet* tablet, const std::string& clone_dir, + virtual Status _finish_clone(Tablet* tablet, const std::string& clone_dir, int64_t committed_version, bool is_incremental_clone); - OLAPStatus _finish_incremental_clone(Tablet* tablet, const TabletMeta& cloned_tablet_meta, + Status _finish_incremental_clone(Tablet* tablet, const TabletMeta& cloned_tablet_meta, int64_t committed_version); - OLAPStatus _finish_full_clone(Tablet* tablet, TabletMeta* cloned_tablet_meta); + Status _finish_full_clone(Tablet* tablet, TabletMeta* cloned_tablet_meta); Status _make_and_download_snapshots(DataDir& data_dir, const string& local_data_path, TBackend* src_host, string* src_file_path, vector* error_msgs, diff --git a/be/src/olap/task/engine_publish_version_task.cpp b/be/src/olap/task/engine_publish_version_task.cpp index 0e655d9f2f..12bde0ea79 100644 --- a/be/src/olap/task/engine_publish_version_task.cpp +++ b/be/src/olap/task/engine_publish_version_task.cpp @@ -31,8 +31,8 @@ EnginePublishVersionTask::EnginePublishVersionTask(TPublishVersionRequest& publi std::vector* error_tablet_ids) : _publish_version_req(publish_version_req), _error_tablet_ids(error_tablet_ids) {} -OLAPStatus EnginePublishVersionTask::finish() { - OLAPStatus res = OLAP_SUCCESS; +Status EnginePublishVersionTask::finish() { + Status res = Status::OK(); int64_t transaction_id = _publish_version_req.transaction_id; VLOG_NOTICE << "begin to process publish version. transaction_id=" << transaction_id; @@ -57,7 +57,7 @@ OLAPStatus EnginePublishVersionTask::finish() { // each tablet for (auto& tablet_rs : tablet_related_rs) { - OLAPStatus publish_status = OLAP_SUCCESS; + Status publish_status = Status::OK(); TabletInfo tablet_info = tablet_rs.first; RowsetSharedPtr rowset = tablet_rs.second; VLOG_CRITICAL << "begin to publish version on tablet. " @@ -72,7 +72,7 @@ OLAPStatus EnginePublishVersionTask::finish() { LOG(WARNING) << "could not find related rowset for tablet " << tablet_info.tablet_id << " txn id " << transaction_id; _error_tablet_ids->push_back(tablet_info.tablet_id); - res = OLAP_ERR_PUSH_ROWSET_NOT_FOUND; + res = Status::OLAPInternalError(OLAP_ERR_PUSH_ROWSET_NOT_FOUND); continue; } TabletSharedPtr tablet = StorageEngine::instance()->tablet_manager()->get_tablet( @@ -81,13 +81,13 @@ OLAPStatus EnginePublishVersionTask::finish() { LOG(WARNING) << "can't get tablet when publish version. tablet_id=" << tablet_info.tablet_id << " schema_hash=" << tablet_info.schema_hash; _error_tablet_ids->push_back(tablet_info.tablet_id); - res = OLAP_ERR_PUSH_TABLE_NOT_EXIST; + res = Status::OLAPInternalError(OLAP_ERR_PUSH_TABLE_NOT_EXIST); continue; } publish_status = StorageEngine::instance()->txn_manager()->publish_txn( partition_id, tablet, transaction_id, version); - if (publish_status != OLAP_SUCCESS) { + if (publish_status != Status::OK()) { LOG(WARNING) << "failed to publish version. rowset_id=" << rowset->rowset_id() << ", tablet_id=" << tablet_info.tablet_id << ", txn_id=" << transaction_id; @@ -98,8 +98,8 @@ OLAPStatus EnginePublishVersionTask::finish() { // add visible rowset to tablet publish_status = tablet->add_inc_rowset(rowset); - if (publish_status != OLAP_SUCCESS && - publish_status != OLAP_ERR_PUSH_VERSION_ALREADY_EXIST) { + if (publish_status != Status::OK() && + publish_status != Status::OLAPInternalError(OLAP_ERR_PUSH_VERSION_ALREADY_EXIST)) { LOG(WARNING) << "fail to add visible rowset to tablet. rowset_id=" << rowset->rowset_id() << ", tablet_id=" << tablet_info.tablet_id << ", txn_id=" << transaction_id << ", res=" << publish_status; @@ -127,21 +127,7 @@ OLAPStatus EnginePublishVersionTask::finish() { // check if the version exist, if not exist, then set publish failed if (!tablet->check_version_exist(version)) { _error_tablet_ids->push_back(tablet_info.tablet_id); - // generate a pull rowset meta task to pull rowset from remote meta store and storage - // pull rowset meta using tablet_id + txn_id - // it depends on the tablet type to download file or only meta - if (tablet->in_eco_mode()) { - if (tablet->is_primary_replica()) { - // primary replica should fetch the meta using txn id - // it will fetch the rowset to meta store, and will be published in next publish version task - StorageEngine::instance()->tablet_sync_service()->fetch_rowset( - tablet, transaction_id, FETCH_DATA); - } else { - // shadow replica should fetch the meta using version - StorageEngine::instance()->tablet_sync_service()->fetch_rowset( - tablet, version, NOT_FETCH_DATA); - } - } + } } } diff --git a/be/src/olap/task/engine_publish_version_task.h b/be/src/olap/task/engine_publish_version_task.h index 8bf1783ddc..2601ed8f60 100644 --- a/be/src/olap/task/engine_publish_version_task.h +++ b/be/src/olap/task/engine_publish_version_task.h @@ -30,7 +30,7 @@ public: vector* error_tablet_ids); ~EnginePublishVersionTask() {} - virtual OLAPStatus finish() override; + virtual Status finish() override; private: const TPublishVersionRequest& _publish_version_req; diff --git a/be/src/olap/task/engine_storage_migration_task.cpp b/be/src/olap/task/engine_storage_migration_task.cpp index b0deb4595c..2e55fbb6e1 100644 --- a/be/src/olap/task/engine_storage_migration_task.cpp +++ b/be/src/olap/task/engine_storage_migration_task.cpp @@ -34,18 +34,18 @@ EngineStorageMigrationTask::EngineStorageMigrationTask(const TabletSharedPtr& ta _task_start_time = time(nullptr); } -OLAPStatus EngineStorageMigrationTask::execute() { +Status EngineStorageMigrationTask::execute() { return _migrate(); } -OLAPStatus EngineStorageMigrationTask::_get_versions( +Status EngineStorageMigrationTask::_get_versions( int32_t start_version, int32_t* end_version, std::vector* consistent_rowsets) { std::shared_lock rdlock(_tablet->get_header_lock()); const RowsetSharedPtr last_version = _tablet->rowset_with_max_version(); if (last_version == nullptr) { LOG(WARNING) << "failed to get rowset with max version, tablet=" << _tablet->full_name(); - return OLAP_ERR_VERSION_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_WRITE_PROTOBUF_ERROR); } *end_version = last_version->end_version(); @@ -53,15 +53,15 @@ OLAPStatus EngineStorageMigrationTask::_get_versions( // rowsets are empty VLOG_DEBUG << "consistent rowsets empty. tablet=" << _tablet->full_name() << ", start_version=" << start_version << ", end_version=" << *end_version; - return OLAP_SUCCESS; + return Status::OK(); } _tablet->capture_consistent_rowsets(Version(start_version, *end_version), consistent_rowsets); if (consistent_rowsets->empty()) { LOG(WARNING) << "fail to capture consistent rowsets. tablet=" << _tablet->full_name() << ", version=" << *end_version; - return OLAP_ERR_VERSION_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_WRITE_PROTOBUF_ERROR); } - return OLAP_SUCCESS; + return Status::OK(); } bool EngineStorageMigrationTask::_is_timeout() { @@ -74,7 +74,7 @@ bool EngineStorageMigrationTask::_is_timeout() { return false; } -OLAPStatus EngineStorageMigrationTask::_check_running_txns() { +Status EngineStorageMigrationTask::_check_running_txns() { // need hold migration lock outside int64_t partition_id; std::set transaction_ids; @@ -83,23 +83,23 @@ OLAPStatus EngineStorageMigrationTask::_check_running_txns() { _tablet->tablet_id(), _tablet->schema_hash(), _tablet->tablet_uid(), &partition_id, &transaction_ids); if (transaction_ids.size() > 0) { - return OLAP_ERR_HEADER_HAS_PENDING_DATA; + return Status::OLAPInternalError(OLAP_ERR_HEADER_HAS_PENDING_DATA); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus EngineStorageMigrationTask::_check_running_txns_until_timeout( +Status EngineStorageMigrationTask::_check_running_txns_until_timeout( std::unique_lock* migration_wlock) { // caller should not hold migration lock, and 'migration_wlock' should not be nullptr // ownership of the migration_wlock is transferred to the caller if check succ DCHECK_NE(migration_wlock, nullptr); - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); int try_times = 1; do { // to avoid invalid loops, the lock is guaranteed to be acquired here std::unique_lock wlock(_tablet->get_migration_lock()); res = _check_running_txns(); - if (res == OLAP_SUCCESS) { + if (res.ok()) { // transfer the lock to the caller *migration_wlock = std::move(wlock); return res; @@ -115,11 +115,11 @@ OLAPStatus EngineStorageMigrationTask::_check_running_txns_until_timeout( return res; } -OLAPStatus EngineStorageMigrationTask::_gen_and_write_header_to_hdr_file( +Status EngineStorageMigrationTask::_gen_and_write_header_to_hdr_file( uint64_t shard, const std::string& full_path, const std::vector& consistent_rowsets) { // need hold migration lock and push lock outside - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); int64_t tablet_id = _tablet->tablet_id(); int32_t schema_hash = _tablet->schema_hash(); TabletMetaSharedPtr new_tablet_meta(new (std::nothrow) TabletMeta()); @@ -129,21 +129,21 @@ OLAPStatus EngineStorageMigrationTask::_gen_and_write_header_to_hdr_file( } std::string new_meta_file = full_path + "/" + std::to_string(tablet_id) + ".hdr"; res = new_tablet_meta->save(new_meta_file); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to save meta to path: " << new_meta_file; return res; } // reset tablet id and rowset id res = TabletMeta::reset_tablet_uid(new_meta_file); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "errors while set tablet uid: '" << new_meta_file; return res; } // it will change rowset id and its create time // rowset create time is useful when load tablet from meta to check which tablet is the tablet to load res = SnapshotManager::instance()->convert_rowset_ids(full_path, tablet_id, schema_hash); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to convert rowset id when do storage migration" << " path = " << full_path; return res; @@ -151,14 +151,14 @@ OLAPStatus EngineStorageMigrationTask::_gen_and_write_header_to_hdr_file( return res; } -OLAPStatus EngineStorageMigrationTask::_reload_tablet(const std::string& full_path) { +Status EngineStorageMigrationTask::_reload_tablet(const std::string& full_path) { // need hold migration lock and push lock outside - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); int64_t tablet_id = _tablet->tablet_id(); int32_t schema_hash = _tablet->schema_hash(); res = StorageEngine::instance()->tablet_manager()->load_tablet_from_dir( _dest_store, tablet_id, schema_hash, full_path, false); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "failed to load tablet from new path. tablet_id=" << tablet_id << " schema_hash=" << schema_hash << " path = " << full_path; return res; @@ -170,7 +170,7 @@ OLAPStatus EngineStorageMigrationTask::_reload_tablet(const std::string& full_pa StorageEngine::instance()->tablet_manager()->get_tablet(tablet_id); if (new_tablet == nullptr) { LOG(WARNING) << "tablet not found. tablet_id=" << tablet_id; - return OLAP_ERR_TABLE_NOT_FOUND; + return Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); } return res; } @@ -188,7 +188,7 @@ bool EngineStorageMigrationTask::_is_rowsets_size_less_than_threshold( return false; } -OLAPStatus EngineStorageMigrationTask::_migrate() { +Status EngineStorageMigrationTask::_migrate() { int64_t tablet_id = _tablet->tablet_id(); LOG(INFO) << "begin to process tablet migrate. " << "tablet_id=" << tablet_id << ", dest_store=" << _dest_store->path(); @@ -199,19 +199,19 @@ OLAPStatus EngineStorageMigrationTask::_migrate() { std::vector consistent_rowsets; // try hold migration lock first - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); uint64_t shard = 0; string full_path; { std::unique_lock migration_wlock(_tablet->get_migration_lock(), std::try_to_lock); if (!migration_wlock.owns_lock()) { - return OLAP_ERR_RWLOCK_ERROR; + return Status::OLAPInternalError(OLAP_ERR_RWLOCK_ERROR); } // check if this tablet has related running txns. if yes, can not do migration. res = _check_running_txns(); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "could not migration because has unfinished txns, " << " tablet=" << _tablet->full_name(); return res; @@ -220,13 +220,13 @@ OLAPStatus EngineStorageMigrationTask::_migrate() { std::lock_guard lock(_tablet->get_push_lock()); // get versions to be migrate res = _get_versions(start_version, &end_version, &consistent_rowsets); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { return res; } // TODO(ygl): the tablet should not under schema change or rollup or load res = _dest_store->get_shard(&shard); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to get shard from store: " << _dest_store->path(); return res; } @@ -240,12 +240,12 @@ OLAPStatus EngineStorageMigrationTask::_migrate() { if (FileUtils::check_exist(full_path)) { LOG(INFO) << "schema hash path already exist, skip this path. " << "full_path=" << full_path; - return OLAP_ERR_FILE_ALREADY_EXIST; + return Status::OLAPInternalError(OLAP_ERR_FILE_ALREADY_EXIST); } Status st = FileUtils::create_dir(full_path); if (!st.ok()) { - res = OLAP_ERR_CANNOT_CREATE_DIR; + res = Status::OLAPInternalError(OLAP_ERR_CANNOT_CREATE_DIR); LOG(WARNING) << "fail to create path. path=" << full_path << ", error:" << st.to_string(); return res; @@ -256,13 +256,13 @@ OLAPStatus EngineStorageMigrationTask::_migrate() { do { // migrate all index and data files but header file res = _copy_index_and_data_files(full_path, temp_consistent_rowsets); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to copy index and data files when migrate. res=" << res; break; } std::unique_lock migration_wlock; res = _check_running_txns_until_timeout(&migration_wlock); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { break; } std::lock_guard lock(_tablet->get_push_lock()); @@ -271,7 +271,7 @@ OLAPStatus EngineStorageMigrationTask::_migrate() { temp_consistent_rowsets.clear(); // get remaining versions res = _get_versions(end_version + 1, &end_version, &temp_consistent_rowsets); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { break; } if (start_version < end_version) { @@ -285,15 +285,13 @@ OLAPStatus EngineStorageMigrationTask::_migrate() { if (_is_rowsets_size_less_than_threshold(temp_consistent_rowsets)) { // force to copy the remaining data and index res = _copy_index_and_data_files(full_path, temp_consistent_rowsets); - if (res != OLAP_SUCCESS) { - LOG(WARNING) - << "fail to copy the remaining index and data files when migrate. res=" - << res; + if (!res.ok()) { + LOG(WARNING) << "fail to copy the remaining index and data files when migrate. res=" << res; break; } } else { if (_is_timeout()) { - res = OLAP_ERR_HEADER_HAS_PENDING_DATA; + res = Status::OLAPInternalError(OLAP_ERR_HEADER_HAS_PENDING_DATA); break; } // there is too much remaining data here. @@ -304,18 +302,18 @@ OLAPStatus EngineStorageMigrationTask::_migrate() { // generate new tablet meta and write to hdr file res = _gen_and_write_header_to_hdr_file(shard, full_path, consistent_rowsets); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { break; } res = _reload_tablet(full_path); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { break; } break; } while (true); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { // we should remove the dir directly for avoid disk full of junk data, and it's safe to remove FileUtils::remove_all(full_path); } @@ -339,12 +337,12 @@ void EngineStorageMigrationTask::_generate_new_header( // remove old meta after the new tablet is loaded successfully } -OLAPStatus EngineStorageMigrationTask::_copy_index_and_data_files( +Status EngineStorageMigrationTask::_copy_index_and_data_files( const string& full_path, const std::vector& consistent_rowsets) const { - OLAPStatus status = OLAP_SUCCESS; + Status status = Status::OK(); for (const auto& rs : consistent_rowsets) { status = rs->copy_files_to(full_path); - if (status != OLAP_SUCCESS) { + if (!status.ok()) { Status ret = FileUtils::remove_all(full_path); if (!ret.ok()) { LOG(FATAL) << "remove storage migration path failed. " diff --git a/be/src/olap/task/engine_storage_migration_task.h b/be/src/olap/task/engine_storage_migration_task.h index 0d67ca5b67..2c163e7297 100644 --- a/be/src/olap/task/engine_storage_migration_task.h +++ b/be/src/olap/task/engine_storage_migration_task.h @@ -28,32 +28,32 @@ namespace doris { // Usually used for storage medium migration, or migration of tablets between disks. class EngineStorageMigrationTask : public EngineTask { public: - virtual OLAPStatus execute(); + virtual Status execute(); public: EngineStorageMigrationTask(const TabletSharedPtr& tablet, DataDir* dest_store); ~EngineStorageMigrationTask() {} private: - OLAPStatus _migrate(); + Status _migrate(); // check if task is timeout bool _is_timeout(); - OLAPStatus _get_versions(int32_t start_version, int32_t* end_version, + Status _get_versions(int32_t start_version, int32_t* end_version, std::vector* consistent_rowsets); - OLAPStatus _check_running_txns(); + Status _check_running_txns(); // caller should not hold migration lock, and 'migration_wlock' should not be nullptr // ownership of the migration lock is transferred to the caller if check succ - OLAPStatus _check_running_txns_until_timeout( + Status _check_running_txns_until_timeout( std::unique_lock* migration_wlock); // if the size less than threshold, return true bool _is_rowsets_size_less_than_threshold( const std::vector& consistent_rowsets); - OLAPStatus _gen_and_write_header_to_hdr_file( + Status _gen_and_write_header_to_hdr_file( uint64_t shard, const std::string& full_path, const std::vector& consistent_rowsets); - OLAPStatus _reload_tablet(const std::string& full_path); + Status _reload_tablet(const std::string& full_path); void _generate_new_header(uint64_t new_shard, const std::vector& consistent_rowsets, @@ -61,7 +61,7 @@ private: // TODO: hkp // rewrite this function - OLAPStatus _copy_index_and_data_files( + Status _copy_index_and_data_files( const std::string& full_path, const std::vector& consistent_rowsets) const; diff --git a/be/src/olap/task/engine_task.h b/be/src/olap/task/engine_task.h index cbfd914ad1..6e5e146f65 100644 --- a/be/src/olap/task/engine_task.h +++ b/be/src/olap/task/engine_task.h @@ -32,10 +32,10 @@ namespace doris { class EngineTask { public: // use olap_status not agent_status, because the task is very close to engine - virtual OLAPStatus prepare() { return OLAP_SUCCESS; } - virtual OLAPStatus execute() { return OLAP_SUCCESS; } - virtual OLAPStatus finish() { return OLAP_SUCCESS; } - virtual OLAPStatus cancel() { return OLAP_SUCCESS; } + virtual Status prepare() { return Status::OK(); } + virtual Status execute() { return Status::OK(); } + virtual Status finish() { return Status::OK(); } + virtual Status cancel() { return Status::OK(); } virtual void get_related_tablets(std::vector* tablet_infos) {} }; diff --git a/be/src/olap/tuple_reader.cpp b/be/src/olap/tuple_reader.cpp index 93ba2513d9..bfb05a2001 100644 --- a/be/src/olap/tuple_reader.cpp +++ b/be/src/olap/tuple_reader.cpp @@ -38,12 +38,12 @@ using std::vector; namespace doris { -OLAPStatus TupleReader::_init_collect_iter(const ReaderParams& read_params, +Status TupleReader::_init_collect_iter(const ReaderParams& read_params, std::vector* valid_rs_readers) { _collect_iter.init(this); std::vector rs_readers; auto res = _capture_rs_readers(read_params, &rs_readers); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to init reader when _capture_rs_readers. res:" << res << ", tablet_id:" << read_params.tablet->tablet_id() << ", schema_hash:" << read_params.tablet->schema_hash() @@ -54,32 +54,32 @@ OLAPStatus TupleReader::_init_collect_iter(const ReaderParams& read_params, for (auto& rs_reader : rs_readers) { RETURN_NOT_OK(rs_reader->init(&_reader_context)); - OLAPStatus res = _collect_iter.add_child(rs_reader); - if (res != OLAP_SUCCESS && res != OLAP_ERR_DATA_EOF) { + Status res = _collect_iter.add_child(rs_reader); + if (!res.ok() && res != Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { LOG(WARNING) << "failed to add child to iterator, err=" << res; return res; } - if (res == OLAP_SUCCESS) { + if (res.ok()) { valid_rs_readers->push_back(rs_reader); } } _collect_iter.build_heap(*valid_rs_readers); _next_key = _collect_iter.current_row(&_next_delete_flag); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus TupleReader::init(const ReaderParams& read_params) { +Status TupleReader::init(const ReaderParams& read_params) { TabletReader::init(read_params); std::vector rs_readers; auto status = _init_collect_iter(read_params, &rs_readers); - if (status != OLAP_SUCCESS) { return status; } + if (!status.ok()) { return status; } if (_optimize_for_single_rowset(rs_readers)) { _next_row_func = _tablet->keys_type() == AGG_KEYS ? &TupleReader::_direct_agg_key_next_row : &TupleReader::_direct_next_row; - return OLAP_SUCCESS; + return Status::OK(); } switch (_tablet->keys_type()) { @@ -97,55 +97,55 @@ OLAPStatus TupleReader::init(const ReaderParams& read_params) { break; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus TupleReader::_direct_next_row(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, +Status TupleReader::_direct_next_row(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof) { if (UNLIKELY(_next_key == nullptr)) { *eof = true; - return OLAP_SUCCESS; + return Status::OK(); } direct_copy_row(row_cursor, *_next_key); auto res = _collect_iter.next(&_next_key, &_next_delete_flag); - if (UNLIKELY(res != OLAP_SUCCESS && res != OLAP_ERR_DATA_EOF)) { + if (UNLIKELY(!res.ok() && res != Status::OLAPInternalError(OLAP_ERR_DATA_EOF))) { return res; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus TupleReader::_direct_agg_key_next_row(RowCursor* row_cursor, MemPool* mem_pool, +Status TupleReader::_direct_agg_key_next_row(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof) { if (UNLIKELY(_next_key == nullptr)) { *eof = true; - return OLAP_SUCCESS; + return Status::OK(); } init_row_with_others(row_cursor, *_next_key, mem_pool, agg_pool); auto res = _collect_iter.next(&_next_key, &_next_delete_flag); - if (UNLIKELY(res != OLAP_SUCCESS && res != OLAP_ERR_DATA_EOF)) { + if (UNLIKELY(!res.ok() && res != Status::OLAPInternalError(OLAP_ERR_DATA_EOF))) { return res; } if (_need_agg_finalize) { agg_finalize_row(_value_cids, row_cursor, mem_pool); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus TupleReader::_agg_key_next_row(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, +Status TupleReader::_agg_key_next_row(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof) { if (UNLIKELY(_next_key == nullptr)) { *eof = true; - return OLAP_SUCCESS; + return Status::OK(); } init_row_with_others(row_cursor, *_next_key, mem_pool, agg_pool); int64_t merged_count = 0; do { auto res = _collect_iter.next(&_next_key, &_next_delete_flag); - if (UNLIKELY(res == OLAP_ERR_DATA_EOF)) { + if (UNLIKELY(res == Status::OLAPInternalError(OLAP_ERR_DATA_EOF))) { break; } - if (UNLIKELY(res != OLAP_SUCCESS)) { + if (UNLIKELY(!res.ok())) { LOG(WARNING) << "next failed: " << res; return res; } @@ -167,17 +167,17 @@ OLAPStatus TupleReader::_agg_key_next_row(RowCursor* row_cursor, MemPool* mem_po agg_finalize_row(_value_cids, row_cursor, mem_pool); } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus TupleReader::_unique_key_next_row(RowCursor* row_cursor, MemPool* mem_pool, +Status TupleReader::_unique_key_next_row(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof) { *eof = false; bool cur_delete_flag = false; do { if (UNLIKELY(_next_key == nullptr)) { *eof = true; - return OLAP_SUCCESS; + return Status::OK(); } cur_delete_flag = _next_delete_flag; // the version is in reverse order, the first row is the highest version, @@ -186,8 +186,8 @@ OLAPStatus TupleReader::_unique_key_next_row(RowCursor* row_cursor, MemPool* mem direct_copy_row(row_cursor, *_next_key); // skip the lower version rows; auto res = _collect_iter.next(&_next_key, &_next_delete_flag); - if (LIKELY(res != OLAP_ERR_DATA_EOF)) { - if (UNLIKELY(res != OLAP_SUCCESS)) { + if (LIKELY(res != Status::OLAPInternalError(OLAP_ERR_DATA_EOF))) { + if (UNLIKELY(!res.ok())) { LOG(WARNING) << "next failed: " << res; return res; } @@ -202,7 +202,7 @@ OLAPStatus TupleReader::_unique_key_next_row(RowCursor* row_cursor, MemPool* mem } _stats.rows_del_filtered++; } while (cur_delete_flag); - return OLAP_SUCCESS; + return Status::OK(); } } // namespace doris diff --git a/be/src/olap/tuple_reader.h b/be/src/olap/tuple_reader.h index c03c04471b..f5b45a87ea 100644 --- a/be/src/olap/tuple_reader.h +++ b/be/src/olap/tuple_reader.h @@ -50,9 +50,9 @@ class RowCursor; class TupleReader final : public TabletReader { public: // Initialize TupleReader with tablet, data version and fetch range. - OLAPStatus init(const ReaderParams& read_params) override; + Status init(const ReaderParams& read_params) override; - OLAPStatus next_row_with_aggregation(RowCursor* row_cursor, MemPool* mem_pool, + Status next_row_with_aggregation(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof) override { return (this->*_next_row_func)(row_cursor, mem_pool, agg_pool, eof); } @@ -63,28 +63,28 @@ private: // Direcly read row from rowset and pass to upper caller. No need to do aggregation. // This is usually used for DUPLICATE KEY tables - OLAPStatus _direct_next_row(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, + Status _direct_next_row(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof); // Just same as _direct_next_row, but this is only for AGGREGATE KEY tables. // And this is an optimization for AGGR tables. // When there is only one rowset and is not overlapping, we can read it directly without aggregation. - OLAPStatus _direct_agg_key_next_row(RowCursor* row_cursor, MemPool* mem_pool, + Status _direct_agg_key_next_row(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof); // For normal AGGREGATE KEY tables, read data by a merge heap. - OLAPStatus _agg_key_next_row(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, + Status _agg_key_next_row(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof); // For UNIQUE KEY tables, read data by a merge heap. // The difference from _agg_key_next_row is that it will read the data from high version to low version, // to minimize the comparison time in merge heap. - OLAPStatus _unique_key_next_row(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, + Status _unique_key_next_row(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof); - OLAPStatus _init_collect_iter(const ReaderParams& read_params, std::vector* valid_rs_readers ); + Status _init_collect_iter(const ReaderParams& read_params, std::vector* valid_rs_readers ); private: const RowCursor* _next_key = nullptr; - OLAPStatus (TupleReader::*_next_row_func)(RowCursor* row_cursor, MemPool* mem_pool, + Status (TupleReader::*_next_row_func)(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof) = nullptr; }; diff --git a/be/src/olap/txn_manager.cpp b/be/src/olap/txn_manager.cpp index f7b994beb2..fbf1a121fb 100644 --- a/be/src/olap/txn_manager.cpp +++ b/be/src/olap/txn_manager.cpp @@ -82,13 +82,13 @@ TxnManager::TxnManager(int32_t txn_map_shard_size, int32_t txn_shard_size) _txn_mutex = new std::mutex[_txn_shard_size]; } -OLAPStatus TxnManager::prepare_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, +Status TxnManager::prepare_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, TTransactionId transaction_id, const PUniqueId& load_id) { return prepare_txn(partition_id, transaction_id, tablet->tablet_id(), tablet->schema_hash(), tablet->tablet_uid(), load_id); } -OLAPStatus TxnManager::commit_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, +Status TxnManager::commit_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, TTransactionId transaction_id, const PUniqueId& load_id, const RowsetSharedPtr& rowset_ptr, bool is_recovery) { return commit_txn(tablet->data_dir()->get_meta(), partition_id, transaction_id, @@ -96,20 +96,20 @@ OLAPStatus TxnManager::commit_txn(TPartitionId partition_id, const TabletSharedP rowset_ptr, is_recovery); } -OLAPStatus TxnManager::publish_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, +Status TxnManager::publish_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, TTransactionId transaction_id, const Version& version) { return publish_txn(tablet->data_dir()->get_meta(), partition_id, transaction_id, tablet->tablet_id(), tablet->schema_hash(), tablet->tablet_uid(), version); } // delete the txn from manager if it is not committed(not have a valid rowset) -OLAPStatus TxnManager::rollback_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, +Status TxnManager::rollback_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, TTransactionId transaction_id) { return rollback_txn(partition_id, transaction_id, tablet->tablet_id(), tablet->schema_hash(), tablet->tablet_uid()); } -OLAPStatus TxnManager::delete_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, +Status TxnManager::delete_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, TTransactionId transaction_id) { return delete_txn(tablet->data_dir()->get_meta(), partition_id, transaction_id, tablet->tablet_id(), tablet->schema_hash(), tablet->tablet_uid()); @@ -118,7 +118,7 @@ OLAPStatus TxnManager::delete_txn(TPartitionId partition_id, const TabletSharedP // prepare txn should always be allowed because ingest task will be retried // could not distinguish rollup, schema change or base table, prepare txn successfully will allow // ingest retried -OLAPStatus TxnManager::prepare_txn(TPartitionId partition_id, TTransactionId transaction_id, +Status TxnManager::prepare_txn(TPartitionId partition_id, TTransactionId transaction_id, TTabletId tablet_id, SchemaHash schema_hash, TabletUid tablet_uid, const PUniqueId& load_id) { TxnKey key(partition_id, transaction_id); @@ -138,7 +138,7 @@ OLAPStatus TxnManager::prepare_txn(TPartitionId partition_id, TTransactionId tra LOG(WARNING) << "find transaction exists when add to engine." << "partition_id: " << key.first << ", transaction_id: " << key.second << ", tablet: " << tablet_info.to_string(); - return OLAP_SUCCESS; + return Status::OK(); } } } @@ -149,7 +149,7 @@ OLAPStatus TxnManager::prepare_txn(TPartitionId partition_id, TTransactionId tra if (txn_partition_map.size() > config::max_runnings_transactions_per_txn_map) { LOG(WARNING) << "too many transactions: " << txn_tablet_map.size() << ", limit: " << config::max_runnings_transactions_per_txn_map; - return OLAP_ERR_TOO_MANY_TRANSACTIONS; + return Status::OLAPInternalError(OLAP_ERR_TOO_MANY_TRANSACTIONS); } // not found load id @@ -162,10 +162,10 @@ OLAPStatus TxnManager::prepare_txn(TPartitionId partition_id, TTransactionId tra VLOG_NOTICE << "add transaction to engine successfully." << "partition_id: " << key.first << ", transaction_id: " << key.second << ", tablet: " << tablet_info.to_string(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus TxnManager::commit_txn(OlapMeta* meta, TPartitionId partition_id, +Status TxnManager::commit_txn(OlapMeta* meta, TPartitionId partition_id, TTransactionId transaction_id, TTabletId tablet_id, SchemaHash schema_hash, TabletUid tablet_uid, const PUniqueId& load_id, const RowsetSharedPtr& rowset_ptr, @@ -181,7 +181,7 @@ OLAPStatus TxnManager::commit_txn(OlapMeta* meta, TPartitionId partition_id, LOG(WARNING) << "could not commit txn because rowset ptr is null. " << "partition_id: " << key.first << ", transaction_id: " << key.second << ", tablet: " << tablet_info.to_string(); - return OLAP_ERR_ROWSET_INVALID; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_INVALID); } std::unique_lock txn_lock(_get_txn_lock(transaction_id)); @@ -205,7 +205,7 @@ OLAPStatus TxnManager::commit_txn(OlapMeta* meta, TPartitionId partition_id, << "partition_id: " << key.first << ", transaction_id: " << key.second << ", tablet: " << tablet_info.to_string() << ", rowset_id: " << load_info.rowset->rowset_id(); - return OLAP_SUCCESS; + return Status::OK(); } else if (load_info.load_id.hi() == load_id.hi() && load_info.load_id.lo() == load_id.lo() && load_info.rowset != nullptr && load_info.rowset->rowset_id() != rowset_ptr->rowset_id()) { @@ -218,7 +218,7 @@ OLAPStatus TxnManager::commit_txn(OlapMeta* meta, TPartitionId partition_id, << ", tablet: " << tablet_info.to_string() << ", exist rowset_id: " << load_info.rowset->rowset_id() << ", new rowset_id: " << rowset_ptr->rowset_id(); - return OLAP_ERR_PUSH_TRANSACTION_ALREADY_EXIST; + return Status::OLAPInternalError(OLAP_ERR_PUSH_TRANSACTION_ALREADY_EXIST); } } } @@ -228,14 +228,14 @@ OLAPStatus TxnManager::commit_txn(OlapMeta* meta, TPartitionId partition_id, // save meta need access disk, it maybe very slow, so that it is not in global txn lock // it is under a single txn lock if (!is_recovery) { - OLAPStatus save_status = + Status save_status = RowsetMetaManager::save(meta, tablet_uid, rowset_ptr->rowset_id(), rowset_ptr->rowset_meta()->get_rowset_pb()); - if (save_status != OLAP_SUCCESS) { + if (save_status != Status::OK()) { LOG(WARNING) << "save committed rowset failed. when commit txn rowset_id:" << rowset_ptr->rowset_id() << "tablet id: " << tablet_id << "txn id:" << transaction_id; - return OLAP_ERR_ROWSET_SAVE_FAILED; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_SAVE_FAILED); } } @@ -251,11 +251,11 @@ OLAPStatus TxnManager::commit_txn(OlapMeta* meta, TPartitionId partition_id, << ", rowsetid: " << rowset_ptr->rowset_id() << ", version: " << rowset_ptr->version().first; } - return OLAP_SUCCESS; + return Status::OK(); } // remove a txn from txn manager -OLAPStatus TxnManager::publish_txn(OlapMeta* meta, TPartitionId partition_id, +Status TxnManager::publish_txn(OlapMeta* meta, TPartitionId partition_id, TTransactionId transaction_id, TTabletId tablet_id, SchemaHash schema_hash, TabletUid tablet_uid, const Version& version) { @@ -283,17 +283,17 @@ OLAPStatus TxnManager::publish_txn(OlapMeta* meta, TPartitionId partition_id, // TODO(ygl): rowset is already set version here, memory is changed, if save failed // it maybe a fatal error rowset_ptr->make_visible(version); - OLAPStatus save_status = + Status save_status = RowsetMetaManager::save(meta, tablet_uid, rowset_ptr->rowset_id(), rowset_ptr->rowset_meta()->get_rowset_pb()); - if (save_status != OLAP_SUCCESS) { + if (save_status != Status::OK()) { LOG(WARNING) << "save committed rowset failed. when publish txn rowset_id:" << rowset_ptr->rowset_id() << ", tablet id: " << tablet_id << ", txn id:" << transaction_id; - return OLAP_ERR_ROWSET_SAVE_FAILED; + return Status::OLAPInternalError(OLAP_ERR_ROWSET_SAVE_FAILED); } } else { - return OLAP_ERR_TRANSACTION_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_TRANSACTION_NOT_EXIST); } { std::lock_guard wrlock(_get_txn_map_lock(transaction_id)); @@ -311,7 +311,7 @@ OLAPStatus TxnManager::publish_txn(OlapMeta* meta, TPartitionId partition_id, _clear_txn_partition_map_unlocked(transaction_id, partition_id); } } - return OLAP_SUCCESS; + return Status::OK(); } } @@ -319,7 +319,7 @@ OLAPStatus TxnManager::publish_txn(OlapMeta* meta, TPartitionId partition_id, // if the txn has related rowset then could not rollback it, because it // may be committed in another thread and our current thread meets errors when writing to data file // BE has to wait for fe call clear txn api -OLAPStatus TxnManager::rollback_txn(TPartitionId partition_id, TTransactionId transaction_id, +Status TxnManager::rollback_txn(TPartitionId partition_id, TTransactionId transaction_id, TTabletId tablet_id, SchemaHash schema_hash, TabletUid tablet_uid) { pair key(partition_id, transaction_id); @@ -336,7 +336,7 @@ OLAPStatus TxnManager::rollback_txn(TPartitionId partition_id, TTransactionId tr if (load_info.rowset != nullptr) { // if rowset is not null, it means other thread may commit the rowset // should not delete txn any more - return OLAP_ERR_TRANSACTION_ALREADY_COMMITTED; + return Status::OLAPInternalError(OLAP_ERR_TRANSACTION_ALREADY_COMMITTED); } } it->second.erase(tablet_info); @@ -348,12 +348,12 @@ OLAPStatus TxnManager::rollback_txn(TPartitionId partition_id, TTransactionId tr _clear_txn_partition_map_unlocked(transaction_id, partition_id); } } - return OLAP_SUCCESS; + return Status::OK(); } // fe call this api to clear unused rowsets in be // could not delete the rowset if it already has a valid version -OLAPStatus TxnManager::delete_txn(OlapMeta* meta, TPartitionId partition_id, +Status TxnManager::delete_txn(OlapMeta* meta, TPartitionId partition_id, TTransactionId transaction_id, TTabletId tablet_id, SchemaHash schema_hash, TabletUid tablet_uid) { pair key(partition_id, transaction_id); @@ -362,7 +362,7 @@ OLAPStatus TxnManager::delete_txn(OlapMeta* meta, TPartitionId partition_id, txn_tablet_map_t& txn_tablet_map = _get_txn_tablet_map(transaction_id); auto it = txn_tablet_map.find(key); if (it == txn_tablet_map.end()) { - return OLAP_ERR_TRANSACTION_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_TRANSACTION_NOT_EXIST); } auto load_itr = it->second.find(tablet_info); if (load_itr != it->second.end()) { @@ -378,7 +378,7 @@ OLAPStatus TxnManager::delete_txn(OlapMeta* meta, TPartitionId partition_id, << ", tablet: " << tablet_info.to_string() << ", rowset id: " << load_info.rowset->rowset_id() << ", version: " << load_info.rowset->version().first; - return OLAP_ERR_TRANSACTION_ALREADY_VISIBLE; + return Status::OLAPInternalError(OLAP_ERR_TRANSACTION_ALREADY_COMMITTED); } else { RowsetMetaManager::remove(meta, tablet_uid, load_info.rowset->rowset_id()); #ifndef BE_TEST @@ -398,7 +398,7 @@ OLAPStatus TxnManager::delete_txn(OlapMeta* meta, TPartitionId partition_id, txn_tablet_map.erase(it); _clear_txn_partition_map_unlocked(transaction_id, partition_id); } - return OLAP_SUCCESS; + return Status::OK(); } void TxnManager::get_tablet_related_txns(TTabletId tablet_id, SchemaHash schema_hash, diff --git a/be/src/olap/txn_manager.h b/be/src/olap/txn_manager.h index 66a2eef6cb..c454537475 100644 --- a/be/src/olap/txn_manager.h +++ b/be/src/olap/txn_manager.h @@ -71,48 +71,48 @@ public: delete[] _txn_mutex; } - OLAPStatus prepare_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, + Status prepare_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, TTransactionId transaction_id, const PUniqueId& load_id); - OLAPStatus commit_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, + Status commit_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, TTransactionId transaction_id, const PUniqueId& load_id, const RowsetSharedPtr& rowset_ptr, bool is_recovery); - OLAPStatus publish_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, + Status publish_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, TTransactionId transaction_id, const Version& version); // delete the txn from manager if it is not committed(not have a valid rowset) - OLAPStatus rollback_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, + Status rollback_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, TTransactionId transaction_id); - OLAPStatus delete_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, + Status delete_txn(TPartitionId partition_id, const TabletSharedPtr& tablet, TTransactionId transaction_id); // add a txn to manager // partition id is useful in publish version stage because version is associated with partition - OLAPStatus prepare_txn(TPartitionId partition_id, TTransactionId transaction_id, + Status prepare_txn(TPartitionId partition_id, TTransactionId transaction_id, TTabletId tablet_id, SchemaHash schema_hash, TabletUid tablet_uid, const PUniqueId& load_id); - OLAPStatus commit_txn(OlapMeta* meta, TPartitionId partition_id, TTransactionId transaction_id, + Status commit_txn(OlapMeta* meta, TPartitionId partition_id, TTransactionId transaction_id, TTabletId tablet_id, SchemaHash schema_hash, TabletUid tablet_uid, const PUniqueId& load_id, const RowsetSharedPtr& rowset_ptr, bool is_recovery); // remove a txn from txn manager // not persist rowset meta because - OLAPStatus publish_txn(OlapMeta* meta, TPartitionId partition_id, TTransactionId transaction_id, + Status publish_txn(OlapMeta* meta, TPartitionId partition_id, TTransactionId transaction_id, TTabletId tablet_id, SchemaHash schema_hash, TabletUid tablet_uid, const Version& version); // delete the txn from manager if it is not committed(not have a valid rowset) - OLAPStatus rollback_txn(TPartitionId partition_id, TTransactionId transaction_id, + Status rollback_txn(TPartitionId partition_id, TTransactionId transaction_id, TTabletId tablet_id, SchemaHash schema_hash, TabletUid tablet_uid); // remove the txn from txn manager // delete the related rowset if it is not null // delete rowset related data if it is not null - OLAPStatus delete_txn(OlapMeta* meta, TPartitionId partition_id, TTransactionId transaction_id, + Status delete_txn(OlapMeta* meta, TPartitionId partition_id, TTransactionId transaction_id, TTabletId tablet_id, SchemaHash schema_hash, TabletUid tablet_uid); void get_tablet_related_txns(TTabletId tablet_id, SchemaHash schema_hash, TabletUid tablet_uid, diff --git a/be/src/olap/types.h b/be/src/olap/types.h index 142c34e6af..457dfb2aa4 100644 --- a/be/src/olap/types.h +++ b/be/src/olap/types.h @@ -66,10 +66,10 @@ public: virtual void direct_copy_may_cut(void* dest, const void* src) const = 0; // Convert and deep copy value from other type's source. - virtual OLAPStatus convert_from(void* dest, const void* src, const TypeInfo* src_type, + virtual Status convert_from(void* dest, const void* src, const TypeInfo* src_type, MemPool* mem_pool, size_t variable_len = 0) const = 0; - virtual OLAPStatus from_string(void* buf, const std::string& scan_key) const = 0; + virtual Status from_string(void* buf, const std::string& scan_key) const = 0; virtual std::string to_string(const void* src) const = 0; @@ -111,12 +111,12 @@ public: } // Convert and deep copy value from other type's source. - OLAPStatus convert_from(void* dest, const void* src, const TypeInfo* src_type, + Status convert_from(void* dest, const void* src, const TypeInfo* src_type, MemPool* mem_pool, size_t variable_len = 0) const override { return _convert_from(dest, src, src_type, mem_pool, variable_len); } - OLAPStatus from_string(void* buf, const std::string& scan_key) const override { + Status from_string(void* buf, const std::string& scan_key) const override { return _from_string(buf, scan_key); } @@ -159,10 +159,10 @@ private: void (*_copy_object)(void* dest, const void* src, MemPool* mem_pool); void (*_direct_copy)(void* dest, const void* src); void (*_direct_copy_may_cut)(void* dest, const void* src); - OLAPStatus (*_convert_from)(void* dest, const void* src, const TypeInfo* src_type, + Status (*_convert_from)(void* dest, const void* src, const TypeInfo* src_type, MemPool* mem_pool, size_t variable_len); - OLAPStatus (*_from_string)(void* buf, const std::string& scan_key); + Status (*_from_string)(void* buf, const std::string& scan_key); std::string (*_to_string)(const void* src); void (*_set_to_max)(void* buf); @@ -355,13 +355,13 @@ public: direct_copy(dest, src); } - OLAPStatus convert_from(void* dest, const void* src, const TypeInfo* src_type, + Status convert_from(void* dest, const void* src, const TypeInfo* src_type, MemPool* mem_pool, size_t variable_len = 0) const override { - return OLAPStatus::OLAP_ERR_FUNC_NOT_IMPLEMENTED; + return Status::OLAPInternalError(OLAP_ERR_FUNC_NOT_IMPLEMENTED); } - OLAPStatus from_string(void* buf, const std::string& scan_key) const override { - return OLAPStatus::OLAP_ERR_FUNC_NOT_IMPLEMENTED; + Status from_string(void* buf, const std::string& scan_key) const override { + return Status::OLAPInternalError(OLAP_ERR_FUNC_NOT_IMPLEMENTED); } std::string to_string(const void* src) const override { @@ -562,9 +562,9 @@ struct BaseFieldtypeTraits : public CppTypeTraits { static inline void direct_copy_may_cut(void* dest, const void* src) { direct_copy(dest, src); } - static OLAPStatus convert_from(void* dest, const void* src, const TypeInfo* src_type, + static Status convert_from(void* dest, const void* src, const TypeInfo* src_type, MemPool* mem_pool, size_t variable_len = 0) { - return OLAPStatus::OLAP_ERR_FUNC_NOT_IMPLEMENTED; + return Status::OLAPInternalError(OLAP_ERR_FUNC_NOT_IMPLEMENTED); } static inline void set_to_max(void* buf) { @@ -583,13 +583,13 @@ struct BaseFieldtypeTraits : public CppTypeTraits { return std::to_string(*reinterpret_cast(src)); } - static OLAPStatus from_string(void* buf, const std::string& scan_key) { + static Status from_string(void* buf, const std::string& scan_key) { CppType value = 0; if (scan_key.length() > 0) { value = static_cast(strtol(scan_key.c_str(), nullptr, 10)); } *reinterpret_cast(buf) = value; - return OLAP_SUCCESS; + return Status::OK(); } }; @@ -617,20 +617,20 @@ T convert_from_varchar(const Slice* src_value, StringParser::ParseResult& parse_ } template -OLAPStatus arithmetic_convert_from_varchar(void* dest, const void* src) { +Status arithmetic_convert_from_varchar(void* dest, const void* src) { auto src_value = reinterpret_cast(src); StringParser::ParseResult parse_res; //TODO: use C++17 if constexpr to replace label assignment auto result = convert_from_varchar(src_value, parse_res, std::is_integral()); if (UNLIKELY(parse_res != StringParser::PARSE_SUCCESS)) { - return OLAPStatus::OLAP_ERR_INVALID_SCHEMA; + return Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA); } memcpy(dest, &result, sizeof(T)); - return OLAPStatus::OLAP_SUCCESS; + return Status::OK(); } template -OLAPStatus numeric_convert_from_char(void* dest, const void* src) { +Status numeric_convert_from_char(void* dest, const void* src) { prepare_char_before_convert(src); return arithmetic_convert_from_varchar(dest, src); } @@ -645,7 +645,7 @@ struct NumericFieldtypeTraits : public BaseFieldtypeTraits { return std::to_string(*reinterpret_cast(src)); } - static OLAPStatus convert_from(void* dest, const void* src, const TypeInfo* src_type, + static Status convert_from(void* dest, const void* src, const TypeInfo* src_type, MemPool* mem_pool, size_t variable_len = 0) { if (src_type->type() == OLAP_FIELD_TYPE_VARCHAR || src_type->type() == OLAP_FIELD_TYPE_STRING) { @@ -653,7 +653,7 @@ struct NumericFieldtypeTraits : public BaseFieldtypeTraits { } else if (src_type->type() == OLAP_FIELD_TYPE_CHAR) { return numeric_convert_from_char(dest, src); } - return OLAPStatus::OLAP_ERR_INVALID_SCHEMA; + return Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA); } }; @@ -682,7 +682,7 @@ struct FieldTypeTraits : public BaseFieldtypeTraits struct FieldTypeTraits : public NumericFieldtypeTraits { - static OLAPStatus from_string(void* buf, const std::string& scan_key) { + static Status from_string(void* buf, const std::string& scan_key) { int128_t value = 0; const char* value_string = scan_key.c_str(); @@ -719,7 +719,7 @@ struct FieldTypeTraits *reinterpret_cast(buf) = value; - return OLAP_SUCCESS; + return Status::OK(); } static std::string to_string(const void* src) { char buf[1024]; @@ -787,13 +787,13 @@ struct FieldTypeTraits template <> struct FieldTypeTraits : public NumericFieldtypeTraits { - static OLAPStatus from_string(void* buf, const std::string& scan_key) { + static Status from_string(void* buf, const std::string& scan_key) { CppType value = 0.0f; if (scan_key.length() > 0) { value = static_cast(atof(scan_key.c_str())); } *reinterpret_cast(buf) = value; - return OLAP_SUCCESS; + return Status::OK(); } static std::string to_string(const void* src) { char buf[1024] = {'\0'}; @@ -808,13 +808,13 @@ struct FieldTypeTraits template <> struct FieldTypeTraits : public NumericFieldtypeTraits { - static OLAPStatus from_string(void* buf, const std::string& scan_key) { + static Status from_string(void* buf, const std::string& scan_key) { CppType value = 0.0; if (scan_key.length() > 0) { value = atof(scan_key.c_str()); } *reinterpret_cast(buf) = value; - return OLAP_SUCCESS; + return Status::OK(); } static std::string to_string(const void* src) { char buf[1024] = {'\0'}; @@ -824,7 +824,7 @@ struct FieldTypeTraits << *reinterpret_cast(src); return std::string(buf); } - static OLAPStatus convert_from(void* dest, const void* src, const TypeInfo* src_type, + static Status convert_from(void* dest, const void* src, const TypeInfo* src_type, MemPool* mem_pool, size_t variable_len = 0) { //only support float now if (src_type->type() == OLAP_FIELD_TYPE_FLOAT) { @@ -843,7 +843,7 @@ struct FieldTypeTraits snprintf(buf, 64, "%f", *reinterpret_cast(src)); char* tg; *reinterpret_cast(dest) = strtod(buf, &tg); - return OLAPStatus::OLAP_SUCCESS; + return Status::OK(); } return NumericFieldtypeTraits::convert_from( @@ -854,7 +854,7 @@ struct FieldTypeTraits template <> struct FieldTypeTraits : public BaseFieldtypeTraits { - static OLAPStatus from_string(void* buf, const std::string& scan_key) { + static Status from_string(void* buf, const std::string& scan_key) { CppType* data_ptr = reinterpret_cast(buf); return data_ptr->from_string(scan_key); } @@ -876,7 +876,7 @@ struct FieldTypeTraits template <> struct FieldTypeTraits : public BaseFieldtypeTraits { - static OLAPStatus from_string(void* buf, const std::string& scan_key) { + static Status from_string(void* buf, const std::string& scan_key) { tm time_tm; char* res = strptime(scan_key.c_str(), "%Y-%m-%d", &time_tm); @@ -889,12 +889,12 @@ struct FieldTypeTraits : public BaseFieldtypeTraits(buf) = 716833; } - return OLAP_SUCCESS; + return Status::OK(); } static std::string to_string(const void* src) { return reinterpret_cast(src)->to_string(); } - static OLAPStatus convert_from(void* dest, const void* src, const TypeInfo* src_type, + static Status convert_from(void* dest, const void* src, const TypeInfo* src_type, MemPool* mem_pool, size_t variable_len = 0) { if (src_type->type() == FieldType::OLAP_FIELD_TYPE_DATETIME) { using SrcType = typename CppTypeTraits::CppType; @@ -905,7 +905,7 @@ struct FieldTypeTraits : public BaseFieldtypeTraits((part1 / 100) % 100); CppType mday = static_cast(part1 % 100); *reinterpret_cast(dest) = (year << 9) + (mon << 5) + mday; - return OLAPStatus::OLAP_SUCCESS; + return Status::OK(); } if (src_type->type() == FieldType::OLAP_FIELD_TYPE_INT) { @@ -913,13 +913,13 @@ struct FieldTypeTraits : public BaseFieldtypeTraits(src); DateTimeValue dt; if (!dt.from_date_int64(src_value)) { - return OLAPStatus::OLAP_ERR_INVALID_SCHEMA; + return Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA); } CppType year = static_cast(src_value / 10000); CppType month = static_cast((src_value % 10000) / 100); CppType day = static_cast(src_value % 100); *reinterpret_cast(dest) = (year << 9) + (month << 5) + day; - return OLAPStatus::OLAP_SUCCESS; + return Status::OK(); } if (src_type->type() == OLAP_FIELD_TYPE_VARCHAR || @@ -936,13 +936,13 @@ struct FieldTypeTraits : public BaseFieldtypeTraits(dest) = (dt.year() << 9) + (dt.month() << 5) + dt.day(); - return OLAPStatus::OLAP_SUCCESS; + return Status::OK(); } } - return OLAPStatus::OLAP_ERR_INVALID_SCHEMA; + return Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA); } - return OLAPStatus::OLAP_ERR_INVALID_SCHEMA; + return Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA); } static void set_to_max(void* buf) { // max is 9999 * 16 * 32 + 12 * 32 + 31; @@ -957,7 +957,7 @@ struct FieldTypeTraits : public BaseFieldtypeTraits struct FieldTypeTraits : public BaseFieldtypeTraits { - static OLAPStatus from_string(void* buf, const std::string& scan_key) { + static Status from_string(void* buf, const std::string& scan_key) { tm time_tm; char* res = strptime(scan_key.c_str(), "%Y-%m-%d %H:%M:%S", &time_tm); @@ -972,7 +972,7 @@ struct FieldTypeTraits *reinterpret_cast(buf) = 14000101000000L; } - return OLAP_SUCCESS; + return Status::OK(); } static std::string to_string(const void* src) { tm time_tm; @@ -992,7 +992,7 @@ struct FieldTypeTraits strftime(buf, 20, "%Y-%m-%d %H:%M:%S", &time_tm); return std::string(buf); } - static OLAPStatus convert_from(void* dest, const void* src, const TypeInfo* src_type, + static Status convert_from(void* dest, const void* src, const TypeInfo* src_type, MemPool* memPool, size_t variable_len = 0) { // when convert date to datetime, automatic padding zero if (src_type->type() == FieldType::OLAP_FIELD_TYPE_DATE) { @@ -1002,9 +1002,9 @@ struct FieldTypeTraits int mon = static_cast(value >> 5 & 15); int year = static_cast(value >> 9); *reinterpret_cast(dest) = (year * 10000L + mon * 100L + day) * 1000000; - return OLAPStatus::OLAP_SUCCESS; + return Status::OK(); } - return OLAPStatus::OLAP_ERR_INVALID_SCHEMA; + return Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA); } static void set_to_max(void* buf) { // 设置为最大时间，其含义为：9999-12-31 23:59:59 @@ -1025,12 +1025,12 @@ struct FieldTypeTraits : public BaseFieldtypeTraits(right); return l_slice->compare(*r_slice); } - static OLAPStatus from_string(void* buf, const std::string& scan_key) { + static Status from_string(void* buf, const std::string& scan_key) { size_t value_len = scan_key.length(); if (value_len > OLAP_VARCHAR_MAX_LENGTH) { LOG(WARNING) << "the len of value string is too long, len=" << value_len << ", max_len=" << OLAP_VARCHAR_MAX_LENGTH; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } auto slice = reinterpret_cast(buf); @@ -1046,7 +1046,7 @@ struct FieldTypeTraits : public BaseFieldtypeTraitsdata + value_len, 0, slice->size - value_len); } - return OLAP_SUCCESS; + return Status::OK(); } static std::string to_string(const void* src) { auto slice = reinterpret_cast(src); @@ -1098,21 +1098,21 @@ struct FieldTypeTraits : public BaseFieldtypeTraits struct FieldTypeTraits : public FieldTypeTraits { - static OLAPStatus from_string(void* buf, const std::string& scan_key) { + static Status from_string(void* buf, const std::string& scan_key) { size_t value_len = scan_key.length(); if (value_len > OLAP_VARCHAR_MAX_LENGTH) { LOG(WARNING) << "the len of value string is too long, len=" << value_len << ", max_len=" << OLAP_VARCHAR_MAX_LENGTH; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } auto slice = reinterpret_cast(buf); memory_copy(slice->data, scan_key.c_str(), value_len); slice->size = value_len; - return OLAP_SUCCESS; + return Status::OK(); } - static OLAPStatus convert_from(void* dest, const void* src, const TypeInfo* src_type, + static Status convert_from(void* dest, const void* src, const TypeInfo* src_type, MemPool* mem_pool, size_t variable_len = 0) { assert(variable_len > 0); switch (src_type->type()) { @@ -1125,19 +1125,19 @@ struct FieldTypeTraits : public FieldTypeTraitsto_string(src); - if (result.size() > variable_len) return OLAP_ERR_INPUT_PARAMETER_ERROR; + if (result.size() > variable_len) return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); auto slice = reinterpret_cast(dest); slice->data = reinterpret_cast(mem_pool->allocate(result.size())); memcpy(slice->data, result.c_str(), result.size()); slice->size = result.size(); - return OLAP_SUCCESS; + return Status::OK(); } case OLAP_FIELD_TYPE_CHAR: prepare_char_before_convert(src); deep_copy(dest, src, mem_pool); - return OLAP_SUCCESS; + return Status::OK(); default: - return OLAP_ERR_INVALID_SCHEMA; + return Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA); } } @@ -1149,21 +1149,21 @@ struct FieldTypeTraits : public FieldTypeTraits struct FieldTypeTraits : public FieldTypeTraits { - static OLAPStatus from_string(void* buf, const std::string& scan_key) { + static Status from_string(void* buf, const std::string& scan_key) { size_t value_len = scan_key.length(); if (value_len > config::string_type_length_soft_limit_bytes) { LOG(WARNING) << "the len of value string is too long, len=" << value_len << ", max_len=" << config::string_type_length_soft_limit_bytes; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } auto slice = reinterpret_cast(buf); memory_copy(slice->data, scan_key.c_str(), value_len); slice->size = value_len; - return OLAP_SUCCESS; + return Status::OK(); } - static OLAPStatus convert_from(void* dest, const void* src, const TypeInfo* src_type, + static Status convert_from(void* dest, const void* src, const TypeInfo* src_type, MemPool* mem_pool, size_t variable_len = 0) { switch (src_type->type()) { case OLAP_FIELD_TYPE_TINYINT: @@ -1179,15 +1179,15 @@ struct FieldTypeTraits : public FieldTypeTraitsdata = reinterpret_cast(mem_pool->allocate(result.size())); memcpy(slice->data, result.c_str(), result.size()); slice->size = result.size(); - return OLAP_SUCCESS; + return Status::OK(); } case OLAP_FIELD_TYPE_CHAR: prepare_char_before_convert(src); case OLAP_FIELD_TYPE_VARCHAR: deep_copy(dest, src, mem_pool); - return OLAP_SUCCESS; + return Status::OK(); default: - return OLAP_ERR_INVALID_SCHEMA; + return Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA); } } diff --git a/be/src/olap/utils.cpp b/be/src/olap/utils.cpp index e82e3e80f3..847a4274cc 100644 --- a/be/src/olap/utils.cpp +++ b/be/src/olap/utils.cpp @@ -58,14 +58,14 @@ using std::vector; namespace doris { -OLAPStatus olap_compress(const char* src_buf, size_t src_len, char* dest_buf, size_t dest_len, +Status olap_compress(const char* src_buf, size_t src_len, char* dest_buf, size_t dest_len, size_t* written_len, OLAPCompressionType compression_type) { if (nullptr == src_buf || nullptr == dest_buf || nullptr == written_len) { OLAP_LOG_WARNING( "input param with nullptr pointer. [src_buf=%p dest_buf=%p written_len=%p]", src_buf, dest_buf, written_len); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } *written_len = dest_len; @@ -78,17 +78,17 @@ OLAPStatus olap_compress(const char* src_buf, size_t src_len, char* dest_buf, si if (LZO_E_OK != (lzo_res = lzo1x_1_compress( reinterpret_cast(src_buf), src_len, reinterpret_cast(dest_buf), written_len, mem))) { - OLAP_LOG_WARNING( - "compress failed." - "[src_len=%lu; dest_len=%lu; written_len=%lu; lzo_res=%d]", - src_len, dest_len, *written_len, lzo_res); + LOG(WARNING) << "compress failed. src_len=" << src_len + << "; dest_len= " << dest_len + << "; written_len=" << *written_len + << "; lzo_res=" << lzo_res; - return OLAP_ERR_COMPRESS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_COMPRESS_ERROR); } else if (*written_len > dest_len) { VLOG_NOTICE << "buffer overflow when compressing. " << "dest_len=" << dest_len << ", written_len=" << *written_len; - return OLAP_ERR_BUFFER_OVERFLOW; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } break; } @@ -99,17 +99,17 @@ OLAPStatus olap_compress(const char* src_buf, size_t src_len, char* dest_buf, si if (LZO_E_OK != (lzo_res = lzo1c_99_compress( reinterpret_cast(src_buf), src_len, reinterpret_cast(dest_buf), written_len, mem))) { - OLAP_LOG_WARNING( - "compress failed." - "[src_len=%lu; dest_len=%lu; written_len=%lu; lzo_res=%d]", - src_len, dest_len, *written_len, lzo_res); + LOG(WARNING) << "compress failed. src_len=" << src_len + << "; dest_len= " << dest_len + << "; written_len=" << *written_len + << "; lzo_res=" << lzo_res; - return OLAP_ERR_COMPRESS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_COMPRESS_ERROR); } else if (*written_len > dest_len) { VLOG_NOTICE << "buffer overflow when compressing. " << ", dest_len=" << dest_len << ", written_len=" << *written_len; - return OLAP_ERR_BUFFER_OVERFLOW; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } break; } @@ -122,7 +122,7 @@ OLAPStatus olap_compress(const char* src_buf, size_t src_len, char* dest_buf, si if (0 == lz4_res) { VLOG_TRACE << "compress failed. src_len=" << src_len << ", dest_len=" << dest_len << ", written_len=" << *written_len << ", lz4_res=" << lz4_res; - return OLAP_ERR_BUFFER_OVERFLOW; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } break; } @@ -130,17 +130,17 @@ OLAPStatus olap_compress(const char* src_buf, size_t src_len, char* dest_buf, si OLAP_LOG_WARNING("unknown compression type. [type=%d]", compression_type); break; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus olap_decompress(const char* src_buf, size_t src_len, char* dest_buf, size_t dest_len, +Status olap_decompress(const char* src_buf, size_t src_len, char* dest_buf, size_t dest_len, size_t* written_len, OLAPCompressionType compression_type) { if (nullptr == src_buf || nullptr == dest_buf || nullptr == written_len) { OLAP_LOG_WARNING( "input param with nullptr pointer. [src_buf=%p dest_buf=%p written_len=%p]", src_buf, dest_buf, written_len); - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } *written_len = dest_len; @@ -151,17 +151,16 @@ OLAPStatus olap_decompress(const char* src_buf, size_t src_len, char* dest_buf, reinterpret_cast(dest_buf), written_len, nullptr); if (LZO_E_OK != lzo_res) { - OLAP_LOG_WARNING( - "decompress failed." - "[src_len=%lu; dest_len=%lu; written_len=%lu; lzo_res=%d]", - src_len, dest_len, *written_len, lzo_res); - - return OLAP_ERR_DECOMPRESS_ERROR; + LOG(WARNING) << "decompress failed. src_len=" << src_len + << "; dest_len= " << dest_len + << "; written_len=" << *written_len + << "; lzo_res=" << lzo_res; + return Status::OLAPInternalError(OLAP_ERR_DECOMPRESS_ERROR); } else if (*written_len > dest_len) { OLAP_LOG_WARNING("buffer overflow when decompressing. [dest_len=%lu written_len=%lu]", dest_len, *written_len); - return OLAP_ERR_BUFFER_OVERFLOW; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } break; } @@ -170,17 +169,16 @@ OLAPStatus olap_decompress(const char* src_buf, size_t src_len, char* dest_buf, reinterpret_cast(dest_buf), written_len, nullptr); if (LZO_E_OK != lzo_res) { - OLAP_LOG_WARNING( - "decompress failed." - "[src_len=%lu; dest_len=%lu; written_len=%lu; lzo_res=%d]", - src_len, dest_len, *written_len, lzo_res); - - return OLAP_ERR_DECOMPRESS_ERROR; + LOG(WARNING) << "compress failed. src_len=" << src_len + << "; dest_len= " << dest_len + << "; written_len=" << *written_len + << "; lzo_res=" << lzo_res; + return Status::OLAPInternalError(OLAP_ERR_DECOMPRESS_ERROR); } else if (*written_len > dest_len) { OLAP_LOG_WARNING("buffer overflow when decompressing. [dest_len=%lu written_len=%lu]", dest_len, *written_len); - return OLAP_ERR_BUFFER_OVERFLOW; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } break; } @@ -190,12 +188,11 @@ OLAPStatus olap_decompress(const char* src_buf, size_t src_len, char* dest_buf, int lz4_res = LZ4_decompress_safe(src_buf, dest_buf, src_len, dest_len); *written_len = lz4_res; if (lz4_res < 0) { - OLAP_LOG_WARNING( - "decompress failed." - "[src_len=%lu; dest_len=%lu; written_len=%lu; lzo_res=%d]", - src_len, dest_len, *written_len, lz4_res); - - return OLAP_ERR_BUFFER_OVERFLOW; + LOG(WARNING) << "decompress failed. src_len=" << src_len + << "; dest_len= " << dest_len + << "; written_len=" << *written_len + << "; lzo_res=" << lz4_res; + return Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW); } break; } @@ -203,7 +200,7 @@ OLAPStatus olap_decompress(const char* src_buf, size_t src_len, char* dest_buf, LOG(FATAL) << "unknown compress kind. kind=" << compression_type; break; } - return OLAP_SUCCESS; + return Status::OK(); } uint32_t olap_adler32(uint32_t adler, const char* buf, size_t len) { @@ -564,36 +561,36 @@ uint32_t olap_crc32(uint32_t crc32, const char* buf, size_t len) { #endif } -OLAPStatus gen_timestamp_string(string* out_string) { +Status gen_timestamp_string(string* out_string) { time_t now = time(nullptr); tm local_tm; if (localtime_r(&now, &local_tm) == nullptr) { OLAP_LOG_WARNING("fail to localtime_r time. [time=%lu]", now); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } char time_suffix[16] = {0}; // Example: 20150706111404, 长度是15个字符 if (strftime(time_suffix, sizeof(time_suffix), "%Y%m%d%H%M%S", &local_tm) == 0) { OLAP_LOG_WARNING("fail to strftime time. [time=%lu]", now); - return OLAP_ERR_OS_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OS_ERROR); } *out_string = time_suffix; - return OLAP_SUCCESS; + return Status::OK(); } int operator-(const BinarySearchIterator& left, const BinarySearchIterator& right) { return *left - *right; } -OLAPStatus read_write_test_file(const string& test_file_path) { +Status read_write_test_file(const string& test_file_path) { if (access(test_file_path.c_str(), F_OK) == 0) { if (remove(test_file_path.c_str()) != 0) { char errmsg[64]; LOG(WARNING) << "fail to delete test file. " << "path=" << test_file_path << ", errno=" << errno << ", err=" << strerror_r(errno, errmsg, 64); - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } } else { if (errno != ENOENT) { @@ -601,13 +598,13 @@ OLAPStatus read_write_test_file(const string& test_file_path) { LOG(WARNING) << "fail to access test file. " << "path=" << test_file_path << ", errno=" << errno << ", err=" << strerror_r(errno, errmsg, 64); - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } } - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); FileHandler file_handler; if ((res = file_handler.open_with_mode(test_file_path.c_str(), O_RDWR | O_CREAT | O_SYNC, - S_IRUSR | S_IWUSR)) != OLAP_SUCCESS) { + S_IRUSR | S_IWUSR)) != Status::OK()) { LOG(WARNING) << "fail to create test file. path=" << test_file_path; return res; } @@ -617,12 +614,12 @@ OLAPStatus read_write_test_file(const string& test_file_path) { char* read_test_buff = nullptr; if (posix_memalign((void**)&write_test_buff, DIRECT_IO_ALIGNMENT, TEST_FILE_BUF_SIZE) != 0) { LOG(WARNING) << "fail to allocate write buffer memory. size=" << TEST_FILE_BUF_SIZE; - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } std::unique_ptr write_buff(write_test_buff, &std::free); if (posix_memalign((void**)&read_test_buff, DIRECT_IO_ALIGNMENT, TEST_FILE_BUF_SIZE) != 0) { LOG(WARNING) << "fail to allocate read buffer memory. size=" << TEST_FILE_BUF_SIZE; - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } std::unique_ptr read_buff(read_test_buff, &std::free); // generate random numbers @@ -631,21 +628,20 @@ OLAPStatus read_write_test_file(const string& test_file_path) { int32_t tmp_value = rand_r(&rand_seed); write_test_buff[i] = static_cast(tmp_value); } - if ((res = file_handler.pwrite(write_buff.get(), TEST_FILE_BUF_SIZE, SEEK_SET)) != - OLAP_SUCCESS) { + if (!(res = file_handler.pwrite(write_buff.get(), TEST_FILE_BUF_SIZE, SEEK_SET))) { LOG(WARNING) << "fail to write test file. [file_name=" << test_file_path << "]"; return res; } - if ((res = file_handler.pread(read_buff.get(), TEST_FILE_BUF_SIZE, SEEK_SET)) != OLAP_SUCCESS) { + if ((res = file_handler.pread(read_buff.get(), TEST_FILE_BUF_SIZE, SEEK_SET)) != Status::OK()) { LOG(WARNING) << "fail to read test file. [file_name=" << test_file_path << "]"; return res; } if (memcmp(write_buff.get(), read_buff.get(), TEST_FILE_BUF_SIZE) != 0) { LOG(WARNING) << "the test file write_buf and read_buf not equal, [file_name = " << test_file_path << "]"; - return OLAP_ERR_TEST_FILE_ERROR; + return Status::OLAPInternalError(OLAP_ERR_TEST_FILE_ERROR); } - if ((res = file_handler.close()) != OLAP_SUCCESS) { + if ((res = file_handler.close()) != Status::OK()) { LOG(WARNING) << "fail to close test file. [file_name=" << test_file_path << "]"; return res; } @@ -653,7 +649,7 @@ OLAPStatus read_write_test_file(const string& test_file_path) { char errmsg[64]; VLOG_NOTICE << "fail to delete test file. [err='" << strerror_r(errno, errmsg, 64) << "' path='" << test_file_path << "']"; - return OLAP_ERR_IO_ERROR; + return Status::OLAPInternalError(OLAP_ERR_IO_ERROR); } return res; } @@ -662,8 +658,8 @@ bool check_datapath_rw(const string& path) { if (!FileUtils::check_exist(path)) return false; string file_path = path + "/.read_write_test_file"; try { - OLAPStatus res = read_write_test_file(file_path); - return res == OLAP_SUCCESS; + Status res = read_write_test_file(file_path); + return res.ok(); } catch (...) { // do nothing } diff --git a/be/src/olap/utils.h b/be/src/olap/utils.h index b34a8eada7..3c2599f25d 100644 --- a/be/src/olap/utils.h +++ b/be/src/olap/utils.h @@ -77,17 +77,17 @@ private: // @param separator 分隔符 // @param result 切分结果 template -OLAPStatus split_string(const std::string& base, const T separator, +Status split_string(const std::string& base, const T separator, std::vector* result) { if (!result) { - return OLAP_ERR_OTHER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_OTHER_ERROR); } // 处理base为空的情况 // 在删除功能中，当varchar类型列的过滤条件为空时，会出现这种情况 if (base.size() == 0) { result->push_back(""); - return OLAP_SUCCESS; + return Status::OK(); } size_t offset = 0; @@ -102,7 +102,7 @@ OLAPStatus split_string(const std::string& base, const T separator, } } - return OLAP_SUCCESS; + return Status::OK(); } template @@ -117,10 +117,10 @@ void _destruct_array(const void* array, void*) { // 根据压缩类型的不同，执行压缩。dest_buf_len是dest_buf的最大长度， // 通过指针返回的written_len是实际写入的长度。 -OLAPStatus olap_compress(const char* src_buf, size_t src_len, char* dest_buf, size_t dest_len, +Status olap_compress(const char* src_buf, size_t src_len, char* dest_buf, size_t dest_len, size_t* written_len, OLAPCompressionType compression_type); -OLAPStatus olap_decompress(const char* src_buf, size_t src_len, char* dest_buf, size_t dest_len, +Status olap_decompress(const char* src_buf, size_t src_len, char* dest_buf, size_t dest_len, size_t* written_len, OLAPCompressionType compression_type); // 计算adler32的包装函数 @@ -133,7 +133,7 @@ uint32_t olap_adler32(uint32_t adler, const char* buf, size_t len); uint32_t olap_crc32(uint32_t crc32, const char* buf, size_t len); // 获取系统当前时间，并将时间转换为字符串 -OLAPStatus gen_timestamp_string(std::string* out_string); +Status gen_timestamp_string(std::string* out_string); enum ComparatorEnum { COMPARATOR_LESS = 0, @@ -193,7 +193,7 @@ unsigned int crc32c_lut(char const* b, unsigned int off, unsigned int len, unsig bool check_datapath_rw(const std::string& path); -OLAPStatus read_write_test_file(const std::string& test_file_path); +Status read_write_test_file(const std::string& test_file_path); //转换两个list template @@ -219,10 +219,10 @@ private: static __thread char _buf[BUF_SIZE]; }; -inline bool is_io_error(OLAPStatus status) { - return (((OLAP_ERR_IO_ERROR == status || OLAP_ERR_READ_UNENOUGH == status) && errno == EIO) || - OLAP_ERR_CHECKSUM_ERROR == status || OLAP_ERR_FILE_DATA_ERROR == status || - OLAP_ERR_TEST_FILE_ERROR == status || OLAP_ERR_ROWBLOCK_READ_INFO_ERROR == status); +inline bool is_io_error(Status status) { + return (((Status::OLAPInternalError(OLAP_ERR_IO_ERROR) == status || Status::OLAPInternalError(OLAP_ERR_READ_UNENOUGH) == status) && errno == EIO) || + Status::OLAPInternalError(OLAP_ERR_CHECKSUM_ERROR) == status || Status::OLAPInternalError(OLAP_ERR_FILE_DATA_ERROR) == status || + Status::OLAPInternalError(OLAP_ERR_TEST_FILE_ERROR) == status || Status::OLAPInternalError(OLAP_ERR_ROWBLOCK_READ_INFO_ERROR) == status); } #define ENDSWITH(str, suffix) ((str).rfind(suffix) == (str).size() - strlen(suffix)) diff --git a/be/src/olap/version_graph.cpp b/be/src/olap/version_graph.cpp index 5d7daf9395..59b841a7bc 100644 --- a/be/src/olap/version_graph.cpp +++ b/be/src/olap/version_graph.cpp @@ -319,7 +319,7 @@ void TimestampedVersionTracker::add_stale_path_version( } // Capture consistent versions from graph. -OLAPStatus TimestampedVersionTracker::capture_consistent_versions( +Status TimestampedVersionTracker::capture_consistent_versions( const Version& spec_version, std::vector* version_path) const { return _version_graph.capture_consistent_versions(spec_version, version_path); } @@ -509,7 +509,7 @@ void VersionGraph::add_version_to_graph(const Version& version) { _version_graph[end_vertex_index].edges.insert(start_vertex_it, start_vertex_index); } -OLAPStatus VersionGraph::delete_version_from_graph(const Version& version) { +Status VersionGraph::delete_version_from_graph(const Version& version) { int64_t start_vertex_value = version.first; int64_t end_vertex_value = version.second + 1; @@ -517,7 +517,7 @@ OLAPStatus VersionGraph::delete_version_from_graph(const Version& version) { _vertex_index_map.find(end_vertex_value) == _vertex_index_map.end()) { LOG(WARNING) << "vertex for version does not exists. " << "version=" << version.first << "-" << version.second; - return OLAP_ERR_HEADER_DELETE_VERSION; + return Status::OLAPInternalError(OLAP_ERR_HEADER_DELETE_VERSION); } int64_t start_vertex_index = _vertex_index_map[start_vertex_value]; @@ -544,7 +544,7 @@ OLAPStatus VersionGraph::delete_version_from_graph(const Version& version) { // Here we do not delete vertex in `_version_graph` even if its edges are empty. // the `_version_graph` will be rebuilt when doing trash sweep. - return OLAP_SUCCESS; + return Status::OK(); } void VersionGraph::_add_vertex_to_graph(int64_t vertex_value) { @@ -558,12 +558,12 @@ void VersionGraph::_add_vertex_to_graph(int64_t vertex_value) { _vertex_index_map[vertex_value] = _version_graph.size() - 1; } -OLAPStatus VersionGraph::capture_consistent_versions(const Version& spec_version, +Status VersionGraph::capture_consistent_versions(const Version& spec_version, std::vector* version_path) const { if (spec_version.first > spec_version.second) { LOG(WARNING) << "invalid specified version. " << "spec_version=" << spec_version.first << "-" << spec_version.second; - return OLAP_ERR_INPUT_PARAMETER_ERROR; + return Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR); } int64_t cur_idx = -1; @@ -577,7 +577,7 @@ OLAPStatus VersionGraph::capture_consistent_versions(const Version& spec_version if (cur_idx < 0) { LOG(WARNING) << "failed to find path in version_graph. " << "spec_version: " << spec_version.first << "-" << spec_version.second; - return OLAP_ERR_VERSION_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_WRITE_PROTOBUF_ERROR); } int64_t end_value = spec_version.second + 1; @@ -608,7 +608,7 @@ OLAPStatus VersionGraph::capture_consistent_versions(const Version& spec_version } else { VLOG_NOTICE << "fail to find path in version_graph. " << "spec_version: " << spec_version.first << "-" << spec_version.second; - return OLAP_ERR_VERSION_NOT_EXIST; + return Status::OLAPInternalError(OLAP_ERR_WRITE_PROTOBUF_ERROR); } } @@ -621,7 +621,7 @@ OLAPStatus VersionGraph::capture_consistent_versions(const Version& spec_version << ", path=" << shortest_path_for_debug.str(); } - return OLAP_SUCCESS; + return Status::OK(); } double VersionGraph::get_orphan_vertex_ratio() { diff --git a/be/src/olap/version_graph.h b/be/src/olap/version_graph.h index 403630a704..50c7acf492 100644 --- a/be/src/olap/version_graph.h +++ b/be/src/olap/version_graph.h @@ -45,10 +45,10 @@ public: void add_version_to_graph(const Version& version); /// Delete a version from graph. Notice that this del operation only remove this edges and /// remain the vertex. - OLAPStatus delete_version_from_graph(const Version& version); + Status delete_version_from_graph(const Version& version); /// Given a spec_version, this method can find a version path which is the shortest path /// in the graph. The version paths are added to version_path as return info. - OLAPStatus capture_consistent_versions(const Version& spec_version, + Status capture_consistent_versions(const Version& spec_version, std::vector* version_path) const; // See comment of TimestampedVersionTracker's get_orphan_vertex_ratio(); @@ -157,7 +157,7 @@ public: /// Given a spec_version, this method can find a version path which is the shortest path /// in the graph. The version paths are added to version_path as return info. /// If this version not in main version, version_path can be included expired rowset. - OLAPStatus capture_consistent_versions(const Version& spec_version, + Status capture_consistent_versions(const Version& spec_version, std::vector* version_path) const; /// Capture all expired path version. diff --git a/be/src/olap/wrapper_field.h b/be/src/olap/wrapper_field.h index 494f94acdb..7ab9696fd3 100644 --- a/be/src/olap/wrapper_field.h +++ b/be/src/olap/wrapper_field.h @@ -54,7 +54,7 @@ public: // Deserialize field value from incoming string. // // NOTE: the parameter must be a '\0' terminated string. It do not include the null flag. - OLAPStatus from_string(const std::string& value_string) { + Status from_string(const std::string& value_string) { if (_is_string_type) { if (value_string.size() > _var_length) { Slice* slice = reinterpret_cast(cell_ptr()); diff --git a/be/src/runtime/dpp_writer.cpp b/be/src/runtime/dpp_writer.cpp index 7e0de66135..445ff32fe1 100644 --- a/be/src/runtime/dpp_writer.cpp +++ b/be/src/runtime/dpp_writer.cpp @@ -243,8 +243,8 @@ Status DppWriter::add_batch(RowBatch* batch) { return status; } int len = _pos - _buf; - OLAPStatus olap_status = _fp->write(_buf, len); - if (olap_status != OLAP_SUCCESS) { + Status olap_status = _fp->write(_buf, len); + if (!olap_status.ok()) { return Status::InternalError("write to file failed."); } _content_adler32 = olap_adler32(_content_adler32, _buf, len); diff --git a/be/src/runtime/mem_pool.h b/be/src/runtime/mem_pool.h index da3fe5c17e..bf24dec8ad 100644 --- a/be/src/runtime/mem_pool.h +++ b/be/src/runtime/mem_pool.h @@ -106,7 +106,7 @@ public: } /// Same as Allocate() expect add a check when return a nullptr - OLAPStatus allocate_safely(int64_t size, uint8_t*& ret, Status* rst = nullptr) { + Status allocate_safely(int64_t size, uint8_t*& ret, Status* rst = nullptr) { return allocate_safely(size, DEFAULT_ALIGNMENT, ret, rst); } @@ -270,14 +270,14 @@ private: } template - OLAPStatus ALWAYS_INLINE allocate_safely(int64_t size, int alignment, uint8_t*& ret, + Status ALWAYS_INLINE allocate_safely(int64_t size, int alignment, uint8_t*& ret, Status* rst = nullptr) { uint8_t* result = allocate(size, alignment, rst); if (result == nullptr) { - return OLAP_ERR_MALLOC_ERROR; + return Status::OLAPInternalError(OLAP_ERR_MALLOC_ERROR); } ret = result; - return OLAP_SUCCESS; + return Status::OK(); } private: diff --git a/be/src/runtime/snapshot_loader.cpp b/be/src/runtime/snapshot_loader.cpp index 0bbd2fa2b8..02340d4931 100644 --- a/be/src/runtime/snapshot_loader.cpp +++ b/be/src/runtime/snapshot_loader.cpp @@ -410,9 +410,9 @@ Status SnapshotLoader::move(const std::string& snapshot_path, TabletSharedPtr ta } // rename the rowset ids and tabletid info in rowset meta - OLAPStatus convert_status = + Status convert_status = SnapshotManager::instance()->convert_rowset_ids(snapshot_path, tablet_id, schema_hash); - if (convert_status != OLAP_SUCCESS) { + if (convert_status != Status::OK()) { std::stringstream ss; ss << "failed to convert rowsetids in snapshot: " << snapshot_path << ", tablet path: " << tablet_path; @@ -468,9 +468,9 @@ Status SnapshotLoader::move(const std::string& snapshot_path, TabletSharedPtr ta // snapshot loader not need to change tablet uid // fixme: there is no header now and can not call load_one_tablet here // reload header - OLAPStatus ost = StorageEngine::instance()->tablet_manager()->load_tablet_from_dir( + Status ost = StorageEngine::instance()->tablet_manager()->load_tablet_from_dir( store, tablet_id, schema_hash, tablet_path, true); - if (ost != OLAP_SUCCESS) { + if (!ost.ok()) { std::stringstream ss; ss << "failed to reload header of tablet: " << tablet_id; LOG(WARNING) << ss.str(); diff --git a/be/src/runtime/tablets_channel.cpp b/be/src/runtime/tablets_channel.cpp index 40687f07a2..6ae7721cf9 100644 --- a/be/src/runtime/tablets_channel.cpp +++ b/be/src/runtime/tablets_channel.cpp @@ -126,11 +126,11 @@ Status TabletsChannel::add_batch(const PTabletWriterAddBatchRequest& request, strings::Substitute("unknown tablet to append data, tablet=$0", tablet_to_rowidxs_it.first)); } - OLAPStatus st = tablet_writer_it->second->write(&row_batch, tablet_to_rowidxs_it.second); - if (st != OLAP_SUCCESS) { + Status st = tablet_writer_it->second->write(&row_batch, tablet_to_rowidxs_it.second); + if (!st.ok()) { auto err_msg = strings::Substitute( "tablet writer write failed, tablet_id=$0, txn_id=$1, err=$2", - tablet_to_rowidxs_it.first, _txn_id, st); + tablet_to_rowidxs_it.first, _txn_id, st.to_string()); LOG(WARNING) << err_msg; PTabletError* error = tablet_errors->Add(); error->set_tablet_id(tablet_to_rowidxs_it.first); @@ -176,7 +176,7 @@ Status TabletsChannel::close(int sender_id, int64_t backend_id, bool* finished, for (auto& it : _tablet_writers) { if (_partition_ids.count(it.second->partition_id()) > 0) { auto st = it.second->close(); - if (st != OLAP_SUCCESS) { + if (!st.ok()) { LOG(WARNING) << "close tablet writer failed, tablet_id=" << it.first << ", transaction_id=" << _txn_id << ", err=" << st; // just skip this tablet(writer) and continue to close others @@ -185,7 +185,7 @@ Status TabletsChannel::close(int sender_id, int64_t backend_id, bool* finished, need_wait_writers.push_back(it.second); } else { auto st = it.second->cancel(); - if (st != OLAP_SUCCESS) { + if (!st.ok()) { LOG(WARNING) << "cancel tablet writer failed, tablet_id=" << it.first << ", transaction_id=" << _txn_id; // just skip this tablet(writer) and continue to close others @@ -252,8 +252,8 @@ Status TabletsChannel::reduce_mem_usage(int64_t mem_limit) { } for (int i = 0; i < counter; i++) { - OLAPStatus st = writers[i]->wait_flush(); - if (st != OLAP_SUCCESS) { + Status st = writers[i]->wait_flush(); + if (!st.ok()) { return Status::InternalError(fmt::format("failed to reduce mem consumption by flushing memtable. err: {}", st)); } } @@ -289,7 +289,7 @@ Status TabletsChannel::_open_all_writers(const PTabletWriterOpenRequest& request DeltaWriter* writer = nullptr; auto st = DeltaWriter::open(&wrequest, &writer); - if (st != OLAP_SUCCESS) { + if (!st.ok()) { std::stringstream ss; ss << "open delta writer failed, tablet_id=" << tablet.tablet_id() << ", txn_id=" << _txn_id << ", partition_id=" << tablet.partition_id() diff --git a/be/src/service/doris_main.cpp b/be/src/service/doris_main.cpp index 5d68b417c2..5708d24d10 100644 --- a/be/src/service/doris_main.cpp +++ b/be/src/service/doris_main.cpp @@ -359,7 +359,7 @@ int main(int argc, char** argv) { std::vector paths; auto olap_res = doris::parse_conf_store_paths(doris::config::storage_root_path, &paths); - if (olap_res != doris::OLAP_SUCCESS) { + if (!olap_res) { LOG(FATAL) << "parse config storage path failed, path=" << doris::config::storage_root_path; exit(-1); } diff --git a/be/src/tools/meta_tool.cpp b/be/src/tools/meta_tool.cpp index c226cce869..41923b277d 100644 --- a/be/src/tools/meta_tool.cpp +++ b/be/src/tools/meta_tool.cpp @@ -46,9 +46,7 @@ using std::filesystem::path; using doris::DataDir; -using doris::OLAP_SUCCESS; using doris::OlapMeta; -using doris::OLAPStatus; using doris::Status; using doris::TabletMeta; using doris::TabletMetaManager; @@ -97,8 +95,8 @@ std::string get_usage(const std::string& progname) { void show_meta() { TabletMeta tablet_meta; - OLAPStatus s = tablet_meta.create_from_file(FLAGS_pb_meta_path); - if (s != OLAP_SUCCESS) { + Status s = tablet_meta.create_from_file(FLAGS_pb_meta_path); + if (!s.ok()) { std::cout << "load pb meta file:" << FLAGS_pb_meta_path << " failed" << ", status:" << s << std::endl; return; @@ -114,9 +112,9 @@ void show_meta() { void get_meta(DataDir* data_dir) { std::string value; - OLAPStatus s = + Status s = TabletMetaManager::get_json_meta(data_dir, FLAGS_tablet_id, FLAGS_schema_hash, &value); - if (s == doris::OLAP_ERR_META_KEY_NOT_FOUND) { + if (s == doris::Status::OLAPInternalError(OLAP_ERR_META_KEY_NOT_FOUND)) { std::cout << "no tablet meta for tablet_id:" << FLAGS_tablet_id << ", schema_hash:" << FLAGS_schema_hash << std::endl; return; @@ -126,8 +124,8 @@ void get_meta(DataDir* data_dir) { void load_meta(DataDir* data_dir) { // load json tablet meta into meta - OLAPStatus s = TabletMetaManager::load_json_meta(data_dir, FLAGS_json_meta_path); - if (s != OLAP_SUCCESS) { + Status s = TabletMetaManager::load_json_meta(data_dir, FLAGS_json_meta_path); + if (!s.ok()) { std::cout << "load meta failed, status:" << s << std::endl; return; } @@ -135,8 +133,8 @@ void load_meta(DataDir* data_dir) { } void delete_meta(DataDir* data_dir) { - OLAPStatus s = TabletMetaManager::remove(data_dir, FLAGS_tablet_id, FLAGS_schema_hash); - if (s != OLAP_SUCCESS) { + Status s = TabletMetaManager::remove(data_dir, FLAGS_tablet_id, FLAGS_schema_hash); + if (!s.ok()) { std::cout << "delete tablet meta failed for tablet_id:" << FLAGS_tablet_id << ", schema_hash:" << FLAGS_schema_hash << ", status:" << s << std::endl; return; @@ -154,7 +152,7 @@ Status init_data_dir(const std::string& dir, std::unique_ptr* ret) { } doris::StorePath path; auto res = parse_root_path(root_path, &path); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { std::cout << "parse root path failed:" << root_path << std::endl; return Status::InternalError("parse root path failed"); } @@ -238,8 +236,8 @@ void batch_delete_meta(const std::string& tablet_file) { continue; } - OLAPStatus s = TabletMetaManager::remove(data_dir, tablet_id, schema_hash); - if (s != OLAP_SUCCESS) { + Status s = TabletMetaManager::remove(data_dir, tablet_id, schema_hash); + if (!s.ok()) { std::cout << "delete tablet meta failed for tablet_id:" << tablet_id << ", schema_hash:" << schema_hash << ", status:" << s << std::endl; err_num++; diff --git a/be/src/util/broker_storage_backend.cpp b/be/src/util/broker_storage_backend.cpp index 05619c2c94..65ddbb30a8 100644 --- a/be/src/util/broker_storage_backend.cpp +++ b/be/src/util/broker_storage_backend.cpp @@ -61,9 +61,9 @@ Status BrokerStorageBackend::download(const std::string& remote, const std::stri // 3. open local file for write FileHandler file_handler; - OLAPStatus ost = + Status ost = file_handler.open_with_mode(local, O_CREAT | O_TRUNC | O_WRONLY, S_IRUSR | S_IWUSR); - if (ost != OLAP_SUCCESS) { + if (!ost.ok()) { return Status::InternalError("failed to open file: " + local); } @@ -84,7 +84,7 @@ Status BrokerStorageBackend::download(const std::string& remote, const std::stri if (read_len > 0) { ost = file_handler.pwrite(read_buf, read_len, write_offset); - if (ost != OLAP_SUCCESS) { + if (!ost.ok()) { return Status::InternalError("failed to write file: " + local); } @@ -103,8 +103,8 @@ Status BrokerStorageBackend::direct_download(const std::string& remote, std::str Status BrokerStorageBackend::upload(const std::string& local, const std::string& remote) { // read file and write to broker FileHandler file_handler; - OLAPStatus ost = file_handler.open(local, O_RDONLY); - if (ost != OLAP_SUCCESS) { + Status ost = file_handler.open(local, O_RDONLY); + if (!ost.ok()) { return Status::InternalError("failed to open file: " + local); } @@ -127,7 +127,7 @@ Status BrokerStorageBackend::upload(const std::string& local, const std::string& while (left_len > 0) { size_t read_len = left_len > buf_sz ? buf_sz : left_len; ost = file_handler.pread(read_buf, read_len, read_offset); - if (ost != OLAP_SUCCESS) { + if (!ost.ok()) { return Status::InternalError("failed to read file: " + local); } // write through broker diff --git a/be/src/vec/exec/volap_scanner.cpp b/be/src/vec/exec/volap_scanner.cpp index c186e9a5c7..c29d1aa60e 100644 --- a/be/src/vec/exec/volap_scanner.cpp +++ b/be/src/vec/exec/volap_scanner.cpp @@ -57,12 +57,12 @@ Status VOlapScanner::get_block(RuntimeState* state, vectorized::Block* block, bo do { // Read one block from block reader auto res = _tablet_reader->next_block_with_aggregation(block, nullptr, nullptr, eof); - if (res != OLAP_SUCCESS) { + if (!res) { std::stringstream ss; ss << "Internal Error: read storage fail. res=" << res << ", tablet=" << _tablet->full_name() << ", backend=" << BackendOptions::get_localhost(); - return Status::InternalError(ss.str()); + return res; } _num_rows_read += block->rows(); _update_realtime_counter(); diff --git a/be/src/vec/olap/block_reader.cpp b/be/src/vec/olap/block_reader.cpp index 1959fc70fa..8ad582129e 100644 --- a/be/src/vec/olap/block_reader.cpp +++ b/be/src/vec/olap/block_reader.cpp @@ -36,12 +36,12 @@ BlockReader::~BlockReader() { } } -OLAPStatus BlockReader::_init_collect_iter(const ReaderParams& read_params, +Status BlockReader::_init_collect_iter(const ReaderParams& read_params, std::vector* valid_rs_readers) { _vcollect_iter.init(this); std::vector rs_readers; auto res = _capture_rs_readers(read_params, &rs_readers); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { LOG(WARNING) << "fail to init reader when _capture_rs_readers. res:" << res << ", tablet_id:" << read_params.tablet->tablet_id() << ", schema_hash:" << read_params.tablet->schema_hash() @@ -54,12 +54,12 @@ OLAPStatus BlockReader::_init_collect_iter(const ReaderParams& read_params, _reader_context.is_vec = true; for (auto& rs_reader : rs_readers) { RETURN_NOT_OK(rs_reader->init(&_reader_context)); - OLAPStatus res = _vcollect_iter.add_child(rs_reader); - if (res != OLAP_SUCCESS && res != OLAP_ERR_DATA_EOF) { + Status res = _vcollect_iter.add_child(rs_reader); + if (!res.ok() && res != Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { LOG(WARNING) << "failed to add child to iterator, err=" << res; return res; } - if (res == OLAP_SUCCESS) { + if (res.ok()) { valid_rs_readers->push_back(rs_reader); } } @@ -67,10 +67,10 @@ OLAPStatus BlockReader::_init_collect_iter(const ReaderParams& read_params, _vcollect_iter.build_heap(*valid_rs_readers); if (_vcollect_iter.is_merge()) { auto status = _vcollect_iter.current_row(&_next_row); - _eof = status == OLAP_ERR_DATA_EOF; + _eof = status == Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } - return OLAP_SUCCESS; + return Status::OK(); } void BlockReader::_init_agg_state(const ReaderParams& read_params) { @@ -119,7 +119,7 @@ void BlockReader::_init_agg_state(const ReaderParams& read_params) { } } -OLAPStatus BlockReader::init(const ReaderParams& read_params) { +Status BlockReader::init(const ReaderParams& read_params) { TabletReader::init(read_params); auto return_column_size = @@ -142,13 +142,13 @@ OLAPStatus BlockReader::init(const ReaderParams& read_params) { std::vector rs_readers; auto status = _init_collect_iter(read_params, &rs_readers); - if (status != OLAP_SUCCESS) { + if (!status.ok()) { return status; } if (_direct_mode) { _next_block_func = &BlockReader::_direct_next_block; - return OLAP_SUCCESS; + return Status::OK(); } switch (tablet()->keys_type()) { @@ -167,29 +167,29 @@ OLAPStatus BlockReader::init(const ReaderParams& read_params) { break; } - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BlockReader::_direct_next_block(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, +Status BlockReader::_direct_next_block(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof) { auto res = _vcollect_iter.next(block); - if (UNLIKELY(res != OLAP_SUCCESS && res != OLAP_ERR_DATA_EOF)) { + if (UNLIKELY(!res.ok() && res != Status::OLAPInternalError(OLAP_ERR_DATA_EOF))) { return res; } - *eof = res == OLAP_ERR_DATA_EOF; - return OLAP_SUCCESS; + *eof = res == Status::OLAPInternalError(OLAP_ERR_DATA_EOF); + return Status::OK(); } -OLAPStatus BlockReader::_direct_agg_key_next_block(Block* block, MemPool* mem_pool, +Status BlockReader::_direct_agg_key_next_block(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof) { - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BlockReader::_agg_key_next_block(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, +Status BlockReader::_agg_key_next_block(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof) { if (UNLIKELY(_eof)) { *eof = true; - return OLAP_SUCCESS; + return Status::OK(); } auto target_block_row = 0; @@ -201,11 +201,11 @@ OLAPStatus BlockReader::_agg_key_next_block(Block* block, MemPool* mem_pool, Obj while (true) { auto res = _vcollect_iter.next(&_next_row); - if (UNLIKELY(res == OLAP_ERR_DATA_EOF)) { + if (UNLIKELY(res == Status::OLAPInternalError(OLAP_ERR_DATA_EOF))) { *eof = true; break; } - if (UNLIKELY(res != OLAP_SUCCESS)) { + if (UNLIKELY(!res.ok())) { LOG(WARNING) << "next failed: " << res; return res; } @@ -229,14 +229,14 @@ OLAPStatus BlockReader::_agg_key_next_block(Block* block, MemPool* mem_pool, Obj _update_agg_data(target_columns); _merged_rows += target_block_row; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus BlockReader::_unique_key_next_block(Block* block, MemPool* mem_pool, +Status BlockReader::_unique_key_next_block(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof) { if (UNLIKELY(_eof)) { *eof = true; - return OLAP_SUCCESS; + return Status::OK(); } auto target_block_row = 0; @@ -250,19 +250,19 @@ OLAPStatus BlockReader::_unique_key_next_block(Block* block, MemPool* mem_pool, // in UNIQUE_KEY highest version is the final result, there is no need to // merge the lower versions auto res = _vcollect_iter.next(&_next_row); - if (UNLIKELY(res == OLAP_ERR_DATA_EOF)) { + if (UNLIKELY(res == Status::OLAPInternalError(OLAP_ERR_DATA_EOF))) { *eof = true; break; } - if (UNLIKELY(res != OLAP_SUCCESS)) { + if (UNLIKELY(!res.ok())) { LOG(WARNING) << "next failed: " << res; return res; } } while (target_block_row < _batch_size); _merged_rows += target_block_row; - return OLAP_SUCCESS; + return Status::OK(); } void BlockReader::_insert_data_normal(MutableColumns& columns) { diff --git a/be/src/vec/olap/block_reader.h b/be/src/vec/olap/block_reader.h index 322316ff53..fcc46066ff 100644 --- a/be/src/vec/olap/block_reader.h +++ b/be/src/vec/olap/block_reader.h @@ -37,14 +37,14 @@ public: ~BlockReader() override; // Initialize BlockReader with tablet, data version and fetch range. - OLAPStatus init(const ReaderParams& read_params) override; + Status init(const ReaderParams& read_params) override; - OLAPStatus next_row_with_aggregation(RowCursor* row_cursor, MemPool* mem_pool, + Status next_row_with_aggregation(RowCursor* row_cursor, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof) override { - return OLAP_ERR_READER_INITIALIZE_ERROR; + return Status::OLAPInternalError(OLAP_ERR_READER_INITIALIZE_ERROR); } - OLAPStatus next_block_with_aggregation(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, + Status next_block_with_aggregation(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof) override { return (this->*_next_block_func)(block, mem_pool, agg_pool, eof); } @@ -55,22 +55,22 @@ private: // Directly read row from rowset and pass to upper caller. No need to do aggregation. // This is usually used for DUPLICATE KEY tables - OLAPStatus _direct_next_block(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof); + Status _direct_next_block(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof); // Just same as _direct_next_block, but this is only for AGGREGATE KEY tables. // And this is an optimization for AGGR tables. // When there is only one rowset and is not overlapping, we can read it directly without aggregation. - OLAPStatus _direct_agg_key_next_block(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, + Status _direct_agg_key_next_block(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof); // For normal AGGREGATE KEY tables, read data by a merge heap. - OLAPStatus _agg_key_next_block(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, + Status _agg_key_next_block(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof); // For UNIQUE KEY tables, read data by a merge heap. // The difference from _agg_key_next_block is that it will read the data from high version to low version, // to minimize the comparison time in merge heap. - OLAPStatus _unique_key_next_block(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, + Status _unique_key_next_block(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof); - OLAPStatus _init_collect_iter(const ReaderParams& read_params, + Status _init_collect_iter(const ReaderParams& read_params, std::vector* valid_rs_readers); void _init_agg_state(const ReaderParams& read_params); @@ -108,7 +108,7 @@ private: bool _eof = false; - OLAPStatus (BlockReader::*_next_block_func)(Block* block, MemPool* mem_pool, + Status (BlockReader::*_next_block_func)(Block* block, MemPool* mem_pool, ObjectPool* agg_pool, bool* eof) = nullptr; }; diff --git a/be/src/vec/olap/vcollect_iterator.cpp b/be/src/vec/olap/vcollect_iterator.cpp index 18d80225d4..2f0177892f 100644 --- a/be/src/vec/olap/vcollect_iterator.cpp +++ b/be/src/vec/olap/vcollect_iterator.cpp @@ -35,10 +35,10 @@ void VCollectIterator::init(TabletReader* reader) { } } -OLAPStatus VCollectIterator::add_child(RowsetReaderSharedPtr rs_reader) { +Status VCollectIterator::add_child(RowsetReaderSharedPtr rs_reader) { std::unique_ptr child(new Level0Iterator(rs_reader, _reader)); _children.push_back(child.release()); - return OLAP_SUCCESS; + return Status::OK(); } // Build a merge heap. If _merge is true, a rowset with the max rownum @@ -54,7 +54,7 @@ void VCollectIterator::build_heap(std::vector& rs_readers DCHECK(!rs_readers.empty()); for (auto [c_iter, r_iter] = std::pair {_children.begin(), rs_readers.begin()}; c_iter != _children.end();) { - if ((*c_iter)->init() != OLAP_SUCCESS) { + if ((*c_iter)->init() != Status::OK()) { delete (*c_iter); c_iter = _children.erase(c_iter); r_iter = rs_readers.erase(r_iter); @@ -140,31 +140,31 @@ bool VCollectIterator::LevelIteratorComparator::operator()(LevelIterator* lhs, L return lower; } -OLAPStatus VCollectIterator::current_row(IteratorRowRef* ref) const { +Status VCollectIterator::current_row(IteratorRowRef* ref) const { if (LIKELY(_inner_iter)) { *ref = *_inner_iter->current_row_ref(); if (ref->row_pos == -1) { - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } else { - return OLAP_SUCCESS; + return Status::OK(); } } - return OLAP_ERR_DATA_ROW_BLOCK_ERROR; + return Status::OLAPInternalError(OLAP_ERR_DATA_ROW_BLOCK_ERROR); } -OLAPStatus VCollectIterator::next(IteratorRowRef* ref) { +Status VCollectIterator::next(IteratorRowRef* ref) { if (LIKELY(_inner_iter)) { return _inner_iter->next(ref); } else { - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } } -OLAPStatus VCollectIterator::next(Block* block) { +Status VCollectIterator::next(Block* block) { if (LIKELY(_inner_iter)) { return _inner_iter->next(block); } else { - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } } @@ -177,7 +177,7 @@ VCollectIterator::Level0Iterator::Level0Iterator(RowsetReaderSharedPtr rs_reader _ref.is_same = false; } -OLAPStatus VCollectIterator::Level0Iterator::init() { +Status VCollectIterator::Level0Iterator::init() { return _refresh_current_row(); } @@ -185,33 +185,33 @@ int64_t VCollectIterator::Level0Iterator::version() const { return _rs_reader->version().second; } -OLAPStatus VCollectIterator::Level0Iterator::_refresh_current_row() { +Status VCollectIterator::Level0Iterator::_refresh_current_row() { do { if (_block->rows() != 0 && _ref.row_pos < _block->rows()) { - return OLAP_SUCCESS; + return Status::OK(); } else { _ref.is_same = false; _ref.row_pos = 0; _block->clear_column_data(); auto res = _rs_reader->next_block(_block.get()); - if (res != OLAP_SUCCESS) { + if (!res.ok()) { return res; } } } while (_block->rows() != 0); _ref.row_pos = -1; - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } -OLAPStatus VCollectIterator::Level0Iterator::next(IteratorRowRef* ref) { +Status VCollectIterator::Level0Iterator::next(IteratorRowRef* ref) { _ref.row_pos++; RETURN_NOT_OK(_refresh_current_row()); *ref = _ref; - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus VCollectIterator::Level0Iterator::next(Block* block) { +Status VCollectIterator::Level0Iterator::next(Block* block) { return _rs_reader->next_block(block); } @@ -238,12 +238,12 @@ VCollectIterator::Level1Iterator::~Level1Iterator() { // Read next row into *row. // Returns // OLAP_SUCCESS when read successfully. -// OLAP_ERR_DATA_EOF and set *row to nullptr when EOF is reached. +// Status::OLAPInternalError(OLAP_ERR_DATA_EOF) and set *row to nullptr when EOF is reached. // Others when error happens -OLAPStatus VCollectIterator::Level1Iterator::next(IteratorRowRef* ref) { +Status VCollectIterator::Level1Iterator::next(IteratorRowRef* ref) { if (UNLIKELY(_cur_child == nullptr)) { _ref.row_pos = -1; - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } if (_merge) { return _merge_next(ref); @@ -255,11 +255,11 @@ OLAPStatus VCollectIterator::Level1Iterator::next(IteratorRowRef* ref) { // Read next block // Returns // OLAP_SUCCESS when read successfully. -// OLAP_ERR_DATA_EOF and set *row to nullptr when EOF is reached. +// Status::OLAPInternalError(OLAP_ERR_DATA_EOF) and set *row to nullptr when EOF is reached. // Others when error happens -OLAPStatus VCollectIterator::Level1Iterator::next(Block* block) { +Status VCollectIterator::Level1Iterator::next(Block* block) { if (UNLIKELY(_cur_child == nullptr)) { - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } return _normal_next(block); } @@ -271,9 +271,9 @@ int64_t VCollectIterator::Level1Iterator::version() const { return -1; } -OLAPStatus VCollectIterator::Level1Iterator::init() { +Status VCollectIterator::Level1Iterator::init() { if (_children.empty()) { - return OLAP_SUCCESS; + return Status::OK(); } // Only when there are multiple children that need to be merged @@ -288,7 +288,7 @@ OLAPStatus VCollectIterator::Level1Iterator::init() { _heap.reset(new MergeHeap {LevelIteratorComparator(sequence_loc)}); for (auto child : _children) { DCHECK(child != nullptr); - //DCHECK(child->current_row() == OLAP_SUCCESS); + //DCHECK(child->current_row().ok()); _heap->push(child); } _cur_child = _heap->top(); @@ -300,16 +300,16 @@ OLAPStatus VCollectIterator::Level1Iterator::init() { _cur_child = *_children.begin(); } _ref = *_cur_child->current_row_ref(); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus VCollectIterator::Level1Iterator::_merge_next(IteratorRowRef* ref) { +Status VCollectIterator::Level1Iterator::_merge_next(IteratorRowRef* ref) { _heap->pop(); auto res = _cur_child->next(ref); - if (LIKELY(res == OLAP_SUCCESS)) { + if (LIKELY(res.ok())) { _heap->push(_cur_child); _cur_child = _heap->top(); - } else if (res == OLAP_ERR_DATA_EOF) { + } else if (res == Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { // current child has been read, to read next delete _cur_child; if (!_heap->empty()) { @@ -317,7 +317,7 @@ OLAPStatus VCollectIterator::Level1Iterator::_merge_next(IteratorRowRef* ref) { } else { _cur_child = nullptr; _ref.row_pos = -1; - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } } else { _cur_child = nullptr; @@ -336,15 +336,15 @@ OLAPStatus VCollectIterator::Level1Iterator::_merge_next(IteratorRowRef* ref) { _cur_child->set_same(false); - return OLAP_SUCCESS; + return Status::OK(); } -OLAPStatus VCollectIterator::Level1Iterator::_normal_next(IteratorRowRef* ref) { +Status VCollectIterator::Level1Iterator::_normal_next(IteratorRowRef* ref) { auto res = _cur_child->next(ref); - if (LIKELY(res == OLAP_SUCCESS)) { + if (LIKELY(res.ok())) { _ref = *ref; - return OLAP_SUCCESS; - } else if (res == OLAP_ERR_DATA_EOF) { + return Status::OK(); + } else if (res == Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { // current child has been read, to read next delete _cur_child; _children.pop_front(); @@ -353,7 +353,7 @@ OLAPStatus VCollectIterator::Level1Iterator::_normal_next(IteratorRowRef* ref) { return _normal_next(ref); } else { _cur_child = nullptr; - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } } else { _cur_child = nullptr; @@ -362,11 +362,11 @@ OLAPStatus VCollectIterator::Level1Iterator::_normal_next(IteratorRowRef* ref) { } } -OLAPStatus VCollectIterator::Level1Iterator::_normal_next(Block* block) { +Status VCollectIterator::Level1Iterator::_normal_next(Block* block) { auto res = _cur_child->next(block); - if (LIKELY(res == OLAP_SUCCESS)) { - return OLAP_SUCCESS; - } else if (res == OLAP_ERR_DATA_EOF) { + if (LIKELY(res.ok())) { + return Status::OK(); + } else if (res == Status::OLAPInternalError(OLAP_ERR_DATA_EOF)) { // current child has been read, to read next delete _cur_child; _children.pop_front(); @@ -375,7 +375,7 @@ OLAPStatus VCollectIterator::Level1Iterator::_normal_next(Block* block) { return _normal_next(block); } else { _cur_child = nullptr; - return OLAP_ERR_DATA_EOF; + return Status::OLAPInternalError(OLAP_ERR_DATA_EOF); } } else { _cur_child = nullptr; diff --git a/be/src/vec/olap/vcollect_iterator.h b/be/src/vec/olap/vcollect_iterator.h index 8894462571..13ebc4be64 100644 --- a/be/src/vec/olap/vcollect_iterator.h +++ b/be/src/vec/olap/vcollect_iterator.h @@ -47,20 +47,20 @@ public: void init(TabletReader* reader); - OLAPStatus add_child(RowsetReaderSharedPtr rs_reader); + Status add_child(RowsetReaderSharedPtr rs_reader); void build_heap(std::vector& rs_readers); // Get top row of the heap, nullptr if reach end. - OLAPStatus current_row(IteratorRowRef* ref) const; + Status current_row(IteratorRowRef* ref) const; // Read nest order row in Block. // Returns // OLAP_SUCCESS when read successfully. - // OLAP_ERR_DATA_EOF and set *row to nullptr when EOF is reached. + // Status::OLAPInternalError(OLAP_ERR_DATA_EOF) and set *row to nullptr when EOF is reached. // Others when error happens - OLAPStatus next(IteratorRowRef* ref); + Status next(IteratorRowRef* ref); - OLAPStatus next(Block* block); + Status next(Block* block); bool is_merge() const { return _merge; } @@ -75,15 +75,15 @@ private: public: LevelIterator(TabletReader* reader) : _schema(reader->tablet()->tablet_schema()) {}; - virtual OLAPStatus init() = 0; + virtual Status init() = 0; virtual int64_t version() const = 0; const IteratorRowRef* current_row_ref() const { return &_ref; } - virtual OLAPStatus next(IteratorRowRef* ref) = 0; + virtual Status next(IteratorRowRef* ref) = 0; - virtual OLAPStatus next(Block* block) = 0; + virtual Status next(Block* block) = 0; void set_same(bool same) { _ref.is_same = same; } @@ -124,16 +124,16 @@ private: Level0Iterator(RowsetReaderSharedPtr rs_reader, TabletReader* reader); ~Level0Iterator() {} - OLAPStatus init() override; + Status init() override; int64_t version() const override; - OLAPStatus next(IteratorRowRef* ref) override; + Status next(IteratorRowRef* ref) override; - OLAPStatus next(Block* block) override; + Status next(Block* block) override; private: - OLAPStatus _refresh_current_row(); + Status _refresh_current_row(); RowsetReaderSharedPtr _rs_reader; TabletReader* _reader = nullptr; @@ -146,22 +146,22 @@ private: Level1Iterator(const std::list& children, TabletReader* reader, bool merge, bool skip_same); - OLAPStatus init() override; + Status init() override; int64_t version() const override; - OLAPStatus next(IteratorRowRef* ref) override; + Status next(IteratorRowRef* ref) override; - OLAPStatus next(Block* block) override; + Status next(Block* block) override; ~Level1Iterator(); private: - OLAPStatus _merge_next(IteratorRowRef* ref); + Status _merge_next(IteratorRowRef* ref); - OLAPStatus _normal_next(IteratorRowRef* ref); + Status _normal_next(IteratorRowRef* ref); - OLAPStatus _normal_next(Block* block); + Status _normal_next(Block* block); // Each LevelIterator corresponds to a rowset reader, // it will be cleared after '_heap' has been initialized when '_merge == true'. diff --git a/be/test/agent/agent_server_test.cpp b/be/test/agent/agent_server_test.cpp index 0f2d4d240a..5ffdb7b84a 100644 --- a/be/test/agent/agent_server_test.cpp +++ b/be/test/agent/agent_server_test.cpp @@ -127,7 +127,7 @@ TEST(MakeSnapshotTest, TestMakeSnapshot) { EXPECT_CALL(mock_command_executor, make_snapshot(_, _)) .Times(1) - .WillOnce(DoAll(SetArgPointee<1>("snapshot path"), Return(OLAP_SUCCESS))); + .WillOnce(DoAll(SetArgPointee<1>("snapshot path"), Return(Status::OK()))); agent_server.make_snapshot(return_value, snapshot_request); EXPECT_EQ(TStatusCode::OK, return_value.status.status_code); @@ -136,7 +136,7 @@ TEST(MakeSnapshotTest, TestMakeSnapshot) { TAgentResult return_value2; EXPECT_CALL(mock_command_executor, make_snapshot(_, _)) .Times(1) - .WillOnce(Return(OLAP_ERR_VERSION_NOT_EXIST)); + .WillOnce(Return(Status::OLAPInternalError(OLAP_ERR_WRITE_PROTOBUF_ERROR))); agent_server.make_snapshot(return_value2, snapshot_request); EXPECT_EQ(TStatusCode::RUNTIME_ERROR, return_value2.status.status_code); @@ -158,7 +158,7 @@ TEST(ReleaseSnapshotTest, TestReleaseSnapshot) { EXPECT_CALL(mock_command_executor, release_snapshot(snapshot_path)) .Times(1) - .WillOnce(Return(OLAP_SUCCESS)); + .WillOnce(Return(Status::OK())); agent_server.release_snapshot(return_value, snapshot_path); EXPECT_EQ(TStatusCode::OK, return_value.status.status_code); @@ -167,7 +167,7 @@ TEST(ReleaseSnapshotTest, TestReleaseSnapshot) { TAgentResult return_value2; EXPECT_CALL(mock_command_executor, release_snapshot(snapshot_path)) .Times(1) - .WillOnce(Return(OLAP_ERR_VERSION_NOT_EXIST)); + .WillOnce(Return(Status::OLAPInternalError(OLAP_ERR_WRITE_PROTOBUF_ERROR))); agent_server.release_snapshot(return_value2, snapshot_path); EXPECT_EQ(TStatusCode::RUNTIME_ERROR, return_value2.status.status_code); diff --git a/be/test/olap/bit_field_test.cpp b/be/test/olap/bit_field_test.cpp index 1b019db2c5..b3ce669981 100644 --- a/be/test/olap/bit_field_test.cpp +++ b/be/test/olap/bit_field_test.cpp @@ -51,13 +51,13 @@ public: } void CreateReader() { - EXPECT_EQ(OLAP_SUCCESS, + EXPECT_EQ(Status::OK(), _helper.open_with_mode(_file_path.c_str(), O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR)); _out_stream->write_to_file(&_helper, 0); _helper.close(); - EXPECT_EQ(OLAP_SUCCESS, + EXPECT_EQ(Status::OK(), _helper.open_with_mode(_file_path.c_str(), O_RDONLY, S_IRUSR | S_IWUSR)); _shared_buffer = StorageByteBuffer::create(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE + @@ -67,7 +67,7 @@ public: _stream = new (std::nothrow) ReadOnlyFileStream(&_helper, &_shared_buffer, 0, _helper.length(), nullptr, OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, &_stats); - EXPECT_EQ(OLAP_SUCCESS, _stream->init()); + EXPECT_EQ(Status::OK(), _stream->init()); _reader = new (std::nothrow) BitFieldReader(_stream); EXPECT_TRUE(_reader != nullptr); @@ -87,14 +87,14 @@ public: TEST_F(TestBitField, ReadWriteOneBit) { // write data - EXPECT_EQ(OLAP_SUCCESS, _writer->write(true)); - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->write(true)); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); char value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 1); } @@ -102,19 +102,19 @@ TEST_F(TestBitField, ReadWriteMultiBits) { // write data for (int32_t i = 0; i < 100; i++) { if (0 == i % 2) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(true)); + EXPECT_EQ(Status::OK(), _writer->write(true)); } else { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(false)); + EXPECT_EQ(Status::OK(), _writer->write(false)); } } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); char value = 0; for (int32_t i = 0; i < 100; i++) { - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); if (0 == i % 2) { EXPECT_EQ(value, 1); } else { @@ -127,17 +127,17 @@ TEST_F(TestBitField, Seek) { // write data for (int32_t i = 0; i < 100; i++) { if (0 == i % 2) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(true)); + EXPECT_EQ(Status::OK(), _writer->write(true)); } else { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(false)); + EXPECT_EQ(Status::OK(), _writer->write(false)); } } PositionEntryWriter index_entry; _writer->get_position(&index_entry); - EXPECT_EQ(OLAP_SUCCESS, _writer->write(true)); + EXPECT_EQ(Status::OK(), _writer->write(true)); - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -150,7 +150,7 @@ TEST_F(TestBitField, Seek) { PositionProvider position(&entry); _reader->seek(&position); - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 1); } @@ -158,22 +158,22 @@ TEST_F(TestBitField, Skip) { // write data for (int32_t i = 0; i < 100; i++) { if (0 == i % 2) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(true)); + EXPECT_EQ(Status::OK(), _writer->write(true)); } else { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(false)); + EXPECT_EQ(Status::OK(), _writer->write(false)); } } - EXPECT_EQ(OLAP_SUCCESS, _writer->write(true)); + EXPECT_EQ(Status::OK(), _writer->write(true)); - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); char value = 0; _reader->skip(100); - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 1); } diff --git a/be/test/olap/bloom_filter_index_test.cpp b/be/test/olap/bloom_filter_index_test.cpp index 02a9e32f0b..23f67b703a 100644 --- a/be/test/olap/bloom_filter_index_test.cpp +++ b/be/test/olap/bloom_filter_index_test.cpp @@ -59,9 +59,9 @@ TEST_F(TestBloomFilterIndex, normal_read_and_write) { char buffer[expect_size]; memset(buffer, 0, expect_size); - EXPECT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, expect_size)); + EXPECT_EQ(Status::OK(), writer.write_to_buffer(buffer, expect_size)); - EXPECT_EQ(OLAP_SUCCESS, + EXPECT_EQ(Status::OK(), reader.init(buffer, expect_size, true, bf_0->hash_function_num(), bf_0->bit_num())); EXPECT_EQ(2, reader.entry_count()); @@ -79,9 +79,9 @@ TEST_F(TestBloomFilterIndex, normal_read_and_write) { TEST_F(TestBloomFilterIndex, abnormal_write) { char buffer[24]; BloomFilterIndexWriter writer; - EXPECT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, writer.write_to_buffer(nullptr)); - EXPECT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, writer.write_to_buffer(nullptr, 0)); - EXPECT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, writer.write_to_buffer(buffer, 0)); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), writer.write_to_buffer(nullptr)); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), writer.write_to_buffer(nullptr, 0)); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), writer.write_to_buffer(buffer, 0)); EXPECT_EQ(sizeof(BloomFilterIndexHeader), writer.estimate_buffered_memory()); } @@ -95,10 +95,10 @@ TEST_F(TestBloomFilterIndex, abnormal_read) { BloomFilterIndexReader reader; header->block_count = 1; - EXPECT_EQ(OLAP_SUCCESS, reader.init(buffer, buffer_size, true, hash_function_num, bit_num)); + EXPECT_EQ(Status::OK(), reader.init(buffer, buffer_size, true, hash_function_num, bit_num)); header->block_count = 3; - EXPECT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), reader.init(buffer, buffer_size, true, hash_function_num, bit_num)); } diff --git a/be/test/olap/byte_buffer_test.cpp b/be/test/olap/byte_buffer_test.cpp index eb6cf680d1..8cccb1707c 100644 --- a/be/test/olap/byte_buffer_test.cpp +++ b/be/test/olap/byte_buffer_test.cpp @@ -48,23 +48,23 @@ TEST_F(TestByteBuffer, TestReadWrite) { char in[10] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}; for (int i = 0; i < 5; i++) { - EXPECT_EQ(OLAP_SUCCESS, buf1->put(in, sizeof(in))); + EXPECT_EQ(Status::OK(), buf1->put(in, sizeof(in))); EXPECT_EQ(100u - (i + 1) * sizeof(in), buf1->remaining()); EXPECT_EQ((i + 1) * sizeof(in), buf1->position()); } // 参数错误的指定写 - EXPECT_EQ(OLAP_ERR_OUT_OF_BOUND, buf1->put(in, sizeof(in), 5, 10)); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND), buf1->put(in, sizeof(in), 5, 10)); for (int i = 0; i < 50; i++) { - EXPECT_EQ(OLAP_SUCCESS, buf1->put(i)); + EXPECT_EQ(Status::OK(), buf1->put(i)); EXPECT_EQ(50u - (i + 1), buf1->remaining()); EXPECT_EQ(50u + i + 1, buf1->position()); } // 再写就失败了 - EXPECT_EQ(OLAP_ERR_BUFFER_OVERFLOW, buf1->put(0)); - EXPECT_EQ(OLAP_ERR_BUFFER_OVERFLOW, buf1->put(in, sizeof(in))); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW), buf1->put(0)); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW), buf1->put(in, sizeof(in))); // 转为读模式 buf1->flip(); @@ -72,16 +72,16 @@ TEST_F(TestByteBuffer, TestReadWrite) { for (int i = 0; i < 5; i++) { for (int j = 0; j < 10; j++) { char byte; - EXPECT_EQ(OLAP_SUCCESS, buf1->get(&byte)); + EXPECT_EQ(Status::OK(), buf1->get(&byte)); EXPECT_EQ(100u - (i * 10 + j + 1), buf1->remaining()); EXPECT_EQ(i * 10 + j + 1, buf1->position()); EXPECT_EQ('a' + j, byte); } } char buf[50]; - EXPECT_EQ(OLAP_ERR_OUT_OF_BOUND, buf1->get(buf, 100)); - EXPECT_EQ(OLAP_ERR_BUFFER_OVERFLOW, buf1->get(buf, 10, 50)); - EXPECT_EQ(OLAP_SUCCESS, buf1->get(buf, sizeof(buf))); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND), buf1->get(buf, 100)); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_BUFFER_OVERFLOW), buf1->get(buf, 10, 50)); + EXPECT_EQ(Status::OK(), buf1->get(buf, sizeof(buf))); EXPECT_EQ(0u, buf1->remaining()); EXPECT_EQ(100u, buf1->position()); @@ -89,21 +89,21 @@ TEST_F(TestByteBuffer, TestReadWrite) { EXPECT_EQ(i, buf[i]); } char byte; - EXPECT_EQ(OLAP_ERR_OUT_OF_BOUND, buf1->get(&byte)); - EXPECT_EQ(OLAP_ERR_OUT_OF_BOUND, buf1->get(&byte, 1)); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND), buf1->get(&byte)); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_OUT_OF_BOUND), buf1->get(&byte, 1)); - EXPECT_EQ(OLAP_SUCCESS, buf1->put(10, 'x')); - EXPECT_EQ(OLAP_SUCCESS, buf1->get(10, &byte)); + EXPECT_EQ(Status::OK(), buf1->put(10, 'x')); + EXPECT_EQ(Status::OK(), buf1->get(10, &byte)); EXPECT_EQ('x', byte); - EXPECT_EQ(OLAP_SUCCESS, buf1->set_limit(11)); + EXPECT_EQ(Status::OK(), buf1->set_limit(11)); EXPECT_EQ(11u, buf1->limit()); EXPECT_EQ(11u, buf1->position()); - EXPECT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, buf1->set_limit(101)); - EXPECT_EQ(OLAP_SUCCESS, buf1->set_position(10)); - EXPECT_EQ(OLAP_SUCCESS, buf1->get(&byte)); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), buf1->set_limit(101)); + EXPECT_EQ(Status::OK(), buf1->set_position(10)); + EXPECT_EQ(Status::OK(), buf1->get(&byte)); EXPECT_EQ('x', byte); - EXPECT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, buf1->set_position(12)); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), buf1->set_position(12)); SAFE_DELETE(buf1); } @@ -117,7 +117,7 @@ TEST_F(TestByteBuffer, TestRef) { EXPECT_TRUE(buf1 != nullptr); for (int i = 0; i < 256; i++) { - EXPECT_EQ(OLAP_SUCCESS, buf1->put(i)); + EXPECT_EQ(Status::OK(), buf1->put(i)); } StorageByteBuffer buf2 = *buf1; EXPECT_EQ(buf2.array(), buf1->array()); @@ -133,7 +133,7 @@ TEST_F(TestByteBuffer, TestRef) { for (int i = 0; i < 90; i++) { char byte; - EXPECT_EQ(OLAP_SUCCESS, buf3->get(&byte)); + EXPECT_EQ(Status::OK(), buf3->get(&byte)); EXPECT_EQ(i + 10, byte); } @@ -147,18 +147,18 @@ TEST_F(TestByteBuffer, TestRef) { TEST_F(TestByteBuffer, TestMmap) { FileHandler file_handle; std::string file_name = ".test_byte_buffer"; - OLAPStatus res = file_handle.open_with_mode(file_name, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR); - EXPECT_EQ(OLAP_SUCCESS, res); + Status res = file_handle.open_with_mode(file_name, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR); + EXPECT_EQ(Status::OK(), res); char buf[100]; for (int i = 0; i < 100; i++) { buf[i] = i; } - EXPECT_EQ(OLAP_SUCCESS, file_handle.write(buf, 100)); + EXPECT_EQ(Status::OK(), file_handle.write(buf, 100)); file_handle.close(); res = file_handle.open(file_name, O_RDWR); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); StorageByteBuffer* buf1 = StorageByteBuffer::mmap(nullptr, 80, PROT_READ | PROT_WRITE, MAP_SHARED, file_handle.fd(), 0); // mmap完成后就可以关闭原fd @@ -167,21 +167,21 @@ TEST_F(TestByteBuffer, TestMmap) { for (int i = 0; i < 80; i++) { char byte; - EXPECT_EQ(OLAP_SUCCESS, buf1->get(&byte)); + EXPECT_EQ(Status::OK(), buf1->get(&byte)); EXPECT_EQ(i, byte); } // 测试通过mmap写入数据 buf1->set_position(0); for (int i = 0; i < 10; i++) { - EXPECT_EQ(OLAP_SUCCESS, buf1->put('x')); + EXPECT_EQ(Status::OK(), buf1->put('x')); } SAFE_DELETE(buf1); res = file_handle.open(file_name, O_RDONLY); - EXPECT_EQ(OLAP_SUCCESS, res); - EXPECT_EQ(OLAP_SUCCESS, file_handle.pread(buf, 10, SEEK_SET)); + EXPECT_EQ(Status::OK(), res); + EXPECT_EQ(Status::OK(), file_handle.pread(buf, 10, SEEK_SET)); for (int i = 0; i < 10; i++) { EXPECT_EQ('x', buf[i]); } diff --git a/be/test/olap/column_reader_test.cpp b/be/test/olap/column_reader_test.cpp index 0df74f26e2..c3c1001b3e 100644 --- a/be/test/olap/column_reader_test.cpp +++ b/be/test/olap/column_reader_test.cpp @@ -83,7 +83,7 @@ public: BLOOM_FILTER_DEFAULT_FPP); EXPECT_TRUE(_column_writer != nullptr); - EXPECT_EQ(_column_writer->init(), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->init(), Status::OK()); } void create_column_reader(const TabletSchema& tablet_schema) { @@ -108,7 +108,7 @@ public: EXPECT_EQ(system("mkdir -p ./ut_dir"), 0); EXPECT_EQ(system("rm ./ut_dir/tmp_file"), 0); - EXPECT_EQ(OLAP_SUCCESS, + EXPECT_EQ(Status::OK(), helper.open_with_mode("./ut_dir/tmp_file", O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR)); std::vector off; @@ -151,7 +151,7 @@ public: } helper.close(); - EXPECT_EQ(OLAP_SUCCESS, + EXPECT_EQ(Status::OK(), helper.open_with_mode("./ut_dir/tmp_file", O_RDONLY, S_IRUSR | S_IWUSR)); _shared_buffer = StorageByteBuffer::create(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE + @@ -162,13 +162,13 @@ public: ReadOnlyFileStream* in_stream = new (std::nothrow) ReadOnlyFileStream(&helper, &_shared_buffer, off[i], length[i], lz4_decompress, buffer_size[i], &_stats); - EXPECT_EQ(OLAP_SUCCESS, in_stream->init()); + EXPECT_EQ(Status::OK(), in_stream->init()); _map_in_streams[name[i]] = in_stream; } EXPECT_EQ(_column_reader->init(&_map_in_streams, 1024, _mem_pool.get(), &_stats), - OLAP_SUCCESS); + Status::OK()); } void set_tablet_schema_with_one_column(std::string name, std::string type, @@ -192,7 +192,7 @@ public: } void create_and_save_last_position() { - EXPECT_EQ(_column_writer->create_row_index_entry(), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->create_row_index_entry(), Status::OK()); } ColumnWriter* _column_writer; @@ -240,10 +240,10 @@ TEST_F(TestColumn, VectorizedTinyColumnWithoutPresent) { block.set_row(1, write_row); block.finalize(2); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -252,7 +252,7 @@ TEST_F(TestColumn, VectorizedTinyColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); @@ -288,7 +288,7 @@ TEST_F(TestColumn, SeekTinyColumnWithoutPresent) { block.set_row(1, write_row); block.finalize(2); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); create_and_save_last_position(); @@ -297,12 +297,12 @@ TEST_F(TestColumn, SeekTinyColumnWithoutPresent) { block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); create_and_save_last_position(); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -323,9 +323,9 @@ TEST_F(TestColumn, SeekTinyColumnWithoutPresent) { PositionProvider position0(&entry1); PositionProvider position1(&entry2); - EXPECT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position0), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 1); @@ -333,9 +333,9 @@ TEST_F(TestColumn, SeekTinyColumnWithoutPresent) { value = *reinterpret_cast(data); EXPECT_EQ(value, 2); - EXPECT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position1), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 3); @@ -370,10 +370,10 @@ TEST_F(TestColumn, SkipTinyColumnWithoutPresent) { block.set_row(2, write_row); block.finalize(3); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -381,9 +381,9 @@ TEST_F(TestColumn, SkipTinyColumnWithoutPresent) { RowCursor read_row; read_row.init(tablet_schema); - EXPECT_EQ(_column_reader->skip(2), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(2), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 3); @@ -413,10 +413,10 @@ TEST_F(TestColumn, VectorizedTinyColumnWithPresent) { block.set_row(1, write_row); block.finalize(2); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -425,7 +425,7 @@ TEST_F(TestColumn, VectorizedTinyColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); bool* is_null = _col_vector->is_null(); EXPECT_EQ(is_null[0], true); @@ -458,10 +458,10 @@ TEST_F(TestColumn, TinyColumnIndex) { block.set_row(1, write_row); block.finalize(2); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -470,7 +470,7 @@ TEST_F(TestColumn, TinyColumnIndex) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 1); @@ -503,7 +503,7 @@ TEST_F(TestColumn, SeekTinyColumnWithPresent) { block.set_row(1, write_row); block.finalize(2); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); create_and_save_last_position(); @@ -512,12 +512,12 @@ TEST_F(TestColumn, SeekTinyColumnWithPresent) { block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); create_and_save_last_position(); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -538,18 +538,18 @@ TEST_F(TestColumn, SeekTinyColumnWithPresent) { PositionProvider position1(&entry1); PositionProvider position2(&entry2); - EXPECT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position1), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 1); value = *reinterpret_cast(data + 1); EXPECT_EQ(value, 2); - EXPECT_EQ(_column_reader->seek(&position2), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position2), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 3); @@ -583,10 +583,10 @@ TEST_F(TestColumn, SkipTinyColumnWithPresent) { block.set_row(2, write_row); block.finalize(3); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -594,9 +594,9 @@ TEST_F(TestColumn, SkipTinyColumnWithPresent) { RowCursor read_row; read_row.init(tablet_schema); - EXPECT_EQ(_column_reader->skip(2), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(2), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 3); @@ -626,10 +626,10 @@ TEST_F(TestColumn, VectorizedShortColumnWithoutPresent) { block.set_row(1, write_row); block.finalize(2); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -638,7 +638,7 @@ TEST_F(TestColumn, VectorizedShortColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 1); @@ -670,7 +670,7 @@ TEST_F(TestColumn, SeekShortColumnWithoutPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(1, write_row); block.finalize(2); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); create_and_save_last_position(); @@ -678,12 +678,12 @@ TEST_F(TestColumn, SeekShortColumnWithoutPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); create_and_save_last_position(); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -704,9 +704,9 @@ TEST_F(TestColumn, SeekShortColumnWithoutPresent) { PositionProvider position0(&entry1); PositionProvider position1(&entry2); - EXPECT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position0), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 1); @@ -714,9 +714,9 @@ TEST_F(TestColumn, SeekShortColumnWithoutPresent) { value = *reinterpret_cast(data + sizeof(int16_t)); EXPECT_EQ(value, 2); - EXPECT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position1), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 3); @@ -750,10 +750,10 @@ TEST_F(TestColumn, SkipShortColumnWithoutPresent) { block.set_row(2, write_row); block.finalize(3); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -761,9 +761,9 @@ TEST_F(TestColumn, SkipShortColumnWithoutPresent) { RowCursor read_row; read_row.init(tablet_schema); - EXPECT_EQ(_column_reader->skip(2), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(2), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 3); @@ -792,7 +792,7 @@ TEST_F(TestColumn, SeekShortColumnWithPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(1, write_row); block.finalize(2); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); create_and_save_last_position(); @@ -800,12 +800,12 @@ TEST_F(TestColumn, SeekShortColumnWithPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); create_and_save_last_position(); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -827,16 +827,16 @@ TEST_F(TestColumn, SeekShortColumnWithPresent) { PositionProvider position0(&entry1); PositionProvider position1(&entry2); - EXPECT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position0), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 1); - EXPECT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position1), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 3); @@ -867,10 +867,10 @@ TEST_F(TestColumn, VectorizedShortColumnWithPresent) { block.set_row(1, write_row); block.finalize(2); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -879,7 +879,7 @@ TEST_F(TestColumn, VectorizedShortColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); bool* is_null = _col_vector->is_null(); EXPECT_EQ(is_null[0], true); @@ -918,10 +918,10 @@ TEST_F(TestColumn, SkipShortColumnWithPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(2, write_row); block.finalize(3); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -930,9 +930,9 @@ TEST_F(TestColumn, SkipShortColumnWithPresent) { RowCursor read_row; read_row.init(tablet_schema); - EXPECT_EQ(_column_reader->skip(2), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(2), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 3); @@ -963,10 +963,10 @@ TEST_F(TestColumn, VectorizedIntColumnWithoutPresent) { block.set_row(1, write_row); block.finalize(2); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -976,7 +976,7 @@ TEST_F(TestColumn, VectorizedIntColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 1); @@ -1006,10 +1006,10 @@ TEST_F(TestColumn, VectorizedIntColumnMassWithoutPresent) { block.set_row(i, write_row); } block.finalize(10000); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1024,7 +1024,7 @@ TEST_F(TestColumn, VectorizedIntColumnMassWithoutPresent) { for (int32_t i = 0; i < 10000; ++i) { if (i % 1000 == 0) { EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1000, _mem_pool.get()), - OLAP_SUCCESS); + Status::OK()); data = reinterpret_cast(_col_vector->col_data()); } @@ -1054,15 +1054,15 @@ TEST_F(TestColumn, VectorizedIntColumnWithPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1073,7 +1073,7 @@ TEST_F(TestColumn, VectorizedIntColumnWithPresent) { _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); bool* is_null = _col_vector->is_null(); char* data = reinterpret_cast(_col_vector->col_data()); @@ -1104,16 +1104,16 @@ TEST_F(TestColumn, VectorizedLongColumnWithoutPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); value = 3; write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1123,7 +1123,7 @@ TEST_F(TestColumn, VectorizedLongColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_EQ(value, 1); @@ -1151,17 +1151,17 @@ TEST_F(TestColumn, VectorizedLongColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); int64_t value = 3; write_row.set_not_null(0); write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1171,7 +1171,7 @@ TEST_F(TestColumn, VectorizedLongColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); bool* is_null = _col_vector->is_null(); EXPECT_EQ(is_null[0], true); @@ -1202,16 +1202,16 @@ TEST_F(TestColumn, VectorizedFloatColumnWithoutPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); value = 3.234; write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1221,7 +1221,7 @@ TEST_F(TestColumn, VectorizedFloatColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_FLOAT_EQ(value, 1.234); @@ -1250,17 +1250,17 @@ TEST_F(TestColumn, VectorizedFloatColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); float value = 3.234; write_row.set_not_null(0); write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1270,7 +1270,7 @@ TEST_F(TestColumn, VectorizedFloatColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); bool* is_null = _col_vector->is_null(); EXPECT_EQ(is_null[0], true); @@ -1301,7 +1301,7 @@ TEST_F(TestColumn, SeekFloatColumnWithPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); create_and_save_last_position(); @@ -1309,12 +1309,12 @@ TEST_F(TestColumn, SeekFloatColumnWithPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); create_and_save_last_position(); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1336,9 +1336,9 @@ TEST_F(TestColumn, SeekFloatColumnWithPresent) { PositionProvider position0(&entry1); PositionProvider position1(&entry2); - EXPECT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position0), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_FLOAT_EQ(value, 1.234); @@ -1367,16 +1367,16 @@ TEST_F(TestColumn, SkipFloatColumnWithPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); value = 3.234; write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1385,9 +1385,9 @@ TEST_F(TestColumn, SkipFloatColumnWithPresent) { RowCursor read_row; read_row.init(tablet_schema); - EXPECT_EQ(_column_reader->skip(1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(1), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_FLOAT_EQ(value, 3.234); @@ -1413,16 +1413,16 @@ TEST_F(TestColumn, VectorizedDoubleColumnWithoutPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); value = 3.23456789; write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1432,7 +1432,7 @@ TEST_F(TestColumn, VectorizedDoubleColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); EXPECT_DOUBLE_EQ(value, 1.23456789); @@ -1461,17 +1461,17 @@ TEST_F(TestColumn, VectorizedDoubleColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); double value = 3.23456789; write_row.set_not_null(0); write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1481,7 +1481,7 @@ TEST_F(TestColumn, VectorizedDoubleColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); bool* is_null = _col_vector->is_null(); EXPECT_EQ(is_null[0], true); @@ -1515,10 +1515,10 @@ TEST_F(TestColumn, VectorizedDatetimeColumnWithoutPresent) { write_row.from_tuple(tuple); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1528,7 +1528,7 @@ TEST_F(TestColumn, VectorizedDatetimeColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&2000-10-10 10:10:10", @@ -1554,7 +1554,7 @@ TEST_F(TestColumn, VectorizedDatetimeColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); std::vector val_string_array; val_string_array.push_back("2000-10-10 10:10:10"); @@ -1563,10 +1563,10 @@ TEST_F(TestColumn, VectorizedDatetimeColumnWithPresent) { write_row.set_not_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1576,7 +1576,7 @@ TEST_F(TestColumn, VectorizedDatetimeColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); bool* is_null = _col_vector->is_null(); EXPECT_EQ(is_null[0], true); @@ -1588,7 +1588,7 @@ TEST_F(TestColumn, VectorizedDatetimeColumnWithPresent) { EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&2000-10-10 10:10:10", strlen("0&2000-10-10 10:10:10")) == 0); - EXPECT_NE(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_NE(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); } TEST_F(TestColumn, VectorizedDatetimeColumnZero) { // write data @@ -1609,7 +1609,7 @@ TEST_F(TestColumn, VectorizedDatetimeColumnZero) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); std::vector val_string_array; val_string_array.push_back("1000-01-01 00:00:00"); @@ -1618,10 +1618,10 @@ TEST_F(TestColumn, VectorizedDatetimeColumnZero) { write_row.set_not_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1631,7 +1631,7 @@ TEST_F(TestColumn, VectorizedDatetimeColumnZero) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); bool* is_null = _col_vector->is_null(); EXPECT_EQ(is_null[0], true); @@ -1643,7 +1643,7 @@ TEST_F(TestColumn, VectorizedDatetimeColumnZero) { EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&1000-01-01 00:00:00", strlen("0&1000-01-01 00:00:00")) == 0); - EXPECT_NE(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_NE(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); } TEST_F(TestColumn, VectorizedDateColumnWithoutPresent) { @@ -1668,10 +1668,10 @@ TEST_F(TestColumn, VectorizedDateColumnWithoutPresent) { write_row.from_tuple(tuple); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1681,7 +1681,7 @@ TEST_F(TestColumn, VectorizedDateColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&2000-10-10", strlen("0&2000-10-10")) == 0); @@ -1706,7 +1706,7 @@ TEST_F(TestColumn, VectorizedDateColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); std::vector val_string_array; val_string_array.push_back("2000-10-10"); @@ -1716,11 +1716,11 @@ TEST_F(TestColumn, VectorizedDateColumnWithPresent) { write_row.set_not_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); } ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1730,7 +1730,7 @@ TEST_F(TestColumn, VectorizedDateColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 101, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 101, _mem_pool.get()), Status::OK()); bool* is_null = _col_vector->is_null(); EXPECT_EQ(is_null[0], true); @@ -1766,7 +1766,7 @@ TEST_F(TestColumn, VectorizedDecimalColumnWithoutPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back("5678.1234"); @@ -1774,10 +1774,10 @@ TEST_F(TestColumn, VectorizedDecimalColumnWithoutPresent) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1787,7 +1787,7 @@ TEST_F(TestColumn, VectorizedDecimalColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&1234.5678", strlen("0&1234.5678")) == 0); @@ -1817,7 +1817,7 @@ TEST_F(TestColumn, VectorizedDecimalColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back("5678.1234"); @@ -1826,10 +1826,10 @@ TEST_F(TestColumn, VectorizedDecimalColumnWithPresent) { write_row.set_not_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1839,7 +1839,7 @@ TEST_F(TestColumn, VectorizedDecimalColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); bool* is_null = _col_vector->is_null(); EXPECT_EQ(is_null[0], true); @@ -1871,17 +1871,17 @@ TEST_F(TestColumn, SkipDecimalColumnWithPresent) { write_row.from_tuple(val_string_array); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back("5678.1234"); write_row.from_tuple(val_string_array); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1892,9 +1892,9 @@ TEST_F(TestColumn, SkipDecimalColumnWithPresent) { char read_value[20]; memset(read_value, 0, 20); - EXPECT_EQ(_column_reader->skip(1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(1), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0); @@ -1922,7 +1922,7 @@ TEST_F(TestColumn, SeekDecimalColumnWithPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); create_and_save_last_position(); @@ -1932,12 +1932,12 @@ TEST_F(TestColumn, SeekDecimalColumnWithPresent) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); create_and_save_last_position(); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -1960,17 +1960,17 @@ TEST_F(TestColumn, SeekDecimalColumnWithPresent) { char read_value[20]; memset(read_value, 0, 20); - EXPECT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position0), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&1234.5678", strlen("0&1234.5678")) == 0); memset(read_value, 0, 20); - EXPECT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position1), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0); @@ -2004,7 +2004,7 @@ TEST_F(TestColumn, VectorizedLargeIntColumnWithoutPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back(value2); @@ -2012,10 +2012,10 @@ TEST_F(TestColumn, VectorizedLargeIntColumnWithoutPresent) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -2025,7 +2025,7 @@ TEST_F(TestColumn, VectorizedLargeIntColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); value1 = "0&" + value1; @@ -2062,7 +2062,7 @@ TEST_F(TestColumn, VectorizedLargeIntColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); std::vector val_string_array; val_string_array.push_back(value1); @@ -2071,7 +2071,7 @@ TEST_F(TestColumn, VectorizedLargeIntColumnWithPresent) { write_row.set_not_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back(value2); @@ -2080,10 +2080,10 @@ TEST_F(TestColumn, VectorizedLargeIntColumnWithPresent) { write_row.set_not_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data @@ -2093,7 +2093,7 @@ TEST_F(TestColumn, VectorizedLargeIntColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 3, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 3, _mem_pool.get()), Status::OK()); bool* is_null = _col_vector->is_null(); EXPECT_EQ(is_null[0], true); EXPECT_EQ(is_null[1], false); @@ -2140,7 +2140,7 @@ TEST_F(TestColumn, SkipLargeIntColumnWithPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back(value2); @@ -2148,10 +2148,10 @@ TEST_F(TestColumn, SkipLargeIntColumnWithPresent) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -2159,9 +2159,9 @@ TEST_F(TestColumn, SkipLargeIntColumnWithPresent) { read_row.init(tablet_schema); value2 = "0&" + value2; - EXPECT_EQ(_column_reader->skip(1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(1), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); EXPECT_TRUE(strncmp(read_row.to_string().c_str(), value2.c_str(), value2.size()) == 0); @@ -2191,11 +2191,11 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWithoutPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); for (uint32_t i = 0; i < 2; i++) { block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); } val_string_array.clear(); val_string_array.push_back("ZWRjYmE="); //"edcba" base_64_encode is "ZWRjYmE=" @@ -2204,11 +2204,11 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWithoutPresent) { for (uint32_t i = 0; i < 2; i++) { block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); } ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -2219,7 +2219,7 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWithoutPresent) { _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), Status::OK()); Slice* value = reinterpret_cast(_col_vector->col_data()); EXPECT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0); for (uint32_t i = 0; i < 2; i++) { @@ -2230,7 +2230,7 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWithoutPresent) { value++; EXPECT_TRUE(strncmp(value->data, "ZWRjYmE=", value->size) == 0); } - EXPECT_NE(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_NE(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); } TEST_F(TestColumn, VectorizedDirectVarcharColumnWithPresent) { @@ -2252,7 +2252,7 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); std::vector val_string_array; val_string_array.push_back("YWJjZGU="); //"abcde" base_64_encode is "YWJjZGU=" @@ -2261,10 +2261,10 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWithPresent) { write_row.set_not_null(0); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -2274,7 +2274,7 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWithPresent) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); bool* is_null = _col_vector->is_null(); EXPECT_EQ(is_null[0], true); EXPECT_EQ(is_null[1], false); @@ -2307,7 +2307,7 @@ TEST_F(TestColumn, SkipDirectVarcharColumnWithPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back("YWFhYWE="); //"aaaaa" base_64_encode is "YWJjZGU=" @@ -2315,10 +2315,10 @@ TEST_F(TestColumn, SkipDirectVarcharColumnWithPresent) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -2329,9 +2329,9 @@ TEST_F(TestColumn, SkipDirectVarcharColumnWithPresent) { char read_value[20]; memset(read_value, 0, 20); - EXPECT_EQ(_column_reader->skip(1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(1), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); Slice* value = reinterpret_cast(_col_vector->col_data()); EXPECT_TRUE(strncmp(value->data, "YWFhYWE=", value->size) == 0); } @@ -2359,7 +2359,7 @@ TEST_F(TestColumn, SeekDirectVarcharColumnWithoutPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); _column_writer->create_row_index_entry(); @@ -2369,12 +2369,12 @@ TEST_F(TestColumn, SeekDirectVarcharColumnWithoutPresent) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); _column_writer->create_row_index_entry(); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -2396,15 +2396,15 @@ TEST_F(TestColumn, SeekDirectVarcharColumnWithoutPresent) { PositionProvider position0(&entry1); PositionProvider position1(&entry2); - EXPECT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position0), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); Slice* value = reinterpret_cast(_col_vector->col_data()); EXPECT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0); - EXPECT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position1), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); value = reinterpret_cast(_col_vector->col_data()); EXPECT_TRUE(strncmp(value->data, "YWFhYWE=", value->size) == 0); } @@ -2432,7 +2432,7 @@ TEST_F(TestColumn, SeekDirectVarcharColumnWithPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); _column_writer->create_row_index_entry(); @@ -2442,12 +2442,12 @@ TEST_F(TestColumn, SeekDirectVarcharColumnWithPresent) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); _column_writer->create_row_index_entry(); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -2469,15 +2469,15 @@ TEST_F(TestColumn, SeekDirectVarcharColumnWithPresent) { PositionProvider position0(&entry1); PositionProvider position1(&entry2); - EXPECT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position0), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); Slice* value = reinterpret_cast(_col_vector->col_data()); EXPECT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0); - EXPECT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position1), Status::OK()); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); value = reinterpret_cast(_col_vector->col_data()); EXPECT_TRUE(strncmp(value->data, "YWFhYWE=", value->size) == 0); } @@ -2504,11 +2504,11 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); for (uint32_t i = 0; i < 2; i++) { block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); } val_string_array.clear(); val_string_array.push_back("edcba"); //"edcba" base_64_encode is "ZWRjYmE=" @@ -2517,11 +2517,11 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutPresent) { for (uint32_t i = 0; i < 2; i++) { block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); } ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -2531,7 +2531,7 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutPresent) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), Status::OK()); Slice* value = reinterpret_cast(_col_vector->col_data()); EXPECT_TRUE(strncmp(value->data, "abcde", value->size) == 0); @@ -2543,7 +2543,7 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutPresent) { value++; EXPECT_TRUE(strncmp(value->data, "edcba", value->size) == 0); } - EXPECT_NE(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_NE(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); } TEST_F(TestColumn, VectorizedCharColumnWithPresent) { @@ -2572,10 +2572,10 @@ TEST_F(TestColumn, VectorizedCharColumnWithPresent) { write_row.set_not_null(0); block.set_row(1, write_row); block.finalize(2); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -2585,7 +2585,7 @@ TEST_F(TestColumn, VectorizedCharColumnWithPresent) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); bool* is_null = _col_vector->is_null(); EXPECT_EQ(is_null[0], true); EXPECT_EQ(is_null[1], false); @@ -2617,7 +2617,7 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutoutPresent2) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back("aaaaa"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2625,7 +2625,7 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutoutPresent2) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back("bbbbb"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2633,7 +2633,7 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutoutPresent2) { write_row.from_tuple(tuple3); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back("ccccc"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2641,7 +2641,7 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutoutPresent2) { write_row.from_tuple(tuple4); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back("ddddd"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2649,10 +2649,10 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutoutPresent2) { write_row.from_tuple(tuple5); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -2662,7 +2662,7 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutoutPresent2) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), Status::OK()); Slice* value = reinterpret_cast(_col_vector->col_data()); EXPECT_TRUE(strncmp(value->data, "abcde", value->size) == 0); @@ -2702,11 +2702,11 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); for (uint32_t i = 0; i < 2; i++) { block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); } val_string_array.clear(); val_string_array.push_back("edcba"); //"edcba" base_64_encode is "ZWRjYmE=" @@ -2715,11 +2715,11 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutPresent) { for (uint32_t i = 0; i < 2; i++) { block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); } ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -2729,7 +2729,7 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutPresent) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), Status::OK()); Slice* value = reinterpret_cast(_col_vector->col_data()); EXPECT_TRUE(strncmp(value->data, "abcde", value->size) == 0); @@ -2741,7 +2741,7 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutPresent) { value++; EXPECT_TRUE(strncmp(value->data, "edcba", value->size) == 0); } - EXPECT_NE(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_NE(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); } TEST_F(TestColumn, VectorizedStringColumnWithPresent) { @@ -2770,10 +2770,10 @@ TEST_F(TestColumn, VectorizedStringColumnWithPresent) { write_row.set_not_null(0); block.set_row(1, write_row); block.finalize(2); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -2783,7 +2783,7 @@ TEST_F(TestColumn, VectorizedStringColumnWithPresent) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); bool* is_null = _col_vector->is_null(); EXPECT_EQ(is_null[0], true); EXPECT_EQ(is_null[1], false); @@ -2815,7 +2815,7 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutoutPresent2) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back("aaaaa"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2823,7 +2823,7 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutoutPresent2) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back("bbbbb"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2831,7 +2831,7 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutoutPresent2) { write_row.from_tuple(tuple3); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back("ccccc"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2839,7 +2839,7 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutoutPresent2) { write_row.from_tuple(tuple4); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back("ddddd"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2847,10 +2847,10 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutoutPresent2) { write_row.from_tuple(tuple5); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -2860,7 +2860,7 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutoutPresent2) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), Status::OK()); Slice* value = reinterpret_cast(_col_vector->col_data()); EXPECT_TRUE(strncmp(value->data, "abcde", value->size) == 0); @@ -2897,10 +2897,10 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWith65533) { std::vector val_string_array; val_string_array.push_back(std::string(65533, 'a')); OlapTuple tuple1(val_string_array); - EXPECT_EQ(OLAP_SUCCESS, write_row.from_tuple(tuple1)); + EXPECT_EQ(Status::OK(), write_row.from_tuple(tuple1)); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); val_string_array.clear(); val_string_array.push_back("edcba"); //"edcba" base_64_encode is "ZWRjYmE=" @@ -2909,11 +2909,11 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWith65533) { for (uint32_t i = 0; i < 2; i++) { block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); } ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data create_column_reader(tablet_schema); @@ -2923,7 +2923,7 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWith65533) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 3, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 3, _mem_pool.get()), Status::OK()); Slice* value = reinterpret_cast(_col_vector->col_data()); for (uint32_t i = 0; i < 65533; i++) { diff --git a/be/test/olap/comparison_predicate_test.cpp b/be/test/olap/comparison_predicate_test.cpp index 63fcde12ed..19fff88c60 100644 --- a/be/test/olap/comparison_predicate_test.cpp +++ b/be/test/olap/comparison_predicate_test.cpp @@ -430,7 +430,7 @@ TEST_F(TestEqualPredicate, STRING_COLUMN) { &char_tablet_schema); // test WrapperField.from_string() for char type WrapperField* field = WrapperField::create(char_tablet_schema.column(0)); - EXPECT_EQ(OLAP_SUCCESS, field->from_string("true")); + EXPECT_EQ(Status::OK(), field->from_string("true")); const std::string tmp = field->to_string(); EXPECT_EQ(5, tmp.size()); EXPECT_EQ('t', tmp[0]); diff --git a/be/test/olap/delete_handler_test.cpp b/be/test/olap/delete_handler_test.cpp index 039ff828db..2f13c9cb1a 100644 --- a/be/test/olap/delete_handler_test.cpp +++ b/be/test/olap/delete_handler_test.cpp @@ -257,10 +257,10 @@ protected: // 1. Prepare for query split key. // create base tablet - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); set_default_create_tablet_request(&_create_tablet); res = k_engine->create_tablet(_create_tablet); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); tablet = k_engine->tablet_manager()->get_tablet(_create_tablet.tablet_id, _create_tablet.tablet_schema.schema_hash); EXPECT_NE(tablet.get(), nullptr); @@ -268,7 +268,7 @@ protected: set_create_duplicate_tablet_request(&_create_dup_tablet); res = k_engine->create_tablet(_create_dup_tablet); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); dup_tablet = k_engine->tablet_manager()->get_tablet( _create_dup_tablet.tablet_id, _create_dup_tablet.tablet_schema.schema_hash); EXPECT_TRUE(dup_tablet.get() != NULL); @@ -294,7 +294,7 @@ protected: }; TEST_F(TestDeleteConditionHandler, StoreCondSucceed) { - OLAPStatus success_res; + Status success_res; std::vector conditions; TCondition condition; @@ -344,7 +344,7 @@ TEST_F(TestDeleteConditionHandler, StoreCondSucceed) { DeletePredicatePB del_pred; success_res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred); - EXPECT_EQ(OLAP_SUCCESS, success_res); + EXPECT_EQ(Status::OK(), success_res); // 验证存储在header中的过滤条件正确 EXPECT_EQ(size_t(6), del_pred.sub_predicates_size()); @@ -366,10 +366,10 @@ TEST_F(TestDeleteConditionHandler, StoreCondInvalidParameters) { // 空的过滤条件 std::vector conditions; DeletePredicatePB del_pred; - OLAPStatus failed_res = _delete_condition_handler.generate_delete_predicate( + Status failed_res = _delete_condition_handler.generate_delete_predicate( tablet->tablet_schema(), conditions, &del_pred); ; - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_PARAMETERS, failed_res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_PARAMETERS), failed_res); } // 检测过滤条件中指定的列不存在,或者列不符合要求 @@ -383,10 +383,10 @@ TEST_F(TestDeleteConditionHandler, StoreCondNonexistentColumn) { condition.condition_values.push_back("2"); conditions.push_back(condition); DeletePredicatePB del_pred; - OLAPStatus failed_res = _delete_condition_handler.generate_delete_predicate( + Status failed_res = _delete_condition_handler.generate_delete_predicate( tablet->tablet_schema(), conditions, &del_pred); ; - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, failed_res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), failed_res); // 'v'是value列 conditions.clear(); @@ -399,7 +399,7 @@ TEST_F(TestDeleteConditionHandler, StoreCondNonexistentColumn) { failed_res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred); ; - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, failed_res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), failed_res); // value column in duplicate model can be deleted; conditions.clear(); @@ -409,10 +409,10 @@ TEST_F(TestDeleteConditionHandler, StoreCondNonexistentColumn) { condition.condition_values.push_back("5"); conditions.push_back(condition); - OLAPStatus success_res = _delete_condition_handler.generate_delete_predicate( + Status success_res = _delete_condition_handler.generate_delete_predicate( dup_tablet->tablet_schema(), conditions, &del_pred); ; - EXPECT_EQ(OLAP_SUCCESS, success_res); + EXPECT_EQ(Status::OK(), success_res); } // 测试删除条件值不符合类型要求 @@ -434,10 +434,10 @@ protected: // 1. Prepare for query split key. // create base tablet - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); set_default_create_tablet_request(&_create_tablet); res = k_engine->create_tablet(_create_tablet); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); tablet = k_engine->tablet_manager()->get_tablet(_create_tablet.tablet_id, _create_tablet.tablet_schema.schema_hash); EXPECT_TRUE(tablet.get() != nullptr); @@ -459,7 +459,7 @@ protected: }; TEST_F(TestDeleteConditionHandler2, ValidConditionValue) { - OLAPStatus res; + Status res; std::vector conditions; // 测试数据中, k1,k2,k3,k4类型分别为int8, int16, int32, int64 @@ -491,7 +491,7 @@ TEST_F(TestDeleteConditionHandler2, ValidConditionValue) { DeletePredicatePB del_pred; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); // k5类型为int128 conditions.clear(); @@ -504,7 +504,7 @@ TEST_F(TestDeleteConditionHandler2, ValidConditionValue) { DeletePredicatePB del_pred_2; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_2); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); // k9类型为decimal, precision=6, frac=3 conditions.clear(); @@ -517,28 +517,28 @@ TEST_F(TestDeleteConditionHandler2, ValidConditionValue) { DeletePredicatePB del_pred_3; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_3); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); conditions[0].condition_values.clear(); conditions[0].condition_values.push_back("2"); DeletePredicatePB del_pred_4; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_4); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); conditions[0].condition_values.clear(); conditions[0].condition_values.push_back("-2"); DeletePredicatePB del_pred_5; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_5); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); conditions[0].condition_values.clear(); conditions[0].condition_values.push_back("-2.3"); DeletePredicatePB del_pred_6; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_6); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); // k10,k11类型分别为date, datetime conditions.clear(); @@ -557,7 +557,7 @@ TEST_F(TestDeleteConditionHandler2, ValidConditionValue) { DeletePredicatePB del_pred_7; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_7); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); // k12,k13类型分别为string(64), varchar(64) conditions.clear(); @@ -576,11 +576,11 @@ TEST_F(TestDeleteConditionHandler2, ValidConditionValue) { DeletePredicatePB del_pred_8; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_8); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); } TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { - OLAPStatus res; + Status res; std::vector conditions; // 测试k1的值越上界，k1类型为int8 @@ -594,7 +594,7 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_1; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_1); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); // 测试k1的值越下界，k1类型为int8 conditions[0].condition_values.clear(); @@ -602,7 +602,7 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_2; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_2); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); // 测试k2的值越上界，k2类型为int16 conditions[0].condition_values.clear(); @@ -611,7 +611,7 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_3; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_3); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); // 测试k2的值越下界，k2类型为int16 conditions[0].condition_values.clear(); @@ -619,7 +619,7 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_4; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_4); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); // 测试k3的值越上界，k3类型为int32 conditions[0].condition_values.clear(); @@ -628,7 +628,7 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_5; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_5); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); // 测试k3的值越下界，k3类型为int32 conditions[0].condition_values.clear(); @@ -636,7 +636,7 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_6; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_6); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); // 测试k4的值越上界，k2类型为int64 conditions[0].condition_values.clear(); @@ -645,7 +645,7 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_7; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_7); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); // 测试k4的值越下界，k1类型为int64 conditions[0].condition_values.clear(); @@ -653,7 +653,7 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_8; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_8); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); // 测试k5的值越上界，k5类型为int128 conditions[0].condition_values.clear(); @@ -662,7 +662,7 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_9; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_9); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); // 测试k5的值越下界，k5类型为int128 conditions[0].condition_values.clear(); @@ -670,7 +670,7 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_10; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_10); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); // 测试k9整数部分长度过长，k9类型为decimal, precision=6, frac=3 conditions[0].condition_values.clear(); @@ -679,7 +679,7 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_11; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_11); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); // 测试k9小数部分长度过长，k9类型为decimal, precision=6, frac=3 conditions[0].condition_values.clear(); @@ -687,7 +687,7 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_12; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_12); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); // 测试k9没有小数部分，但包含小数点 conditions[0].condition_values.clear(); @@ -695,7 +695,7 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_13; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_13); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); // 测试k10类型的过滤值不符合对应格式，k10为date conditions[0].condition_values.clear(); @@ -704,21 +704,21 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_14; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_14); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); conditions[0].condition_values.clear(); conditions[0].condition_values.push_back("2013-64-01"); DeletePredicatePB del_pred_15; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_15); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); conditions[0].condition_values.clear(); conditions[0].condition_values.push_back("2013-01-40"); DeletePredicatePB del_pred_16; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_16); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); // 测试k11类型的过滤值不符合对应格式，k11为datetime conditions[0].condition_values.clear(); @@ -727,42 +727,42 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_17; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_17); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); conditions[0].condition_values.clear(); conditions[0].condition_values.push_back("2013-64-01 00:00:00"); DeletePredicatePB del_pred_18; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_18); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); conditions[0].condition_values.clear(); conditions[0].condition_values.push_back("2013-01-40 00:00:00"); DeletePredicatePB del_pred_19; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_19); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); conditions[0].condition_values.clear(); conditions[0].condition_values.push_back("2013-01-01 24:00:00"); DeletePredicatePB del_pred_20; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_20); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); conditions[0].condition_values.clear(); conditions[0].condition_values.push_back("2013-01-01 00:60:00"); DeletePredicatePB del_pred_21; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_21); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); conditions[0].condition_values.clear(); conditions[0].condition_values.push_back("2013-01-01 00:00:60"); DeletePredicatePB del_pred_22; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_22); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); // 测试k12和k13类型的过滤值过长，k12,k13类型分别为string(64), varchar(64) conditions[0].condition_values.clear(); @@ -774,7 +774,7 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_23; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_23); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); conditions[0].condition_values.clear(); conditions[0].column_name = "k13"; @@ -785,7 +785,7 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { DeletePredicatePB del_pred_24; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_24); - EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, res); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DELETE_INVALID_CONDITION), res); } class TestDeleteHandler : public testing::Test { @@ -809,10 +809,10 @@ protected: // 1. Prepare for query split key. // create base tablet - OLAPStatus res = OLAP_SUCCESS; + Status res = Status::OK(); set_default_create_tablet_request(&_create_tablet); res = k_engine->create_tablet(_create_tablet); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); tablet = k_engine->tablet_manager()->get_tablet(_create_tablet.tablet_id, _create_tablet.tablet_schema.schema_hash); EXPECT_TRUE(tablet != nullptr); @@ -840,7 +840,7 @@ protected: }; TEST_F(TestDeleteHandler, InitSuccess) { - OLAPStatus res; + Status res; std::vector conditions; // 往头文件中添加过滤条件 @@ -866,7 +866,7 @@ TEST_F(TestDeleteHandler, InitSuccess) { DeletePredicatePB del_pred; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); tablet->add_delete_predicate(del_pred, 1); conditions.clear(); @@ -879,7 +879,7 @@ TEST_F(TestDeleteHandler, InitSuccess) { DeletePredicatePB del_pred_2; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_2); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); tablet->add_delete_predicate(del_pred_2, 2); conditions.clear(); @@ -892,7 +892,7 @@ TEST_F(TestDeleteHandler, InitSuccess) { DeletePredicatePB del_pred_3; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_3); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); tablet->add_delete_predicate(del_pred_3, 3); conditions.clear(); @@ -905,12 +905,12 @@ TEST_F(TestDeleteHandler, InitSuccess) { DeletePredicatePB del_pred_4; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_4); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); tablet->add_delete_predicate(del_pred_4, 4); // 从header文件中取出版本号小于等于7的过滤条件 res = _delete_handler.init(tablet->tablet_schema(), tablet->delete_predicates(), 4); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); EXPECT_EQ(4, _delete_handler.conditions_num()); std::vector conds_version = _delete_handler.get_conds_version(); EXPECT_EQ(4, conds_version.size()); @@ -926,7 +926,7 @@ TEST_F(TestDeleteHandler, InitSuccess) { // 测试一个过滤条件包含的子条件之间是and关系, // 即只有满足一条过滤条件包含的所有子条件，这条数据才会被过滤 TEST_F(TestDeleteHandler, FilterDataSubconditions) { - OLAPStatus res; + Status res; std::vector conditions; // 往Header中添加过滤条件 @@ -947,12 +947,12 @@ TEST_F(TestDeleteHandler, FilterDataSubconditions) { DeletePredicatePB del_pred; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); tablet->add_delete_predicate(del_pred, 1); // 指定版本号为10以载入Header中的所有过滤条件(在这个case中，只有过滤条件1) res = _delete_handler.init(tablet->tablet_schema(), tablet->delete_predicates(), 4); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); EXPECT_EQ(1, _delete_handler.conditions_num()); // 构造一行测试数据 @@ -970,14 +970,14 @@ TEST_F(TestDeleteHandler, FilterDataSubconditions) { data_str.push_back("1"); OlapTuple tuple1(data_str); res = _data_row_cursor.from_tuple(tuple1); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); EXPECT_TRUE(_delete_handler.is_filter_data(1, _data_row_cursor)); // 构造一行测试数据 data_str[1] = "4"; OlapTuple tuple2(data_str); res = _data_row_cursor.from_tuple(tuple2); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); // 不满足子条件：k2!=4 EXPECT_FALSE(_delete_handler.is_filter_data(1, _data_row_cursor)); @@ -987,7 +987,7 @@ TEST_F(TestDeleteHandler, FilterDataSubconditions) { // 测试多个过滤条件之间是or关系， // 即如果存在多个过滤条件，会一次检查数据是否符合这些过滤条件；只要有一个过滤条件符合，则过滤数据 TEST_F(TestDeleteHandler, FilterDataConditions) { - OLAPStatus res; + Status res; std::vector conditions; // 往Header中添加过滤条件 @@ -1008,7 +1008,7 @@ TEST_F(TestDeleteHandler, FilterDataConditions) { DeletePredicatePB del_pred; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); tablet->add_delete_predicate(del_pred, 1); // 过滤条件2 @@ -1022,7 +1022,7 @@ TEST_F(TestDeleteHandler, FilterDataConditions) { DeletePredicatePB del_pred_2; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_2); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); tablet->add_delete_predicate(del_pred_2, 2); // 过滤条件3 @@ -1036,12 +1036,12 @@ TEST_F(TestDeleteHandler, FilterDataConditions) { DeletePredicatePB del_pred_3; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_3); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); tablet->add_delete_predicate(del_pred_3, 3); // 指定版本号为4以载入meta中的所有过滤条件(在这个case中，只有过滤条件1) res = _delete_handler.init(tablet->tablet_schema(), tablet->delete_predicates(), 4); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); EXPECT_EQ(3, _delete_handler.conditions_num()); std::vector data_str; @@ -1058,7 +1058,7 @@ TEST_F(TestDeleteHandler, FilterDataConditions) { data_str.push_back("1"); OlapTuple tuple(data_str); res = _data_row_cursor.from_tuple(tuple); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); // 这行数据会因为过滤条件3而被过滤 EXPECT_TRUE(_delete_handler.is_filter_data(3, _data_row_cursor)); @@ -1067,7 +1067,7 @@ TEST_F(TestDeleteHandler, FilterDataConditions) { // 测试在过滤时，版本号小于数据版本的过滤条件将不起作用 TEST_F(TestDeleteHandler, FilterDataVersion) { - OLAPStatus res; + Status res; std::vector conditions; // 往Header中添加过滤条件 @@ -1088,7 +1088,7 @@ TEST_F(TestDeleteHandler, FilterDataVersion) { DeletePredicatePB del_pred; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); tablet->add_delete_predicate(del_pred, 3); // 过滤条件2 @@ -1102,12 +1102,12 @@ TEST_F(TestDeleteHandler, FilterDataVersion) { DeletePredicatePB del_pred_2; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_2); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); tablet->add_delete_predicate(del_pred_2, 4); // 指定版本号为4以载入meta中的所有过滤条件(过滤条件1，过滤条件2) res = _delete_handler.init(tablet->tablet_schema(), tablet->delete_predicates(), 4); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); EXPECT_EQ(2, _delete_handler.conditions_num()); // 构造一行测试数据 @@ -1125,7 +1125,7 @@ TEST_F(TestDeleteHandler, FilterDataVersion) { data_str.push_back("1"); OlapTuple tuple(data_str); res = _data_row_cursor.from_tuple(tuple); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); // 如果数据版本小于3，则过滤条件1生效，这条数据被过滤 EXPECT_TRUE(_delete_handler.is_filter_data(2, _data_row_cursor)); // 如果数据版本大于3，则过滤条件1会被跳过 diff --git a/be/test/olap/delta_writer_test.cpp b/be/test/olap/delta_writer_test.cpp index be45fae591..1c94897b7e 100644 --- a/be/test/olap/delta_writer_test.cpp +++ b/be/test/olap/delta_writer_test.cpp @@ -347,8 +347,8 @@ public: TEST_F(TestDeltaWriter, open) { TCreateTabletReq request; create_tablet_request(10003, 270068375, &request); - OLAPStatus res = k_engine->create_tablet(request); - EXPECT_EQ(OLAP_SUCCESS, res); + Status res = k_engine->create_tablet(request); + EXPECT_EQ(Status::OK(), res); TDescriptorTable tdesc_tbl = create_descriptor_tablet(); ObjectPool obj_pool; @@ -364,23 +364,23 @@ TEST_F(TestDeltaWriter, open) { DeltaWriter::open(&write_req, &delta_writer); EXPECT_NE(delta_writer, nullptr); res = delta_writer->close(); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); res = delta_writer->close_wait(nullptr, false); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); SAFE_DELETE(delta_writer); TDropTabletReq drop_request; auto tablet_id = 10003; auto schema_hash = 270068375; res = k_engine->tablet_manager()->drop_tablet(tablet_id, schema_hash); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); } TEST_F(TestDeltaWriter, write) { TCreateTabletReq request; create_tablet_request(10004, 270068376, &request); - OLAPStatus res = k_engine->create_tablet(request); - EXPECT_EQ(OLAP_SUCCESS, res); + Status res = k_engine->create_tablet(request); + EXPECT_EQ(Status::OK(), res); TDescriptorTable tdesc_tbl = create_descriptor_tablet(); ObjectPool obj_pool; @@ -459,13 +459,13 @@ TEST_F(TestDeltaWriter, write) { *(DecimalV2Value*)(tuple->get_slot(slots[19]->tuple_offset())) = val_decimal; res = delta_writer->write(tuple); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); } res = delta_writer->close(); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); res = delta_writer->close_wait(nullptr, false); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); // publish version success TabletSharedPtr tablet = @@ -482,24 +482,24 @@ TEST_F(TestDeltaWriter, write) { res = k_engine->txn_manager()->publish_txn(meta, write_req.partition_id, write_req.txn_id, write_req.tablet_id, write_req.schema_hash, tablet_rs.first.tablet_uid, version); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); res = tablet->add_inc_rowset(rowset); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); } EXPECT_EQ(1, tablet->num_rows()); auto tablet_id = 10003; auto schema_hash = 270068375; res = k_engine->tablet_manager()->drop_tablet(tablet_id, schema_hash); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); delete delta_writer; } TEST_F(TestDeltaWriter, sequence_col) { TCreateTabletReq request; create_tablet_request_with_sequence_col(10005, 270068377, &request); - OLAPStatus res = k_engine->create_tablet(request); - EXPECT_EQ(OLAP_SUCCESS, res); + Status res = k_engine->create_tablet(request); + EXPECT_EQ(Status::OK(), res); TDescriptorTable tdesc_tbl = create_descriptor_tablet_with_sequence_col(); ObjectPool obj_pool; @@ -530,13 +530,13 @@ TEST_F(TestDeltaWriter, sequence_col) { ->from_date_str("2020-07-16 19:39:43", 19); res = delta_writer->write(tuple); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); } res = delta_writer->close(); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); res = delta_writer->close_wait(nullptr, false); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); // publish version success TabletSharedPtr tablet = @@ -553,16 +553,16 @@ TEST_F(TestDeltaWriter, sequence_col) { res = k_engine->txn_manager()->publish_txn(meta, write_req.partition_id, write_req.txn_id, write_req.tablet_id, write_req.schema_hash, tablet_rs.first.tablet_uid, version); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); res = tablet->add_inc_rowset(rowset); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); } EXPECT_EQ(1, tablet->num_rows()); auto tablet_id = 10005; auto schema_hash = 270068377; res = k_engine->tablet_manager()->drop_tablet(tablet_id, schema_hash); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); delete delta_writer; } diff --git a/be/test/olap/engine_storage_migration_task_test.cpp b/be/test/olap/engine_storage_migration_task_test.cpp index 2de5b1cb98..7d70f1cb01 100644 --- a/be/test/olap/engine_storage_migration_task_test.cpp +++ b/be/test/olap/engine_storage_migration_task_test.cpp @@ -157,8 +157,8 @@ public: TEST_F(TestEngineStorageMigrationTask, write_and_migration) { TCreateTabletReq request; create_tablet_request_with_sequence_col(10005, 270068377, &request); - OLAPStatus res = k_engine->create_tablet(request); - EXPECT_EQ(OLAP_SUCCESS, res); + Status res = k_engine->create_tablet(request); + EXPECT_EQ(Status::OK(), res); TDescriptorTable tdesc_tbl = create_descriptor_tablet_with_sequence_col(); ObjectPool obj_pool; @@ -189,13 +189,13 @@ TEST_F(TestEngineStorageMigrationTask, write_and_migration) { ->from_date_str("2020-07-16 19:39:43", 19); res = delta_writer->write(tuple); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); } res = delta_writer->close(); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); res = delta_writer->close_wait(nullptr, false); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); // publish version success TabletSharedPtr tablet = @@ -212,9 +212,9 @@ TEST_F(TestEngineStorageMigrationTask, write_and_migration) { res = k_engine->txn_manager()->publish_txn(meta, write_req.partition_id, write_req.txn_id, write_req.tablet_id, write_req.schema_hash, tablet_rs.first.tablet_uid, version); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); res = tablet->add_inc_rowset(rowset); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); } EXPECT_EQ(1, tablet->num_rows()); // we should sleep 1 second for the migrated tablet has different time with the current tablet @@ -232,7 +232,7 @@ TEST_F(TestEngineStorageMigrationTask, write_and_migration) { // migrating EngineStorageMigrationTask engine_task(tablet, dest_store); res = engine_task.execute(); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); // reget the tablet from manager after migration auto tablet_id = 10005; auto schema_hash = 270068377; @@ -253,7 +253,7 @@ TEST_F(TestEngineStorageMigrationTask, write_and_migration) { EXPECT_NE(dest_store->path(), tablet2->data_dir()->path()); EngineStorageMigrationTask engine_task2(tablet2, dest_store); res = engine_task2.execute(); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); TabletSharedPtr tablet3 = k_engine->tablet_manager()->get_tablet(tablet_id, schema_hash); // check path EXPECT_EQ(tablet3->data_dir()->path(), tablet->data_dir()->path()); @@ -265,7 +265,7 @@ TEST_F(TestEngineStorageMigrationTask, write_and_migration) { // test case 2 end res = k_engine->tablet_manager()->drop_tablet(tablet_id, schema_hash); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); delete delta_writer; } diff --git a/be/test/olap/file_helper_test.cpp b/be/test/olap/file_helper_test.cpp index 2bc2229bb5..259bce5c00 100644 --- a/be/test/olap/file_helper_test.cpp +++ b/be/test/olap/file_helper_test.cpp @@ -63,9 +63,9 @@ TEST_F(FileHandlerTest, TestWrite) { std::string file_name = _s_test_data_path + "/abcd123.txt"; // create a file using open EXPECT_FALSE(std::filesystem::exists(file_name)); - OLAPStatus op_status = + Status op_status = file_handler.open_with_mode(file_name, O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR); - EXPECT_EQ(OLAPStatus::OLAP_SUCCESS, op_status); + EXPECT_EQ(Status::OK(), op_status); EXPECT_TRUE(std::filesystem::exists(file_name)); // tell current offset diff --git a/be/test/olap/file_utils_test.cpp b/be/test/olap/file_utils_test.cpp index 0b0f390e62..18e1b0e427 100644 --- a/be/test/olap/file_utils_test.cpp +++ b/be/test/olap/file_utils_test.cpp @@ -71,9 +71,9 @@ TEST_F(FileUtilsTest, TestCopyFile) { std::string src_file_name = _s_test_data_path + "/abcd12345.txt"; // create a file using open EXPECT_FALSE(std::filesystem::exists(src_file_name)); - OLAPStatus op_status = src_file_handler.open_with_mode( + Status op_status = src_file_handler.open_with_mode( src_file_name, O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR); - EXPECT_EQ(OLAPStatus::OLAP_SUCCESS, op_status); + EXPECT_EQ(Status::OK(), op_status); EXPECT_TRUE(std::filesystem::exists(src_file_name)); char large_bytes2[(1 << 12)]; diff --git a/be/test/olap/memtable_flush_executor_test.cpp b/be/test/olap/memtable_flush_executor_test.cpp index aab1a92403..42b98b6ef6 100644 --- a/be/test/olap/memtable_flush_executor_test.cpp +++ b/be/test/olap/memtable_flush_executor_test.cpp @@ -96,7 +96,7 @@ TEST_F(TestMemTableFlushExecutor, create_flush_handler) { EXPECT_NE(nullptr, flush_handler.get()); FlushResult res; - res.flush_status = OLAP_SUCCESS; + res.flush_status = Status::OK(); res.flush_time_ns = 100; flush_handler->on_flush_finished(res); EXPECT_FALSE(flush_handler->is_cancelled()); @@ -104,13 +104,13 @@ TEST_F(TestMemTableFlushExecutor, create_flush_handler) { EXPECT_EQ(1, flush_handler->get_stats().flush_count); FlushResult res2; - res2.flush_status = OLAP_ERR_OTHER_ERROR; + res2.flush_status = Status::OLAPInternalError(OLAP_ERR_OTHER_ERROR); flush_handler->on_flush_finished(res2); EXPECT_TRUE(flush_handler->is_cancelled()); EXPECT_EQ(100, flush_handler->get_stats().flush_time_ns); EXPECT_EQ(1, flush_handler->get_stats().flush_count); - EXPECT_EQ(OLAP_ERR_OTHER_ERROR, flush_handler->wait()); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_OTHER_ERROR), flush_handler->wait()); } } // namespace doris diff --git a/be/test/olap/olap_meta_test.cpp b/be/test/olap/olap_meta_test.cpp index 42d7599aff..c871b367d6 100644 --- a/be/test/olap/olap_meta_test.cpp +++ b/be/test/olap/olap_meta_test.cpp @@ -42,8 +42,8 @@ public: FileUtils::create_dir(_root_path); _meta = new OlapMeta(_root_path); - OLAPStatus s = _meta->init(); - EXPECT_EQ(OLAP_SUCCESS, s); + Status s = _meta->init(); + EXPECT_EQ(Status::OK(), s); EXPECT_TRUE(std::filesystem::exists(_root_path + "/meta")); } @@ -66,44 +66,44 @@ TEST_F(OlapMetaTest, TestPutAndGet) { // normal cases std::string key = "key"; std::string value = "value"; - OLAPStatus s = _meta->put(META_COLUMN_FAMILY_INDEX, key, value); - EXPECT_EQ(OLAP_SUCCESS, s); + Status s = _meta->put(META_COLUMN_FAMILY_INDEX, key, value); + EXPECT_EQ(Status::OK(), s); std::string value_get; s = _meta->get(META_COLUMN_FAMILY_INDEX, key, &value_get); - EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(Status::OK(), s); EXPECT_EQ(value, value_get); // abnormal cases s = _meta->get(META_COLUMN_FAMILY_INDEX, "key_not_exist", &value_get); - EXPECT_EQ(OLAP_ERR_META_KEY_NOT_FOUND, s); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_META_KEY_NOT_FOUND), s); } TEST_F(OlapMetaTest, TestRemove) { // normal cases std::string key = "key"; std::string value = "value"; - OLAPStatus s = _meta->put(META_COLUMN_FAMILY_INDEX, key, value); - EXPECT_EQ(OLAP_SUCCESS, s); + Status s = _meta->put(META_COLUMN_FAMILY_INDEX, key, value); + EXPECT_EQ(Status::OK(), s); std::string value_get; s = _meta->get(META_COLUMN_FAMILY_INDEX, key, &value_get); - EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(Status::OK(), s); EXPECT_EQ(value, value_get); s = _meta->remove(META_COLUMN_FAMILY_INDEX, key); - EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(Status::OK(), s); s = _meta->remove(META_COLUMN_FAMILY_INDEX, "key_not_exist"); - EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(Status::OK(), s); } TEST_F(OlapMetaTest, TestIterate) { // normal cases std::string key = "hdr_key"; std::string value = "value"; - OLAPStatus s = OLAP_SUCCESS; + Status s = Status::OK(); for (int i = 0; i < 10; i++) { std::stringstream ss; ss << key << "_" << i; s = _meta->put(META_COLUMN_FAMILY_INDEX, ss.str(), value); - EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(Status::OK(), s); } bool error_flag = false; s = _meta->iterate(META_COLUMN_FAMILY_INDEX, "hdr_", @@ -115,7 +115,7 @@ TEST_F(OlapMetaTest, TestIterate) { return true; }); EXPECT_EQ(false, error_flag); - EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(Status::OK(), s); } } // namespace doris diff --git a/be/test/olap/options_test.cpp b/be/test/olap/options_test.cpp index 4631d71997..9fc6ff3927 100644 --- a/be/test/olap/options_test.cpp +++ b/be/test/olap/options_test.cpp @@ -53,21 +53,21 @@ TEST_F(OptionsTest, parse_root_path) { // /path<.extension>, { root_path = path1; - EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_EQ(Status::OK(), parse_root_path(root_path, &path)); EXPECT_STREQ(path1.c_str(), path.path.c_str()); EXPECT_EQ(-1, path.capacity_bytes); EXPECT_EQ(TStorageMedium::HDD, path.storage_medium); } { root_path = path2; - EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_EQ(Status::OK(), parse_root_path(root_path, &path)); EXPECT_STREQ(path2.c_str(), path.path.c_str()); EXPECT_EQ(-1, path.capacity_bytes); EXPECT_EQ(TStorageMedium::SSD, path.storage_medium); } { root_path = path2 + ", 50"; - EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_EQ(Status::OK(), parse_root_path(root_path, &path)); EXPECT_STREQ(path2.c_str(), path.path.c_str()); EXPECT_EQ(50 * GB_EXCHANGE_BYTE, path.capacity_bytes); EXPECT_EQ(TStorageMedium::SSD, path.storage_medium); @@ -76,35 +76,35 @@ TEST_F(OptionsTest, parse_root_path) { // /path, :,... { root_path = path1 + ", capacity:50, medium: ssd"; - EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_EQ(Status::OK(), parse_root_path(root_path, &path)); EXPECT_STREQ(path1.c_str(), path.path.c_str()); EXPECT_EQ(50 * GB_EXCHANGE_BYTE, path.capacity_bytes); EXPECT_EQ(TStorageMedium::SSD, path.storage_medium); } { root_path = path1 + ", medium: ssd, capacity:30"; - EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_EQ(Status::OK(), parse_root_path(root_path, &path)); EXPECT_STREQ(path1.c_str(), path.path.c_str()); EXPECT_EQ(30 * GB_EXCHANGE_BYTE, path.capacity_bytes); EXPECT_EQ(TStorageMedium::SSD, path.storage_medium); } { root_path = path1 + " , medium: ssd, 60"; - EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_EQ(Status::OK(), parse_root_path(root_path, &path)); EXPECT_STREQ(path1.c_str(), path.path.c_str()); EXPECT_EQ(60 * GB_EXCHANGE_BYTE, path.capacity_bytes); EXPECT_EQ(TStorageMedium::SSD, path.storage_medium); } { root_path = path1 + ", medium: ssd, 60, medium: hdd, capacity: 10"; - EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_EQ(Status::OK(), parse_root_path(root_path, &path)); EXPECT_STREQ(path1.c_str(), path.path.c_str()); EXPECT_EQ(10 * GB_EXCHANGE_BYTE, path.capacity_bytes); EXPECT_EQ(TStorageMedium::HDD, path.storage_medium); } { root_path = path2 + ", medium: hdd, 60, capacity: 10"; - EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_EQ(Status::OK(), parse_root_path(root_path, &path)); EXPECT_STREQ(path2.c_str(), path.path.c_str()); EXPECT_EQ(10 * GB_EXCHANGE_BYTE, path.capacity_bytes); EXPECT_EQ(TStorageMedium::HDD, path.storage_medium); diff --git a/be/test/olap/row_cursor_test.cpp b/be/test/olap/row_cursor_test.cpp index c67dd191a5..817fa9ade3 100644 --- a/be/test/olap/row_cursor_test.cpp +++ b/be/test/olap/row_cursor_test.cpp @@ -269,8 +269,8 @@ TEST_F(TestRowCursor, InitRowCursor) { TabletSchema tablet_schema; set_tablet_schema_for_init(&tablet_schema); RowCursor row; - OLAPStatus res = row.init(tablet_schema); - EXPECT_EQ(res, OLAP_SUCCESS); + Status res = row.init(tablet_schema); + EXPECT_EQ(res, Status::OK()); EXPECT_EQ(row.get_fixed_len(), 126); EXPECT_EQ(row.get_variable_len(), 20); } @@ -279,8 +279,8 @@ TEST_F(TestRowCursor, InitRowCursorWithColumnCount) { TabletSchema tablet_schema; set_tablet_schema_for_init(&tablet_schema); RowCursor row; - OLAPStatus res = row.init(tablet_schema, 5); - EXPECT_EQ(res, OLAP_SUCCESS); + Status res = row.init(tablet_schema, 5); + EXPECT_EQ(res, Status::OK()); EXPECT_EQ(row.get_fixed_len(), 23); EXPECT_EQ(row.get_variable_len(), 0); row.allocate_memory_for_string_type(tablet_schema); @@ -297,8 +297,8 @@ TEST_F(TestRowCursor, InitRowCursorWithColIds) { } RowCursor row; - OLAPStatus res = row.init(tablet_schema, col_ids); - EXPECT_EQ(res, OLAP_SUCCESS); + Status res = row.init(tablet_schema, col_ids); + EXPECT_EQ(res, Status::OK()); EXPECT_EQ(row.get_fixed_len(), 63); EXPECT_EQ(row.get_variable_len(), 20); } @@ -315,14 +315,14 @@ TEST_F(TestRowCursor, InitRowCursorWithScanKey) { std::shared_ptr schema = std::make_shared(tablet_schema.columns(), columns); RowCursor row; - OLAPStatus res = row.init_scan_key(tablet_schema, scan_keys, schema); - EXPECT_EQ(res, OLAP_SUCCESS); + Status res = row.init_scan_key(tablet_schema, scan_keys, schema); + EXPECT_EQ(res, Status::OK()); EXPECT_EQ(row.get_fixed_len(), 34); EXPECT_EQ(row.get_variable_len(), 39); OlapTuple tuple1(scan_keys); res = row.from_tuple(tuple1); - EXPECT_EQ(res, OLAP_SUCCESS); + EXPECT_EQ(res, Status::OK()); OlapTuple tuple2 = row.to_tuple(); EXPECT_TRUE(strncmp(tuple2.get_value(0).c_str(), "0&char_exceed_length", 20)); @@ -334,8 +334,8 @@ TEST_F(TestRowCursor, EqualAndCompare) { set_tablet_schema_for_cmp_and_aggregate(&tablet_schema); RowCursor left; - OLAPStatus res = left.init(tablet_schema); - EXPECT_EQ(res, OLAP_SUCCESS); + Status res = left.init(tablet_schema); + EXPECT_EQ(res, Status::OK()); EXPECT_EQ(left.get_fixed_len(), 78); EXPECT_EQ(left.get_variable_len(), 20); @@ -372,8 +372,8 @@ TEST_F(TestRowCursor, IndexCmp) { set_tablet_schema_for_cmp_and_aggregate(&tablet_schema); RowCursor left; - OLAPStatus res = left.init(tablet_schema, 2); - EXPECT_EQ(res, OLAP_SUCCESS); + Status res = left.init(tablet_schema, 2); + EXPECT_EQ(res, Status::OK()); EXPECT_EQ(left.get_fixed_len(), 22); EXPECT_EQ(left.get_variable_len(), 4); @@ -413,8 +413,8 @@ TEST_F(TestRowCursor, FullKeyCmp) { set_tablet_schema_for_cmp_and_aggregate(&tablet_schema); RowCursor left; - OLAPStatus res = left.init(tablet_schema); - EXPECT_EQ(res, OLAP_SUCCESS); + Status res = left.init(tablet_schema); + EXPECT_EQ(res, Status::OK()); EXPECT_EQ(left.get_fixed_len(), 78); EXPECT_EQ(left.get_variable_len(), 20); @@ -454,8 +454,8 @@ TEST_F(TestRowCursor, AggregateWithoutNull) { RowCursor row; - OLAPStatus res = row.init(tablet_schema); - EXPECT_EQ(res, OLAP_SUCCESS); + Status res = row.init(tablet_schema); + EXPECT_EQ(res, Status::OK()); EXPECT_EQ(row.get_fixed_len(), 78); EXPECT_EQ(row.get_variable_len(), 20); row.allocate_memory_for_string_type(tablet_schema); @@ -518,8 +518,8 @@ TEST_F(TestRowCursor, AggregateWithNull) { RowCursor row; - OLAPStatus res = row.init(tablet_schema); - EXPECT_EQ(res, OLAP_SUCCESS); + Status res = row.init(tablet_schema); + EXPECT_EQ(res, Status::OK()); EXPECT_EQ(row.get_fixed_len(), 78); EXPECT_EQ(row.get_variable_len(), 20); row.allocate_memory_for_string_type(tablet_schema); diff --git a/be/test/olap/rowset/alpha_rowset_test.cpp b/be/test/olap/rowset/alpha_rowset_test.cpp index 85e8d4d0e6..c5f82a100f 100644 --- a/be/test/olap/rowset/alpha_rowset_test.cpp +++ b/be/test/olap/rowset/alpha_rowset_test.cpp @@ -182,11 +182,11 @@ TEST_F(AlphaRowsetTest, TestAlphaRowsetWriter) { create_tablet_schema(AGG_KEYS, &tablet_schema); RowsetWriterContext rowset_writer_context; create_rowset_writer_context(&tablet_schema, &rowset_writer_context); - EXPECT_EQ(OLAP_SUCCESS, + EXPECT_EQ(Status::OK(), RowsetFactory::create_rowset_writer(rowset_writer_context, &_alpha_rowset_writer)); RowCursor row; - OLAPStatus res = row.init(tablet_schema); - EXPECT_EQ(OLAP_SUCCESS, res); + Status res = row.init(tablet_schema); + EXPECT_EQ(Status::OK(), res); int32_t field_0 = 10; row.set_field_content(0, reinterpret_cast(&field_0), _mem_pool.get()); @@ -210,12 +210,12 @@ TEST_F(AlphaRowsetTest, TestAlphaRowsetReader) { RowsetWriterContext rowset_writer_context; create_rowset_writer_context(&tablet_schema, &rowset_writer_context); - EXPECT_EQ(OLAP_SUCCESS, + EXPECT_EQ(Status::OK(), RowsetFactory::create_rowset_writer(rowset_writer_context, &_alpha_rowset_writer)); RowCursor row; - OLAPStatus res = row.init(tablet_schema); - EXPECT_EQ(OLAP_SUCCESS, res); + Status res = row.init(tablet_schema); + EXPECT_EQ(Status::OK(), res); int32_t field_0 = 10; row.set_not_null(0); @@ -227,9 +227,9 @@ TEST_F(AlphaRowsetTest, TestAlphaRowsetReader) { row.set_not_null(2); row.set_field_content(2, reinterpret_cast(&field_2), _mem_pool.get()); res = _alpha_rowset_writer->add_row(row); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); res = _alpha_rowset_writer->flush(); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); RowsetSharedPtr alpha_rowset = _alpha_rowset_writer->build(); EXPECT_TRUE(alpha_rowset != nullptr); RowsetId rowset_id; @@ -238,7 +238,7 @@ TEST_F(AlphaRowsetTest, TestAlphaRowsetReader) { EXPECT_EQ(1, alpha_rowset->num_rows()); RowsetReaderSharedPtr rowset_reader; res = alpha_rowset->create_reader(&rowset_reader); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); std::vector return_columns; for (int i = 0; i < tablet_schema.num_columns(); ++i) { return_columns.push_back(i); @@ -246,7 +246,7 @@ TEST_F(AlphaRowsetTest, TestAlphaRowsetReader) { DeleteHandler delete_handler; DelPredicateArray predicate_array; res = delete_handler.init(tablet_schema, predicate_array, 4); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); RowsetReaderContext rowset_reader_context; std::set load_bf_columns; @@ -255,10 +255,10 @@ TEST_F(AlphaRowsetTest, TestAlphaRowsetReader) { create_rowset_reader_context(&tablet_schema, &return_columns, &delete_handler, &predicates, &load_bf_columns, &conditions, &rowset_reader_context); res = rowset_reader->init(&rowset_reader_context); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); RowBlock* row_block = nullptr; res = rowset_reader->next_block(&row_block); - EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(Status::OK(), res); EXPECT_EQ(1, row_block->remaining()); } diff --git a/be/test/olap/rowset/beta_rowset_test.cpp b/be/test/olap/rowset/beta_rowset_test.cpp index 0725aacd10..53b62c3fa9 100644 --- a/be/test/olap/rowset/beta_rowset_test.cpp +++ b/be/test/olap/rowset/beta_rowset_test.cpp @@ -153,16 +153,16 @@ protected: void create_and_init_rowset_reader(Rowset* rowset, RowsetReaderContext& context, RowsetReaderSharedPtr* result) { auto s = rowset->create_reader(result); - EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(Status::OK(), s); EXPECT_TRUE(*result != nullptr); s = (*result)->init(&context); - EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(Status::OK(), s); } }; TEST_F(BetaRowsetTest, BasicFunctionTest) { - OLAPStatus s; + Status s; TabletSchema tablet_schema; create_tablet_schema(&tablet_schema); @@ -175,7 +175,7 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { std::unique_ptr rowset_writer; s = RowsetFactory::create_rowset_writer(writer_context, &rowset_writer); - EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(Status::OK(), s); RowCursor input_row; input_row.init(tablet_schema); @@ -194,10 +194,10 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { input_row.set_field_content(1, reinterpret_cast(&k2), &mem_pool); input_row.set_field_content(2, reinterpret_cast(&k3), &mem_pool); s = rowset_writer->add_row(input_row); - EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(Status::OK(), s); } s = rowset_writer->flush(); - EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(Status::OK(), s); } rowset = rowset_writer->build(); @@ -221,7 +221,7 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { create_and_init_rowset_reader(rowset.get(), reader_context, &rowset_reader); RowBlock* output_block; uint32_t num_rows_read = 0; - while ((s = rowset_reader->next_block(&output_block)) == OLAP_SUCCESS) { + while ((s = rowset_reader->next_block(&output_block)) == Status::OK()) { EXPECT_TRUE(output_block != nullptr); EXPECT_GT(output_block->row_num(), 0); EXPECT_EQ(0, output_block->pos()); @@ -244,7 +244,7 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { num_rows_read++; } } - EXPECT_EQ(OLAP_ERR_DATA_EOF, s); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DATA_EOF), s); EXPECT_TRUE(output_block == nullptr); EXPECT_EQ(rowset->rowset_meta()->num_rows(), num_rows_read); } @@ -260,7 +260,7 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { create_and_init_rowset_reader(rowset.get(), reader_context, &rowset_reader); RowBlock* output_block; uint32_t num_rows_read = 0; - while ((s = rowset_reader->next_block(&output_block)) == OLAP_SUCCESS) { + while ((s = rowset_reader->next_block(&output_block)) == Status::OK()) { EXPECT_TRUE(output_block != nullptr); EXPECT_EQ(1, output_block->row_num()); EXPECT_EQ(0, output_block->pos()); @@ -280,7 +280,7 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { num_rows_read++; } } - EXPECT_EQ(OLAP_ERR_DATA_EOF, s); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DATA_EOF), s); EXPECT_TRUE(output_block == nullptr); EXPECT_EQ(1, num_rows_read); } @@ -302,7 +302,7 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { RowBlock* output_block; uint32_t num_rows_read = 0; - while ((s = rowset_reader->next_block(&output_block)) == OLAP_SUCCESS) { + while ((s = rowset_reader->next_block(&output_block)) == Status::OK()) { EXPECT_TRUE(output_block != nullptr); EXPECT_GT(output_block->row_num(), 0); EXPECT_EQ(0, output_block->pos()); @@ -318,7 +318,7 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { num_rows_read++; } } - EXPECT_EQ(OLAP_ERR_DATA_EOF, s); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DATA_EOF), s); EXPECT_TRUE(output_block == nullptr); EXPECT_EQ(rowset->rowset_meta()->num_rows(), num_rows_read); } @@ -335,7 +335,7 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { RowBlock* output_block; uint32_t num_rows_read = 0; - while ((s = rowset_reader->next_block(&output_block)) == OLAP_SUCCESS) { + while ((s = rowset_reader->next_block(&output_block)) == Status::OK()) { EXPECT_TRUE(output_block != nullptr); EXPECT_LE(output_block->row_num(), 100); EXPECT_EQ(0, output_block->pos()); @@ -351,7 +351,7 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { num_rows_read++; } } - EXPECT_EQ(OLAP_ERR_DATA_EOF, s); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_DATA_EOF), s); EXPECT_TRUE(output_block == nullptr); EXPECT_EQ(100, num_rows_read); delete predicate; diff --git a/be/test/olap/rowset/rowset_meta_manager_test.cpp b/be/test/olap/rowset/rowset_meta_manager_test.cpp index 54fcf6e79d..1927d6adbd 100644 --- a/be/test/olap/rowset/rowset_meta_manager_test.cpp +++ b/be/test/olap/rowset/rowset_meta_manager_test.cpp @@ -60,8 +60,8 @@ public: EXPECT_TRUE(std::filesystem::create_directory(meta_path)); _meta = new (std::nothrow) OlapMeta(meta_path); EXPECT_NE(nullptr, _meta); - OLAPStatus st = _meta->init(); - EXPECT_TRUE(st == OLAP_SUCCESS); + Status st = _meta->init(); + EXPECT_TRUE(st == Status::OK()); EXPECT_TRUE(std::filesystem::exists("./meta")); std::ifstream infile(rowset_meta_path); @@ -98,32 +98,32 @@ TEST_F(RowsetMetaManagerTest, TestSaveAndGetAndRemove) { EXPECT_EQ(rowset_meta.rowset_id(), rowset_id); RowsetMetaPB rowset_meta_pb; rowset_meta.to_rowset_pb(&rowset_meta_pb); - OLAPStatus status = RowsetMetaManager::save(_meta, _tablet_uid, rowset_id, rowset_meta_pb); - EXPECT_TRUE(status == OLAP_SUCCESS); + Status status = RowsetMetaManager::save(_meta, _tablet_uid, rowset_id, rowset_meta_pb); + EXPECT_TRUE(status == Status::OK()); EXPECT_TRUE(RowsetMetaManager::check_rowset_meta(_meta, _tablet_uid, rowset_id)); std::string json_rowset_meta_read; status = RowsetMetaManager::get_json_rowset_meta(_meta, _tablet_uid, rowset_id, &json_rowset_meta_read); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); EXPECT_EQ(_json_rowset_meta, json_rowset_meta_read); status = RowsetMetaManager::remove(_meta, _tablet_uid, rowset_id); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); EXPECT_FALSE(RowsetMetaManager::check_rowset_meta(_meta, _tablet_uid, rowset_id)); RowsetMetaSharedPtr rowset_meta_read(new RowsetMeta()); status = RowsetMetaManager::get_rowset_meta(_meta, _tablet_uid, rowset_id, rowset_meta_read); - EXPECT_TRUE(status != OLAP_SUCCESS); + EXPECT_TRUE(status != Status::OK()); } TEST_F(RowsetMetaManagerTest, TestLoad) { RowsetId rowset_id; rowset_id.init(10000); - OLAPStatus status = RowsetMetaManager::load_json_rowset_meta(_meta, rowset_meta_path); - EXPECT_TRUE(status == OLAP_SUCCESS); + Status status = RowsetMetaManager::load_json_rowset_meta(_meta, rowset_meta_path); + EXPECT_TRUE(status == Status::OK()); EXPECT_TRUE(RowsetMetaManager::check_rowset_meta(_meta, _tablet_uid, rowset_id)); std::string json_rowset_meta_read; status = RowsetMetaManager::get_json_rowset_meta(_meta, _tablet_uid, rowset_id, &json_rowset_meta_read); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); EXPECT_EQ(_json_rowset_meta, json_rowset_meta_read); } diff --git a/be/test/olap/rowset/rowset_meta_test.cpp b/be/test/olap/rowset/rowset_meta_test.cpp index da101f0f6b..0eb7957eee 100644 --- a/be/test/olap/rowset/rowset_meta_test.cpp +++ b/be/test/olap/rowset/rowset_meta_test.cpp @@ -48,8 +48,8 @@ public: EXPECT_TRUE(std::filesystem::create_directory(meta_path)); _meta = new (std::nothrow) OlapMeta(meta_path); EXPECT_NE(nullptr, _meta); - OLAPStatus st = _meta->init(); - EXPECT_TRUE(st == OLAP_SUCCESS); + Status st = _meta->init(); + EXPECT_TRUE(st == Status::OK()); EXPECT_TRUE(std::filesystem::exists("./meta")); std::ifstream infile(rowset_meta_path); diff --git a/be/test/olap/rowset/segment_v2/segment_test.cpp b/be/test/olap/rowset/segment_v2/segment_test.cpp index 5ea303aabb..d7b03e1195 100644 --- a/be/test/olap/rowset/segment_v2/segment_test.cpp +++ b/be/test/olap/rowset/segment_v2/segment_test.cpp @@ -123,7 +123,7 @@ protected: RowCursor row; auto olap_st = row.init(build_schema); - EXPECT_EQ(OLAP_SUCCESS, olap_st); + EXPECT_EQ(Status::OK(), olap_st); for (size_t rid = 0; rid < nrows; ++rid) { for (int cid = 0; cid < build_schema.num_columns(); ++cid) { @@ -448,7 +448,7 @@ TEST_F(SegmentReaderWriterTest, TestIndex) { condition.__set_condition_values(vals); std::shared_ptr conditions(new Conditions()); conditions->set_tablet_schema(&tablet_schema); - EXPECT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); + EXPECT_EQ(Status::OK(), conditions->append_condition(condition)); StorageReadOptions read_opts; read_opts.stats = &stats; @@ -471,7 +471,7 @@ TEST_F(SegmentReaderWriterTest, TestIndex) { condition.__set_condition_values(vals); std::shared_ptr conditions(new Conditions()); conditions->set_tablet_schema(&tablet_schema); - EXPECT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); + EXPECT_EQ(Status::OK(), conditions->append_condition(condition)); StorageReadOptions read_opts; read_opts.stats = &stats; @@ -520,7 +520,7 @@ TEST_F(SegmentReaderWriterTest, TestIndex) { condition.__set_condition_values(vals); std::shared_ptr conditions(new Conditions()); conditions->set_tablet_schema(&tablet_schema); - EXPECT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); + EXPECT_EQ(Status::OK(), conditions->append_condition(condition)); // the second page read will be pruned by the following delete predicate TCondition delete_condition; @@ -530,7 +530,7 @@ TEST_F(SegmentReaderWriterTest, TestIndex) { delete_condition.__set_condition_values(vals2); std::shared_ptr delete_conditions(new Conditions()); delete_conditions->set_tablet_schema(&tablet_schema); - EXPECT_EQ(OLAP_SUCCESS, delete_conditions->append_condition(delete_condition)); + EXPECT_EQ(Status::OK(), delete_conditions->append_condition(delete_condition)); StorageReadOptions read_opts; read_opts.stats = &stats; @@ -583,7 +583,7 @@ TEST_F(SegmentReaderWriterTest, TestIndex) { condition.__set_condition_values(vals); std::shared_ptr conditions(new Conditions()); conditions->set_tablet_schema(&tablet_schema); - EXPECT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); + EXPECT_EQ(Status::OK(), conditions->append_condition(condition)); read_opts.conditions = conditions.get(); std::unique_ptr iter; segment->new_iterator(schema, read_opts, &iter); @@ -630,7 +630,7 @@ TEST_F(SegmentReaderWriterTest, estimate_segment_size) { RowCursor row; auto olap_st = row.init(*tablet_schema); - EXPECT_EQ(OLAP_SUCCESS, olap_st); + EXPECT_EQ(Status::OK(), olap_st); // 0, 1, 2, 3 // 10, 11, 12, 13 @@ -803,7 +803,7 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { RowCursor row; auto olap_st = row.init(*tablet_schema); - EXPECT_EQ(OLAP_SUCCESS, olap_st); + EXPECT_EQ(Status::OK(), olap_st); // 0, 1, 2, 3 // 10, 11, 12, 13 @@ -943,7 +943,7 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { condition.__set_condition_values(vals); std::shared_ptr conditions(new Conditions()); conditions->set_tablet_schema(tablet_schema.get()); - EXPECT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); + EXPECT_EQ(Status::OK(), conditions->append_condition(condition)); StorageReadOptions read_opts; read_opts.stats = &stats; @@ -1000,7 +1000,7 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { condition.__set_condition_values(vals); std::shared_ptr conditions(new Conditions()); conditions->set_tablet_schema(tablet_schema.get()); - EXPECT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); + EXPECT_EQ(Status::OK(), conditions->append_condition(condition)); StorageReadOptions read_opts; read_opts.stats = &stats; diff --git a/be/test/olap/run_length_byte_test.cpp b/be/test/olap/run_length_byte_test.cpp index a7c2473dab..7e5cc3445d 100644 --- a/be/test/olap/run_length_byte_test.cpp +++ b/be/test/olap/run_length_byte_test.cpp @@ -53,9 +53,9 @@ TEST(TestStream, UncompressOutStream) { EXPECT_EQ(head.type, StreamHead::UNCOMPRESSED); EXPECT_EQ(head.length, 1); char data; - EXPECT_EQ(OLAP_SUCCESS, (*it)->get((char*)&data)); + EXPECT_EQ(Status::OK(), (*it)->get((char*)&data)); EXPECT_EQ(0x5A, data); - EXPECT_NE(OLAP_SUCCESS, (*it)->get((char*)&data)); + EXPECT_NE(Status::OK(), (*it)->get((char*)&data)); SAFE_DELETE(out_stream); } @@ -92,15 +92,15 @@ TEST(TestStream, UncompressOutStream2) { char data; for (int32_t i = 0; i < OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE - 1; i++) { - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5a); } - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5a); - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5a); - EXPECT_NE(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_NE(in_stream->read(&data), Status::OK()); SAFE_DELETE(out_stream); SAFE_DELETE(in_stream); @@ -142,16 +142,16 @@ TEST(TestStream, UncompressOutStream3) { char data; for (int32_t i = 0; i < OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE; i++) { - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5a); } - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5a); - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5a); - EXPECT_NE(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_NE(in_stream->read(&data), Status::OK()); SAFE_DELETE(in_stream); SAFE_DELETE(out_stream); @@ -185,7 +185,7 @@ TEST(TestStream, UncompressInStream) { EXPECT_EQ(in_stream->available(), 1); char data; - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5a); SAFE_DELETE(in_stream); @@ -251,13 +251,13 @@ TEST(TestStream, CompressOutStream2) { char data; for (int32_t i = 0; i < OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE; i++) { - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5a); } - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5a); - EXPECT_NE(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_NE(in_stream->read(&data), Status::OK()); SAFE_DELETE(in_stream); SAFE_DELETE(out_stream); @@ -297,15 +297,15 @@ TEST(TestStream, CompressOutStream3) { char data; for (int32_t i = 0; i < OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE; i++) { - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5a); } for (int32_t i = 0; i < sizeof(write_data); i++) { - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, write_data[i]); } - EXPECT_NE(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_NE(in_stream->read(&data), Status::OK()); SAFE_DELETE(in_stream); SAFE_DELETE(out_stream); @@ -348,21 +348,21 @@ TEST(TestStream, CompressOutStream4) { char data; for (int32_t i = 0; i < 15; i++) { - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5a); } for (int32_t i = 0; i < 12; i++) { - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5a); } for (int32_t i = 0; i < 6; i++) { - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, i); } - EXPECT_NE(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_NE(in_stream->read(&data), Status::OK()); SAFE_DELETE(in_stream); SAFE_DELETE(out_stream); @@ -402,15 +402,15 @@ TEST(TestStream, CompressMassOutStream) { char data; for (int32_t i = 0; i < 100; i++) { - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5a); } for (int32_t i = 0; i < 100; i++) { - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, i); } - EXPECT_NE(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_NE(in_stream->read(&data), Status::OK()); SAFE_DELETE(in_stream); for (auto input : inputs) { @@ -447,12 +447,12 @@ TEST(TestStream, CompressInStream) { EXPECT_EQ(in_stream->available(), OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE); char data; for (int32_t i = 0; i < OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE - 1; ++i) { - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5a); } - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5a); - EXPECT_NE(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_NE(in_stream->read(&data), Status::OK()); SAFE_DELETE_ARRAY(write_data); SAFE_DELETE(out_stream); @@ -510,7 +510,7 @@ TEST(TestStream, SeekUncompress) { in_stream->seek(&position); char data; - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5b); SAFE_DELETE(out_stream); SAFE_DELETE(in_stream); @@ -549,7 +549,7 @@ TEST(TestStream, SkipUncompress) { EXPECT_EQ(in_stream->available(), sizeof(write_data) + 1); in_stream->skip(sizeof(write_data) - 1); char data; - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, write_data[sizeof(write_data) - 1]); SAFE_DELETE(out_stream); SAFE_DELETE(in_stream); @@ -602,7 +602,7 @@ TEST(TestStream, SeekCompress) { PositionProvider position(&entry); in_stream->seek(&position); char data; - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5b); SAFE_DELETE(out_stream); SAFE_DELETE(in_stream); @@ -639,7 +639,7 @@ TEST(TestStream, SkipCompress) { in_stream->skip(10); char data; - EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), Status::OK()); EXPECT_EQ(data, 0x5e); SAFE_DELETE(out_stream); @@ -673,13 +673,13 @@ public: } void CreateReader() { - EXPECT_EQ(OLAP_SUCCESS, + EXPECT_EQ(Status::OK(), helper.open_with_mode(_file_path.c_str(), O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR)); _out_stream->write_to_file(&helper, 0); helper.close(); - EXPECT_EQ(OLAP_SUCCESS, + EXPECT_EQ(Status::OK(), helper.open_with_mode(_file_path.c_str(), O_RDONLY, S_IRUSR | S_IWUSR)); _shared_buffer = StorageByteBuffer::create(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE + @@ -689,7 +689,7 @@ public: _stream = new (std::nothrow) ReadOnlyFileStream(&helper, &_shared_buffer, 0, helper.length(), nullptr, OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, &_stats); - EXPECT_EQ(OLAP_SUCCESS, _stream->init()); + EXPECT_EQ(Status::OK(), _stream->init()); _reader = new (std::nothrow) RunLengthByteReader(_stream); EXPECT_TRUE(_reader != nullptr); @@ -713,7 +713,7 @@ TEST_F(TestRunLengthByte, ReadWriteOneByte) { EXPECT_TRUE(_reader->has_next()); char value = 0xff; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 0X5A); EXPECT_FALSE(_reader->has_next()); @@ -737,7 +737,7 @@ TEST_F(TestRunLengthByte, ReadWriteMultiBytes) { for (int32_t i = 0; i < sizeof(write_data); i++) { EXPECT_TRUE(_reader->has_next()); char value = 0xff; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -762,7 +762,7 @@ TEST_F(TestRunLengthByte, ReadWriteSameBytes) { for (int32_t i = 0; i < sizeof(write_data); i++) { EXPECT_TRUE(_reader->has_next()); char value = 0xff; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -801,13 +801,13 @@ TEST_F(TestRunLengthByte, Seek) { PositionProvider position(&entry); _reader->seek(&position); char value = 0xff; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 0x5e); - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 0x5f); - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 0x60); - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 0x61); } @@ -825,9 +825,9 @@ TEST_F(TestRunLengthByte, Skip) { _reader->skip(sizeof(write_data) - 1); char value = 0xff; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[sizeof(write_data) - 1]); - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 0x5e); } diff --git a/be/test/olap/run_length_integer_test.cpp b/be/test/olap/run_length_integer_test.cpp index 5a70e121a4..11149d4cf4 100644 --- a/be/test/olap/run_length_integer_test.cpp +++ b/be/test/olap/run_length_integer_test.cpp @@ -52,13 +52,13 @@ public: } void CreateReader() { - EXPECT_EQ(OLAP_SUCCESS, + EXPECT_EQ(Status::OK(), helper.open_with_mode(_file_path.c_str(), O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR)); _out_stream->write_to_file(&helper, 0); helper.close(); - EXPECT_EQ(OLAP_SUCCESS, + EXPECT_EQ(Status::OK(), helper.open_with_mode(_file_path.c_str(), O_RDONLY, S_IRUSR | S_IWUSR)); _shared_buffer = StorageByteBuffer::create(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE + @@ -68,7 +68,7 @@ public: _stream = new (std::nothrow) ReadOnlyFileStream(&helper, &_shared_buffer, 0, helper.length(), nullptr, OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, &_stats); - EXPECT_EQ(OLAP_SUCCESS, _stream->init()); + EXPECT_EQ(Status::OK(), _stream->init()); _reader = new (std::nothrow) RunLengthIntegerReader(_stream, false); EXPECT_TRUE(_reader != nullptr); @@ -87,15 +87,15 @@ public: TEST_F(TestRunLengthUnsignInteger, ReadWriteOneInteger) { // write data - EXPECT_EQ(OLAP_SUCCESS, _writer->write(100)); - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->write(100)); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 100); EXPECT_FALSE(_reader->has_next()); @@ -105,10 +105,10 @@ TEST_F(TestRunLengthUnsignInteger, ReadWriteMultiInteger) { // write data int64_t write_data[] = {100, 102, 105, 106}; for (int32_t i = 0; i < 4; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -116,7 +116,7 @@ TEST_F(TestRunLengthUnsignInteger, ReadWriteMultiInteger) { for (int32_t i = 0; i < 4; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -127,7 +127,7 @@ TEST_F(TestRunLengthUnsignInteger, seek) { // write data int64_t write_data[] = {100, 102, 105, 106}; for (int32_t i = 0; i < 4; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } PositionEntryWriter index_entry; @@ -138,7 +138,7 @@ TEST_F(TestRunLengthUnsignInteger, seek) { _writer->write(109); _writer->write(110); - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -151,13 +151,13 @@ TEST_F(TestRunLengthUnsignInteger, seek) { PositionProvider position(&entry); _reader->seek(&position); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 107); - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 108); - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 109); - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 110); } @@ -165,30 +165,30 @@ TEST_F(TestRunLengthUnsignInteger, skip) { // write data int64_t write_data[] = {100, 102, 105, 106}; for (int32_t i = 0; i < 4; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); _reader->skip(2); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 105); - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 106); - EXPECT_NE(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_NE(Status::OK(), _reader->next(&value)); } TEST_F(TestRunLengthUnsignInteger, ShortRepeatEncoding) { // write data int64_t write_data[] = {100, 100, 100, 100}; for (int32_t i = 0; i < 4; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -196,7 +196,7 @@ TEST_F(TestRunLengthUnsignInteger, ShortRepeatEncoding) { for (int32_t i = 0; i < 4; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -207,9 +207,9 @@ TEST_F(TestRunLengthUnsignInteger, ShortRepeatEncoding2) { // write data int64_t write_data[] = {876012345678912, 876012345678912, 876012345678912, 876012345678912}; for (int32_t i = 0; i < 4; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -217,7 +217,7 @@ TEST_F(TestRunLengthUnsignInteger, ShortRepeatEncoding2) { for (int32_t i = 0; i < 4; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -228,9 +228,9 @@ TEST_F(TestRunLengthUnsignInteger, ShortRepeatEncoding3) { // write data int64_t write_data[] = {876012345678912}; for (int32_t i = 0; i < 1; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -238,7 +238,7 @@ TEST_F(TestRunLengthUnsignInteger, ShortRepeatEncoding3) { for (int32_t i = 0; i < 1; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -249,9 +249,9 @@ TEST_F(TestRunLengthUnsignInteger, DirectEncoding) { // write data int64_t write_data[] = {1703, 6054, 8760, 902}; for (int32_t i = 0; i < 4; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -259,7 +259,7 @@ TEST_F(TestRunLengthUnsignInteger, DirectEncoding) { for (int32_t i = 0; i < 4; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -270,9 +270,9 @@ TEST_F(TestRunLengthUnsignInteger, DirectEncoding2) { // write data int64_t write_data[] = {1703, 6054, 876012345678912, 902, 9292, 184932, 873624, 827364, 999, 8}; for (int32_t i = 0; i < 10; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -280,7 +280,7 @@ TEST_F(TestRunLengthUnsignInteger, DirectEncoding2) { for (int32_t i = 0; i < 10; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -293,9 +293,9 @@ TEST_F(TestRunLengthUnsignInteger, PatchedBaseEncoding1) { 1703, 6054, 876012345678912, 902, 9292, 184932, 873624, 827364, 999, 8, 1, 3323, 432232523, 90982, 9, 223234, 5, 44, 5, 3}; for (int32_t i = 0; i < 20; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -303,7 +303,7 @@ TEST_F(TestRunLengthUnsignInteger, PatchedBaseEncoding1) { for (int32_t i = 0; i < 20; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -316,9 +316,9 @@ TEST_F(TestRunLengthUnsignInteger, PatchedBaseEncoding2) { 1703, 6054, 902, 9292, 184932, 873624, 827364, 999, 8, 1, 3323, 432232523, 90982, 9, 223234, 5, 876012345678912, 44, 5, 3}; for (int32_t i = 0; i < 20; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -326,7 +326,7 @@ TEST_F(TestRunLengthUnsignInteger, PatchedBaseEncoding2) { for (int32_t i = 0; i < 20; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -357,13 +357,13 @@ public: } void CreateReader() { - EXPECT_EQ(OLAP_SUCCESS, + EXPECT_EQ(Status::OK(), helper.open_with_mode(_file_path.c_str(), O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR)); _out_stream->write_to_file(&helper, 0); helper.close(); - EXPECT_EQ(OLAP_SUCCESS, + EXPECT_EQ(Status::OK(), helper.open_with_mode(_file_path.c_str(), O_RDONLY, S_IRUSR | S_IWUSR)); _shared_buffer = StorageByteBuffer::create(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE + @@ -373,7 +373,7 @@ public: _stream = new (std::nothrow) ReadOnlyFileStream(&helper, &_shared_buffer, 0, helper.length(), nullptr, OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, &_stats); - EXPECT_EQ(OLAP_SUCCESS, _stream->init()); + EXPECT_EQ(Status::OK(), _stream->init()); _reader = new (std::nothrow) RunLengthIntegerReader(_stream, true); EXPECT_TRUE(_reader != nullptr); @@ -391,15 +391,15 @@ public: TEST_F(TestRunLengthSignInteger, ReadWriteOneInteger) { // write data - EXPECT_EQ(OLAP_SUCCESS, _writer->write(100)); - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->write(100)); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 100); EXPECT_FALSE(_reader->has_next()); @@ -407,15 +407,15 @@ TEST_F(TestRunLengthSignInteger, ReadWriteOneInteger) { TEST_F(TestRunLengthSignInteger, ReadWriteOneInteger2) { // write data - EXPECT_EQ(OLAP_SUCCESS, _writer->write(1234567800)); - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->write(1234567800)); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 1234567800); EXPECT_FALSE(_reader->has_next()); @@ -425,10 +425,10 @@ TEST_F(TestRunLengthSignInteger, ReadWriteMultiInteger) { // write data int64_t write_data[] = {100, 101, 104, 107}; for (int32_t i = 0; i < 4; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -436,7 +436,7 @@ TEST_F(TestRunLengthSignInteger, ReadWriteMultiInteger) { for (int32_t i = 0; i < 4; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -447,7 +447,7 @@ TEST_F(TestRunLengthSignInteger, seek) { // write data int64_t write_data[] = {100, 102, 105, 106}; for (int32_t i = 0; i < 4; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } PositionEntryWriter index_entry; @@ -458,7 +458,7 @@ TEST_F(TestRunLengthSignInteger, seek) { _writer->write(109); _writer->write(110); - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -471,13 +471,13 @@ TEST_F(TestRunLengthSignInteger, seek) { PositionProvider position(&entry); _reader->seek(&position); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 107); - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 108); - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 109); - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 110); } @@ -485,30 +485,30 @@ TEST_F(TestRunLengthSignInteger, skip) { // write data int64_t write_data[] = {100, 102, 105, 106}; for (int32_t i = 0; i < 4; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); _reader->skip(2); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 105); - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, 106); - EXPECT_NE(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_NE(Status::OK(), _reader->next(&value)); } TEST_F(TestRunLengthSignInteger, ShortRepeatEncoding) { // write data int64_t write_data[] = {-100, -100, -100, -100}; for (int32_t i = 0; i < 4; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -516,7 +516,7 @@ TEST_F(TestRunLengthSignInteger, ShortRepeatEncoding) { for (int32_t i = 0; i < 4; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -527,9 +527,9 @@ TEST_F(TestRunLengthSignInteger, DirectEncoding) { // write data int64_t write_data[] = {-1703, -6054, -8760, -902}; for (int32_t i = 0; i < 4; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -537,7 +537,7 @@ TEST_F(TestRunLengthSignInteger, DirectEncoding) { for (int32_t i = 0; i < 4; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -547,10 +547,10 @@ TEST_F(TestRunLengthSignInteger, DirectEncoding) { TEST_F(TestRunLengthUnsignInteger, ReadWriteMassInteger) { // write data for (int64_t i = 0; i < 100000; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(i)); + EXPECT_EQ(Status::OK(), _writer->write(i)); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -558,7 +558,7 @@ TEST_F(TestRunLengthUnsignInteger, ReadWriteMassInteger) { for (int64_t i = 0; i < 100000; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, i); } } @@ -569,9 +569,9 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding1) { 1703, 6054, -876012345678912, 902, 9292, 184932, 873624, 827364, 999, 8, 1, 3323, 432232523, -90982, 9, 223234, 5, 44, 5, 3}; for (int32_t i = 0; i < 20; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -579,7 +579,7 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding1) { for (int32_t i = 0; i < 20; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -592,9 +592,9 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding2) { -1703, -6054, -876012345678912, -902, -9292, -184932, -873624, -827364, -999, -8, -1, -3323, -432232523, -90982, -9, -223234, -5, -44, -5, -3}; for (int32_t i = 0; i < 20; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -602,7 +602,7 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding2) { for (int32_t i = 0; i < 20; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -616,9 +616,9 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding3) { 1703, 6054, 876012345678912, 902, 9292, 184932, 873624, 827364, 999, 888, -300, 3323, 432232523, -90982, 450, 223234, 690, 444, 555, 333}; for (int32_t i = 0; i < 20; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -626,7 +626,7 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding3) { for (int32_t i = 0; i < 20; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -919,9 +919,9 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding4) { 876012345678912}; for (int32_t i = 0; i < 281; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -929,7 +929,7 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding4) { for (int32_t i = 0; i < 281; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -994,9 +994,9 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding5) { 3323, 876012345678912}; for (int32_t i = 0; i < 512; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -1004,7 +1004,7 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding5) { for (int32_t i = 0; i < 512; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -1028,9 +1028,9 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding6) { -15605417571528704, -15605417571528704, -13322895849418752, -13322895849418752, -15605417571528704, -13322895849418752}; for (int32_t i = 0; i < 30; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -1038,7 +1038,7 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding6) { for (int32_t i = 0; i < 30; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -1049,10 +1049,10 @@ TEST_F(TestRunLengthSignInteger, DirectEncodingForDeltaOverflows1) { // write data int64_t write_data[] = {4513343538618202711, 2911390882471569739, -9181829309989854913}; for (int32_t i = 0; i < 3; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -1060,7 +1060,7 @@ TEST_F(TestRunLengthSignInteger, DirectEncodingForDeltaOverflows1) { for (int32_t i = 0; i < 3; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } @@ -1459,9 +1459,9 @@ TEST_F(TestRunLengthSignInteger, DirectEncodingForDeltaOverflows2) { 9223372036854775807}; for (int32_t i = 0; i < 388; i++) { - EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(Status::OK(), _writer->write(write_data[i])); } - EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(Status::OK(), _writer->flush()); // read data CreateReader(); @@ -1469,7 +1469,7 @@ TEST_F(TestRunLengthSignInteger, DirectEncodingForDeltaOverflows2) { for (int32_t i = 0; i < 388; i++) { EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(Status::OK(), _reader->next(&value)); EXPECT_EQ(value, write_data[i]); } diff --git a/be/test/olap/schema_change_test.cpp b/be/test/olap/schema_change_test.cpp index c3a4a7fb8f..4b58363320 100644 --- a/be/test/olap/schema_change_test.cpp +++ b/be/test/olap/schema_change_test.cpp @@ -86,7 +86,7 @@ public: _column_writer = ColumnWriter::create(0, tablet_schema, _stream_factory, 1024, BLOOM_FILTER_DEFAULT_FPP); EXPECT_TRUE(_column_writer != nullptr); - EXPECT_EQ(_column_writer->init(), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->init(), Status::OK()); } void create_column_reader(const TabletSchema& tablet_schema) { @@ -112,7 +112,7 @@ public: EXPECT_EQ(system("mkdir -p ./ut_dir"), 0); EXPECT_EQ(system("rm -f ./ut_dir/tmp_file"), 0); - EXPECT_EQ(OLAP_SUCCESS, + EXPECT_EQ(Status::OK(), helper.open_with_mode("./ut_dir/tmp_file", O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR)); std::vector off; @@ -154,7 +154,7 @@ public: } helper.close(); - EXPECT_EQ(OLAP_SUCCESS, + EXPECT_EQ(Status::OK(), helper.open_with_mode("./ut_dir/tmp_file", O_RDONLY, S_IRUSR | S_IWUSR)); SAFE_DELETE(_shared_buffer); @@ -171,12 +171,12 @@ public: ReadOnlyFileStream* in_stream = new (std::nothrow) ReadOnlyFileStream(&helper, &_shared_buffer, off[i], length[i], lz4_decompress, buffer_size[i], &_stats); - EXPECT_EQ(OLAP_SUCCESS, in_stream->init()); + EXPECT_EQ(Status::OK(), in_stream->init()); _map_in_streams[name[i]] = in_stream; } EXPECT_EQ(_column_reader->init(&_map_in_streams, 1024, _mem_pool.get(), &_stats), - OLAP_SUCCESS); + Status::OK()); } void set_tablet_schema(const std::string& name, const std::string& type, @@ -195,12 +195,12 @@ public: } void create_and_save_last_position() { - EXPECT_EQ(_column_writer->create_row_index_entry(), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->create_row_index_entry(), Status::OK()); } template void test_convert_to_varchar(const std::string& type_name, int type_size, T val, - const std::string& expected_val, OLAPStatus expected_st, + const std::string& expected_val, Status expected_st, int varchar_len = 255) { TabletSchema src_tablet_schema; set_tablet_schema("ConvertColumn", type_name, "REPLACE", type_size, false, false, @@ -216,9 +216,9 @@ public: write_row.set_field_content(0, reinterpret_cast(&val), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); helper.close(); TabletSchema dst_tablet_schema; @@ -229,23 +229,23 @@ public: read_row.init(dst_tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); auto st = read_row.convert_from(0, data, write_row.column_schema(0)->type_info(), _mem_pool.get()); EXPECT_EQ(st, expected_st); - if (st == OLAP_SUCCESS) { + if (st == Status::OK()) { std::string dst_str = read_row.column_schema(0)->to_string(read_row.cell_ptr(0)); EXPECT_TRUE(dst_str.compare(0, expected_val.size(), expected_val) == 0); } const auto* tp = get_scalar_type_info(); st = read_row.convert_from(0, read_row.cell_ptr(0), tp, _mem_pool.get()); - EXPECT_EQ(st, OLAP_ERR_INVALID_SCHEMA); + EXPECT_EQ(st, Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA)); } void test_convert_from_varchar(const std::string& type_name, int type_size, - const std::string& value, OLAPStatus expected_st) { + const std::string& value, Status expected_st) { TabletSchema tablet_schema; set_tablet_schema("VarcharColumn", "VARCHAR", "REPLACE", 255, false, false, &tablet_schema); create_column_writer(tablet_schema); @@ -260,9 +260,9 @@ public: write_row.set_field_content(0, reinterpret_cast(&normal_str), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); helper.close(); TabletSchema converted_tablet_schema; @@ -273,19 +273,19 @@ public: read_row.init(converted_tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); auto st = read_row.convert_from(0, data, write_row.column_schema(0)->type_info(), _mem_pool.get()); EXPECT_EQ(st, expected_st); - if (st == OLAP_SUCCESS) { + if (st == Status::OK()) { std::string dst_str = read_row.column_schema(0)->to_string(read_row.cell_ptr(0)); EXPECT_TRUE(dst_str.compare(0, value.size(), value) == 0); } const auto* tp = get_scalar_type_info(); st = read_row.convert_from(0, read_row.cell_ptr(0), tp, _mem_pool.get()); - EXPECT_EQ(st, OLAP_ERR_INVALID_SCHEMA); + EXPECT_EQ(st, Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA)); } ColumnWriter* _column_writer; @@ -326,16 +326,16 @@ TEST_F(TestColumn, ConvertFloatToDouble) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); value = 3.234; write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data TabletSchema convert_tablet_schema; @@ -344,7 +344,7 @@ TEST_F(TestColumn, ConvertFloatToDouble) { RowCursor read_row; read_row.init(convert_tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); read_row.convert_from(0, data, write_row.column_schema(0)->type_info(), _mem_pool.get()); //float val1 = *reinterpret_cast(read_row.cell_ptr(0)); @@ -359,8 +359,8 @@ TEST_F(TestColumn, ConvertFloatToDouble) { //test not support type const auto* tp = get_scalar_type_info(); - OLAPStatus st = read_row.convert_from(0, data, tp, _mem_pool.get()); - EXPECT_TRUE(st == OLAP_ERR_INVALID_SCHEMA); + Status st = read_row.convert_from(0, data, tp, _mem_pool.get()); + EXPECT_TRUE(st == Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA)); } TEST_F(TestColumn, ConvertDatetimeToDate) { @@ -382,10 +382,10 @@ TEST_F(TestColumn, ConvertDatetimeToDate) { write_row.from_tuple(tuple); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // read data TabletSchema convert_tablet_schema; @@ -395,7 +395,7 @@ TEST_F(TestColumn, ConvertDatetimeToDate) { read_row.init(convert_tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); read_row.convert_from(0, data, write_row.column_schema(0)->type_info(), _mem_pool.get()); std::string dest_string = read_row.column_schema(0)->to_string(read_row.cell_ptr(0)); @@ -403,8 +403,8 @@ TEST_F(TestColumn, ConvertDatetimeToDate) { //test not support type const auto* tp = get_scalar_type_info(); - OLAPStatus st = read_row.convert_from(0, data, tp, _mem_pool.get()); - EXPECT_TRUE(st == OLAP_ERR_INVALID_SCHEMA); + Status st = read_row.convert_from(0, data, tp, _mem_pool.get()); + EXPECT_TRUE(st == Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA)); } TEST_F(TestColumn, ConvertDateToDatetime) { @@ -427,10 +427,10 @@ TEST_F(TestColumn, ConvertDateToDatetime) { write_row.from_tuple(tuple); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header_message; - EXPECT_EQ(_column_writer->finalize(&header_message), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header_message), Status::OK()); TabletSchema convert_tablet_schema; set_tablet_schema("DateTimeColumn", "DATETIME", "REPLACE", 8, false, false, @@ -439,7 +439,7 @@ TEST_F(TestColumn, ConvertDateToDatetime) { RowCursor read_row; read_row.init(convert_tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); read_row.convert_from(0, data, write_row.column_schema(0)->type_info(), _mem_pool.get()); @@ -448,8 +448,8 @@ TEST_F(TestColumn, ConvertDateToDatetime) { //test not support type const auto* tp = get_scalar_type_info(); - OLAPStatus st = read_row.convert_from(0, data, tp, _mem_pool.get()); - EXPECT_TRUE(st == OLAP_ERR_INVALID_SCHEMA); + Status st = read_row.convert_from(0, data, tp, _mem_pool.get()); + EXPECT_TRUE(st == Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA)); } TEST_F(TestColumn, ConvertIntToDate) { @@ -469,10 +469,10 @@ TEST_F(TestColumn, ConvertIntToDate) { write_row.set_field_content(0, reinterpret_cast(&time_val), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); TabletSchema convert_tablet_schema; set_tablet_schema("DateColumn", "DATE", "REPLACE", 3, false, false, &convert_tablet_schema); @@ -482,7 +482,7 @@ TEST_F(TestColumn, ConvertIntToDate) { read_row.init(convert_tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); read_row.convert_from(0, data, write_row.column_schema(0)->type_info(), _mem_pool.get()); std::string dest_string = read_row.column_schema(0)->to_string(read_row.cell_ptr(0)); @@ -490,8 +490,8 @@ TEST_F(TestColumn, ConvertIntToDate) { //test not support type const auto* tp = get_scalar_type_info(); - OLAPStatus st = read_row.convert_from(0, read_row.cell_ptr(0), tp, _mem_pool.get()); - EXPECT_TRUE(st == OLAP_ERR_INVALID_SCHEMA); + Status st = read_row.convert_from(0, read_row.cell_ptr(0), tp, _mem_pool.get()); + EXPECT_TRUE(st == Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA)); } TEST_F(TestColumn, ConvertVarcharToDate) { @@ -516,10 +516,10 @@ TEST_F(TestColumn, ConvertVarcharToDate) { write_row.set_field_content(0, reinterpret_cast(&src_str), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); // because file_helper is reused in this case, we should close it. helper.close(); @@ -530,7 +530,7 @@ TEST_F(TestColumn, ConvertVarcharToDate) { read_row.init(convert_tablet_schema); _col_vector.reset(new ColumnVector()); - EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), Status::OK()); char* data = reinterpret_cast(_col_vector->col_data()); read_row.convert_from(0, data, write_row.column_schema(0)->type_info(), _mem_pool.get()); std::string dst_str = read_row.column_schema(0)->to_string(read_row.cell_ptr(0)); @@ -545,54 +545,54 @@ TEST_F(TestColumn, ConvertVarcharToDate) { //test not support type const auto* tp = get_scalar_type_info(); - OLAPStatus st = read_row.convert_from(0, read_row.cell_ptr(0), tp, _mem_pool.get()); - EXPECT_EQ(st, OLAP_ERR_INVALID_SCHEMA); + Status st = read_row.convert_from(0, read_row.cell_ptr(0), tp, _mem_pool.get()); + EXPECT_EQ(st, Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA)); } TEST_F(TestColumn, ConvertVarcharToTinyInt1) { - test_convert_from_varchar("TINYINT", 1, "127", OLAP_SUCCESS); + test_convert_from_varchar("TINYINT", 1, "127", Status::OK()); } TEST_F(TestColumn, ConvertVarcharToTinyInt2) { - test_convert_from_varchar("TINYINT", 1, "128", OLAP_ERR_INVALID_SCHEMA); + test_convert_from_varchar("TINYINT", 1, "128", Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA)); } TEST_F(TestColumn, ConvertVarcharToSmallInt1) { - test_convert_from_varchar("SMALLINT", 2, "32767", OLAP_SUCCESS); + test_convert_from_varchar("SMALLINT", 2, "32767", Status::OK()); } TEST_F(TestColumn, ConvertVarcharToSmallInt2) { - test_convert_from_varchar("SMALLINT", 2, "32768", OLAP_ERR_INVALID_SCHEMA); + test_convert_from_varchar("SMALLINT", 2, "32768", Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA)); } TEST_F(TestColumn, ConvertVarcharToInt1) { - test_convert_from_varchar("INT", 4, "2147483647", OLAP_SUCCESS); + test_convert_from_varchar("INT", 4, "2147483647", Status::OK()); } TEST_F(TestColumn, ConvertVarcharToInt2) { - test_convert_from_varchar("INT", 4, "2147483648", OLAP_ERR_INVALID_SCHEMA); + test_convert_from_varchar("INT", 4, "2147483648", Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA)); } TEST_F(TestColumn, ConvertVarcharToBigInt1) { - test_convert_from_varchar("BIGINT", 8, "9223372036854775807", OLAP_SUCCESS); + test_convert_from_varchar("BIGINT", 8, "9223372036854775807", Status::OK()); } TEST_F(TestColumn, ConvertVarcharToBigInt2) { - test_convert_from_varchar("BIGINT", 8, "9223372036854775808", OLAP_ERR_INVALID_SCHEMA); + test_convert_from_varchar("BIGINT", 8, "9223372036854775808", Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA)); } TEST_F(TestColumn, ConvertVarcharToLargeInt1) { test_convert_from_varchar("LARGEINT", 16, "170141183460469000000000000000000000000", - OLAP_SUCCESS); + Status::OK()); } TEST_F(TestColumn, ConvertVarcharToLargeInt2) { test_convert_from_varchar("LARGEINT", 16, "1701411834604690000000000000000000000000", - OLAP_ERR_INVALID_SCHEMA); + Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA)); } TEST_F(TestColumn, ConvertVarcharToFloat1) { - test_convert_from_varchar("FLOAT", 4, "3.40282e+38", OLAP_SUCCESS); + test_convert_from_varchar("FLOAT", 4, "3.40282e+38", Status::OK()); } TEST_F(TestColumn, ConvertVarcharToFloat2) { @@ -602,11 +602,11 @@ TEST_F(TestColumn, ConvertVarcharToFloat2) { "52996321966094455338163203127744334848599000464911410516510916727344709727599413825823" "04802812882753059262973637182942535982636884444611376868582636745405553206881859340916" "3400929532301499014067384276511218551077374242324480.999", - OLAP_ERR_INVALID_SCHEMA); + Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA)); } TEST_F(TestColumn, ConvertVarcharToDouble1) { - test_convert_from_varchar("DOUBLE", 8, "123.456", OLAP_SUCCESS); + test_convert_from_varchar("DOUBLE", 8, "123.456", Status::OK()); } TEST_F(TestColumn, ConvertVarcharToDouble2) { @@ -616,76 +616,76 @@ TEST_F(TestColumn, ConvertVarcharToDouble2) { "52996321966094455338163203127744334848599000464911410516510916727344709727599413825823" "04802812882753059262973637182942535982636884444611376868582636745405553206881859340916" "3400929532301499014067384276511218551077374242324480.0000000000", - OLAP_ERR_INVALID_SCHEMA); + Status::OLAPInternalError(OLAP_ERR_INVALID_SCHEMA)); } TEST_F(TestColumn, ConvertTinyIntToVarchar3) { - test_convert_to_varchar("TINYINT", 1, 127, "", OLAP_ERR_INPUT_PARAMETER_ERROR, 3); + test_convert_to_varchar("TINYINT", 1, 127, "", Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 3); } TEST_F(TestColumn, ConvertTinyIntToVarchar5) { - test_convert_to_varchar("TINYINT", 1, 127, "127", OLAP_SUCCESS, 3 + 2); + test_convert_to_varchar("TINYINT", 1, 127, "127", Status::OK(), 3 + 2); } TEST_F(TestColumn, ConvertTinyIntToVarchar4) { - test_convert_to_varchar("TINYINT", 1, -127, "", OLAP_ERR_INPUT_PARAMETER_ERROR, 4); + test_convert_to_varchar("TINYINT", 1, -127, "", Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 4); } TEST_F(TestColumn, ConvertTinyIntToVarchar6) { // 4: tinyint digit count + minus symbol, +2 for var len bytes - test_convert_to_varchar("TINYINT", 1, -127, "-127", OLAP_SUCCESS, 4 + 2); + test_convert_to_varchar("TINYINT", 1, -127, "-127", Status::OK(), 4 + 2); } TEST_F(TestColumn, ConvertSmallIntToVarchar5) { - test_convert_to_varchar("SMALLINT", 2, 32767, "", OLAP_ERR_INPUT_PARAMETER_ERROR, 5); + test_convert_to_varchar("SMALLINT", 2, 32767, "", Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 5); } TEST_F(TestColumn, ConvertSmallIntToVarchar7) { - test_convert_to_varchar("SMALLINT", 2, 32767, "32767", OLAP_SUCCESS, 7); + test_convert_to_varchar("SMALLINT", 2, 32767, "32767", Status::OK(), 7); } TEST_F(TestColumn, ConvertSmallIntToVarchar6) { - test_convert_to_varchar("SMALLINT", 2, -32767, "", OLAP_ERR_INPUT_PARAMETER_ERROR, 6); + test_convert_to_varchar("SMALLINT", 2, -32767, "", Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 6); } TEST_F(TestColumn, ConvertSmallIntToVarchar8) { - test_convert_to_varchar("SMALLINT", 2, -32767, "-32767", OLAP_SUCCESS, 8); + test_convert_to_varchar("SMALLINT", 2, -32767, "-32767", Status::OK(), 8); } TEST_F(TestColumn, ConvertIntToVarchar10) { - test_convert_to_varchar("INT", 4, 2147483647, "", OLAP_ERR_INPUT_PARAMETER_ERROR, 10); + test_convert_to_varchar("INT", 4, 2147483647, "", Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 10); } TEST_F(TestColumn, ConvertIntToVarchar12) { - test_convert_to_varchar("INT", 4, 2147483647, "2147483647", OLAP_SUCCESS, 12); + test_convert_to_varchar("INT", 4, 2147483647, "2147483647", Status::OK(), 12); } TEST_F(TestColumn, ConvertIntToVarchar11) { - test_convert_to_varchar("INT", 4, -2147483647, "", OLAP_ERR_INPUT_PARAMETER_ERROR, 11); + test_convert_to_varchar("INT", 4, -2147483647, "", Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 11); } TEST_F(TestColumn, ConvertIntToVarchar13) { - test_convert_to_varchar("INT", 4, -2147483647, "-2147483647", OLAP_SUCCESS, 13); + test_convert_to_varchar("INT", 4, -2147483647, "-2147483647", Status::OK(), 13); } TEST_F(TestColumn, ConvertBigIntToVarchar19) { test_convert_to_varchar("BIGINT", 8, 9223372036854775807, "", - OLAP_ERR_INPUT_PARAMETER_ERROR, 19); + Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 19); } TEST_F(TestColumn, ConvertBigIntToVarchar21) { test_convert_to_varchar("BIGINT", 8, 9223372036854775807, "9223372036854775807", - OLAP_SUCCESS, 21); + Status::OK(), 21); } TEST_F(TestColumn, ConvertBigIntToVarchar20) { test_convert_to_varchar("BIGINT", 8, -9223372036854775807, "", - OLAP_ERR_INPUT_PARAMETER_ERROR, 20); + Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 20); } TEST_F(TestColumn, ConvertBigIntToVarchar22) { test_convert_to_varchar("BIGINT", 8, -9223372036854775807, "-9223372036854775807", - OLAP_SUCCESS, 22); + Status::OK(), 22); } TEST_F(TestColumn, ConvertLargeIntToVarchar39) { @@ -695,7 +695,7 @@ TEST_F(TestColumn, ConvertLargeIntToVarchar39) { StringParser::string_to_int(str_val.c_str(), str_val.length(), &result); DCHECK(result == StringParser::PARSE_SUCCESS); test_convert_to_varchar("LARGEINT", 16, int128_val, "", - OLAP_ERR_INPUT_PARAMETER_ERROR, 39); + Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 39); } TEST_F(TestColumn, ConvertLargeIntToVarchar41) { @@ -704,7 +704,7 @@ TEST_F(TestColumn, ConvertLargeIntToVarchar41) { int128_t int128_val = StringParser::string_to_int(str_val.c_str(), str_val.length(), &result); DCHECK(result == StringParser::PARSE_SUCCESS); - test_convert_to_varchar("LARGEINT", 16, int128_val, str_val, OLAP_SUCCESS, 41); + test_convert_to_varchar("LARGEINT", 16, int128_val, str_val, Status::OK(), 41); } TEST_F(TestColumn, ConvertLargeIntToVarchar40) { @@ -714,7 +714,7 @@ TEST_F(TestColumn, ConvertLargeIntToVarchar40) { StringParser::string_to_int(str_val.c_str(), str_val.length(), &result); DCHECK(result == StringParser::PARSE_SUCCESS); test_convert_to_varchar("LARGEINT", 16, int128_val, "", - OLAP_ERR_INPUT_PARAMETER_ERROR, 40); + Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 40); } TEST_F(TestColumn, ConvertLargeIntToVarchar46) { @@ -723,149 +723,149 @@ TEST_F(TestColumn, ConvertLargeIntToVarchar46) { int128_t int128_val = StringParser::string_to_int(str_val.c_str(), str_val.length(), &result); DCHECK(result == StringParser::PARSE_SUCCESS); - test_convert_to_varchar("LARGEINT", 16, int128_val, str_val, OLAP_SUCCESS, 42); + test_convert_to_varchar("LARGEINT", 16, int128_val, str_val, Status::OK(), 42); } TEST_F(TestColumn, ConvertFloatToVarchar11) { test_convert_to_varchar("FLOAT", 4, 3.40282e+38, "3.40282e+38", - OLAP_ERR_INPUT_PARAMETER_ERROR, 11); + Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 11); } TEST_F(TestColumn, ConvertFloatToVarchar13) { - test_convert_to_varchar("FLOAT", 4, 3.40282e+38, "3.40282e+38", OLAP_SUCCESS, 13); + test_convert_to_varchar("FLOAT", 4, 3.40282e+38, "3.40282e+38", Status::OK(), 13); } TEST_F(TestColumn, ConvertFloatToVarchar13_2) { - test_convert_to_varchar("FLOAT", 4, 3402820000000000000.0, "3.40282e+18", OLAP_SUCCESS, + test_convert_to_varchar("FLOAT", 4, 3402820000000000000.0, "3.40282e+18", Status::OK(), 13); } TEST_F(TestColumn, ConvertFloatToVarchar12) { test_convert_to_varchar("FLOAT", 4, -3.40282e+38, "-3.40282e+38", - OLAP_ERR_INPUT_PARAMETER_ERROR, 12); + Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 12); } TEST_F(TestColumn, ConvertFloatToVarchar14) { - test_convert_to_varchar("FLOAT", 4, -3.40282e+38, "-3.40282e+38", OLAP_SUCCESS, 14); + test_convert_to_varchar("FLOAT", 4, -3.40282e+38, "-3.40282e+38", Status::OK(), 14); } TEST_F(TestColumn, ConvertFloatToVarchar14_2) { - test_convert_to_varchar("FLOAT", 4, -3402820000000000000.0, "-3.40282e+18", OLAP_SUCCESS, + test_convert_to_varchar("FLOAT", 4, -3402820000000000000.0, "-3.40282e+18", Status::OK(), 14); } TEST_F(TestColumn, ConvertFloatToVarchar13_3) { test_convert_to_varchar("FLOAT", 4, 1.17549435082228750796873653722224568e-38F, - "1.1754944e-38", OLAP_ERR_INPUT_PARAMETER_ERROR, 13); + "1.1754944e-38", Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 13); } TEST_F(TestColumn, ConvertFloatToVarchar15) { test_convert_to_varchar("FLOAT", 4, 1.17549435082228750796873653722224568e-38F, - "1.1754944e-38", OLAP_SUCCESS, 15); + "1.1754944e-38", Status::OK(), 15); } TEST_F(TestColumn, ConvertFloatToVarchar14_3) { test_convert_to_varchar("FLOAT", 4, -1.17549435082228750796873653722224568e-38F, - "-1.1754944e-38", OLAP_ERR_INPUT_PARAMETER_ERROR, 14); + "-1.1754944e-38", Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 14); } TEST_F(TestColumn, ConvertFloatToVarchar16) { test_convert_to_varchar("FLOAT", 4, -1.17549435082228750796873653722224568e-38F, - "-1.1754944e-38", OLAP_SUCCESS, 16); + "-1.1754944e-38", Status::OK(), 16); } TEST_F(TestColumn, ConvertDoubleToVarchar7) { - test_convert_to_varchar("DOUBLE", 8, 123.456, "123.456", OLAP_ERR_INPUT_PARAMETER_ERROR, + test_convert_to_varchar("DOUBLE", 8, 123.456, "123.456", Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 7); } TEST_F(TestColumn, ConvertDoubleToVarchar9) { - test_convert_to_varchar("DOUBLE", 8, 123.456, "123.456", OLAP_SUCCESS, 9); + test_convert_to_varchar("DOUBLE", 8, 123.456, "123.456", Status::OK(), 9); } TEST_F(TestColumn, ConvertDoubleToVarchar23) { test_convert_to_varchar("DOUBLE", 8, 1.79769313486231570814527423731704357e+308, - "1.7976931348623157e+308", OLAP_ERR_INPUT_PARAMETER_ERROR, 23); + "1.7976931348623157e+308", Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 23); } TEST_F(TestColumn, ConvertDoubleToVarchar25) { test_convert_to_varchar("DOUBLE", 8, 1.79769313486231570814527423731704357e+308, - "1.7976931348623157e+308", OLAP_SUCCESS, 25); + "1.7976931348623157e+308", Status::OK(), 25); } TEST_F(TestColumn, ConvertDoubleToVarchar22) { test_convert_to_varchar("DOUBLE", 8, 1797693134862315708.0, "1.7976931348623158e+18", - OLAP_ERR_INPUT_PARAMETER_ERROR, 22); + Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 22); } TEST_F(TestColumn, ConvertDoubleToVarchar24) { test_convert_to_varchar("DOUBLE", 8, 1797693134862315708.0, "1.7976931348623158e+18", - OLAP_SUCCESS, 24); + Status::OK(), 24); } TEST_F(TestColumn, ConvertDoubleToVarchar23_2) { test_convert_to_varchar("DOUBLE", 8, -1797693134862315708.0, "-1.7976931348623158e+18", - OLAP_ERR_INPUT_PARAMETER_ERROR, 23); + Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 23); } TEST_F(TestColumn, ConvertDoubleToVarchar25_2) { test_convert_to_varchar("DOUBLE", 8, -1797693134862315708.0, "-1.7976931348623158e+18", - OLAP_SUCCESS, 25); + Status::OK(), 25); } TEST_F(TestColumn, ConvertDoubleToVarchar23_3) { test_convert_to_varchar("DOUBLE", 8, 2.22507385850720138309023271733240406e-308, - "2.2250738585072014e-308", OLAP_ERR_INPUT_PARAMETER_ERROR, 23); + "2.2250738585072014e-308", Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 23); } TEST_F(TestColumn, ConvertDoubleToVarchar25_3) { test_convert_to_varchar("DOUBLE", 8, 2.22507385850720138309023271733240406e-308, - "2.2250738585072014e-308", OLAP_SUCCESS, 25); + "2.2250738585072014e-308", Status::OK(), 25); } TEST_F(TestColumn, ConvertDoubleToVarchar24_2) { test_convert_to_varchar("DOUBLE", 8, -2.22507385850720138309023271733240406e-308, - "-2.2250738585072014e-308", OLAP_ERR_INPUT_PARAMETER_ERROR, 24); + "-2.2250738585072014e-308", Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 24); } TEST_F(TestColumn, ConvertDoubleToVarchar26) { test_convert_to_varchar("DOUBLE", 8, -2.22507385850720138309023271733240406e-308, - "-2.2250738585072014e-308", OLAP_SUCCESS, 26); + "-2.2250738585072014e-308", Status::OK(), 26); } TEST_F(TestColumn, ConvertDecimalToVarchar13) { decimal12_t val = {456, 789000000}; test_convert_to_varchar("Decimal", 12, val, "456.789000000", - OLAP_ERR_INPUT_PARAMETER_ERROR, 13); + Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 13); } TEST_F(TestColumn, ConvertDecimalToVarchar15) { decimal12_t val = {456, 789000000}; - test_convert_to_varchar("Decimal", 12, val, "456.789000000", OLAP_SUCCESS, 15); + test_convert_to_varchar("Decimal", 12, val, "456.789000000", Status::OK(), 15); } TEST_F(TestColumn, ConvertDecimalToVarchar28) { decimal12_t val = {999999999999999999, 999999999}; - test_convert_to_varchar("Decimal", 12, val, "", OLAP_ERR_INPUT_PARAMETER_ERROR, + test_convert_to_varchar("Decimal", 12, val, "", Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 28); } TEST_F(TestColumn, ConvertDecimalToVarchar30) { decimal12_t val = {999999999999999999, 999999999}; test_convert_to_varchar("Decimal", 12, val, "999999999999999999.999999999", - OLAP_SUCCESS, 30); + Status::OK(), 30); } TEST_F(TestColumn, ConvertDecimalToVarchar29) { decimal12_t val = {-999999999999999999, 999999999}; - test_convert_to_varchar("Decimal", 12, val, "", OLAP_ERR_INPUT_PARAMETER_ERROR, + test_convert_to_varchar("Decimal", 12, val, "", Status::OLAPInternalError(OLAP_ERR_INPUT_PARAMETER_ERROR), 29); } TEST_F(TestColumn, ConvertDecimalToVarchar31) { decimal12_t val = {-999999999999999999, 999999999}; test_convert_to_varchar("Decimal", 12, val, "-999999999999999999.999999999", - OLAP_SUCCESS, 31); + Status::OK(), 31); } void CreateTabletSchema(TabletSchema& tablet_schema) { @@ -943,9 +943,9 @@ TEST_F(TestColumn, ConvertIntToBitmap) { write_row.from_tuple(tuple); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); //Materialized View tablet schema TabletSchemaPB mv_tablet_schema_pb; @@ -1026,9 +1026,9 @@ TEST_F(TestColumn, ConvertCharToHLL) { write_row.from_tuple(tuple); block.set_row(0, write_row); block.finalize(1); - EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), Status::OK()); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); //Materialized View tablet schema TabletSchemaPB mv_tablet_schema_pb; @@ -1109,7 +1109,7 @@ TEST_F(TestColumn, ConvertCharToCount) { block.finalize(1); ColumnDataHeaderMessage header; - EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), Status::OK()); //Materialized View tablet schema TabletSchemaPB mv_tablet_schema_pb; diff --git a/be/test/olap/stream_index_test.cpp b/be/test/olap/stream_index_test.cpp index 21d00cfe14..75191378d1 100644 --- a/be/test/olap/stream_index_test.cpp +++ b/be/test/olap/stream_index_test.cpp @@ -52,7 +52,7 @@ TEST_F(TestStreamIndex, index_write) { ColumnStatistics stat; stat.init(OLAP_FIELD_TYPE_INT, true); - EXPECT_EQ(OLAP_SUCCESS, stat.init(OLAP_FIELD_TYPE_INT, true)); + EXPECT_EQ(Status::OK(), stat.init(OLAP_FIELD_TYPE_INT, true)); static const uint32_t loop = 10; uint32_t i = 0; @@ -74,10 +74,10 @@ TEST_F(TestStreamIndex, index_write) { char* buffer = new char[output_size]; - EXPECT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); + EXPECT_EQ(Status::OK(), writer.write_to_buffer(buffer, output_size)); StreamIndexReader reader; - EXPECT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); + EXPECT_EQ(Status::OK(), reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); EXPECT_EQ(loop, reader.entry_count()); @@ -122,10 +122,10 @@ TEST_F(TestStreamIndex, remove_written_position) { size_t output_size = writer.output_size(); char* buffer = new char[output_size]; - EXPECT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); + EXPECT_EQ(Status::OK(), writer.write_to_buffer(buffer, output_size)); StreamIndexReader reader; - EXPECT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); + EXPECT_EQ(Status::OK(), reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); EXPECT_EQ(loop, reader.entry_count()); @@ -164,10 +164,10 @@ TEST_F(TestStreamIndex, remove_written_position) { size_t output_size = writer.output_size(); char* buffer = new char[output_size]; - EXPECT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); + EXPECT_EQ(Status::OK(), writer.write_to_buffer(buffer, output_size)); StreamIndexReader reader; - EXPECT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); + EXPECT_EQ(Status::OK(), reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); EXPECT_EQ(loop, reader.entry_count()); @@ -207,10 +207,10 @@ TEST_F(TestStreamIndex, remove_written_position) { size_t output_size = writer.output_size(); char* buffer = new char[output_size]; - EXPECT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); + EXPECT_EQ(Status::OK(), writer.write_to_buffer(buffer, output_size)); StreamIndexReader reader; - EXPECT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); + EXPECT_EQ(Status::OK(), reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); EXPECT_EQ(loop, reader.entry_count()); @@ -250,10 +250,10 @@ TEST_F(TestStreamIndex, remove_written_position) { size_t output_size = writer.output_size(); char* buffer = new char[output_size]; - EXPECT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); + EXPECT_EQ(Status::OK(), writer.write_to_buffer(buffer, output_size)); StreamIndexReader reader; - EXPECT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); + EXPECT_EQ(Status::OK(), reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); EXPECT_EQ(loop, reader.entry_count()); @@ -271,7 +271,7 @@ TEST_F(TestStreamIndex, remove_written_position) { TEST_F(TestStreamIndex, test_statistic) { ColumnStatistics stat; - EXPECT_EQ(OLAP_SUCCESS, stat.init(OLAP_FIELD_TYPE_INT, true)); + EXPECT_EQ(Status::OK(), stat.init(OLAP_FIELD_TYPE_INT, true)); WrapperField* field = WrapperField::create_by_type(OLAP_FIELD_TYPE_INT); @@ -316,7 +316,7 @@ TEST_F(TestStreamIndex, test_statistic) { EXPECT_STREQ(stat.maximum()->to_string().c_str(), "6"); ColumnStatistics stat2; - EXPECT_EQ(OLAP_SUCCESS, stat2.init(OLAP_FIELD_TYPE_INT, true)); + EXPECT_EQ(Status::OK(), stat2.init(OLAP_FIELD_TYPE_INT, true)); char buf[256]; stat.write_to_buffer(buf, sizeof(buf)); @@ -332,7 +332,7 @@ TEST_F(TestStreamIndex, statistic) { PositionEntryWriter entry; ColumnStatistics stat; - EXPECT_EQ(OLAP_SUCCESS, stat.init(OLAP_FIELD_TYPE_INT, true)); + EXPECT_EQ(Status::OK(), stat.init(OLAP_FIELD_TYPE_INT, true)); WrapperField* field = WrapperField::create_by_type(OLAP_FIELD_TYPE_INT); EXPECT_TRUE(nullptr != field); @@ -365,10 +365,10 @@ TEST_F(TestStreamIndex, statistic) { char* buffer = new char[output_size]; - EXPECT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); + EXPECT_EQ(Status::OK(), writer.write_to_buffer(buffer, output_size)); StreamIndexReader reader; - EXPECT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); + EXPECT_EQ(Status::OK(), reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); EXPECT_EQ(loop, reader.entry_count()); diff --git a/be/test/olap/tablet_meta_manager_test.cpp b/be/test/olap/tablet_meta_manager_test.cpp index 8179ab3b5e..6ecdf96059 100644 --- a/be/test/olap/tablet_meta_manager_test.cpp +++ b/be/test/olap/tablet_meta_manager_test.cpp @@ -79,30 +79,30 @@ TEST_F(TabletMetaManagerTest, TestSaveAndGetAndRemove) { std::string meta_binary; tablet_meta_pb.SerializeToString(&meta_binary); TabletMetaSharedPtr tablet_meta(new TabletMeta()); - OLAPStatus s = tablet_meta->deserialize(meta_binary); - EXPECT_EQ(OLAP_SUCCESS, s); + Status s = tablet_meta->deserialize(meta_binary); + EXPECT_EQ(Status::OK(), s); s = TabletMetaManager::save(_data_dir, tablet_id, schema_hash, tablet_meta); - EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(Status::OK(), s); std::string json_meta_read; s = TabletMetaManager::get_json_meta(_data_dir, tablet_id, schema_hash, &json_meta_read); - EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(Status::OK(), s); EXPECT_EQ(_json_header, json_meta_read); s = TabletMetaManager::remove(_data_dir, tablet_id, schema_hash); - EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(Status::OK(), s); TabletMetaSharedPtr meta_read(new TabletMeta()); s = TabletMetaManager::get_meta(_data_dir, tablet_id, schema_hash, meta_read); - EXPECT_EQ(OLAP_ERR_META_KEY_NOT_FOUND, s); + EXPECT_EQ(Status::OLAPInternalError(OLAP_ERR_META_KEY_NOT_FOUND), s); } TEST_F(TabletMetaManagerTest, TestLoad) { const TTabletId tablet_id = 15672; const TSchemaHash schema_hash = 567997577; - OLAPStatus s = TabletMetaManager::load_json_meta(_data_dir, meta_path); - EXPECT_EQ(OLAP_SUCCESS, s); + Status s = TabletMetaManager::load_json_meta(_data_dir, meta_path); + EXPECT_EQ(Status::OK(), s); std::string json_meta_read; s = TabletMetaManager::get_json_meta(_data_dir, tablet_id, schema_hash, &json_meta_read); - EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(Status::OK(), s); EXPECT_EQ(_json_header, json_meta_read); } diff --git a/be/test/olap/tablet_meta_test.cpp b/be/test/olap/tablet_meta_test.cpp index 6090a8a028..afff946bd8 100644 --- a/be/test/olap/tablet_meta_test.cpp +++ b/be/test/olap/tablet_meta_test.cpp @@ -28,7 +28,7 @@ TEST(TabletMetaTest, SaveAndParse) { TabletMeta old_tablet_meta(1, 2, 3, 4, 5, TTabletSchema(), 6, {{7, 8}}, UniqueId(9, 10), TTabletType::TABLET_TYPE_DISK, TStorageMedium::HDD, ""); - EXPECT_EQ(OLAP_SUCCESS, old_tablet_meta.save(meta_path)); + EXPECT_EQ(Status::OK(), old_tablet_meta.save(meta_path)); { // Just to make stack space dirty diff --git a/be/test/olap/tablet_mgr_test.cpp b/be/test/olap/tablet_mgr_test.cpp index 7ba81ecddf..840e5968ce 100644 --- a/be/test/olap/tablet_mgr_test.cpp +++ b/be/test/olap/tablet_mgr_test.cpp @@ -103,8 +103,8 @@ TEST_F(TabletMgrTest, CreateTablet) { create_tablet_req.__set_version(2); std::vector data_dirs; data_dirs.push_back(_data_dir); - OLAPStatus create_st = _tablet_mgr->create_tablet(create_tablet_req, data_dirs); - EXPECT_TRUE(create_st == OLAP_SUCCESS); + Status create_st = _tablet_mgr->create_tablet(create_tablet_req, data_dirs); + EXPECT_TRUE(create_st == Status::OK()); TabletSharedPtr tablet = _tablet_mgr->get_tablet(111); EXPECT_TRUE(tablet != nullptr); // check dir exist @@ -112,18 +112,18 @@ TEST_F(TabletMgrTest, CreateTablet) { EXPECT_TRUE(dir_exist); // check meta has this tablet TabletMetaSharedPtr new_tablet_meta(new TabletMeta()); - OLAPStatus check_meta_st = TabletMetaManager::get_meta(_data_dir, 111, 3333, new_tablet_meta); - EXPECT_TRUE(check_meta_st == OLAP_SUCCESS); + Status check_meta_st = TabletMetaManager::get_meta(_data_dir, 111, 3333, new_tablet_meta); + EXPECT_TRUE(check_meta_st == Status::OK()); // retry create should be successfully create_st = _tablet_mgr->create_tablet(create_tablet_req, data_dirs); - EXPECT_TRUE(create_st == OLAP_SUCCESS); + EXPECT_TRUE(create_st == Status::OK()); - OLAPStatus drop_st = _tablet_mgr->drop_tablet(111, false); - EXPECT_TRUE(drop_st == OLAP_SUCCESS); + Status drop_st = _tablet_mgr->drop_tablet(111, false); + EXPECT_TRUE(drop_st == Status::OK()); tablet.reset(); - OLAPStatus trash_st = _tablet_mgr->start_trash_sweep(); - EXPECT_TRUE(trash_st == OLAP_SUCCESS); + Status trash_st = _tablet_mgr->start_trash_sweep(); + EXPECT_TRUE(trash_st == Status::OK()); } TEST_F(TabletMgrTest, CreateTabletWithSequence) { @@ -161,8 +161,8 @@ TEST_F(TabletMgrTest, CreateTabletWithSequence) { create_tablet_req.__set_version(2); std::vector data_dirs; data_dirs.push_back(_data_dir); - OLAPStatus create_st = _tablet_mgr->create_tablet(create_tablet_req, data_dirs); - EXPECT_TRUE(create_st == OLAP_SUCCESS); + Status create_st = _tablet_mgr->create_tablet(create_tablet_req, data_dirs); + EXPECT_TRUE(create_st == Status::OK()); TabletSharedPtr tablet = _tablet_mgr->get_tablet(111); EXPECT_TRUE(tablet != nullptr); @@ -171,14 +171,14 @@ TEST_F(TabletMgrTest, CreateTabletWithSequence) { EXPECT_TRUE(dir_exist) << tablet->tablet_path_desc().filepath; // check meta has this tablet TabletMetaSharedPtr new_tablet_meta(new TabletMeta()); - OLAPStatus check_meta_st = TabletMetaManager::get_meta(_data_dir, 111, 3333, new_tablet_meta); - EXPECT_TRUE(check_meta_st == OLAP_SUCCESS); + Status check_meta_st = TabletMetaManager::get_meta(_data_dir, 111, 3333, new_tablet_meta); + EXPECT_TRUE(check_meta_st == Status::OK()); - OLAPStatus drop_st = _tablet_mgr->drop_tablet(111, false); - EXPECT_TRUE(drop_st == OLAP_SUCCESS); + Status drop_st = _tablet_mgr->drop_tablet(111, false); + EXPECT_TRUE(drop_st == Status::OK()); tablet.reset(); - OLAPStatus trash_st = _tablet_mgr->start_trash_sweep(); - EXPECT_TRUE(trash_st == OLAP_SUCCESS); + Status trash_st = _tablet_mgr->start_trash_sweep(); + EXPECT_TRUE(trash_st == Status::OK()); } TEST_F(TabletMgrTest, DropTablet) { @@ -202,20 +202,20 @@ TEST_F(TabletMgrTest, DropTablet) { create_tablet_req.__set_version(2); std::vector data_dirs; data_dirs.push_back(_data_dir); - OLAPStatus create_st = _tablet_mgr->create_tablet(create_tablet_req, data_dirs); - EXPECT_TRUE(create_st == OLAP_SUCCESS); + Status create_st = _tablet_mgr->create_tablet(create_tablet_req, data_dirs); + EXPECT_TRUE(create_st == Status::OK()); TabletSharedPtr tablet = _tablet_mgr->get_tablet(111); EXPECT_TRUE(tablet != nullptr); // drop unexist tablet will be success - OLAPStatus drop_st = _tablet_mgr->drop_tablet(1121, false); - EXPECT_TRUE(drop_st == OLAP_SUCCESS); + Status drop_st = _tablet_mgr->drop_tablet(1121, false); + EXPECT_TRUE(drop_st == Status::OK()); tablet = _tablet_mgr->get_tablet(111); EXPECT_TRUE(tablet != nullptr); // drop exist tablet will be success drop_st = _tablet_mgr->drop_tablet(111, false); - EXPECT_TRUE(drop_st == OLAP_SUCCESS); + EXPECT_TRUE(drop_st == Status::OK()); tablet = _tablet_mgr->get_tablet(111); EXPECT_TRUE(tablet == nullptr); tablet = _tablet_mgr->get_tablet(111, true); @@ -228,8 +228,8 @@ TEST_F(TabletMgrTest, DropTablet) { // do trash sweep, tablet will not be garbage collected // because tablet ptr referenced it - OLAPStatus trash_st = _tablet_mgr->start_trash_sweep(); - EXPECT_TRUE(trash_st == OLAP_SUCCESS); + Status trash_st = _tablet_mgr->start_trash_sweep(); + EXPECT_TRUE(trash_st == Status::OK()); tablet = _tablet_mgr->get_tablet(111, true); EXPECT_TRUE(tablet != nullptr); dir_exist = FileUtils::check_exist(tablet_path); @@ -238,7 +238,7 @@ TEST_F(TabletMgrTest, DropTablet) { // reset tablet ptr tablet.reset(); trash_st = _tablet_mgr->start_trash_sweep(); - EXPECT_TRUE(trash_st == OLAP_SUCCESS); + EXPECT_TRUE(trash_st == Status::OK()); tablet = _tablet_mgr->get_tablet(111, true); EXPECT_TRUE(tablet == nullptr); dir_exist = FileUtils::check_exist(tablet_path); diff --git a/be/test/olap/txn_manager_test.cpp b/be/test/olap/txn_manager_test.cpp index a3213da90d..0a143aebca 100644 --- a/be/test/olap/txn_manager_test.cpp +++ b/be/test/olap/txn_manager_test.cpp @@ -112,8 +112,8 @@ public: EXPECT_TRUE(std::filesystem::create_directory(meta_path)); _meta = new (std::nothrow) OlapMeta(meta_path); EXPECT_NE(nullptr, _meta); - OLAPStatus st = _meta->init(); - EXPECT_TRUE(st == OLAP_SUCCESS); + Status st = _meta->init(); + EXPECT_TRUE(st == Status::OK()); EXPECT_TRUE(std::filesystem::exists("./meta")); load_id.set_hi(0); load_id.set_lo(0); @@ -135,9 +135,9 @@ public: EXPECT_EQ(rowset_meta->rowset_id(), rowset_id); FilePathDesc rowset_meta_path_desc; rowset_meta_path_desc.filepath = rowset_meta_path; - EXPECT_EQ(OLAP_SUCCESS, RowsetFactory::create_rowset(_schema.get(), rowset_meta_path_desc, + EXPECT_EQ(Status::OK(), RowsetFactory::create_rowset(_schema.get(), rowset_meta_path_desc, rowset_meta, &_alpha_rowset)); - EXPECT_EQ(OLAP_SUCCESS, RowsetFactory::create_rowset(_schema.get(), rowset_meta_path_desc, + EXPECT_EQ(Status::OK(), RowsetFactory::create_rowset(_schema.get(), rowset_meta_path_desc, rowset_meta, &_alpha_rowset_same_id)); // init rowset meta 2 @@ -155,7 +155,7 @@ public: EXPECT_EQ(rowset_meta2->rowset_id(), rowset_id); FilePathDesc rowset_meta_path_desc_2; rowset_meta_path_desc_2.filepath = rowset_meta_path_2; - EXPECT_EQ(OLAP_SUCCESS, RowsetFactory::create_rowset(_schema.get(), rowset_meta_path_desc_2, + EXPECT_EQ(Status::OK(), RowsetFactory::create_rowset(_schema.get(), rowset_meta_path_desc_2, rowset_meta2, &_alpha_rowset_diff_id)); _tablet_uid = TabletUid(10, 10); } @@ -182,115 +182,115 @@ private: }; TEST_F(TxnManagerTest, PrepareNewTxn) { - OLAPStatus status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, + Status status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); } // 1. prepare txn // 2. commit txn // 3. should be success TEST_F(TxnManagerTest, CommitTxnWithPrepare) { - OLAPStatus status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, + Status status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id); _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset, false); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); RowsetMetaSharedPtr rowset_meta(new AlphaRowsetMeta()); status = RowsetMetaManager::get_rowset_meta(_meta, _tablet_uid, _alpha_rowset->rowset_id(), rowset_meta); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); EXPECT_TRUE(rowset_meta->rowset_id() == _alpha_rowset->rowset_id()); } // 1. commit without prepare // 2. should success TEST_F(TxnManagerTest, CommitTxnWithNoPrepare) { - OLAPStatus status = + Status status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset, false); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); } // 1. commit twice with different rowset id // 2. should failed TEST_F(TxnManagerTest, CommitTxnTwiceWithDiffRowsetId) { - OLAPStatus status = + Status status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset, false); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset_diff_id, false); - EXPECT_TRUE(status != OLAP_SUCCESS); + EXPECT_TRUE(status != Status::OK()); } // 1. commit twice with same rowset id // 2. should success TEST_F(TxnManagerTest, CommitTxnTwiceWithSameRowsetId) { - OLAPStatus status = + Status status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset, false); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset_same_id, false); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); } // 1. prepare twice should be success TEST_F(TxnManagerTest, PrepareNewTxnTwice) { - OLAPStatus status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, + Status status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); } // 1. txn could be rollbacked if it is not committed TEST_F(TxnManagerTest, RollbackNotCommittedTxn) { - OLAPStatus status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, + Status status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); status = _txn_mgr->rollback_txn(partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); RowsetMetaSharedPtr rowset_meta(new AlphaRowsetMeta()); status = RowsetMetaManager::get_rowset_meta(_meta, _tablet_uid, _alpha_rowset->rowset_id(), rowset_meta); - EXPECT_TRUE(status != OLAP_SUCCESS); + EXPECT_TRUE(status != Status::OK()); } // 1. txn could not be rollbacked if it is committed TEST_F(TxnManagerTest, RollbackCommittedTxn) { - OLAPStatus status = + Status status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset, false); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); status = _txn_mgr->rollback_txn(partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid); - EXPECT_FALSE(status == OLAP_SUCCESS); + EXPECT_FALSE(status == Status::OK()); RowsetMetaSharedPtr rowset_meta(new AlphaRowsetMeta()); status = RowsetMetaManager::get_rowset_meta(_meta, _tablet_uid, _alpha_rowset->rowset_id(), rowset_meta); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); EXPECT_TRUE(rowset_meta->rowset_id() == _alpha_rowset->rowset_id()); } // 1. publish version success TEST_F(TxnManagerTest, PublishVersionSuccessful) { - OLAPStatus status = + Status status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset, false); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); Version new_version(10, 11); status = _txn_mgr->publish_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, new_version); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); RowsetMetaSharedPtr rowset_meta(new AlphaRowsetMeta()); status = RowsetMetaManager::get_rowset_meta(_meta, _tablet_uid, _alpha_rowset->rowset_id(), rowset_meta); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); EXPECT_TRUE(rowset_meta->rowset_id() == _alpha_rowset->rowset_id()); EXPECT_TRUE(rowset_meta->start_version() == 10); EXPECT_TRUE(rowset_meta->end_version() == 11); @@ -299,36 +299,36 @@ TEST_F(TxnManagerTest, PublishVersionSuccessful) { // 1. publish version failed if not found related txn and rowset TEST_F(TxnManagerTest, PublishNotExistedTxn) { Version new_version(10, 11); - OLAPStatus status = _txn_mgr->publish_txn(_meta, partition_id, transaction_id, tablet_id, + Status status = _txn_mgr->publish_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, new_version); - EXPECT_TRUE(status != OLAP_SUCCESS); + EXPECT_TRUE(status != Status::OK()); } TEST_F(TxnManagerTest, DeletePreparedTxn) { - OLAPStatus status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, + Status status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); status = _txn_mgr->delete_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); } TEST_F(TxnManagerTest, DeleteCommittedTxn) { - OLAPStatus status = + Status status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset, false); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); RowsetMetaSharedPtr rowset_meta(new AlphaRowsetMeta()); status = RowsetMetaManager::get_rowset_meta(_meta, _tablet_uid, _alpha_rowset->rowset_id(), rowset_meta); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); status = _txn_mgr->delete_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid); - EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == Status::OK()); RowsetMetaSharedPtr rowset_meta2(new AlphaRowsetMeta()); status = RowsetMetaManager::get_rowset_meta(_meta, _tablet_uid, _alpha_rowset->rowset_id(), rowset_meta2); - EXPECT_TRUE(status != OLAP_SUCCESS); + EXPECT_TRUE(status != Status::OK()); } } // namespace doris diff --git a/be/test/runtime/load_channel_mgr_test.cpp b/be/test/runtime/load_channel_mgr_test.cpp index 1d6d30ae5b..cfc7f89896 100644 --- a/be/test/runtime/load_channel_mgr_test.cpp +++ b/be/test/runtime/load_channel_mgr_test.cpp @@ -39,9 +39,9 @@ namespace doris { std::unordered_map _k_tablet_recorder; -OLAPStatus open_status; -OLAPStatus add_status; -OLAPStatus close_status; +Status open_status; +Status add_status; +Status close_status; int64_t wait_lock_time_ns; // mock @@ -49,19 +49,19 @@ DeltaWriter::DeltaWriter(WriteRequest* req, StorageEngine* storage_engine) : _re DeltaWriter::~DeltaWriter() {} -OLAPStatus DeltaWriter::init() { - return OLAP_SUCCESS; +Status DeltaWriter::init() { + return Status::OK(); } -OLAPStatus DeltaWriter::open(WriteRequest* req, DeltaWriter** writer) { - if (open_status != OLAP_SUCCESS) { +Status DeltaWriter::open(WriteRequest* req, DeltaWriter** writer) { + if (open_status != Status::OK()) { return open_status; } *writer = new DeltaWriter(req, nullptr); return open_status; } -OLAPStatus DeltaWriter::write(Tuple* tuple) { +Status DeltaWriter::write(Tuple* tuple) { if (_k_tablet_recorder.find(_req.tablet_id) == std::end(_k_tablet_recorder)) { _k_tablet_recorder[_req.tablet_id] = 1; } else { @@ -70,7 +70,7 @@ OLAPStatus DeltaWriter::write(Tuple* tuple) { return add_status; } -OLAPStatus DeltaWriter::write(const RowBatch* row_batch, const std::vector& row_idxs) { +Status DeltaWriter::write(const RowBatch* row_batch, const std::vector& row_idxs) { if (_k_tablet_recorder.find(_req.tablet_id) == std::end(_k_tablet_recorder)) { _k_tablet_recorder[_req.tablet_id] = 0; } @@ -78,25 +78,25 @@ OLAPStatus DeltaWriter::write(const RowBatch* row_batch, const std::vector& return add_status; } -OLAPStatus DeltaWriter::close() { - return OLAP_SUCCESS; +Status DeltaWriter::close() { + return Status::OK(); } -OLAPStatus DeltaWriter::close_wait(google::protobuf::RepeatedPtrField* tablet_vec, +Status DeltaWriter::close_wait(google::protobuf::RepeatedPtrField* tablet_vec, bool is_broken) { return close_status; } -OLAPStatus DeltaWriter::cancel() { - return OLAP_SUCCESS; +Status DeltaWriter::cancel() { + return Status::OK(); } -OLAPStatus DeltaWriter::flush_memtable_and_wait(bool need_wait) { - return OLAP_SUCCESS; +Status DeltaWriter::flush_memtable_and_wait(bool need_wait) { + return Status::OK(); } -OLAPStatus DeltaWriter::wait_flush() { - return OLAP_SUCCESS; +Status DeltaWriter::wait_flush() { + return Status::OK(); } int64_t DeltaWriter::partition_id() const { @@ -112,9 +112,9 @@ public: virtual ~LoadChannelMgrTest() {} void SetUp() override { _k_tablet_recorder.clear(); - open_status = OLAP_SUCCESS; - add_status = OLAP_SUCCESS; - close_status = OLAP_SUCCESS; + open_status = Status::OK(); + add_status = Status::OK(); + close_status = Status::OK(); config::streaming_load_rpc_max_alive_time_sec = 120; } @@ -336,7 +336,7 @@ TEST_F(LoadChannelMgrTest, open_failed) { } request.set_num_senders(1); request.set_need_gen_rollup(false); - open_status = OLAP_ERR_TABLE_NOT_FOUND; + open_status = Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); auto st = mgr.open(request); request.release_id(); EXPECT_FALSE(st.ok()); @@ -423,7 +423,7 @@ TEST_F(LoadChannelMgrTest, add_failed) { } row_batch.serialize(request.mutable_row_batch(), &uncompressed_size, &compressed_size); // DeltaWriter's write will return -215 - add_status = OLAP_ERR_TABLE_NOT_FOUND; + add_status = Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); PTabletWriterAddBatchResult response; auto st = mgr.add_batch(request, &response); request.release_id(); @@ -514,7 +514,7 @@ TEST_F(LoadChannelMgrTest, close_failed) { row_batch.commit_last_row(); } row_batch.serialize(request.mutable_row_batch(), &uncompressed_size, &compressed_size); - close_status = OLAP_ERR_TABLE_NOT_FOUND; + close_status = Status::OLAPInternalError(OLAP_ERR_TABLE_NOT_FOUND); PTabletWriterAddBatchResult response; auto st = mgr.add_batch(request, &response); request.release_id();