You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@doris.apache.org by ka...@apache.org on 2020/11/26 09:01:06 UTC
[incubator-doris] branch master updated: Remove header file
common/names.h (#4945)
This is an automated email from the ASF dual-hosted git repository.
kangkaisen pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-doris.git
The following commit(s) were added to refs/heads/master by this push:
new 10e1e29 Remove header file common/names.h (#4945)
10e1e29 is described below
commit 10e1e2971101decaed06c7af830b777765fba25f
Author: sduzh <zh...@qq.com>
AuthorDate: Thu Nov 26 17:00:48 2020 +0800
Remove header file common/names.h (#4945)
---
be/src/agent/agent_server.cpp | 2 +-
be/src/agent/cgroups_mgr.cpp | 2 +-
be/src/agent/task_worker_pool.cpp | 34 +++----
be/src/agent/utils.cpp | 8 +-
be/src/env/env_posix.cpp | 10 +-
be/src/env/env_util.cpp | 12 +--
be/src/exec/aggregation_node.cpp | 6 +-
be/src/exec/analytic_eval_node.cpp | 12 +--
be/src/exec/csv_scan_node.cpp | 4 +-
be/src/exec/es/es_predicate.cpp | 8 +-
be/src/exec/es/es_query_builder.cpp | 4 +-
be/src/exec/es/es_scroll_parser.cpp | 10 +-
be/src/exec/es_scan_node.cpp | 34 +++----
be/src/exec/exchange_node.cpp | 2 +-
be/src/exec/exec_node.cpp | 6 +-
be/src/exec/hash_join_node.cpp | 4 +-
be/src/exec/hash_table.cpp | 6 +-
be/src/exec/merge_join_node.cpp | 4 +-
be/src/exec/merge_node.cpp | 8 +-
be/src/exec/mysql_scan_node.cpp | 4 +-
be/src/exec/odbc_scan_node.cpp | 4 +-
be/src/exec/parquet_reader.cpp | 2 +-
be/src/exec/partitioned_aggregation_node.cc | 2 +-
be/src/exec/partitioned_hash_table.cc | 4 +-
be/src/exec/repeat_node.cpp | 6 +-
be/src/exec/scan_node.cpp | 8 +-
be/src/exec/schema_scan_node.cpp | 4 +-
be/src/exec/set_operation_node.cpp | 4 +-
be/src/exec/union_node.cpp | 8 +-
be/src/exprs/agg_fn.cc | 16 ++-
be/src/exprs/agg_fn_evaluator.cpp | 6 +-
be/src/exprs/expr.cpp | 14 +--
be/src/exprs/math_functions.cpp | 2 +-
be/src/exprs/new_agg_fn_evaluator.cc | 2 +-
be/src/exprs/scalar_fn_call.cpp | 2 +-
be/src/http/default_path_handlers.cpp | 2 +-
be/src/http/web_page_handler.cpp | 6 +-
be/src/olap/base_compaction.cpp | 2 +-
be/src/olap/compaction.cpp | 6 +-
be/src/olap/comparison_predicate.cpp | 26 ++---
be/src/olap/data_dir.cpp | 34 +++----
be/src/olap/delete_handler.cpp | 12 +--
be/src/olap/fs/block_id.cpp | 4 +-
be/src/olap/fs/file_block_manager.cpp | 12 +--
be/src/olap/in_list_predicate.cpp | 24 ++---
be/src/olap/memory/column.cpp | 8 +-
be/src/olap/null_predicate.cpp | 2 +-
be/src/olap/olap_cond.cpp | 4 +-
be/src/olap/olap_server.cpp | 10 +-
be/src/olap/olap_snapshot_converter.cpp | 4 +-
be/src/olap/options.cpp | 6 +-
be/src/olap/push_handler.cpp | 12 +--
be/src/olap/row_cursor.cpp | 6 +-
be/src/olap/rowset/alpha_rowset.cpp | 4 +-
be/src/olap/rowset/segment_v2/binary_dict_page.cpp | 8 +-
.../olap/rowset/segment_v2/binary_prefix_page.cpp | 6 +-
be/src/olap/rowset/segment_v2/column_reader.cpp | 8 +-
be/src/olap/rowset/segment_v2/column_writer.cpp | 4 +-
.../rowset/segment_v2/indexed_column_reader.cpp | 2 +-
be/src/olap/rowset/segment_v2/page_io.cpp | 6 +-
be/src/olap/rowset/segment_v2/segment.cpp | 10 +-
be/src/olap/schema_change.cpp | 32 +++---
be/src/olap/short_key_index.cpp | 2 +-
be/src/olap/snapshot_manager.cpp | 16 +--
be/src/olap/storage_engine.cpp | 22 ++---
be/src/olap/tablet.cpp | 46 ++++-----
be/src/olap/tablet_manager.cpp | 20 ++--
be/src/olap/tablet_meta.cpp | 10 +-
be/src/olap/task/engine_alter_tablet_task.cpp | 2 +-
be/src/olap/task/engine_batch_load_task.cpp | 4 +-
be/src/olap/task/engine_clone_task.cpp | 36 +++----
be/src/olap/task/engine_publish_version_task.cpp | 2 +-
be/src/olap/task/engine_storage_migration_task.cpp | 6 +-
be/src/olap/utils.cpp | 6 +-
be/src/plugin/plugin_loader.cpp | 2 +-
be/src/plugin/plugin_mgr.cpp | 8 +-
be/src/plugin/plugin_zip.cpp | 8 +-
be/src/runtime/buffered_tuple_stream3.cc | 12 +--
be/src/runtime/bufferpool/buffer_allocator.cc | 109 ++++++++++-----------
be/src/runtime/bufferpool/buffer_allocator.h | 4 +-
be/src/runtime/bufferpool/buffer_pool.cc | 56 +++++------
be/src/runtime/bufferpool/buffer_pool_internal.h | 14 +--
be/src/runtime/bufferpool/reservation_tracker.cc | 50 +++++-----
be/src/runtime/bufferpool/suballocator.cc | 88 ++++++++---------
be/src/runtime/bufferpool/system_allocator.cc | 2 +-
be/src/runtime/initial_reservations.cc | 6 +-
be/src/runtime/mem_pool.cpp | 10 +-
be/src/runtime/mem_tracker.cpp | 50 +++++-----
be/src/runtime/raw_value.cpp | 2 +-
be/src/runtime/row_batch.cpp | 24 ++---
be/src/tools/meta_tool.cpp | 12 +--
be/src/util/arrow/row_batch.cpp | 4 +-
be/src/util/arrow/row_block.cpp | 6 +-
be/src/util/block_compression.cpp | 34 +++----
be/src/util/cgroup_util.cpp | 40 ++++----
be/src/util/cpu_info.cpp | 58 +++++------
be/src/util/file_utils.cpp | 2 +-
be/src/util/os_info.cpp | 13 ++-
be/src/util/os_util.cpp | 6 +-
be/src/util/path_util.cpp | 20 ++--
be/src/util/perf_counters.cpp | 16 +--
be/src/util/thread.cpp | 4 +-
be/src/util/threadpool.cpp | 10 +-
be/src/util/time.cpp | 16 +--
be/src/util/trace.cpp | 10 +-
be/src/util/zlib.cpp | 4 +-
be/test/agent/agent_server_test.cpp | 2 +-
be/test/exec/hash_table_test.cpp | 8 +-
be/test/exec/new_olap_scan_node_test.cpp | 12 +--
be/test/olap/delete_handler_test.cpp | 8 +-
be/test/olap/fs/file_block_manager_test.cpp | 8 +-
be/test/olap/memory/column_delta_test.cpp | 2 +-
be/test/olap/memory/column_test.cpp | 12 +--
be/test/olap/memory/mem_tablet_test.cpp | 6 +-
be/test/olap/memory/partial_row_batch_test.cpp | 2 +-
be/test/olap/olap_snapshot_converter_test.cpp | 2 +-
be/test/olap/rowset/beta_rowset_test.cpp | 2 +-
.../segment_v2/column_reader_writer_test.cpp | 30 +++---
be/test/olap/rowset/segment_v2/segment_test.cpp | 38 +++----
be/test/olap/tablet_mgr_test.cpp | 6 +-
be/test/runtime/buffered_block_mgr2_test.cpp | 88 ++++++++---------
be/test/runtime/buffered_tuple_stream2_test.cpp | 52 +++++-----
be/test/runtime/data_stream_test.cpp | 18 ++--
be/test/runtime/disk_io_mgr_test.cpp | 42 ++++----
be/test/runtime/memory_scratch_sink_test.cpp | 4 +-
be/test/runtime/tmp_file_mgr_test.cpp | 20 ++--
be/test/util/arrow/arrow_work_flow_test.cpp | 4 +-
be/test/util/decompress_test.cpp | 4 +-
be/test/util/internal_queue_test.cpp | 18 ++--
be/test/util/path_util_test.cpp | 2 +-
be/test/util/perf_counters_test.cpp | 4 +-
be/test/util/rle_encoding_test.cpp | 20 ++--
be/test/util/runtime_profile_test.cpp | 6 +-
be/test/util/threadpool_test.cpp | 38 +++----
be/test/util/trace_test.cpp | 6 +-
be/test/util/url_coding_test.cpp | 18 ++--
136 files changed, 937 insertions(+), 941 deletions(-)
diff --git a/be/src/agent/agent_server.cpp b/be/src/agent/agent_server.cpp
index 1f28825..57ed17a 100644
--- a/be/src/agent/agent_server.cpp
+++ b/be/src/agent/agent_server.cpp
@@ -99,7 +99,7 @@ AgentServer::~AgentServer() { }
// TODO(lingbin): each task in the batch may have it own status or FE must check and
// resend request when something is wrong(BE may need some logic to guarantee idempotence.
-void AgentServer::submit_tasks(TAgentResult& agent_result, const vector<TAgentTaskRequest>& tasks) {
+void AgentServer::submit_tasks(TAgentResult& agent_result, const std::vector<TAgentTaskRequest>& tasks) {
Status ret_st;
// TODO check master_info here if it is the same with that of heartbeat rpc
diff --git a/be/src/agent/cgroups_mgr.cpp b/be/src/agent/cgroups_mgr.cpp
index 1577428..128be59 100644
--- a/be/src/agent/cgroups_mgr.cpp
+++ b/be/src/agent/cgroups_mgr.cpp
@@ -193,7 +193,7 @@ AgentStatus CgroupsMgr::_config_disk_throttle(std::string user_name,
// buld load data path, it is alreay in data path
// _exec_env->load_path_mgr()->get_load_data_path(&data_paths);
- stringstream ctrl_cmd;
+ std::stringstream ctrl_cmd;
for (auto store : stores) {
// check disk type
int64_t read_iops = hdd_read_iops;
diff --git a/be/src/agent/task_worker_pool.cpp b/be/src/agent/task_worker_pool.cpp
index 575be14..fac22f0 100644
--- a/be/src/agent/task_worker_pool.cpp
+++ b/be/src/agent/task_worker_pool.cpp
@@ -325,7 +325,7 @@ void TaskWorkerPool::_create_tablet_worker_thread_callback() {
}
TStatusCode::type status_code = TStatusCode::OK;
- vector<string> error_msgs;
+ std::vector<string> error_msgs;
TStatus task_status;
std::vector<TTabletInfo> finish_tablet_infos;
@@ -388,7 +388,7 @@ void TaskWorkerPool::_drop_tablet_worker_thread_callback() {
}
TStatusCode::type status_code = TStatusCode::OK;
- vector<string> error_msgs;
+ std::vector<string> error_msgs;
TStatus task_status;
TabletSharedPtr dropped_tablet = StorageEngine::instance()->tablet_manager()->get_tablet(
drop_tablet_req.tablet_id, drop_tablet_req.schema_hash);
@@ -468,7 +468,7 @@ void TaskWorkerPool::_alter_tablet(const TAgentTaskRequest& agent_task_req, int6
TFinishTaskRequest* finish_task_request) {
AgentStatus status = DORIS_SUCCESS;
TStatus task_status;
- vector<string> error_msgs;
+ std::vector<string> error_msgs;
string process_name;
switch (task_type) {
@@ -516,7 +516,7 @@ void TaskWorkerPool::_alter_tablet(const TAgentTaskRequest& agent_task_req, int6
finish_task_request->__set_task_type(task_type);
finish_task_request->__set_signature(signature);
- vector<TTabletInfo> finish_tablet_infos;
+ std::vector<TTabletInfo> finish_tablet_infos;
if (status == DORIS_SUCCESS) {
TTabletInfo tablet_info;
status = _get_tablet_info(new_tablet_id, new_schema_hash, signature, &tablet_info);
@@ -602,7 +602,7 @@ void TaskWorkerPool::_push_worker_thread_callback() {
LOG(INFO) << "get push task. signature: " << agent_task_req.signature
<< " priority: " << priority << " push_type: " << push_req.push_type;
- vector<TTabletInfo> tablet_infos;
+ std::vector<TTabletInfo> tablet_infos;
EngineBatchLoadTask engine_task(push_req, &tablet_infos, agent_task_req.signature, &status);
_env->storage_engine()->execute_task(&engine_task);
@@ -613,7 +613,7 @@ void TaskWorkerPool::_push_worker_thread_callback() {
continue;
}
// Return result to fe
- vector<string> error_msgs;
+ std::vector<string> error_msgs;
TStatus task_status;
TFinishTaskRequest finish_task_request;
@@ -676,7 +676,7 @@ void TaskWorkerPool::_publish_version_worker_thread_callback() {
LOG(INFO) << "get publish version task, signature:" << agent_task_req.signature;
Status st;
- vector<TTabletId> error_tablet_ids;
+ std::vector<TTabletId> error_tablet_ids;
uint32_t retry_time = 0;
OLAPStatus res = OLAP_SUCCESS;
while (retry_time < PUBLISH_VERSION_MAX_RETRY) {
@@ -740,7 +740,7 @@ void TaskWorkerPool::_clear_transaction_task_worker_thread_callback() {
<< ", partition id size: " << clear_transaction_task_req.partition_id.size();
TStatusCode::type status_code = TStatusCode::OK;
- vector<string> error_msgs;
+ std::vector<string> error_msgs;
TStatus task_status;
if (clear_transaction_task_req.transaction_id > 0) {
@@ -796,7 +796,7 @@ void TaskWorkerPool::_update_tablet_meta_worker_thread_callback() {
LOG(INFO) << "get update tablet meta task, signature:" << agent_task_req.signature;
TStatusCode::type status_code = TStatusCode::OK;
- vector<string> error_msgs;
+ std::vector<string> error_msgs;
TStatus task_status;
for (auto tablet_meta_info : update_tablet_meta_req.tabletMetaInfos) {
@@ -865,8 +865,8 @@ void TaskWorkerPool::_clone_worker_thread_callback() {
DorisMetrics::instance()->clone_requests_total->increment(1);
LOG(INFO) << "get clone task. signature:" << agent_task_req.signature;
- vector<string> error_msgs;
- vector<TTabletInfo> tablet_infos;
+ std::vector<string> error_msgs;
+ std::vector<TTabletInfo> tablet_infos;
EngineCloneTask engine_task(clone_req, _master_info,
agent_task_req.signature, &error_msgs, &tablet_infos, &status);
_env->storage_engine()->execute_task(&engine_task);
@@ -935,7 +935,7 @@ void TaskWorkerPool::_storage_medium_migrate_worker_thread_callback() {
}
TStatus task_status;
- vector<string> error_msgs;
+ std::vector<string> error_msgs;
task_status.__set_status_code(status_code);
task_status.__set_error_msgs(error_msgs);
@@ -1030,7 +1030,7 @@ void TaskWorkerPool::_check_consistency_worker_thread_callback() {
}
TStatusCode::type status_code = TStatusCode::OK;
- vector<string> error_msgs;
+ std::vector<string> error_msgs;
TStatus task_status;
uint32_t checksum = 0;
@@ -1113,7 +1113,7 @@ void TaskWorkerPool::_report_disk_state_worker_thread_callback() {
break;
}
- vector<DataDirInfo> data_dir_infos;
+ std::vector<DataDirInfo> data_dir_infos;
_env->storage_engine()->get_all_data_dir_info(&data_dir_infos, true /* update */);
map<string, TDisk> disks;
@@ -1332,7 +1332,7 @@ void TaskWorkerPool::_make_snapshot_thread_callback() {
LOG(INFO) << "get snapshot task, signature:" << agent_task_req.signature;
TStatusCode::type status_code = TStatusCode::OK;
- vector<string> error_msgs;
+ std::vector<string> error_msgs;
TStatus task_status;
string snapshot_path;
@@ -1413,7 +1413,7 @@ void TaskWorkerPool::_release_snapshot_thread_callback() {
LOG(INFO) << "get release snapshot task, signature:" << agent_task_req.signature;
TStatusCode::type status_code = TStatusCode::OK;
- vector<string> error_msgs;
+ std::vector<string> error_msgs;
TStatus task_status;
string& snapshot_path = release_snapshot_request.snapshot_path;
@@ -1482,7 +1482,7 @@ void TaskWorkerPool::_move_dir_thread_callback() {
<< ", job id:" << move_dir_req.job_id;
TStatusCode::type status_code = TStatusCode::OK;
- vector<string> error_msgs;
+ std::vector<string> error_msgs;
TStatus task_status;
// TODO: move dir
diff --git a/be/src/agent/utils.cpp b/be/src/agent/utils.cpp
index 0a419f6..a24effa 100644
--- a/be/src/agent/utils.cpp
+++ b/be/src/agent/utils.cpp
@@ -147,11 +147,11 @@ AgentStatus AgentUtils::rsync_from_remote(
const string& remote_host,
const string& remote_file_path,
const string& local_file_path,
- const vector<string>& exclude_file_patterns,
+ const std::vector<string>& exclude_file_patterns,
uint32_t transport_speed_limit_kbps,
uint32_t timeout_second) {
int ret_code = 0;
- stringstream cmd_stream;
+ std::stringstream cmd_stream;
cmd_stream << "rsync -r -q -e \"ssh -o StrictHostKeyChecking=no\"";
for (auto exclude_file_pattern : exclude_file_patterns) {
cmd_stream << " --exclude=" << exclude_file_pattern;
@@ -240,7 +240,7 @@ bool AgentUtils::exec_cmd(const string& command, string* errmsg, bool redirect_s
// Execute command.
FILE *fp = popen(cmd.c_str(), "r");
if (fp == NULL) {
- stringstream err_stream;
+ std::stringstream err_stream;
err_stream << "popen failed. " << strerror(errno) << ", with errno: " << errno << ".\n";
*errmsg = err_stream.str();
return false;
@@ -258,7 +258,7 @@ bool AgentUtils::exec_cmd(const string& command, string* errmsg, bool redirect_s
if (errno == ECHILD) {
*errmsg += "pclose cannot obtain the child status.\n";
} else {
- stringstream err_stream;
+ std::stringstream err_stream;
err_stream << "Close popen failed. " << strerror(errno) << ", with errno: "
<< errno << "\n";
*errmsg += err_stream.str();
diff --git a/be/src/env/env_posix.cpp b/be/src/env/env_posix.cpp
index bfd7fb4..dd9bdc2 100644
--- a/be/src/env/env_posix.cpp
+++ b/be/src/env/env_posix.cpp
@@ -90,7 +90,7 @@ static Status do_open(const string& filename, Env::OpenMode mode, int* fd) {
case Env::MUST_EXIST:
break;
default:
- return Status::NotSupported(Substitute("Unknown create mode $0", mode));
+ return Status::NotSupported(strings::Substitute("Unknown create mode $0", mode));
}
int f;
RETRY_ON_EINTR(f, open(filename.c_str(), flags, 0666));
@@ -128,7 +128,7 @@ static Status do_readv_at(int fd, const std::string& filename, uint64_t offset,
if (PREDICT_FALSE(r == 0)) {
return Status::EndOfFile(
- Substitute("EOF trying to read $0 bytes at offset $1", bytes_req, offset));
+ strings::Substitute("EOF trying to read $0 bytes at offset $1", bytes_req, offset));
}
if (PREDICT_TRUE(r == rem)) {
@@ -252,7 +252,7 @@ public:
const string& filename() const override { return _filename; }
private:
- const string _filename;
+ const std::string _filename;
FILE* const _file;
};
@@ -494,7 +494,7 @@ public:
}
private:
- const string _filename;
+ const std::string _filename;
const int _fd;
const bool _sync_on_close = false;
bool _closed = false;
@@ -675,7 +675,7 @@ public:
// because the buffer is allocated by malloc(), see `man 3 realpath`.
std::unique_ptr<char[], FreeDeleter> r(realpath(path.c_str(), nullptr));
if (r == nullptr) {
- return io_error(Substitute("Unable to canonicalize $0", path), errno);
+ return io_error(strings::Substitute("Unable to canonicalize $0", path), errno);
}
*result = std::string(r.get());
return Status::OK();
diff --git a/be/src/env/env_util.cpp b/be/src/env/env_util.cpp
index b383439..2c994e9 100644
--- a/be/src/env/env_util.cpp
+++ b/be/src/env/env_util.cpp
@@ -22,7 +22,7 @@
using std::shared_ptr;
using std::string;
-using std::unique_ptr;
+
namespace doris {
namespace env_util {
@@ -33,14 +33,14 @@ Status open_file_for_write(Env* env, const string& path, shared_ptr<WritableFile
Status open_file_for_write(const WritableFileOptions& opts, Env* env, const string& path,
shared_ptr<WritableFile>* file) {
- unique_ptr<WritableFile> w;
+ std::unique_ptr<WritableFile> w;
RETURN_IF_ERROR(env->new_writable_file(opts, path, &w));
file->reset(w.release());
return Status::OK();
}
Status open_file_for_random(Env* env, const string& path, shared_ptr<RandomAccessFile>* file) {
- unique_ptr<RandomAccessFile> r;
+ std::unique_ptr<RandomAccessFile> r;
RETURN_IF_ERROR(env->new_random_access_file(path, &r));
file->reset(r.release());
return Status::OK();
@@ -48,7 +48,7 @@ Status open_file_for_random(Env* env, const string& path, shared_ptr<RandomAcces
static Status do_write_string_to_file(Env* env, const Slice& data, const std::string& fname,
bool should_sync) {
- unique_ptr<WritableFile> file;
+ std::unique_ptr<WritableFile> file;
Status s = env->new_writable_file(fname, &file);
if (!s.ok()) {
return s;
@@ -78,13 +78,13 @@ Status write_string_to_file_sync(Env* env, const Slice& data, const std::string&
Status read_file_to_string(Env* env, const std::string& fname, faststring* data) {
data->clear();
- unique_ptr<SequentialFile> file;
+ std::unique_ptr<SequentialFile> file;
Status s = env->new_sequential_file(fname, &file);
if (!s.ok()) {
return s;
}
static const int kBufferSize = 8192;
- unique_ptr<uint8_t[]> scratch(new uint8_t[kBufferSize]);
+ std::unique_ptr<uint8_t[]> scratch(new uint8_t[kBufferSize]);
while (true) {
Slice fragment(scratch.get(), kBufferSize);
s = file->read(&fragment);
diff --git a/be/src/exec/aggregation_node.cpp b/be/src/exec/aggregation_node.cpp
index 4768f32..53e3326 100644
--- a/be/src/exec/aggregation_node.cpp
+++ b/be/src/exec/aggregation_node.cpp
@@ -136,7 +136,7 @@ Status AggregationNode::prepare(RuntimeState* state) {
// TODO: how many buckets?
_hash_tbl.reset(new HashTable(
_build_expr_ctxs, _probe_expr_ctxs, 1, true,
- vector<bool>(_build_expr_ctxs.size(), false), id(), mem_tracker(), 1024));
+ std::vector<bool>(_build_expr_ctxs.size(), false), id(), mem_tracker(), 1024));
if (_probe_expr_ctxs.empty()) {
// create single output tuple now; we need to output something
@@ -328,7 +328,7 @@ Status AggregationNode::close(RuntimeState* state) {
Tuple* AggregationNode::construct_intermediate_tuple() {
Tuple* agg_tuple = Tuple::create(_intermediate_tuple_desc->byte_size(), _tuple_pool.get());
- vector<SlotDescriptor*>::const_iterator slot_desc = _intermediate_tuple_desc->slots().begin();
+ std::vector<SlotDescriptor*>::const_iterator slot_desc = _intermediate_tuple_desc->slots().begin();
// copy grouping values
for (int i = 0; i < _probe_expr_ctxs.size(); ++i, ++slot_desc) {
@@ -389,7 +389,7 @@ void AggregationNode::update_tuple(Tuple* tuple, TupleRow* row) {
AggFnEvaluator::add(_aggregate_evaluators, _agg_fn_ctxs, row, tuple);
#if 0
- vector<AggFnEvaluator*>::const_iterator evaluator;
+ std::vector<AggFnEvaluator*>::const_iterator evaluator;
int i = 0;
for (evaluator = _aggregate_evaluators.begin();
evaluator != _aggregate_evaluators.end(); ++evaluator, ++i) {
diff --git a/be/src/exec/analytic_eval_node.cpp b/be/src/exec/analytic_eval_node.cpp
index 099affb..6aae452 100644
--- a/be/src/exec/analytic_eval_node.cpp
+++ b/be/src/exec/analytic_eval_node.cpp
@@ -164,10 +164,10 @@ Status AnalyticEvalNode::prepare(RuntimeState* state) {
if (_partition_by_eq_expr_ctx != NULL || _order_by_eq_expr_ctx != NULL) {
DCHECK(_buffered_tuple_desc != NULL);
- vector<TTupleId> tuple_ids;
+ std::vector<TTupleId> tuple_ids;
tuple_ids.push_back(child(0)->row_desc().tuple_descriptors()[0]->id());
tuple_ids.push_back(_buffered_tuple_desc->id());
- RowDescriptor cmp_row_desc(state->desc_tbl(), tuple_ids, vector<bool>(2, false));
+ RowDescriptor cmp_row_desc(state->desc_tbl(), tuple_ids, std::vector<bool>(2, false));
if (_partition_by_eq_expr_ctx != NULL) {
RETURN_IF_ERROR(
@@ -261,12 +261,12 @@ Status AnalyticEvalNode::open(RuntimeState* state) {
return Status::OK();
}
-string debug_window_bound_string(const TAnalyticWindowBoundary& b) {
+std::string debug_window_bound_string(const TAnalyticWindowBoundary& b) {
if (b.type == TAnalyticWindowBoundaryType::CURRENT_ROW) {
return "CURRENT_ROW";
}
- stringstream ss;
+ std::stringstream ss;
if (b.__isset.rows_offset_value) {
ss << b.rows_offset_value;
@@ -321,7 +321,7 @@ std::string AnalyticEvalNode::debug_window_string() const {
}
std::string AnalyticEvalNode::debug_state_string(bool detailed) const {
- stringstream ss;
+ std::stringstream ss;
ss << "num_returned=" << _input_stream->rows_returned()
<< " num_rows=" << _input_stream->num_rows()
<< " _curr_partition_idx=" << _curr_partition_idx
@@ -910,7 +910,7 @@ Status AnalyticEvalNode::close(RuntimeState* state) {
return Status::OK();
}
-void AnalyticEvalNode::debug_string(int indentation_level, stringstream* out) const {
+void AnalyticEvalNode::debug_string(int indentation_level, std::stringstream* out) const {
*out << string(indentation_level * 2, ' ');
*out << "AnalyticEvalNode("
<< " window=" << debug_window_string();
diff --git a/be/src/exec/csv_scan_node.cpp b/be/src/exec/csv_scan_node.cpp
index a1ef55a..58baecc 100644
--- a/be/src/exec/csv_scan_node.cpp
+++ b/be/src/exec/csv_scan_node.cpp
@@ -361,7 +361,7 @@ Status CsvScanNode::close(RuntimeState* state) {
return Status::OK();
}
-void CsvScanNode::debug_string(int indentation_level, stringstream* out) const {
+void CsvScanNode::debug_string(int indentation_level, std::stringstream* out) const {
*out << string(indentation_level * 2, ' ');
*out << "csvScanNode(tupleid=" << _tuple_id;
*out << ")" << std::endl;
@@ -371,7 +371,7 @@ void CsvScanNode::debug_string(int indentation_level, stringstream* out) const {
}
}
-Status CsvScanNode::set_scan_ranges(const vector<TScanRangeParams>& scan_ranges) {
+Status CsvScanNode::set_scan_ranges(const std::vector<TScanRangeParams>& scan_ranges) {
return Status::OK();
}
diff --git a/be/src/exec/es/es_predicate.cpp b/be/src/exec/es/es_predicate.cpp
index 6c6b609..1070b45 100644
--- a/be/src/exec/es/es_predicate.cpp
+++ b/be/src/exec/es/es_predicate.cpp
@@ -196,7 +196,7 @@ Status EsPredicate::build_disjuncts_list() {
}
// make sure to build by build_disjuncts_list
-const vector<ExtPredicate*>& EsPredicate::get_predicate_list(){
+const std::vector<ExtPredicate*>& EsPredicate::get_predicate_list(){
return _disjuncts;
}
@@ -292,9 +292,9 @@ Status EsPredicate::build_disjuncts_list(const Expr* conjunct) {
}
Expr* expr = conjunct->get_child(1);
ExtLiteral literal(expr->type().type, _context->get_value(expr, NULL));
- vector<ExtLiteral> query_conditions;
+ std::vector<ExtLiteral> query_conditions;
query_conditions.emplace_back(literal);
- vector<ExtColumnDesc> cols;
+ std::vector<ExtColumnDesc> cols;
ExtPredicate* predicate = new ExtFunction(
TExprNodeType::FUNCTION_CALL,
"esquery",
@@ -383,7 +383,7 @@ Status EsPredicate::build_disjuncts_list(const Expr* conjunct) {
"opcode in IN_PRED is neither FILTER_IN nor FILTER_NOT_IN");
}
- vector<ExtLiteral> in_pred_values;
+ std::vector<ExtLiteral> in_pred_values;
const InPredicate* pred = dynamic_cast<const InPredicate*>(conjunct);
const Expr* expr = Expr::expr_without_cast(pred->get_child(0));
if (expr->node_type() != TExprNodeType::SLOT_REF) {
diff --git a/be/src/exec/es/es_query_builder.cpp b/be/src/exec/es/es_query_builder.cpp
index a448ecc..441aa55 100644
--- a/be/src/exec/es/es_query_builder.cpp
+++ b/be/src/exec/es/es_query_builder.cpp
@@ -268,7 +268,7 @@ BooleanQueryBuilder::BooleanQueryBuilder(const std::vector<ExtPredicate*>& predi
if (compound_predicates->op == TExprOpcode::COMPOUND_AND) {
BooleanQueryBuilder* bool_query = new BooleanQueryBuilder();
for (auto es_predicate : compound_predicates->conjuncts) {
- vector<ExtPredicate*> or_predicates = es_predicate->get_predicate_list();
+ std::vector<ExtPredicate*> or_predicates = es_predicate->get_predicate_list();
BooleanQueryBuilder* inner_bool_query = new BooleanQueryBuilder(or_predicates);
bool_query->must(inner_bool_query);
}
@@ -434,7 +434,7 @@ void BooleanQueryBuilder::to_query(const std::vector<EsPredicate*>& predicates,
root->SetObject();
BooleanQueryBuilder bool_query;
for (auto es_predicate : predicates) {
- vector<ExtPredicate*> or_predicates = es_predicate->get_predicate_list();
+ std::vector<ExtPredicate*> or_predicates = es_predicate->get_predicate_list();
BooleanQueryBuilder* inner_bool_query = new BooleanQueryBuilder(or_predicates);
bool_query.must(inner_bool_query);
}
diff --git a/be/src/exec/es/es_scroll_parser.cpp b/be/src/exec/es/es_scroll_parser.cpp
index 4e0ccfe..4bf44dc 100644
--- a/be/src/exec/es/es_scroll_parser.cpp
+++ b/be/src/exec/es/es_scroll_parser.cpp
@@ -71,12 +71,12 @@ std::string json_value_to_string(const rapidjson::Value& value) {
return scratch_buffer.GetString();
}
-static const string ERROR_INVALID_COL_DATA = "Data source returned inconsistent column data. "
+static const std::string ERROR_INVALID_COL_DATA = "Data source returned inconsistent column data. "
"Expected value of type $0 based on column metadata. This likely indicates a "
"problem with the data source library.";
-static const string ERROR_MEM_LIMIT_EXCEEDED = "DataSourceScanNode::$0() failed to allocate "
+static const std::string ERROR_MEM_LIMIT_EXCEEDED = "DataSourceScanNode::$0() failed to allocate "
"$1 bytes for $2.";
-static const string ERROR_COL_DATA_IS_ARRAY = "Data source returned an array for the type $0"
+static const std::string ERROR_COL_DATA_IS_ARRAY = "Data source returned an array for the type $0"
"based on column metadata.";
#define RETURN_ERROR_IF_COL_IS_ARRAY(col, type) \
@@ -301,7 +301,7 @@ Status ScrollParser::fill_tuple(const TupleDescriptor* tuple_desc,
size_t len = _id.length();
char* buffer = reinterpret_cast<char*>(tuple_pool->try_allocate_unaligned(len));
if (UNLIKELY(buffer == NULL)) {
- string details = strings::Substitute(ERROR_MEM_LIMIT_EXCEEDED, "MaterializeNextRow",
+ std::string details = strings::Substitute(ERROR_MEM_LIMIT_EXCEEDED, "MaterializeNextRow",
len, "string slot");
return tuple_pool->mem_tracker()->MemLimitExceeded(NULL, details, len);
}
@@ -351,7 +351,7 @@ Status ScrollParser::fill_tuple(const TupleDescriptor* tuple_desc,
size_t val_size = val.length();
char* buffer = reinterpret_cast<char*>(tuple_pool->try_allocate_unaligned(val_size));
if (UNLIKELY(buffer == NULL)) {
- string details = strings::Substitute(ERROR_MEM_LIMIT_EXCEEDED, "MaterializeNextRow",
+ std::string details = strings::Substitute(ERROR_MEM_LIMIT_EXCEEDED, "MaterializeNextRow",
val_size, "string slot");
return tuple_pool->mem_tracker()->MemLimitExceeded(NULL, details, val_size);
}
diff --git a/be/src/exec/es_scan_node.cpp b/be/src/exec/es_scan_node.cpp
index 54ae643..abde624 100644
--- a/be/src/exec/es_scan_node.cpp
+++ b/be/src/exec/es_scan_node.cpp
@@ -41,10 +41,10 @@
namespace doris {
// $0 = column type (e.g. INT)
-const string ERROR_INVALID_COL_DATA = "Data source returned inconsistent column data. "
+const std::string ERROR_INVALID_COL_DATA = "Data source returned inconsistent column data. "
"Expected value of type $0 based on column metadata. This likely indicates a "
"problem with the data source library.";
-const string ERROR_MEM_LIMIT_EXCEEDED = "DataSourceScanNode::$0() failed to allocate "
+const std::string ERROR_MEM_LIMIT_EXCEEDED = "DataSourceScanNode::$0() failed to allocate "
"$1 bytes for $2.";
EsScanNode::EsScanNode(
@@ -87,7 +87,7 @@ Status EsScanNode::open(RuntimeState* state) {
RETURN_IF_ERROR(ExecNode::open(state));
// TExtOpenParams.row_schema
- vector<TExtColumnDesc> cols;
+ std::vector<TExtColumnDesc> cols;
for (const SlotDescriptor* slot : _tuple_desc->slots()) {
TExtColumnDesc col;
col.__set_name(slot->col_name());
@@ -99,11 +99,11 @@ Status EsScanNode::open(RuntimeState* state) {
row_schema.__isset.cols = true;
// TExtOpenParams.predicates
- vector<vector<TExtPredicate>> predicates;
- vector<int> predicate_to_conjunct;
+ std::vector<vector<TExtPredicate>> predicates;
+ std::vector<int> predicate_to_conjunct;
for (int i = 0; i < _conjunct_ctxs.size(); ++i) {
VLOG(1) << "conjunct: " << _conjunct_ctxs[i]->root()->debug_string();
- vector<TExtPredicate> disjuncts;
+ std::vector<TExtPredicate> disjuncts;
if (get_disjuncts(_conjunct_ctxs[i], _conjunct_ctxs[i]->root(), disjuncts)) {
predicates.emplace_back(std::move(disjuncts));
predicate_to_conjunct.push_back(i);
@@ -111,7 +111,7 @@ Status EsScanNode::open(RuntimeState* state) {
}
// open every scan range
- vector<int> conjunct_accepted_times(_conjunct_ctxs.size(), 0);
+ std::vector<int> conjunct_accepted_times(_conjunct_ctxs.size(), 0);
for (int i = 0; i < _scan_ranges.size(); ++i) {
TEsScanRange& es_scan_range = _scan_ranges[i];
@@ -222,9 +222,9 @@ Status EsScanNode::get_next(RuntimeState* state, RowBatch* row_batch, bool* eos)
// convert
VLOG(1) << "begin to convert: scan_range_idx=" << _scan_range_idx
<< ", num_rows=" << result.rows.num_rows;
- vector<TExtColumnData>& cols = result.rows.cols;
+ std::vector<TExtColumnData>& cols = result.rows.cols;
// indexes of the next non-null value in the row batch, per column.
- vector<int> cols_next_val_idx(_tuple_desc->slots().size(), 0);
+ std::vector<int> cols_next_val_idx(_tuple_desc->slots().size(), 0);
for (int row_idx = 0; row_idx < result.rows.num_rows; row_idx++) {
if (reached_limit()) {
*eos = true;
@@ -311,7 +311,7 @@ Status EsScanNode::close(RuntimeState* state) {
return Status::OK();
}
-void EsScanNode::debug_string(int indentation_level, stringstream* out) const {
+void EsScanNode::debug_string(int indentation_level, std::stringstream* out) const {
*out << string(indentation_level * 2, ' ');
*out << "EsScanNode(tupleid=" << _tuple_id;
*out << ")" << std::endl;
@@ -321,7 +321,7 @@ void EsScanNode::debug_string(int indentation_level, stringstream* out) const {
}
}
-Status EsScanNode::set_scan_ranges(const vector<TScanRangeParams>& scan_ranges) {
+Status EsScanNode::set_scan_ranges(const std::vector<TScanRangeParams>& scan_ranges) {
for (int i = 0; i < scan_ranges.size(); ++i) {
TScanRangeParams scan_range = scan_ranges[i];
DCHECK(scan_range.scan_range.__isset.es_scan_range);
@@ -396,7 +396,7 @@ bool EsScanNode::ignore_cast(SlotDescriptor* slot, Expr* expr) {
}
bool EsScanNode::get_disjuncts(ExprContext* context, Expr* conjunct,
- vector<TExtPredicate>& disjuncts) {
+ std::vector<TExtPredicate>& disjuncts) {
if (TExprNodeType::BINARY_PRED == conjunct->node_type()) {
if (conjunct->children().size() != 2) {
VLOG(1) << "get disjuncts fail: number of children is not 2";
@@ -448,7 +448,7 @@ bool EsScanNode::get_disjuncts(ExprContext* context, Expr* conjunct,
// down it to es
TExtFunction match_function;
match_function.__set_func_name(conjunct->fn().name.function_name);
- vector<TExtLiteral> query_conditions;
+ std::vector<TExtLiteral> query_conditions;
TExtLiteral literal;
@@ -473,7 +473,7 @@ bool EsScanNode::get_disjuncts(ExprContext* context, Expr* conjunct,
return false;
}
TExtInPredicate ext_in_predicate;
- vector<TExtLiteral> in_pred_values;
+ std::vector<TExtLiteral> in_pred_values;
InPredicate* pred = dynamic_cast<InPredicate*>(conjunct);
ext_in_predicate.__set_is_not_in(pred->is_not_in());
if (Expr::type_without_cast(pred->get_child(0)) != TExprNodeType::SLOT_REF) {
@@ -754,8 +754,8 @@ Status EsScanNode::get_next_from_es(TExtGetNextResult& result) {
}
Status EsScanNode::materialize_row(MemPool* tuple_pool, Tuple* tuple,
- const vector<TExtColumnData>& cols, int row_idx,
- vector<int>& cols_next_val_idx) {
+ const std::vector<TExtColumnData>& cols, int row_idx,
+ std::vector<int>& cols_next_val_idx) {
tuple->init(_tuple_desc->byte_size());
for (int i = 0; i < _tuple_desc->slots().size(); ++i) {
@@ -786,7 +786,7 @@ Status EsScanNode::materialize_row(MemPool* tuple_pool, Tuple* tuple,
size_t val_size = val.size();
char* buffer = reinterpret_cast<char*>(tuple_pool->try_allocate_unaligned(val_size));
if (UNLIKELY(buffer == NULL)) {
- string details = strings::Substitute(ERROR_MEM_LIMIT_EXCEEDED, "MaterializeNextRow",
+ std::string details = strings::Substitute(ERROR_MEM_LIMIT_EXCEEDED, "MaterializeNextRow",
val_size, "string slot");
return tuple_pool->mem_tracker()->MemLimitExceeded(NULL, details, val_size);
}
diff --git a/be/src/exec/exchange_node.cpp b/be/src/exec/exchange_node.cpp
index 6c41f77..39a688a 100644
--- a/be/src/exec/exchange_node.cpp
+++ b/be/src/exec/exchange_node.cpp
@@ -37,7 +37,7 @@ ExchangeNode::ExchangeNode(
_num_senders(0),
_stream_recvr(NULL),
_input_row_desc(descs, tnode.exchange_node.input_row_tuples,
- vector<bool>(
+ std::vector<bool>(
tnode.nullable_tuples.begin(),
tnode.nullable_tuples.begin() + tnode.exchange_node.input_row_tuples.size())),
_next_row_idx(0),
diff --git a/be/src/exec/exec_node.cpp b/be/src/exec/exec_node.cpp
index 4713864..1f95313 100644
--- a/be/src/exec/exec_node.cpp
+++ b/be/src/exec/exec_node.cpp
@@ -285,7 +285,7 @@ Status ExecNode::create_tree(RuntimeState* state, ObjectPool* pool, const TPlan&
Status ExecNode::create_tree_helper(
RuntimeState* state,
ObjectPool* pool,
- const vector<TPlanNode>& tnodes,
+ const std::vector<TPlanNode>& tnodes,
const DescriptorTbl& descs,
ExecNode* parent,
int* node_idx,
@@ -509,7 +509,7 @@ bool ExecNode::eval_conjuncts(ExprContext* const* ctxs, int num_ctxs, TupleRow*
return true;
}
-void ExecNode::collect_nodes(TPlanNodeType::type node_type, vector<ExecNode*>* nodes) {
+void ExecNode::collect_nodes(TPlanNodeType::type node_type, std::vector<ExecNode*>* nodes) {
if (_type == node_type) {
nodes->push_back(this);
}
@@ -617,7 +617,7 @@ Status ExecNode::enable_deny_reservation_debug_action() {
debug_action_param_.c_str(), debug_action_param_.size(), &parse_result);
if (parse_result != StringParser::PARSE_SUCCESS || probability < 0.0
|| probability > 1.0) {
- return Status::InternalError(Substitute(
+ return Status::InternalError(strings::Substitute(
"Invalid SET_DENY_RESERVATION_PROBABILITY param: '$0'", debug_action_param_));
}
_buffer_pool_client.SetDebugDenyIncreaseReservation(probability);
diff --git a/be/src/exec/hash_join_node.cpp b/be/src/exec/hash_join_node.cpp
index c120330..4b55462 100644
--- a/be/src/exec/hash_join_node.cpp
+++ b/be/src/exec/hash_join_node.cpp
@@ -55,7 +55,7 @@ HashJoinNode::~HashJoinNode() {
Status HashJoinNode::init(const TPlanNode& tnode, RuntimeState* state) {
RETURN_IF_ERROR(ExecNode::init(tnode, state));
DCHECK(tnode.__isset.hash_join_node);
- const vector<TEqJoinCondition>& eq_join_conjuncts = tnode.hash_join_node.eq_join_conjuncts;
+ const std::vector<TEqJoinCondition>& eq_join_conjuncts = tnode.hash_join_node.eq_join_conjuncts;
for (int i = 0; i < eq_join_conjuncts.size(); ++i) {
ExprContext* ctx = NULL;
@@ -681,7 +681,7 @@ Status HashJoinNode::left_join_get_next(RuntimeState* state,
return Status::OK();
}
-string HashJoinNode::get_probe_row_output_string(TupleRow* probe_row) {
+std::string HashJoinNode::get_probe_row_output_string(TupleRow* probe_row) {
std::stringstream out;
out << "[";
int* _build_tuple_idx_ptr = &_build_tuple_idx[0];
diff --git a/be/src/exec/hash_table.cpp b/be/src/exec/hash_table.cpp
index 48b70b5..471663d 100644
--- a/be/src/exec/hash_table.cpp
+++ b/be/src/exec/hash_table.cpp
@@ -28,8 +28,8 @@ namespace doris {
const float HashTable::MAX_BUCKET_OCCUPANCY_FRACTION = 0.75f;
-HashTable::HashTable(const vector<ExprContext*>& build_expr_ctxs,
- const vector<ExprContext*>& probe_expr_ctxs,
+HashTable::HashTable(const std::vector<ExprContext*>& build_expr_ctxs,
+ const std::vector<ExprContext*>& probe_expr_ctxs,
int num_build_tuples, bool stores_nulls,
const std::vector<bool>& finds_nulls,
int32_t initial_seed,
@@ -85,7 +85,7 @@ void HashTable::close() {
_mem_tracker->Release(_buckets.size() * sizeof(Bucket));
}
-bool HashTable::eval_row(TupleRow* row, const vector<ExprContext*>& ctxs) {
+bool HashTable::eval_row(TupleRow* row, const std::vector<ExprContext*>& ctxs) {
// Put a non-zero constant in the result location for NULL.
// We don't want(NULL, 1) to hash to the same as (0, 1).
// This needs to be as big as the biggest primitive type since the bytes
diff --git a/be/src/exec/merge_join_node.cpp b/be/src/exec/merge_join_node.cpp
index 9121940..12a2571 100644
--- a/be/src/exec/merge_join_node.cpp
+++ b/be/src/exec/merge_join_node.cpp
@@ -57,7 +57,7 @@ MergeJoinNode::~MergeJoinNode() {
Status MergeJoinNode::init(const TPlanNode& tnode, RuntimeState* state) {
DCHECK(tnode.__isset.merge_join_node);
RETURN_IF_ERROR(ExecNode::init(tnode, state));
- const vector<TEqJoinCondition>& cmp_conjuncts =
+ const std::vector<TEqJoinCondition>& cmp_conjuncts =
tnode.merge_join_node.cmp_conjuncts;
for (int i = 0; i < cmp_conjuncts.size(); ++i) {
@@ -326,7 +326,7 @@ Status MergeJoinNode::get_input_row(RuntimeState* state, int child_idx) {
return Status::OK();
}
-void MergeJoinNode::debug_string(int indentation_level, stringstream* out) const {
+void MergeJoinNode::debug_string(int indentation_level, std::stringstream* out) const {
*out << string(indentation_level * 2, ' ');
*out << "MergeJoin(eos=" << (_eos ? "true" : "false")
<< " _left_child_pos=" << (_left_child_ctx.get() ? _left_child_ctx->row_idx : -1)
diff --git a/be/src/exec/merge_node.cpp b/be/src/exec/merge_node.cpp
index a979d95..92152ec 100644
--- a/be/src/exec/merge_node.cpp
+++ b/be/src/exec/merge_node.cpp
@@ -42,16 +42,16 @@ Status MergeNode::init(const TPlanNode& tnode, RuntimeState* state) {
RETURN_IF_ERROR(ExecNode::init(tnode, state));
DCHECK(tnode.__isset.merge_node);
// Create _const_expr_lists from thrift exprs.
- const vector<vector<TExpr>>& const_texpr_lists = tnode.merge_node.const_expr_lists;
+ const std::vector<vector<TExpr>>& const_texpr_lists = tnode.merge_node.const_expr_lists;
for (int i = 0; i < const_texpr_lists.size(); ++i) {
- vector<ExprContext*> ctxs;
+ std::vector<ExprContext*> ctxs;
RETURN_IF_ERROR(Expr::create_expr_trees(_pool, const_texpr_lists[i], &ctxs));
_const_result_expr_ctx_lists.push_back(ctxs);
}
// Create _result_expr__ctx_lists from thrift exprs.
- const vector<vector<TExpr>>& result_texpr_lists = tnode.merge_node.result_expr_lists;
+ const std::vector<vector<TExpr>>& result_texpr_lists = tnode.merge_node.result_expr_lists;
for (int i = 0; i < result_texpr_lists.size(); ++i) {
- vector<ExprContext*> ctxs;
+ std::vector<ExprContext*> ctxs;
RETURN_IF_ERROR(Expr::create_expr_trees(_pool, result_texpr_lists[i], &ctxs));
_result_expr_ctx_lists.push_back(ctxs);
}
diff --git a/be/src/exec/mysql_scan_node.cpp b/be/src/exec/mysql_scan_node.cpp
index f76fcfe..7f087f3 100644
--- a/be/src/exec/mysql_scan_node.cpp
+++ b/be/src/exec/mysql_scan_node.cpp
@@ -250,7 +250,7 @@ Status MysqlScanNode::close(RuntimeState* state) {
return ExecNode::close(state);
}
-void MysqlScanNode::debug_string(int indentation_level, stringstream* out) const {
+void MysqlScanNode::debug_string(int indentation_level, std::stringstream* out) const {
*out << string(indentation_level * 2, ' ');
*out << "MysqlScanNode(tupleid=" << _tuple_id << " table=" << _table_name;
*out << ")" << std::endl;
@@ -260,7 +260,7 @@ void MysqlScanNode::debug_string(int indentation_level, stringstream* out) const
}
}
-Status MysqlScanNode::set_scan_ranges(const vector<TScanRangeParams>& scan_ranges) {
+Status MysqlScanNode::set_scan_ranges(const std::vector<TScanRangeParams>& scan_ranges) {
return Status::OK();
}
diff --git a/be/src/exec/odbc_scan_node.cpp b/be/src/exec/odbc_scan_node.cpp
index 55614c5..91deca2 100644
--- a/be/src/exec/odbc_scan_node.cpp
+++ b/be/src/exec/odbc_scan_node.cpp
@@ -239,7 +239,7 @@ Status OdbcScanNode::close(RuntimeState* state) {
return ExecNode::close(state);
}
-void OdbcScanNode::debug_string(int indentation_level, stringstream* out) const {
+void OdbcScanNode::debug_string(int indentation_level, std::stringstream* out) const {
*out << string(indentation_level * 2, ' ');
*out << "OdbcScanNode(tupleid=" << _tuple_id << " table=" << _table_name;
*out << ")" << std::endl;
@@ -249,7 +249,7 @@ void OdbcScanNode::debug_string(int indentation_level, stringstream* out) const
}
}
-Status OdbcScanNode::set_scan_ranges(const vector<TScanRangeParams>& scan_ranges) {
+Status OdbcScanNode::set_scan_ranges(const std::vector<TScanRangeParams>& scan_ranges) {
return Status::OK();
}
diff --git a/be/src/exec/parquet_reader.cpp b/be/src/exec/parquet_reader.cpp
index dd4bfe9..6ed2020 100644
--- a/be/src/exec/parquet_reader.cpp
+++ b/be/src/exec/parquet_reader.cpp
@@ -310,7 +310,7 @@ Status ParquetReaderWrap::read(Tuple* tuple, const std::vector<SlotDescriptor*>&
if (fixed_array->IsNull(_current_line_of_batch)) {
RETURN_IF_ERROR(set_field_null(tuple, slot_desc));
} else {
- string value = fixed_array->GetString(_current_line_of_batch);
+ std::string value = fixed_array->GetString(_current_line_of_batch);
fill_slot(tuple, slot_desc, mem_pool, (uint8_t*)value.c_str(), value.length());
}
break;
diff --git a/be/src/exec/partitioned_aggregation_node.cc b/be/src/exec/partitioned_aggregation_node.cc
index 2c767e2..feab536 100644
--- a/be/src/exec/partitioned_aggregation_node.cc
+++ b/be/src/exec/partitioned_aggregation_node.cc
@@ -46,7 +46,7 @@
#include "gen_cpp/Exprs_types.h"
#include "gen_cpp/PlanNodes_types.h"
-#include "common/names.h"
+
using namespace strings;
diff --git a/be/src/exec/partitioned_hash_table.cc b/be/src/exec/partitioned_hash_table.cc
index e8ab74a..de79e1d 100644
--- a/be/src/exec/partitioned_hash_table.cc
+++ b/be/src/exec/partitioned_hash_table.cc
@@ -32,7 +32,7 @@
#include "runtime/string_value.h"
#include "util/doris_metrics.h"
-#include "common/names.h"
+
using namespace doris;
using namespace strings;
@@ -155,7 +155,7 @@ Status PartitionedHashTableCtx::Create(ObjectPool* pool, RuntimeState* state,
int num_build_tuples, MemPool* mem_pool, MemPool* expr_results_pool,
const std::shared_ptr<MemTracker>& tracker, const RowDescriptor& row_desc,
const RowDescriptor& row_desc_probe,
- scoped_ptr<PartitionedHashTableCtx>* ht_ctx) {
+ boost::scoped_ptr<PartitionedHashTableCtx>* ht_ctx) {
ht_ctx->reset(new PartitionedHashTableCtx(build_exprs, probe_exprs, stores_nulls,
finds_nulls, initial_seed, max_levels, mem_pool, expr_results_pool, tracker));
return (*ht_ctx)->Init(pool, state, num_build_tuples, row_desc, row_desc_probe);
diff --git a/be/src/exec/repeat_node.cpp b/be/src/exec/repeat_node.cpp
index bfc22f5..7997770 100644
--- a/be/src/exec/repeat_node.cpp
+++ b/be/src/exec/repeat_node.cpp
@@ -78,9 +78,9 @@ Status RepeatNode::get_repeated_batch(
// Fill all slots according to child
MemPool* tuple_pool = row_batch->tuple_data_pool();
- const vector<TupleDescriptor*>& src_tuple_descs = child_row_batch->row_desc().tuple_descriptors();
- const vector<TupleDescriptor*>& dst_tuple_descs = row_batch->row_desc().tuple_descriptors();
- vector<Tuple*> dst_tuples(src_tuple_descs.size(), nullptr);
+ const std::vector<TupleDescriptor*>& src_tuple_descs = child_row_batch->row_desc().tuple_descriptors();
+ const std::vector<TupleDescriptor*>& dst_tuple_descs = row_batch->row_desc().tuple_descriptors();
+ std::vector<Tuple*> dst_tuples(src_tuple_descs.size(), nullptr);
for (int i = 0; i < child_row_batch->num_rows(); ++i) {
int row_idx = row_batch->add_row();
TupleRow* dst_row = row_batch->get_row(row_idx);
diff --git a/be/src/exec/scan_node.cpp b/be/src/exec/scan_node.cpp
index 5654f05..f89b206 100644
--- a/be/src/exec/scan_node.cpp
+++ b/be/src/exec/scan_node.cpp
@@ -21,10 +21,10 @@
namespace doris {
-const string ScanNode::_s_bytes_read_counter = "BytesRead";
-const string ScanNode::_s_rows_read_counter = "RowsRead";
-const string ScanNode::_s_total_throughput_counter = "TotalReadThroughput";
-const string ScanNode::_s_num_disks_accessed_counter = "NumDiskAccess";
+const std::string ScanNode::_s_bytes_read_counter = "BytesRead";
+const std::string ScanNode::_s_rows_read_counter = "RowsRead";
+const std::string ScanNode::_s_total_throughput_counter = "TotalReadThroughput";
+const std::string ScanNode::_s_num_disks_accessed_counter = "NumDiskAccess";
Status ScanNode::prepare(RuntimeState* state) {
RETURN_IF_ERROR(ExecNode::prepare(state));
diff --git a/be/src/exec/schema_scan_node.cpp b/be/src/exec/schema_scan_node.cpp
index e937cc8..2590833 100644
--- a/be/src/exec/schema_scan_node.cpp
+++ b/be/src/exec/schema_scan_node.cpp
@@ -313,7 +313,7 @@ Status SchemaScanNode::close(RuntimeState* state) {
return ExecNode::close(state);
}
-void SchemaScanNode::debug_string(int indentation_level, stringstream* out) const {
+void SchemaScanNode::debug_string(int indentation_level, std::stringstream* out) const {
*out << string(indentation_level * 2, ' ');
*out << "SchemaScanNode(tupleid=" << _tuple_id << " table=" << _table_name;
*out << ")" << std::endl;
@@ -323,7 +323,7 @@ void SchemaScanNode::debug_string(int indentation_level, stringstream* out) cons
}
}
-Status SchemaScanNode::set_scan_ranges(const vector<TScanRangeParams>& scan_ranges) {
+Status SchemaScanNode::set_scan_ranges(const std::vector<TScanRangeParams>& scan_ranges) {
return Status::OK();
}
diff --git a/be/src/exec/set_operation_node.cpp b/be/src/exec/set_operation_node.cpp
index c3fd056..a377dc5 100644
--- a/be/src/exec/set_operation_node.cpp
+++ b/be/src/exec/set_operation_node.cpp
@@ -85,7 +85,7 @@ Status SetOperationNode::close(RuntimeState* state) {
return ExecNode::close(state);
}
-string SetOperationNode::get_row_output_string(TupleRow* row, const RowDescriptor& row_desc) {
+std::string SetOperationNode::get_row_output_string(TupleRow* row, const RowDescriptor& row_desc) {
std::stringstream out;
out << "[";
for (int i = 0; i < row_desc.tuple_descriptors().size(); ++i) {
@@ -136,7 +136,7 @@ Status SetOperationNode::open(RuntimeState* state) {
SCOPED_TIMER(_runtime_profile->total_time_counter());
RETURN_IF_CANCELLED(state);
// open result expr lists.
- for (const vector<ExprContext*>& exprs : _child_expr_lists) {
+ for (const std::vector<ExprContext*>& exprs : _child_expr_lists) {
RETURN_IF_ERROR(Expr::open(exprs, state));
}
// initial build hash table used for remove duplicated
diff --git a/be/src/exec/union_node.cpp b/be/src/exec/union_node.cpp
index 1543fff..c8455bf 100644
--- a/be/src/exec/union_node.cpp
+++ b/be/src/exec/union_node.cpp
@@ -27,7 +27,7 @@
#include "util/runtime_profile.h"
#include "gen_cpp/PlanNodes_types.h"
-// #include "common/names.h"
+//
namespace doris {
@@ -76,7 +76,7 @@ Status UnionNode::prepare(RuntimeState* state) {
_materialize_exprs_evaluate_timer = ADD_TIMER(_runtime_profile, "MaterializeExprsEvaluateTimer");
_codegend_union_materialize_batch_fns.resize(_child_expr_lists.size());
// Prepare const expr lists.
- for (const vector<ExprContext*>& exprs : _const_expr_lists) {
+ for (const std::vector<ExprContext*>& exprs : _const_expr_lists) {
RETURN_IF_ERROR(Expr::prepare(exprs, state, row_desc(), expr_mem_tracker()));
// TODO(zc)
// AddExprCtxsToFree(exprs);
@@ -98,11 +98,11 @@ Status UnionNode::open(RuntimeState* state) {
SCOPED_TIMER(_runtime_profile->total_time_counter());
RETURN_IF_ERROR(ExecNode::open(state));
// open const expr lists.
- for (const vector<ExprContext*>& exprs : _const_expr_lists) {
+ for (const std::vector<ExprContext*>& exprs : _const_expr_lists) {
RETURN_IF_ERROR(Expr::open(exprs, state));
}
// open result expr lists.
- for (const vector<ExprContext*>& exprs : _child_expr_lists) {
+ for (const std::vector<ExprContext*>& exprs : _child_expr_lists) {
RETURN_IF_ERROR(Expr::open(exprs, state));
}
diff --git a/be/src/exprs/agg_fn.cc b/be/src/exprs/agg_fn.cc
index d6fff8c..c739f43 100644
--- a/be/src/exprs/agg_fn.cc
+++ b/be/src/exprs/agg_fn.cc
@@ -22,8 +22,6 @@
#include "runtime/user_function_cache.h"
#include "runtime/runtime_state.h"
-#include "common/names.h"
-
using namespace doris_udf;
namespace doris {
@@ -44,7 +42,7 @@ AggFn::AggFn(const TExprNode& tnode, const SlotDescriptor& intermediate_slot_des
DCHECK_EQ(tnode.node_type, TExprNodeType::AGG_EXPR);
DCHECK_EQ(TypeDescriptor::from_thrift(tnode.type).type,
TypeDescriptor::from_thrift(_fn.ret_type).type);
- const string& fn_name = _fn.name.function_name;
+ const std::string& fn_name = _fn.name.function_name;
if (fn_name == "count") {
agg_op_ = COUNT;
} else if (fn_name == "min") {
@@ -85,7 +83,7 @@ Status AggFn::Init(const RowDescriptor& row_desc, RuntimeState* state) {
(aggregate_fn.merge_fn_symbol.empty() && !aggregate_fn.is_analytic_only_fn)) {
// This path is only for partially implemented builtins.
DCHECK_EQ(_fn.binary_type, TFunctionBinaryType::BUILTIN);
- stringstream ss;
+ std::stringstream ss;
ss << "Function " << _fn.name.function_name << " is not implemented.";
return Status::InternalError(ss.str());
}
@@ -170,12 +168,12 @@ void AggFn::Close() {
Expr::close();
}
-void AggFn::Close(const vector<AggFn*>& exprs) {
+void AggFn::Close(const std::vector<AggFn*>& exprs) {
for (AggFn* expr : exprs) expr->Close();
}
-string AggFn::DebugString() const {
- stringstream out;
+std::string AggFn::DebugString() const {
+ std::stringstream out;
out << "AggFn(op=" << agg_op_;
for (Expr* input_expr : children()) {
out << " " << input_expr->debug_string() << ")";
@@ -184,8 +182,8 @@ string AggFn::DebugString() const {
return out.str();
}
-string AggFn::DebugString(const vector<AggFn*>& agg_fns) {
- stringstream out;
+std::string AggFn::DebugString(const std::vector<AggFn*>& agg_fns) {
+ std::stringstream out;
out << "[";
for (int i = 0; i < agg_fns.size(); ++i) {
out << (i == 0 ? "" : " ") << agg_fns[i]->DebugString();
diff --git a/be/src/exprs/agg_fn_evaluator.cpp b/be/src/exprs/agg_fn_evaluator.cpp
index e3e68e0..dc0558e 100755
--- a/be/src/exprs/agg_fn_evaluator.cpp
+++ b/be/src/exprs/agg_fn_evaluator.cpp
@@ -198,7 +198,7 @@ Status AggFnEvaluator::prepare(
(!_is_analytic_fn && _fn.aggregate_fn.merge_fn_symbol.empty())) {
// This path is only for partially implemented builtins.
DCHECK_EQ(_fn.binary_type, TFunctionBinaryType::BUILTIN);
- stringstream ss;
+ std::stringstream ss;
ss << "Function " << _fn.name.function_name << " is not implemented.";
return Status::InternalError(ss.str());
}
@@ -244,7 +244,7 @@ Status AggFnEvaluator::prepare(
NULL));
}
- vector<FunctionContext::TypeDesc> arg_types;
+ std::vector<FunctionContext::TypeDesc> arg_types;
for (int j = 0; j < _input_exprs_ctxs.size(); ++j) {
arg_types.push_back(
AnyValUtil::column_type_to_type_desc(_input_exprs_ctxs[j]->root()->type()));
@@ -265,7 +265,7 @@ Status AggFnEvaluator::open(RuntimeState* state, FunctionContext* agg_fn_ctx) {
// Now that we have opened all our input exprs, it is safe to evaluate any constant
// values for the UDA's FunctionContext (we cannot evaluate exprs before calling Open()
// on them).
- vector<AnyVal*> constant_args(_input_exprs_ctxs.size());
+ std::vector<AnyVal*> constant_args(_input_exprs_ctxs.size());
for (int i = 0; i < _input_exprs_ctxs.size(); ++i) {
constant_args[i] = _input_exprs_ctxs[i]->root()->get_const_val(_input_exprs_ctxs[i]);
}
diff --git a/be/src/exprs/expr.cpp b/be/src/exprs/expr.cpp
index ee89a33..c7661c2 100644
--- a/be/src/exprs/expr.cpp
+++ b/be/src/exprs/expr.cpp
@@ -279,7 +279,7 @@ Status Expr::create_expr_trees(
Status Expr::create_tree_from_thrift(
ObjectPool* pool,
- const vector<TExprNode>& nodes,
+ const std::vector<TExprNode>& nodes,
Expr* parent,
int* node_idx,
Expr** root_expr,
@@ -892,8 +892,8 @@ Status Expr::create(const TExpr& texpr, const RowDescriptor& row_desc, RuntimeSt
return Status::OK();
}
-Status Expr::create(const vector<TExpr>& texprs, const RowDescriptor& row_desc, RuntimeState* state,
- ObjectPool* pool, vector<Expr*>* exprs,
+Status Expr::create(const std::vector<TExpr>& texprs, const RowDescriptor& row_desc, RuntimeState* state,
+ ObjectPool* pool, std::vector<Expr*>* exprs,
const std::shared_ptr<MemTracker>& tracker) {
exprs->clear();
for (const TExpr& texpr: texprs) {
@@ -910,8 +910,8 @@ Status Expr::create(const TExpr& texpr, const RowDescriptor& row_desc,
return Expr::create(texpr, row_desc, state, state->obj_pool(), scalar_expr, tracker);
}
-Status Expr::create(const vector<TExpr>& texprs, const RowDescriptor& row_desc,
- RuntimeState* state, vector<Expr*>* exprs, const std::shared_ptr<MemTracker>& tracker) {
+Status Expr::create(const std::vector<TExpr>& texprs, const RowDescriptor& row_desc,
+ RuntimeState* state, std::vector<Expr*>* exprs, const std::shared_ptr<MemTracker>& tracker) {
return Expr::create(texprs, row_desc, state, state->obj_pool(), exprs, tracker);
}
@@ -937,7 +937,7 @@ Status Expr::create_tree(const TExpr& texpr, ObjectPool* pool, Expr* root) {
return Status::OK();
}
-Status Expr::create_tree_internal(const vector<TExprNode>& nodes, ObjectPool* pool,
+Status Expr::create_tree_internal(const std::vector<TExprNode>& nodes, ObjectPool* pool,
Expr* root, int* child_node_idx) {
// propagate error case
if (*child_node_idx >= nodes.size()) {
@@ -972,7 +972,7 @@ void Expr::close() {
}
}
-void Expr::close(const vector<Expr*>& exprs) {
+void Expr::close(const std::vector<Expr*>& exprs) {
for (Expr* expr : exprs) expr->close();
}
diff --git a/be/src/exprs/math_functions.cpp b/be/src/exprs/math_functions.cpp
index 6fab648..89c10ea 100644
--- a/be/src/exprs/math_functions.cpp
+++ b/be/src/exprs/math_functions.cpp
@@ -366,7 +366,7 @@ StringVal MathFunctions::hex_string(FunctionContext* ctx, const StringVal& s) {
std::stringstream ss;
ss << std::hex << std::uppercase << std::setfill('0');
for (int i = 0; i < s.len; ++i) {
- // setw is not sticky. stringstream only converts integral values,
+ // setw is not sticky. std::stringstream only converts integral values,
// so a cast to int is required, but only convert the least significant byte to hex.
ss << std::setw(2) << (static_cast<int32_t>(s.ptr[i]) & 0xFF);
}
diff --git a/be/src/exprs/new_agg_fn_evaluator.cc b/be/src/exprs/new_agg_fn_evaluator.cc
index f1a7289..ca90390 100644
--- a/be/src/exprs/new_agg_fn_evaluator.cc
+++ b/be/src/exprs/new_agg_fn_evaluator.cc
@@ -36,7 +36,7 @@
#include <thrift/protocol/TDebugProtocol.h>
-#include "common/names.h"
+
using namespace doris;
using namespace doris_udf;
diff --git a/be/src/exprs/scalar_fn_call.cpp b/be/src/exprs/scalar_fn_call.cpp
index 7c04158..7c6b03f 100644
--- a/be/src/exprs/scalar_fn_call.cpp
+++ b/be/src/exprs/scalar_fn_call.cpp
@@ -120,7 +120,7 @@ Status ScalarFnCall::prepare(
return status;
} else {
DCHECK_EQ(_fn.binary_type, TFunctionBinaryType::NATIVE);
- return Status::InternalError(Substitute("Problem loading UDF '$0':\n$1",
+ return Status::InternalError(strings::Substitute("Problem loading UDF '$0':\n$1",
_fn.name.function_name, status.GetDetail()));
return status;
}
diff --git a/be/src/http/default_path_handlers.cpp b/be/src/http/default_path_handlers.cpp
index 933e6fb..20dd3b0 100644
--- a/be/src/http/default_path_handlers.cpp
+++ b/be/src/http/default_path_handlers.cpp
@@ -140,7 +140,7 @@ void mem_tracker_handler(const WebPageHandler::ArgumentMap& args, std::stringstr
">Peak Consumption</th>";
(*output) << "<tbody>\n";
- vector<shared_ptr<MemTracker>> trackers;
+ std::vector<shared_ptr<MemTracker>> trackers;
MemTracker::ListTrackers(&trackers);
for (const shared_ptr<MemTracker>& tracker : trackers) {
string parent = tracker->parent() == nullptr ? "none" : tracker->parent()->label();
diff --git a/be/src/http/web_page_handler.cpp b/be/src/http/web_page_handler.cpp
index 99576a1..417b357 100644
--- a/be/src/http/web_page_handler.cpp
+++ b/be/src/http/web_page_handler.cpp
@@ -61,7 +61,7 @@ WebPageHandler::~WebPageHandler() {
void WebPageHandler::register_template_page(const std::string& path, const string& alias,
const TemplatePageHandlerCallback& callback, bool is_on_nav_bar) {
// Relative path which will be used to find .mustache file in _www_path
- string render_path = (path == "/") ? "/home" : path;
+ std::string render_path = (path == "/") ? "/home" : path;
auto wrapped_cb = [=](const ArgumentMap& args, std::stringstream* output) {
EasyJson ej;
callback(args, &ej);
@@ -166,7 +166,7 @@ static const std::string kMainTemplate = R"(
)";
std::string WebPageHandler::mustache_partial_tag(const std::string& path) const {
- return Substitute("{{> $0.mustache}}", path);
+ return strings::Substitute("{{> $0.mustache}}", path);
}
bool WebPageHandler::static_pages_available() const {
@@ -178,7 +178,7 @@ bool WebPageHandler::mustache_template_available(const std::string& path) const
if (!static_pages_available()) {
return false;
}
- return Env::Default()->path_exists(Substitute("$0/$1.mustache", _www_path, path)).ok();
+ return Env::Default()->path_exists(strings::Substitute("$0/$1.mustache", _www_path, path)).ok();
}
void WebPageHandler::render_main_template(const std::string& content, std::stringstream* output) {
diff --git a/be/src/olap/base_compaction.cpp b/be/src/olap/base_compaction.cpp
index 03bb6eb..a29a91b 100644
--- a/be/src/olap/base_compaction.cpp
+++ b/be/src/olap/base_compaction.cpp
@@ -131,7 +131,7 @@ OLAPStatus BaseCompaction::pick_rowsets_to_compact() {
return OLAP_ERR_BE_NO_SUITABLE_VERSION;
}
-OLAPStatus BaseCompaction::_check_rowset_overlapping(const vector<RowsetSharedPtr>& rowsets) {
+OLAPStatus BaseCompaction::_check_rowset_overlapping(const std::vector<RowsetSharedPtr>& rowsets) {
for (auto& rs : rowsets) {
if (rs->rowset_meta()->is_segments_overlapping()) {
LOG(WARNING) << "There is overlapping rowset before cumulative point, "
diff --git a/be/src/olap/compaction.cpp b/be/src/olap/compaction.cpp
index 7aa6b9f..919df23 100644
--- a/be/src/olap/compaction.cpp
+++ b/be/src/olap/compaction.cpp
@@ -181,8 +181,8 @@ OLAPStatus Compaction::gc_unused_rowsets() {
// 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(
- vector<RowsetSharedPtr>* rowsets,
- vector<Version>* missing_version) {
+ std::vector<RowsetSharedPtr>* rowsets,
+ std::vector<Version>* missing_version) {
if (rowsets->empty()) {
return OLAP_SUCCESS;
}
@@ -204,7 +204,7 @@ OLAPStatus Compaction::find_longest_consecutive_version(
return OLAP_SUCCESS;
}
-OLAPStatus Compaction::check_version_continuity(const vector<RowsetSharedPtr>& rowsets) {
+OLAPStatus Compaction::check_version_continuity(const std::vector<RowsetSharedPtr>& rowsets) {
RowsetSharedPtr prev_rowset = rowsets.front();
for (size_t i = 1; i < rowsets.size(); ++i) {
RowsetSharedPtr rowset = rowsets[i];
diff --git a/be/src/olap/comparison_predicate.cpp b/be/src/olap/comparison_predicate.cpp
index 23e9d02..08b673f 100644
--- a/be/src/olap/comparison_predicate.cpp
+++ b/be/src/olap/comparison_predicate.cpp
@@ -195,7 +195,7 @@ COMPARISON_PRED_COLUMN_BLOCK_EVALUATE(GreaterEqualPredicate, >=)
#define COMPARISON_PRED_BITMAP_EVALUATE(CLASS, OP) \
template<class type> \
- Status CLASS<type>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const { \
+ Status CLASS<type>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const { \
BitmapIndexIterator* iterator = iterators[_column_id]; \
if (iterator == nullptr) { \
return Status::OK(); \
@@ -288,18 +288,18 @@ COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_DECLARATION(GreaterPredicate)
COMPARISON_PRED_COLUMN_BLOCK_EVALUATE_DECLARATION(GreaterEqualPredicate)
#define COMPARISON_PRED_BITMAP_EVALUATE_DECLARATION(CLASS) \
- template Status CLASS<int8_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<int16_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<int32_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<int64_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<int128_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<float>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<double>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<decimal12_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<StringValue>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<uint24_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<uint64_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<bool>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<int8_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<int16_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<int32_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<int64_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<int128_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<float>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<double>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<decimal12_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<StringValue>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<uint24_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<uint64_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<bool>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
COMPARISON_PRED_BITMAP_EVALUATE_DECLARATION(EqualPredicate)
COMPARISON_PRED_BITMAP_EVALUATE_DECLARATION(NotEqualPredicate)
diff --git a/be/src/olap/data_dir.cpp b/be/src/olap/data_dir.cpp
index 86650d1..9dbe658 100644
--- a/be/src/olap/data_dir.cpp
+++ b/be/src/olap/data_dir.cpp
@@ -97,7 +97,7 @@ DataDir::~DataDir() {
Status DataDir::init() {
if (!FileUtils::check_exist(_path)) {
- RETURN_NOT_OK_STATUS_WITH_WARN(Status::IOError(Substitute("opendir failed, path=$0", _path)),
+ RETURN_NOT_OK_STATUS_WITH_WARN(Status::IOError(strings::Substitute("opendir failed, path=$0", _path)),
"check file exist failed");
}
@@ -123,7 +123,7 @@ Status DataDir::_init_cluster_id() {
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
if (fd < 0 || close(fd) < 0) {
RETURN_NOT_OK_STATUS_WITH_WARN(
- Status::IOError(Substitute("failed to create cluster id file $0, err=$1",
+ Status::IOError(strings::Substitute("failed to create cluster id file $0, err=$1",
cluster_id_path, errno_to_string(errno))),
"create file failed");
}
@@ -134,7 +134,7 @@ Status DataDir::_init_cluster_id() {
fp = fopen(cluster_id_path.c_str(), "r+b");
if (fp == NULL) {
RETURN_NOT_OK_STATUS_WITH_WARN(
- Status::IOError(Substitute("failed to open cluster id file $0", cluster_id_path)),
+ Status::IOError(strings::Substitute("failed to open cluster id file $0", cluster_id_path)),
"open file failed");
}
@@ -143,7 +143,7 @@ Status DataDir::_init_cluster_id() {
fclose(fp);
fp = NULL;
RETURN_NOT_OK_STATUS_WITH_WARN(
- Status::IOError(Substitute("failed to flock cluster id file $0", cluster_id_path)),
+ Status::IOError(strings::Substitute("failed to flock cluster id file $0", cluster_id_path)),
"flock file failed");
}
@@ -159,7 +159,7 @@ Status DataDir::_read_cluster_id(const std::string& cluster_id_path, int32_t* cl
std::fstream fs(cluster_id_path.c_str(), std::fstream::in);
if (!fs.is_open()) {
RETURN_NOT_OK_STATUS_WITH_WARN(
- Status::IOError(Substitute("failed to open cluster id file $0", cluster_id_path)),
+ Status::IOError(strings::Substitute("failed to open cluster id file $0", cluster_id_path)),
"open file failed");
}
@@ -173,7 +173,7 @@ Status DataDir::_read_cluster_id(const std::string& cluster_id_path, int32_t* cl
} else {
RETURN_NOT_OK_STATUS_WITH_WARN(
Status::Corruption(
- Substitute("cluster id file $0 is corrupt. [id=$1 eofbit=$2 failbit=$3 badbit=$4]",
+ strings::Substitute("cluster id file $0 is corrupt. [id=$1 eofbit=$2 failbit=$3 badbit=$4]",
cluster_id_path, tmp_cluster_id, fs.rdstate() & std::fstream::eofbit,
fs.rdstate() & std::fstream::failbit, fs.rdstate() & std::fstream::badbit)),
"file content is error");
@@ -189,7 +189,7 @@ Status DataDir::_init_capacity() {
} else if (_capacity_bytes > disk_capacity) {
RETURN_NOT_OK_STATUS_WITH_WARN(
Status::InvalidArgument(
- Substitute("root path $0's capacity $1 should not larger than disk capacity $2",
+ strings::Substitute("root path $0's capacity $1 should not larger than disk capacity $2",
_path, _capacity_bytes, disk_capacity)),
"init capacity failed");
}
@@ -197,7 +197,7 @@ Status DataDir::_init_capacity() {
std::string data_path = _path + DATA_PREFIX;
if (!FileUtils::check_exist(data_path) && !FileUtils::create_dir(data_path).ok()) {
RETURN_NOT_OK_STATUS_WITH_WARN(
- Status::IOError(Substitute("failed to create data root path $0", data_path)),
+ Status::IOError(strings::Substitute("failed to create data root path $0", data_path)),
"check_exist failed");
}
@@ -209,7 +209,7 @@ Status DataDir::_init_file_system() {
if (stat(_path.c_str(), &s) != 0) {
RETURN_NOT_OK_STATUS_WITH_WARN(
Status::IOError(
- Substitute("stat file $0 failed, err=$1", _path, errno_to_string(errno))),
+ strings::Substitute("stat file $0 failed, err=$1", _path, errno_to_string(errno))),
"stat file failed");
}
@@ -224,7 +224,7 @@ Status DataDir::_init_file_system() {
if ((mount_tablet = setmntent(kMtabPath, "r")) == NULL) {
RETURN_NOT_OK_STATUS_WITH_WARN(
Status::IOError(
- Substitute("setmntent file $0 failed, err=$1", _path, errno_to_string(errno))),
+ strings::Substitute("setmntent file $0 failed, err=$1", _path, errno_to_string(errno))),
"setmntent file failed");
}
@@ -254,7 +254,7 @@ Status DataDir::_init_file_system() {
if (!is_find) {
RETURN_NOT_OK_STATUS_WITH_WARN(
- Status::IOError(Substitute("file system $0 not found", _path)),
+ Status::IOError(strings::Substitute("file system $0 not found", _path)),
"find file system failed");
}
@@ -278,7 +278,7 @@ Status DataDir::_init_meta() {
OLAPStatus res = _meta->init();
if (res != OLAP_SUCCESS) {
RETURN_NOT_OK_STATUS_WITH_WARN(
- Status::IOError(Substitute("open rocksdb failed, path=$0", _path)),
+ Status::IOError(strings::Substitute("open rocksdb failed, path=$0", _path)),
"init OlapMeta failed");
}
return Status::OK();
@@ -367,12 +367,12 @@ void DataDir::clear_tablets(std::vector<TabletInfo>* tablet_infos) {
}
std::string DataDir::get_absolute_shard_path(int64_t shard_id) {
- return Substitute("$0$1/$2", _path, DATA_PREFIX, shard_id);
+ return strings::Substitute("$0$1/$2", _path, DATA_PREFIX, shard_id);
}
std::string DataDir::get_absolute_tablet_path(int64_t shard_id, int64_t tablet_id,
int32_t schema_hash) {
- return Substitute("$0/$1/$2", get_absolute_shard_path(shard_id), tablet_id, schema_hash);
+ return strings::Substitute("$0/$1/$2", get_absolute_shard_path(shard_id), tablet_id, schema_hash);
}
void DataDir::find_tablet_in_trash(int64_t tablet_id, std::vector<std::string>* paths) {
@@ -447,7 +447,7 @@ OLAPStatus DataDir::_convert_old_tablet() {
// convert olap header and files
OLAPHeaderMessage olap_header_msg;
TabletMetaPB tablet_meta_pb;
- vector<RowsetMetaPB> pending_rowsets;
+ std::vector<RowsetMetaPB> pending_rowsets;
bool parsed = olap_header_msg.ParseFromString(value);
if (!parsed) {
LOG(FATAL) << "convert olap header to tablet meta failed when load olap header tablet="
@@ -514,7 +514,7 @@ OLAPStatus DataDir::remove_old_meta_and_files() {
// convert olap header and files
OLAPHeaderMessage olap_header_msg;
TabletMetaPB tablet_meta_pb;
- vector<RowsetMetaPB> pending_rowsets;
+ std::vector<RowsetMetaPB> pending_rowsets;
bool parsed = olap_header_msg.ParseFromString(value);
if (!parsed) {
LOG(FATAL) << "convert olap header to tablet meta failed when load olap header tablet="
@@ -971,7 +971,7 @@ Status DataDir::update_capacity() {
} catch (boost::filesystem::filesystem_error& e) {
RETURN_NOT_OK_STATUS_WITH_WARN(
Status::IOError(
- Substitute("get path $0 available capacity failed, error=$1", _path, e.what())),
+ strings::Substitute("get path $0 available capacity failed, error=$1", _path, e.what())),
"boost::filesystem::space failed");
}
diff --git a/be/src/olap/delete_handler.cpp b/be/src/olap/delete_handler.cpp
index 8e8e80a..52935f5 100644
--- a/be/src/olap/delete_handler.cpp
+++ b/be/src/olap/delete_handler.cpp
@@ -89,7 +89,7 @@ OLAPStatus DeleteConditionHandler::generate_delete_predicate(
return OLAP_SUCCESS;
}
-string DeleteConditionHandler::construct_sub_predicates(const TCondition& condition) {
+std::string DeleteConditionHandler::construct_sub_predicates(const TCondition& condition) {
string op = condition.condition_op;
if (op == "<") {
op += "<";
@@ -298,7 +298,7 @@ bool DeleteHandler::is_filter_data(const int32_t data_version,
// 根据语义,存储在_del_conds的删除条件应该是OR关系
// 因此,只要数据符合其中一条过滤条件,则返回true
- vector<DeleteConditions>::const_iterator it = _del_conds.begin();
+ std::vector<DeleteConditions>::const_iterator it = _del_conds.begin();
for (; it != _del_conds.end(); ++it) {
if (data_version <= it->filter_version && it->del_cond->delete_conditions_eval(row)) {
@@ -309,9 +309,9 @@ bool DeleteHandler::is_filter_data(const int32_t data_version,
return false;
}
-vector<int32_t> DeleteHandler::get_conds_version() {
- vector<int32_t> conds_version;
- vector<DeleteConditions>::const_iterator cond_iter = _del_conds.begin();
+std::vector<int32_t> DeleteHandler::get_conds_version() {
+ std::vector<int32_t> conds_version;
+ std::vector<DeleteConditions>::const_iterator cond_iter = _del_conds.begin();
for (; cond_iter != _del_conds.end(); ++cond_iter) {
conds_version.push_back(cond_iter->filter_version);
@@ -325,7 +325,7 @@ void DeleteHandler::finalize() {
return;
}
- vector<DeleteConditions>::iterator it = _del_conds.begin();
+ std::vector<DeleteConditions>::iterator it = _del_conds.begin();
for (; it != _del_conds.end(); ++it) {
it->del_cond->finalize();
diff --git a/be/src/olap/fs/block_id.cpp b/be/src/olap/fs/block_id.cpp
index 2243b7d..f5cf4f7 100644
--- a/be/src/olap/fs/block_id.cpp
+++ b/be/src/olap/fs/block_id.cpp
@@ -30,8 +30,8 @@ namespace doris {
const uint64_t BlockId::kInvalidId = 0;
-string BlockId::join_strings(const vector<BlockId>& blocks) {
- vector<string> strings;
+std::string BlockId::join_strings(const std::vector<BlockId>& blocks) {
+ std::vector<string> strings;
strings.reserve(blocks.size());
for (const BlockId& block : blocks) {
strings.push_back(block.to_string());
diff --git a/be/src/olap/fs/file_block_manager.cpp b/be/src/olap/fs/file_block_manager.cpp
index c493885..22103fb 100644
--- a/be/src/olap/fs/file_block_manager.cpp
+++ b/be/src/olap/fs/file_block_manager.cpp
@@ -42,7 +42,7 @@
using std::accumulate;
using std::shared_ptr;
using std::string;
-using std::unique_ptr;
+
using strings::Substitute;
namespace doris {
@@ -137,7 +137,7 @@ FileWritableBlock::FileWritableBlock(FileBlockManager* block_manager,
FileWritableBlock::~FileWritableBlock() {
if (_state != CLOSED) {
- WARN_IF_ERROR(abort(), Substitute("Failed to close block $0", _path));
+ WARN_IF_ERROR(abort(), strings::Substitute("Failed to close block $0", _path));
}
}
@@ -229,7 +229,7 @@ Status FileWritableBlock::_close(SyncMode mode) {
if (sync.ok()) {
sync = _block_manager->_sync_metadata(_path);
}
- WARN_IF_ERROR(sync, Substitute("Failed to sync when closing block $0", _path));
+ WARN_IF_ERROR(sync, strings::Substitute("Failed to sync when closing block $0", _path));
}
Status close = _writer->close();
@@ -316,7 +316,7 @@ FileReadableBlock::FileReadableBlock(FileBlockManager* block_manager,
}
FileReadableBlock::~FileReadableBlock() {
- WARN_IF_ERROR(close(), Substitute("Failed to close block $0", _path));
+ WARN_IF_ERROR(close(), strings::Substitute("Failed to close block $0", _path));
}
Status FileReadableBlock::close() {
@@ -402,7 +402,7 @@ Status FileBlockManager::open() {
}
Status FileBlockManager::create_block(const CreateBlockOptions& opts,
- unique_ptr<WritableBlock>* block) {
+ std::unique_ptr<WritableBlock>* block) {
CHECK(!_opts.read_only);
shared_ptr<WritableFile> writer;
@@ -415,7 +415,7 @@ Status FileBlockManager::create_block(const CreateBlockOptions& opts,
return Status::OK();
}
-Status FileBlockManager::open_block(const std::string& path, unique_ptr<ReadableBlock>* block) {
+Status FileBlockManager::open_block(const std::string& path, std::unique_ptr<ReadableBlock>* block) {
VLOG(1) << "Opening block with path at " << path;
std::shared_ptr<OpenedFileHandle<RandomAccessFile>> file_handle(new OpenedFileHandle<RandomAccessFile>());
bool found = _file_cache->lookup(path, file_handle.get());
diff --git a/be/src/olap/in_list_predicate.cpp b/be/src/olap/in_list_predicate.cpp
index 4cfaeaa..166fb0a 100644
--- a/be/src/olap/in_list_predicate.cpp
+++ b/be/src/olap/in_list_predicate.cpp
@@ -111,7 +111,7 @@ IN_LIST_PRED_COLUMN_BLOCK_EVALUATE(NotInListPredicate, ==)
#define IN_LIST_PRED_BITMAP_EVALUATE(CLASS, OP) \
template<class type> \
- Status CLASS<type>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* result) const { \
+ Status CLASS<type>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* result) const { \
BitmapIndexIterator *iterator = iterators[_column_id]; \
if (iterator == nullptr) { \
return Status::OK(); \
@@ -191,17 +191,17 @@ IN_LIST_PRED_COLUMN_BLOCK_EVALUATE_DECLARATION(InListPredicate)
IN_LIST_PRED_COLUMN_BLOCK_EVALUATE_DECLARATION(NotInListPredicate)
#define IN_LIST_PRED_BITMAP_EVALUATE_DECLARATION(CLASS) \
- template Status CLASS<int8_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<int16_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<int32_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<int64_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<int128_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<float>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<double>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<decimal12_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<StringValue>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<uint24_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
- template Status CLASS<uint64_t>::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<int8_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<int16_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<int32_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<int64_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<int128_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<float>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<double>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<decimal12_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<StringValue>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<uint24_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
+ template Status CLASS<uint64_t>::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators, uint32_t num_rows, Roaring* bitmap) const; \
IN_LIST_PRED_BITMAP_EVALUATE_DECLARATION(InListPredicate)
IN_LIST_PRED_BITMAP_EVALUATE_DECLARATION(NotInListPredicate)
diff --git a/be/src/olap/memory/column.cpp b/be/src/olap/memory/column.cpp
index ff8d987..d99e4ec 100644
--- a/be/src/olap/memory/column.cpp
+++ b/be/src/olap/memory/column.cpp
@@ -60,12 +60,12 @@ size_t Column::memory() const {
return base_memory + delta_memory;
}
-string Column::debug_string() const {
+std::string Column::debug_string() const {
return StringPrintf("Column(%s version=%zu)", _cs.debug_string().c_str(),
_versions.back().version);
}
-Status Column::capture_version(uint64_t version, vector<ColumnDelta*>* deltas,
+Status Column::capture_version(uint64_t version, std::vector<ColumnDelta*>* deltas,
uint64_t* real_version) const {
uint64_t base_version = _versions[_base_idx].version;
*real_version = base_version;
@@ -119,7 +119,7 @@ void Column::capture_latest(vector<ColumnDelta*>* deltas, uint64_t* version) con
Status Column::create_reader(uint64_t version, std::unique_ptr<ColumnReader>* reader) {
ColumnType type = schema().type();
bool nullable = schema().is_nullable();
- vector<ColumnDelta*> deltas;
+ std::vector<ColumnDelta*> deltas;
uint64_t real_version;
RETURN_IF_ERROR(capture_version(version, &deltas, &real_version));
@@ -165,7 +165,7 @@ Status Column::create_reader(uint64_t version, std::unique_ptr<ColumnReader>* re
Status Column::create_writer(std::unique_ptr<ColumnWriter>* writer) {
ColumnType type = schema().type();
bool nullable = schema().is_nullable();
- vector<ColumnDelta*> deltas;
+ std::vector<ColumnDelta*> deltas;
uint64_t real_version;
capture_latest(&deltas, &real_version);
diff --git a/be/src/olap/null_predicate.cpp b/be/src/olap/null_predicate.cpp
index eed4df5..af33512 100644
--- a/be/src/olap/null_predicate.cpp
+++ b/be/src/olap/null_predicate.cpp
@@ -78,7 +78,7 @@ void NullPredicate::evaluate(ColumnBlock* block, uint16_t* sel, uint16_t* size)
*size = new_size;
}
-Status NullPredicate::evaluate(const Schema& schema, const vector<BitmapIndexIterator*>& iterators,
+Status NullPredicate::evaluate(const Schema& schema, const std::vector<BitmapIndexIterator*>& iterators,
uint32_t num_rows, Roaring* roaring) const {
if (iterators[_column_id] != nullptr) {
Roaring null_bitmap;
diff --git a/be/src/olap/olap_cond.cpp b/be/src/olap/olap_cond.cpp
index 74c603f..766e132 100644
--- a/be/src/olap/olap_cond.cpp
+++ b/be/src/olap/olap_cond.cpp
@@ -161,9 +161,9 @@ OLAPStatus Cond::init(const TCondition& tcond, const TabletColumn& column) {
auto insert_result = operand_set.insert(f.get());
if (!insert_result.second) {
LOG(WARNING) << "Duplicate operand in in-predicate.[condition=" << operand << "]";
- // Duplicated, let unique_ptr delete field
+ // Duplicated, let std::unique_ptr delete field
} else {
- // Normal case, release this unique_ptr
+ // Normal case, release this std::unique_ptr
f.release();
}
}
diff --git a/be/src/olap/olap_server.cpp b/be/src/olap/olap_server.cpp
index fa1aa7b..3036e78 100644
--- a/be/src/olap/olap_server.cpp
+++ b/be/src/olap/olap_server.cpp
@@ -337,7 +337,7 @@ void StorageEngine::_compaction_tasks_producer_callback() {
compaction_type = CompactionType::BASE_COMPACTION;
round = 0;
}
- vector<TabletSharedPtr> tablets_compaction =
+ std::vector<TabletSharedPtr> tablets_compaction =
_compaction_tasks_generator(compaction_type, data_dirs);
if (tablets_compaction.size() == 0) {
_wakeup_producer_flag = 0;
@@ -363,7 +363,7 @@ void StorageEngine::_compaction_tasks_producer_callback() {
_perform_cumulative_compaction(tablet);
_permit_limiter.release(permits);
std::unique_lock<std::mutex> lock(_tablet_submitted_compaction_mutex);
- vector<TTabletId>::iterator it_tablet =
+ std::vector<TTabletId>::iterator it_tablet =
find(_tablet_submitted_compaction[tablet->data_dir()].begin(),
_tablet_submitted_compaction[tablet->data_dir()].end(),
tablet->tablet_id());
@@ -380,7 +380,7 @@ void StorageEngine::_compaction_tasks_producer_callback() {
_perform_base_compaction(tablet);
_permit_limiter.release(permits);
std::unique_lock<std::mutex> lock(_tablet_submitted_compaction_mutex);
- vector<TTabletId>::iterator it_tablet =
+ std::vector<TTabletId>::iterator it_tablet =
find(_tablet_submitted_compaction[tablet->data_dir()].begin(),
_tablet_submitted_compaction[tablet->data_dir()].end(),
tablet->tablet_id());
@@ -400,9 +400,9 @@ void StorageEngine::_compaction_tasks_producer_callback() {
}
}
-vector<TabletSharedPtr> StorageEngine::_compaction_tasks_generator(
+std::vector<TabletSharedPtr> StorageEngine::_compaction_tasks_generator(
CompactionType compaction_type, std::vector<DataDir*> data_dirs) {
- vector<TabletSharedPtr> tablets_compaction;
+ std::vector<TabletSharedPtr> tablets_compaction;
std::random_shuffle(data_dirs.begin(), data_dirs.end());
for (auto data_dir : data_dirs) {
std::unique_lock<std::mutex> lock(_tablet_submitted_compaction_mutex);
diff --git a/be/src/olap/olap_snapshot_converter.cpp b/be/src/olap/olap_snapshot_converter.cpp
index 0c4c159..a312cd9 100755
--- a/be/src/olap/olap_snapshot_converter.cpp
+++ b/be/src/olap/olap_snapshot_converter.cpp
@@ -95,7 +95,7 @@ OLAPStatus OlapSnapshotConverter::to_olap_header(const TabletMetaPB& tablet_meta
}
OLAPStatus OlapSnapshotConverter::to_tablet_meta_pb(const OLAPHeaderMessage& olap_header,
- TabletMetaPB* tablet_meta_pb, vector<RowsetMetaPB>* pending_rowsets) {
+ TabletMetaPB* tablet_meta_pb, std::vector<RowsetMetaPB>* pending_rowsets) {
if (olap_header.has_tablet_id()) {
tablet_meta_pb->set_tablet_id(olap_header.tablet_id());
}
@@ -442,7 +442,7 @@ OLAPStatus OlapSnapshotConverter::to_alter_tablet_pb(const SchemaChangeStatusMes
// from olap header to tablet meta
OLAPStatus OlapSnapshotConverter::to_new_snapshot(const OLAPHeaderMessage& olap_header, const string& old_data_path_prefix,
const string& new_data_path_prefix, TabletMetaPB* tablet_meta_pb,
- vector<RowsetMetaPB>* pending_rowsets, bool is_startup) {
+ std::vector<RowsetMetaPB>* pending_rowsets, bool is_startup) {
RETURN_NOT_OK(to_tablet_meta_pb(olap_header, tablet_meta_pb, pending_rowsets));
TabletSchema tablet_schema;
diff --git a/be/src/olap/options.cpp b/be/src/olap/options.cpp
index ae35f1c..a7ddd44 100644
--- a/be/src/olap/options.cpp
+++ b/be/src/olap/options.cpp
@@ -49,7 +49,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
OLAPStatus parse_root_path(const string& root_path, StorePath* path) {
- vector<string> tmp_vec = strings::Split(root_path, ",", strings::SkipWhitespace());
+ std::vector<string> tmp_vec = strings::Split(root_path, ",", strings::SkipWhitespace());
// parse root path name
StripWhiteSpace(&tmp_vec[0]);
@@ -131,8 +131,8 @@ OLAPStatus parse_root_path(const string& root_path, StorePath* path) {
return OLAP_SUCCESS;
}
-OLAPStatus parse_conf_store_paths(const string& config_path, vector<StorePath>* paths) {
- vector<string> path_vec = strings::Split(config_path, ";", strings::SkipWhitespace());
+OLAPStatus parse_conf_store_paths(const string& config_path, std::vector<StorePath>* paths) {
+ std::vector<string> path_vec = strings::Split(config_path, ";", strings::SkipWhitespace());
for (auto& item : path_vec) {
StorePath path;
auto res = parse_root_path(item, &path);
diff --git a/be/src/olap/push_handler.cpp b/be/src/olap/push_handler.cpp
index 0ca7235..e764e85 100644
--- a/be/src/olap/push_handler.cpp
+++ b/be/src/olap/push_handler.cpp
@@ -56,13 +56,13 @@ namespace doris {
// very useful in rollup action.
OLAPStatus PushHandler::process_streaming_ingestion(
TabletSharedPtr tablet, const TPushReq& request, PushType push_type,
- vector<TTabletInfo>* tablet_info_vec) {
+ std::vector<TTabletInfo>* tablet_info_vec) {
LOG(INFO) << "begin to realtime push. tablet=" << tablet->full_name()
<< ", transaction_id=" << request.transaction_id;
OLAPStatus res = OLAP_SUCCESS;
_request = request;
- vector<TabletVars> tablet_vars(1);
+ std::vector<TabletVars> tablet_vars(1);
tablet_vars[0].tablet = tablet;
res = _do_streaming_ingestion(tablet, request, push_type, &tablet_vars,
tablet_info_vec);
@@ -82,7 +82,7 @@ OLAPStatus PushHandler::process_streaming_ingestion(
OLAPStatus PushHandler::_do_streaming_ingestion(
TabletSharedPtr tablet, const TPushReq& request, PushType push_type,
- vector<TabletVars>* tablet_vars,
+ std::vector<TabletVars>* tablet_vars,
std::vector<TTabletInfo>* tablet_info_vec) {
// add transaction in engine, then check sc status
// lock, prevent sc handler checking transaction concurrently
@@ -251,8 +251,8 @@ OLAPStatus PushHandler::_do_streaming_ingestion(
return res;
}
-void PushHandler::_get_tablet_infos(const vector<TabletVars>& tablet_vars,
- vector<TTabletInfo>* tablet_info_vec) {
+void PushHandler::_get_tablet_infos(const std::vector<TabletVars>& tablet_vars,
+ std::vector<TTabletInfo>* tablet_info_vec) {
for (const TabletVars& tablet_var : tablet_vars) {
if (tablet_var.tablet.get() == NULL) {
continue;
@@ -1052,7 +1052,7 @@ void PushBrokerReader::print_profile() {
LOG(INFO) << ss.str();
}
-string PushHandler::_debug_version_list(const Versions& versions) const {
+std::string PushHandler::_debug_version_list(const Versions& versions) const {
std::ostringstream txt;
txt << "Versions: ";
diff --git a/be/src/olap/row_cursor.cpp b/be/src/olap/row_cursor.cpp
index 9fad7ba..61433d4 100644
--- a/be/src/olap/row_cursor.cpp
+++ b/be/src/olap/row_cursor.cpp
@@ -102,7 +102,7 @@ OLAPStatus RowCursor::init(const std::vector<TabletColumn>& schema, size_t colum
}
OLAPStatus RowCursor::init(const TabletSchema& schema,
- const vector<uint32_t>& columns) {
+ const std::vector<uint32_t>& columns) {
RETURN_NOT_OK(_init(schema.columns(), columns));
return OLAP_SUCCESS;
}
@@ -253,8 +253,8 @@ OlapTuple RowCursor::to_tuple() const {
return tuple;
}
-string RowCursor::to_string() const {
- string result;
+std::string RowCursor::to_string() const {
+ std::string result;
size_t i = 0;
for (auto cid : _schema->column_ids()) {
if (i++ > 0) {
diff --git a/be/src/olap/rowset/alpha_rowset.cpp b/be/src/olap/rowset/alpha_rowset.cpp
index bb9e6a9..a9f5a4c 100644
--- a/be/src/olap/rowset/alpha_rowset.cpp
+++ b/be/src/olap/rowset/alpha_rowset.cpp
@@ -84,7 +84,7 @@ OLAPStatus AlphaRowset::remove() {
void AlphaRowset::make_visible_extra(Version version, VersionHash version_hash) {
AlphaRowsetMetaSharedPtr alpha_rowset_meta =
std::dynamic_pointer_cast<AlphaRowsetMeta>(_rowset_meta);
- vector<SegmentGroupPB> published_segment_groups;
+ std::vector<SegmentGroupPB> published_segment_groups;
alpha_rowset_meta->get_segment_groups(&published_segment_groups);
int32_t segment_group_idx = 0;
for (auto& segment_group : _segment_groups) {
@@ -167,7 +167,7 @@ OLAPStatus AlphaRowset::split_range(
const RowCursor& start_key,
const RowCursor& end_key,
uint64_t request_block_row_count,
- vector<OlapTuple>* ranges) {
+ std::vector<OlapTuple>* ranges) {
EntrySlice entry;
RowBlockPosition start_pos;
RowBlockPosition end_pos;
diff --git a/be/src/olap/rowset/segment_v2/binary_dict_page.cpp b/be/src/olap/rowset/segment_v2/binary_dict_page.cpp
index a12eb34..82866e0 100644
--- a/be/src/olap/rowset/segment_v2/binary_dict_page.cpp
+++ b/be/src/olap/rowset/segment_v2/binary_dict_page.cpp
@@ -78,7 +78,7 @@ Status BinaryDictPageBuilder::add(const uint8_t* vals, size_t* count) {
if (src->size > 0) {
char* item_mem = (char*)_pool.allocate(src->size);
if (item_mem == nullptr) {
- return Status::MemoryAllocFailed(Substitute("memory allocate failed, size:$0", src->size));
+ return Status::MemoryAllocFailed(strings::Substitute("memory allocate failed, size:$0", src->size));
}
dict_item.relocate(item_mem);
}
@@ -190,7 +190,7 @@ BinaryDictPageDecoder::BinaryDictPageDecoder(Slice data, const PageDecoderOption
Status BinaryDictPageDecoder::init() {
CHECK(!_parsed);
if (_data.size < BINARY_DICT_PAGE_HEADER_SIZE) {
- return Status::Corruption(Substitute("invalid data size:$0, header size:$1",
+ return Status::Corruption(strings::Substitute("invalid data size:$0, header size:$1",
_data.size, BINARY_DICT_PAGE_HEADER_SIZE));
}
size_t type = decode_fixed32_le((const uint8_t*)&_data.data[0]);
@@ -213,7 +213,7 @@ Status BinaryDictPageDecoder::init() {
_data_page_decoder.reset(new BinaryPlainPageDecoder(_data, _options));
} else {
LOG(WARNING) << "invalid encoding type:" << _encoding_type;
- return Status::Corruption(Substitute("invalid encoding type:$0", _encoding_type));
+ return Status::Corruption(strings::Substitute("invalid encoding type:$0", _encoding_type));
}
RETURN_IF_ERROR(_data_page_decoder->init());
@@ -257,7 +257,7 @@ Status BinaryDictPageDecoder::next_batch(size_t* n, ColumnBlockView* dst) {
if (element.size > 0) {
char* destination = (char*)dst->column_block()->pool()->allocate(element.size);
if (destination == nullptr) {
- return Status::MemoryAllocFailed(Substitute(
+ return Status::MemoryAllocFailed(strings::Substitute(
"memory allocate failed, size:$0", element.size));
}
element.relocate(destination);
diff --git a/be/src/olap/rowset/segment_v2/binary_prefix_page.cpp b/be/src/olap/rowset/segment_v2/binary_prefix_page.cpp
index c26602a..d812d8d 100644
--- a/be/src/olap/rowset/segment_v2/binary_prefix_page.cpp
+++ b/be/src/olap/rowset/segment_v2/binary_prefix_page.cpp
@@ -122,7 +122,7 @@ Status BinaryPrefixPageDecoder::_read_next_value() {
uint32_t non_shared_len;
auto data_ptr = _decode_value_lengths(_next_ptr, &shared_len, &non_shared_len);
if (data_ptr == nullptr) {
- return Status::Corruption(Substitute("Failed to decode value at position $0", _cur_pos));
+ return Status::Corruption(strings::Substitute("Failed to decode value at position $0", _cur_pos));
}
_current_value.resize(shared_len);
_current_value.append(data_ptr, non_shared_len);
@@ -214,7 +214,7 @@ Status BinaryPrefixPageDecoder::_read_next_value_to_output(Slice prev, MemPool*
uint32_t non_shared_len;
auto data_ptr = _decode_value_lengths(_next_ptr, &shared_len, &non_shared_len);
if (data_ptr == nullptr) {
- return Status::Corruption(Substitute("Failed to decode value at position $0", _cur_pos));
+ return Status::Corruption(strings::Substitute("Failed to decode value at position $0", _cur_pos));
}
output->size = shared_len + non_shared_len;
@@ -234,7 +234,7 @@ Status BinaryPrefixPageDecoder::_copy_current_to_output(MemPool* mem_pool, Slice
output->data = (char*) mem_pool->allocate(output->size);
if (output->data == nullptr) {
return Status::MemoryAllocFailed(
- Substitute("failed to allocate $0 bytes", output->size));
+ strings::Substitute("failed to allocate $0 bytes", output->size));
}
memcpy(output->data, _current_value.data(), output->size);
}
diff --git a/be/src/olap/rowset/segment_v2/column_reader.cpp b/be/src/olap/rowset/segment_v2/column_reader.cpp
index 7da6150..0307720 100644
--- a/be/src/olap/rowset/segment_v2/column_reader.cpp
+++ b/be/src/olap/rowset/segment_v2/column_reader.cpp
@@ -86,7 +86,7 @@ ColumnReader::~ColumnReader() = default;
Status ColumnReader::init() {
_type_info = get_type_info(&_meta);
if (_type_info == nullptr) {
- return Status::NotSupported(Substitute("unsupported typeinfo, type=$0", _meta.type()));
+ return Status::NotSupported(strings::Substitute("unsupported typeinfo, type=$0", _meta.type()));
}
RETURN_IF_ERROR(EncodingInfo::get(_type_info, _meta.encoding(), &_encoding_info));
RETURN_IF_ERROR(get_block_compression_codec(_meta.compression(), &_compress_codec));
@@ -107,12 +107,12 @@ Status ColumnReader::init() {
_bf_index_meta = &index_meta.bloom_filter_index();
break;
default:
- return Status::Corruption(Substitute(
+ return Status::Corruption(strings::Substitute(
"Bad file $0: invalid column index type $1", _file_name, index_meta.type()));
}
}
if (_ordinal_index_meta == nullptr) {
- return Status::Corruption(Substitute(
+ return Status::Corruption(strings::Substitute(
"Bad file $0: missing ordinal index for column $1", _file_name, _meta.column_id()));
}
return Status::OK();
@@ -312,7 +312,7 @@ Status ColumnReader::seek_at_or_before(ordinal_t ordinal, OrdinalPageIndexIterat
RETURN_IF_ERROR(_ensure_index_loaded());
*iter = _ordinal_index->seek_at_or_before(ordinal);
if (!iter->valid()) {
- return Status::NotFound(Substitute("Failed to seek to ordinal $0, ", ordinal));
+ return Status::NotFound(strings::Substitute("Failed to seek to ordinal $0, ", ordinal));
}
return Status::OK();
}
diff --git a/be/src/olap/rowset/segment_v2/column_writer.cpp b/be/src/olap/rowset/segment_v2/column_writer.cpp
index cb7420f..abc48ab 100644
--- a/be/src/olap/rowset/segment_v2/column_writer.cpp
+++ b/be/src/olap/rowset/segment_v2/column_writer.cpp
@@ -193,7 +193,7 @@ Status ScalarColumnWriter::init() {
RETURN_IF_ERROR(_encoding_info->create_page_builder(opts, &page_builder));
if (page_builder == nullptr) {
return Status::NotSupported(
- Substitute("Failed to create page builder for type $0 and encoding $1",
+ strings::Substitute("Failed to create page builder for type $0 and encoding $1",
get_field()->type(), _opts.meta->encoding()));
}
// should store more concrete encoding type instead of DEFAULT_ENCODING
@@ -372,7 +372,7 @@ Status ScalarColumnWriter::finish_current_page() {
}
// build data page body : encoded values + [nullmap]
- vector<Slice> body;
+ std::vector<Slice> body;
OwnedSlice encoded_values = _page_builder->finish();
_page_builder->reset();
body.push_back(encoded_values.slice());
diff --git a/be/src/olap/rowset/segment_v2/indexed_column_reader.cpp b/be/src/olap/rowset/segment_v2/indexed_column_reader.cpp
index 4afc319..be3153e 100644
--- a/be/src/olap/rowset/segment_v2/indexed_column_reader.cpp
+++ b/be/src/olap/rowset/segment_v2/indexed_column_reader.cpp
@@ -33,7 +33,7 @@ Status IndexedColumnReader::load(bool use_page_cache, bool kept_in_memory) {
_type_info = get_type_info((FieldType)_meta.data_type());
if (_type_info == nullptr) {
- return Status::NotSupported(Substitute("unsupported typeinfo, type=$0", _meta.data_type()));
+ return Status::NotSupported(strings::Substitute("unsupported typeinfo, type=$0", _meta.data_type()));
}
RETURN_IF_ERROR(EncodingInfo::get(_type_info, _meta.encoding(), &_encoding_info));
RETURN_IF_ERROR(get_block_compression_codec(_meta.compression(), &_compress_codec));
diff --git a/be/src/olap/rowset/segment_v2/page_io.cpp b/be/src/olap/rowset/segment_v2/page_io.cpp
index 4871b90..3531e31 100644
--- a/be/src/olap/rowset/segment_v2/page_io.cpp
+++ b/be/src/olap/rowset/segment_v2/page_io.cpp
@@ -136,7 +136,7 @@ Status PageIO::read_and_decompress_page(const PageReadOptions& opts,
// every page contains 4 bytes footer length and 4 bytes checksum
const uint32_t page_size = opts.page_pointer.size;
if (page_size < 8) {
- return Status::Corruption(Substitute("Bad page: too small size ($0)", page_size));
+ return Status::Corruption(strings::Substitute("Bad page: too small size ($0)", page_size));
}
// hold compressed page at first, reset to decompressed page later
@@ -152,7 +152,7 @@ Status PageIO::read_and_decompress_page(const PageReadOptions& opts,
uint32_t expect = decode_fixed32_le((uint8_t*) page_slice.data + page_slice.size - 4);
uint32_t actual = crc32c::Value(page_slice.data, page_slice.size - 4);
if (expect != actual) {
- return Status::Corruption(Substitute(
+ return Status::Corruption(strings::Substitute(
"Bad page: checksum mismatch (actual=$0 vs expect=$1)", actual, expect));
}
}
@@ -179,7 +179,7 @@ Status PageIO::read_and_decompress_page(const PageReadOptions& opts,
Slice decompressed_body(decompressed_page.get(), footer->uncompressed_size());
RETURN_IF_ERROR(opts.codec->decompress(compressed_body, &decompressed_body));
if (decompressed_body.size != footer->uncompressed_size()) {
- return Status::Corruption(Substitute(
+ return Status::Corruption(strings::Substitute(
"Bad page: record uncompressed size=$0 vs real decompressed size=$1",
footer->uncompressed_size(), decompressed_body.size));
}
diff --git a/be/src/olap/rowset/segment_v2/segment.cpp b/be/src/olap/rowset/segment_v2/segment.cpp
index 73fb8ae..24487f7 100644
--- a/be/src/olap/rowset/segment_v2/segment.cpp
+++ b/be/src/olap/rowset/segment_v2/segment.cpp
@@ -97,7 +97,7 @@ Status Segment::_parse_footer() {
RETURN_IF_ERROR(rblock->size(&file_size));
if (file_size < 12) {
- return Status::Corruption(Substitute("Bad segment file $0: file size $1 < 12", _fname, file_size));
+ return Status::Corruption(strings::Substitute("Bad segment file $0: file size $1 < 12", _fname, file_size));
}
uint8_t fixed_buf[12];
@@ -105,14 +105,14 @@ Status Segment::_parse_footer() {
// validate magic number
if (memcmp(fixed_buf + 8, k_segment_magic, k_segment_magic_length) != 0) {
- return Status::Corruption(Substitute("Bad segment file $0: magic number not match", _fname));
+ return Status::Corruption(strings::Substitute("Bad segment file $0: magic number not match", _fname));
}
// read footer PB
uint32_t footer_length = decode_fixed32_le(fixed_buf);
if (file_size < 12 + footer_length) {
return Status::Corruption(
- Substitute("Bad segment file $0: file size $1 < $2", _fname, file_size, 12 + footer_length));
+ strings::Substitute("Bad segment file $0: file size $1 < $2", _fname, file_size, 12 + footer_length));
}
std::string footer_buf;
footer_buf.resize(footer_length);
@@ -123,13 +123,13 @@ Status Segment::_parse_footer() {
uint32_t actual_checksum = crc32c::Value(footer_buf.data(), footer_buf.size());
if (actual_checksum != expect_checksum) {
return Status::Corruption(
- Substitute("Bad segment file $0: footer checksum not match, actual=$1 vs expect=$2",
+ strings::Substitute("Bad segment file $0: footer checksum not match, actual=$1 vs expect=$2",
_fname, actual_checksum, expect_checksum));
}
// deserialize footer PB
if (!_footer.ParseFromString(footer_buf)) {
- return Status::Corruption(Substitute("Bad segment file $0: failed to parse SegmentFooterPB", _fname));
+ return Status::Corruption(strings::Substitute("Bad segment file $0: failed to parse SegmentFooterPB", _fname));
}
return Status::OK();
}
diff --git a/be/src/olap/schema_change.cpp b/be/src/olap/schema_change.cpp
index a85cce4..c16ef09 100644
--- a/be/src/olap/schema_change.cpp
+++ b/be/src/olap/schema_change.cpp
@@ -421,7 +421,7 @@ OLAPStatus RowBlockChanger::change_row_block(const RowBlock* ref_block, int32_t
// 对于没有filter的来说,相当于全部设置为1后留下
const uint32_t row_num = ref_block->row_block_info().row_num;
// (0表示过滤掉不要,1表示要,过程中2表示此row要切后续不需要再比较其他列)
- vector<int8_t> is_data_left_vec(row_num, 1);
+ std::vector<int8_t> is_data_left_vec(row_num, 1);
// 一行一行地进行比较
for (size_t row_index = 0; row_index < row_num; ++row_index) {
@@ -686,7 +686,7 @@ bool RowBlockSorter::sort(RowBlock** row_block) {
}
RowBlock* temp = nullptr;
- vector<RowCursor*> row_cursor_list((*row_block)->row_block_info().row_num, nullptr);
+ std::vector<RowCursor*> row_cursor_list((*row_block)->row_block_info().row_num, nullptr);
// create an list of row cursor as long as the number of rows in data block.
for (size_t i = 0; i < (*row_block)->row_block_info().row_num; ++i) {
@@ -797,7 +797,7 @@ RowBlockMerger::RowBlockMerger(TabletSharedPtr tablet) : _tablet(tablet) {}
RowBlockMerger::~RowBlockMerger() {}
-bool RowBlockMerger::merge(const vector<RowBlock*>& row_block_arr, RowsetWriter* rowset_writer,
+bool RowBlockMerger::merge(const std::vector<RowBlock*>& row_block_arr, RowsetWriter* rowset_writer,
uint64_t* merged_rows) {
uint64_t tmp_merged_rows = 0;
RowCursor row_cursor;
@@ -866,7 +866,7 @@ MERGE_ERR:
return false;
}
-bool RowBlockMerger::_make_heap(const vector<RowBlock*>& row_block_arr) {
+bool RowBlockMerger::_make_heap(const std::vector<RowBlock*>& row_block_arr) {
for (auto row_block : row_block_arr) {
MergeElement element;
element.row_block = row_block;
@@ -1126,11 +1126,11 @@ OLAPStatus SchemaChangeWithSorting::process(RowsetReaderSharedPtr rowset_reader,
// for internal sorting
RowBlock* new_row_block = nullptr;
- vector<RowBlock*> row_block_arr;
+ std::vector<RowBlock*> row_block_arr;
// for external sorting
// src_rowsets to store the rowset generated by internal sorting
- vector<RowsetSharedPtr> src_rowsets;
+ std::vector<RowsetSharedPtr> src_rowsets;
_temp_delta_versions.first = _temp_delta_versions.second;
@@ -1300,7 +1300,7 @@ SORTING_PROCESS_ERR:
return res;
}
-bool SchemaChangeWithSorting::_internal_sorting(const vector<RowBlock*>& row_block_arr,
+bool SchemaChangeWithSorting::_internal_sorting(const std::vector<RowBlock*>& row_block_arr,
const Version& version, VersionHash version_hash,
TabletSharedPtr new_tablet,
RowsetTypePB new_rowset_type,
@@ -1346,7 +1346,7 @@ bool SchemaChangeWithSorting::_internal_sorting(const vector<RowBlock*>& row_blo
bool SchemaChangeWithSorting::_external_sorting(vector<RowsetSharedPtr>& src_rowsets,
RowsetWriter* rowset_writer,
TabletSharedPtr new_tablet) {
- vector<RowsetReaderSharedPtr> rs_readers;
+ std::vector<RowsetReaderSharedPtr> rs_readers;
for (auto& rowset : src_rowsets) {
RowsetReaderSharedPtr rs_reader;
auto res = rowset->create_reader(&rs_reader);
@@ -1452,8 +1452,8 @@ OLAPStatus SchemaChangeHandler::_do_process_alter_tablet_v2(const TAlterTabletRe
// check if the tablet has alter task
// if it has alter task, it means it is under old alter process
- vector<Version> versions_to_be_changed;
- vector<RowsetReaderSharedPtr> rs_readers;
+ std::vector<Version> versions_to_be_changed;
+ std::vector<RowsetReaderSharedPtr> rs_readers;
// delete handlers for new tablet
DeleteHandler delete_handler;
std::vector<ColumnId> return_columns;
@@ -1483,8 +1483,8 @@ OLAPStatus SchemaChangeHandler::_do_process_alter_tablet_v2(const TAlterTabletRe
// remove all data from new tablet, prevent to rewrite data(those double pushed when wait)
LOG(INFO) << "begin to remove all data from new tablet to prevent rewrite."
<< " new_tablet=" << new_tablet->full_name();
- vector<RowsetSharedPtr> rowsets_to_delete;
- vector<Version> new_tablet_versions;
+ std::vector<RowsetSharedPtr> rowsets_to_delete;
+ std::vector<Version> new_tablet_versions;
new_tablet->list_versions(&new_tablet_versions);
for (auto& version : new_tablet_versions) {
if (version.second <= max_rowset->end_version()) {
@@ -1752,14 +1752,14 @@ SCHEMA_VERSION_CONVERT_ERR:
}
OLAPStatus SchemaChangeHandler::_get_versions_to_be_changed(
- TabletSharedPtr base_tablet, vector<Version>* versions_to_be_changed) {
+ TabletSharedPtr base_tablet, std::vector<Version>* 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;
}
- vector<Version> span_versions;
+ std::vector<Version> span_versions;
RETURN_NOT_OK(base_tablet->capture_consistent_versions(Version(0, rowset->version().second),
&span_versions));
versions_to_be_changed->insert(versions_to_be_changed->end(),
@@ -1771,7 +1771,7 @@ OLAPStatus SchemaChangeHandler::_get_versions_to_be_changed(
OLAPStatus SchemaChangeHandler::_add_alter_task(AlterTabletType alter_tablet_type,
TabletSharedPtr base_tablet,
TabletSharedPtr new_tablet,
- const vector<Version>& versions_to_be_changed) {
+ const std::vector<Version>& versions_to_be_changed) {
// check new tablet exists,
// prevent to set base's status after new's dropping (clear base's status)
if (StorageEngine::instance()->tablet_manager()->get_tablet(
@@ -1786,7 +1786,7 @@ OLAPStatus SchemaChangeHandler::_add_alter_task(AlterTabletType alter_tablet_typ
versions_to_be_changed, alter_tablet_type);
base_tablet->save_meta();
new_tablet->add_alter_task(base_tablet->tablet_id(), base_tablet->schema_hash(),
- vector<Version>(), // empty versions
+ std::vector<Version>(), // empty versions
alter_tablet_type);
new_tablet->save_meta();
LOG(INFO) << "successfully add alter task to both base and new";
diff --git a/be/src/olap/short_key_index.cpp b/be/src/olap/short_key_index.cpp
index 6c6cf68..da5dd58 100644
--- a/be/src/olap/short_key_index.cpp
+++ b/be/src/olap/short_key_index.cpp
@@ -58,7 +58,7 @@ Status ShortKeyIndexDecoder::parse(const Slice& body, const segment_v2::ShortKey
// check if body size match footer's information
if (body.size != (_footer.key_bytes() + _footer.offset_bytes())) {
return Status::Corruption(
- Substitute("Index size not match, need=$0, real=$1",
+ strings::Substitute("Index size not match, need=$0, real=$1",
_footer.key_bytes() + _footer.offset_bytes(), body.size));
}
diff --git a/be/src/olap/snapshot_manager.cpp b/be/src/olap/snapshot_manager.cpp
index 10173a2..2cbdb71 100644
--- a/be/src/olap/snapshot_manager.cpp
+++ b/be/src/olap/snapshot_manager.cpp
@@ -272,7 +272,7 @@ OLAPStatus SnapshotManager::_calc_snapshot_id_path(
return res;
}
- stringstream snapshot_id_path_stream;
+ std::stringstream snapshot_id_path_stream;
MutexLock auto_lock(&_snapshot_mutex); // will automatically unlock when function return.
snapshot_id_path_stream << tablet->data_dir()->path() << SNAPSHOT_PREFIX
<< "/" << time_str << "." << _snapshot_base_id++
@@ -283,10 +283,10 @@ OLAPStatus SnapshotManager::_calc_snapshot_id_path(
// location: /path/to/data/DATA_PREFIX/shard_id
// return: /path/to/data/DATA_PREFIX/shard_id/tablet_id/schema_hash
-string SnapshotManager::get_schema_hash_full_path(
+std::string SnapshotManager::get_schema_hash_full_path(
const TabletSharedPtr& ref_tablet,
const string& location) const {
- stringstream schema_full_path_stream;
+ std::stringstream schema_full_path_stream;
schema_full_path_stream << location
<< "/" << ref_tablet->tablet_id()
<< "/" << ref_tablet->schema_hash();
@@ -295,10 +295,10 @@ string SnapshotManager::get_schema_hash_full_path(
return schema_full_path;
}
-string SnapshotManager::_get_header_full_path(
+std::string SnapshotManager::_get_header_full_path(
const TabletSharedPtr& ref_tablet,
const std::string& schema_hash_path) const {
- stringstream header_name_stream;
+ std::stringstream header_name_stream;
header_name_stream << schema_hash_path << "/" << ref_tablet->tablet_id() << ".hdr";
return header_name_stream.str();
}
@@ -364,7 +364,7 @@ OLAPStatus SnapshotManager::_create_snapshot_files(
res = OLAP_ERR_MALLOC_ERROR;
break;
}
- vector<RowsetSharedPtr> consistent_rowsets;
+ std::vector<RowsetSharedPtr> consistent_rowsets;
if (request.__isset.missing_version) {
ReadLock rdlock(ref_tablet->get_header_lock_ptr());
for (int64_t missed_version : request.missing_version) {
@@ -419,7 +419,7 @@ OLAPStatus SnapshotManager::_create_snapshot_files(
ref_tablet->generate_tablet_meta_copy_unlocked(new_tablet_meta);
}
- vector<RowsetMetaSharedPtr> rs_metas;
+ std::vector<RowsetMetaSharedPtr> rs_metas;
for (auto& rs : consistent_rowsets) {
res = rs->link_files_to(schema_full_path, rs->rowset_id());
if (res != OLAP_SUCCESS) { break; }
@@ -519,7 +519,7 @@ OLAPStatus SnapshotManager::_create_snapshot_files(
}
OLAPStatus SnapshotManager::_convert_beta_rowsets_to_alpha(const TabletMetaSharedPtr& new_tablet_meta,
- const vector<RowsetMetaSharedPtr>& rowset_metas, const std::string& dst_path, bool is_incremental) {
+ const std::vector<RowsetMetaSharedPtr>& rowset_metas, const std::string& dst_path, bool is_incremental) {
OLAPStatus res = OLAP_SUCCESS;
RowsetConverter rowset_converter(new_tablet_meta);
std::vector<RowsetMetaSharedPtr> new_rowset_metas;
diff --git a/be/src/olap/storage_engine.cpp b/be/src/olap/storage_engine.cpp
index be3fbf1..905699c 100644
--- a/be/src/olap/storage_engine.cpp
+++ b/be/src/olap/storage_engine.cpp
@@ -212,7 +212,7 @@ Status StorageEngine::_init_store_map() {
for (auto store : tmp_stores) {
delete store;
}
- return Status::InternalError(Substitute("init path failed, error=$0", error_msg));
+ return Status::InternalError(strings::Substitute("init path failed, error=$0", error_msg));
}
for (auto store : tmp_stores) {
@@ -247,7 +247,7 @@ Status StorageEngine::_judge_and_update_effective_cluster_id(int32_t cluster_id)
} else {
if (cluster_id != _effective_cluster_id) {
RETURN_NOT_OK_STATUS_WITH_WARN(
- Status::Corruption(Substitute("multiple cluster ids is not equal. one=$0, other=",
+ Status::Corruption(strings::Substitute("multiple cluster ids is not equal. one=$0, other=",
_effective_cluster_id, cluster_id)),
"cluster id not equal");
}
@@ -380,7 +380,7 @@ Status StorageEngine::_check_all_root_path_cluster_id() {
cluster_id = tmp_cluster_id;
} else {
RETURN_NOT_OK_STATUS_WITH_WARN(
- Status::Corruption(Substitute("multiple cluster ids is not equal. one=$0, other=",
+ Status::Corruption(strings::Substitute("multiple cluster ids is not equal. one=$0, other=",
cluster_id, tmp_cluster_id)),
"cluster id not equal");
}
@@ -455,7 +455,7 @@ static bool too_many_disks_are_failed(uint32_t unused_num, uint32_t total_num) {
}
bool StorageEngine::_delete_tablets_on_unused_root_path() {
- vector<TabletInfo> tablet_info_vec;
+ std::vector<TabletInfo> tablet_info_vec;
uint32_t unused_root_path_num = 0;
uint32_t total_root_path_num = 0;
@@ -542,7 +542,7 @@ void StorageEngine::clear_transaction_task(const TTransactionId transaction_id)
}
void StorageEngine::clear_transaction_task(const TTransactionId transaction_id,
- const vector<TPartitionId>& partition_ids) {
+ const std::vector<TPartitionId>& partition_ids) {
LOG(INFO) << "begin to clear transaction task. transaction_id=" << transaction_id;
for (const TPartitionId& partition_id : partition_ids) {
@@ -881,7 +881,7 @@ OLAPStatus StorageEngine::obtain_shard_path(
return res;
}
- stringstream root_path_stream;
+ std::stringstream root_path_stream;
root_path_stream << stores[0]->path() << DATA_PREFIX << "/" << shard;
*shard_path = root_path_stream.str();
*store = stores[0];
@@ -916,7 +916,7 @@ OLAPStatus StorageEngine::load_header(
}
}
- stringstream schema_hash_path_stream;
+ std::stringstream schema_hash_path_stream;
schema_hash_path_stream << shard_path
<< "/" << request.tablet_id
<< "/" << request.schema_hash;
@@ -966,10 +966,10 @@ OLAPStatus StorageEngine::execute_task(EngineTask* task) {
// 2. do prepare work
// 3. release wlock
{
- vector<TabletInfo> tablet_infos;
+ std::vector<TabletInfo> tablet_infos;
task->get_related_tablets(&tablet_infos);
sort(tablet_infos.begin(), tablet_infos.end());
- vector<TabletSharedPtr> related_tablets;
+ std::vector<TabletSharedPtr> related_tablets;
for (TabletInfo& tablet_info : tablet_infos) {
TabletSharedPtr tablet = _tablet_manager->get_tablet(
tablet_info.tablet_id, tablet_info.schema_hash);
@@ -1001,11 +1001,11 @@ OLAPStatus StorageEngine::execute_task(EngineTask* task) {
// 2. do finish work
// 3. release wlock
{
- vector<TabletInfo> tablet_infos;
+ std::vector<TabletInfo> tablet_infos;
// related tablets may be changed after execute task, so that get them here again
task->get_related_tablets(&tablet_infos);
sort(tablet_infos.begin(), tablet_infos.end());
- vector<TabletSharedPtr> related_tablets;
+ std::vector<TabletSharedPtr> related_tablets;
for (TabletInfo& tablet_info : tablet_infos) {
TabletSharedPtr tablet = _tablet_manager->get_tablet(
tablet_info.tablet_id, tablet_info.schema_hash);
diff --git a/be/src/olap/tablet.cpp b/be/src/olap/tablet.cpp
index 8529892..e34a764 100644
--- a/be/src/olap/tablet.cpp
+++ b/be/src/olap/tablet.cpp
@@ -150,8 +150,8 @@ void Tablet::save_meta() {
}
OLAPStatus Tablet::revise_tablet_meta(
- const vector<RowsetMetaSharedPtr>& rowsets_to_clone,
- const vector<Version>& versions_to_delete) {
+ const std::vector<RowsetMetaSharedPtr>& rowsets_to_clone,
+ const std::vector<Version>& versions_to_delete) {
LOG(INFO) << "begin to clone data to tablet. tablet=" << full_name()
<< ", rowsets_to_clone=" << rowsets_to_clone.size()
<< ", versions_to_delete_size=" << versions_to_delete.size();
@@ -231,7 +231,7 @@ OLAPStatus Tablet::add_rowset(RowsetSharedPtr rowset, bool need_persist) {
_rs_version_map[rowset->version()] = rowset;
_timestamped_version_tracker.add_version(rowset->version());
- vector<RowsetSharedPtr> rowsets_to_delete;
+ std::vector<RowsetSharedPtr> rowsets_to_delete;
// yiguolei: temp code, should remove the rowset contains by this rowset
// but it should be removed in multi path version
for (auto& it : _rs_version_map) {
@@ -257,14 +257,14 @@ OLAPStatus Tablet::add_rowset(RowsetSharedPtr rowset, bool need_persist) {
return OLAP_SUCCESS;
}
-void Tablet::modify_rowsets(const vector<RowsetSharedPtr>& to_add,
- const vector<RowsetSharedPtr>& to_delete) {
+void Tablet::modify_rowsets(const std::vector<RowsetSharedPtr>& to_add,
+ const std::vector<RowsetSharedPtr>& to_delete) {
// the compaction process allow to compact the single version, eg: version[4-4].
// this kind of "single version compaction" has same "input version" and "output version".
// which means "to_add->version()" equals to "to_delete->version()".
// So we should delete the "to_delete" before adding the "to_add",
// otherwise, the "to_add" will be deleted from _rs_version_map, eventually.
- vector<RowsetMetaSharedPtr> rs_metas_to_delete;
+ std::vector<RowsetMetaSharedPtr> rs_metas_to_delete;
for (auto& rs : to_delete) {
rs_metas_to_delete.push_back(rs->rowset_meta());
_rs_version_map.erase(rs->version());
@@ -273,7 +273,7 @@ void Tablet::modify_rowsets(const vector<RowsetSharedPtr>& to_add,
_stale_rs_version_map[rs->version()] = rs;
}
- vector<RowsetMetaSharedPtr> rs_metas_to_add;
+ std::vector<RowsetMetaSharedPtr> rs_metas_to_add;
for (auto& rs : to_add) {
rs_metas_to_add.push_back(rs->rowset_meta());
_rs_version_map[rs->version()] = rs;
@@ -396,7 +396,7 @@ void Tablet::_delete_stale_rowset_by_version(const Version& version) {
void Tablet::delete_expired_inc_rowsets() {
int64_t now = UnixSeconds();
- vector<pair<Version, VersionHash>> expired_versions;
+ std::vector<pair<Version, VersionHash>> expired_versions;
WriteLock wrlock(&_meta_lock);
for (auto& rs_meta : _tablet_meta->all_inc_rs_metas()) {
double diff = ::difftime(now, rs_meta->creation_time());
@@ -426,7 +426,7 @@ void Tablet::delete_expired_inc_rowsets() {
void Tablet::delete_expired_stale_rowset() {
int64_t now = UnixSeconds();
- vector<pair<Version, VersionHash>> expired_versions;
+ std::vector<pair<Version, VersionHash>> expired_versions;
WriteLock wrlock(&_meta_lock);
// Compute the end time to delete rowsets, when a expired rowset createtime less then this time, it will be deleted.
double expired_stale_sweep_endtime = ::difftime(now, config::tablet_rowset_stale_sweep_time_sec);
@@ -568,7 +568,7 @@ void Tablet::delete_expired_stale_rowset() {
}
OLAPStatus Tablet::capture_consistent_versions(const Version& spec_version,
- vector<Version>* version_path) const {
+ std::vector<Version>* version_path) const {
// OLAPStatus status = _rs_graph.capture_consistent_versions(spec_version, version_path);
OLAPStatus status = _timestamped_version_tracker.capture_consistent_versions(spec_version, version_path);
@@ -614,15 +614,15 @@ void Tablet::list_versions(vector<Version>* versions) const {
}
OLAPStatus Tablet::capture_consistent_rowsets(const Version& spec_version,
- vector<RowsetSharedPtr>* rowsets) const {
- vector<Version> version_path;
+ std::vector<RowsetSharedPtr>* rowsets) const {
+ std::vector<Version> 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;
}
-OLAPStatus Tablet::_capture_consistent_rowsets_unlocked(const vector<Version>& version_path,
- vector<RowsetSharedPtr>* rowsets) const {
+OLAPStatus Tablet::_capture_consistent_rowsets_unlocked(const std::vector<Version>& version_path,
+ std::vector<RowsetSharedPtr>* rowsets) const {
DCHECK(rowsets != nullptr && rowsets->empty());
rowsets->reserve(version_path.size());
for (auto& version : version_path) {
@@ -654,15 +654,15 @@ OLAPStatus Tablet::_capture_consistent_rowsets_unlocked(const vector<Version>& v
}
OLAPStatus Tablet::capture_rs_readers(const Version& spec_version,
- vector<RowsetReaderSharedPtr>* rs_readers) const {
- vector<Version> version_path;
+ std::vector<RowsetReaderSharedPtr>* rs_readers) const {
+ std::vector<Version> 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;
}
-OLAPStatus Tablet::capture_rs_readers(const vector<Version>& version_path,
- vector<RowsetReaderSharedPtr>* rs_readers) const {
+OLAPStatus Tablet::capture_rs_readers(const std::vector<Version>& version_path,
+ std::vector<RowsetReaderSharedPtr>* rs_readers) const {
DCHECK(rs_readers != nullptr && rs_readers->empty());
for (auto version : version_path) {
auto it = _rs_version_map.find(version);
@@ -710,7 +710,7 @@ AlterTabletTaskSharedPtr Tablet::alter_task() {
void Tablet::add_alter_task(int64_t related_tablet_id,
int32_t related_schema_hash,
- const vector<Version>& versions_to_alter,
+ const std::vector<Version>& versions_to_alter,
const AlterTabletType alter_type) {
AlterTabletTask alter_task;
alter_task.set_alter_state(ALTER_RUNNING);
@@ -801,7 +801,7 @@ void Tablet::compute_version_hash_from_rowsets(
*version_hash = v_hash;
}
-void Tablet::calc_missed_versions(int64_t spec_version, vector<Version>* missed_versions) {
+void Tablet::calc_missed_versions(int64_t spec_version, std::vector<Version>* missed_versions) {
ReadLock rdlock(&_meta_lock);
calc_missed_versions_unlocked(spec_version, missed_versions);
}
@@ -811,7 +811,7 @@ void Tablet::calc_missed_versions(int64_t spec_version, vector<Version>* missed_
// [0-4][5-5][8-8][9-9]
// if spec_version = 6, we still return {6, 7} other than {7}
void Tablet::calc_missed_versions_unlocked(int64_t spec_version,
- vector<Version>* missed_versions) const {
+ std::vector<Version>* missed_versions) const {
DCHECK(spec_version > 0) << "invalid spec_version: " << spec_version;
std::list<Version> existing_versions;
for (auto& rs : _tablet_meta->all_rs_metas()) {
@@ -850,7 +850,7 @@ void Tablet::max_continuous_version_from_beginning(Version* version,
void Tablet::_max_continuous_version_from_beginning_unlocked(Version* version,
VersionHash* v_hash) const {
- vector<pair<Version, VersionHash>> existing_versions;
+ std::vector<pair<Version, VersionHash>> existing_versions;
for (auto& rs : _tablet_meta->all_rs_metas()) {
existing_versions.emplace_back(rs->version() , rs->version_hash());
}
@@ -892,7 +892,7 @@ void Tablet::calculate_cumulative_point() {
OLAPStatus Tablet::split_range(const OlapTuple& start_key_strings,
const OlapTuple& end_key_strings,
uint64_t request_block_row_count,
- vector<OlapTuple>* ranges) {
+ std::vector<OlapTuple>* ranges) {
DCHECK(ranges != nullptr);
RowCursor start_key;
diff --git a/be/src/olap/tablet_manager.cpp b/be/src/olap/tablet_manager.cpp
index 5cdfe7b..0f6ef10 100644
--- a/be/src/olap/tablet_manager.cpp
+++ b/be/src/olap/tablet_manager.cpp
@@ -175,7 +175,7 @@ OLAPStatus TabletManager::_add_tablet_to_map_unlocked(TTabletId tablet_id, Schem
if (drop_old) {
// If the new tablet is fresher than the existing one, then replace
// the existing tablet with the new one.
- RETURN_NOT_OK_LOG(_drop_tablet_unlocked(tablet_id, schema_hash, keep_files), Substitute(
+ RETURN_NOT_OK_LOG(_drop_tablet_unlocked(tablet_id, schema_hash, keep_files), strings::Substitute(
"failed to drop old tablet when add new tablet. tablet_id=$0, schema_hash=$1",
tablet_id, schema_hash));
}
@@ -332,7 +332,7 @@ TabletSharedPtr TabletManager::_internal_create_tablet_unlocked(
} else {
// add alter task to new tablet if it is a new tablet during schema change
tablet->add_alter_task(base_tablet->tablet_id(), base_tablet->schema_hash(),
- vector<Version>(), alter_type);
+ std::vector<Version>(), alter_type);
}
// 有可能出现以下2种特殊情况:
// 1. 因为操作系统时间跳变,导致新生成的表的creation_time小于旧表的creation_time时间
@@ -542,7 +542,7 @@ OLAPStatus TabletManager::_drop_tablet_unlocked(
}
OLAPStatus TabletManager::drop_tablets_on_error_root_path(
- const vector<TabletInfo>& tablet_info_vec) {
+ const std::vector<TabletInfo>& tablet_info_vec) {
OLAPStatus res = OLAP_SUCCESS;
for (int32 i = 0; i < _tablet_map_lock_shard_size; i++) {
RWMutex& tablet_map_lock = _tablet_map_lock_array[i];
@@ -681,7 +681,7 @@ void TabletManager::get_tablet_stat(TTabletStatResult* result) {
TabletSharedPtr TabletManager::find_best_tablet_to_compaction(
CompactionType compaction_type, DataDir* data_dir,
- vector<TTabletId> &tablet_submitted_compaction) {
+ std::vector<TTabletId> &tablet_submitted_compaction) {
int64_t now_ms = UnixMillis();
const string& compaction_type_str = compaction_type == CompactionType::BASE_COMPACTION ? "base" : "cumulative";
double highest_score = 0.0;
@@ -693,7 +693,7 @@ TabletSharedPtr TabletManager::find_best_tablet_to_compaction(
tablet_map_t& tablet_map = _tablet_map_array[i];
for (tablet_map_t::value_type& table_ins : tablet_map){
for (TabletSharedPtr& tablet_ptr : table_ins.second.table_arr) {
- vector<TTabletId>::iterator it_tablet =
+ std::vector<TTabletId>::iterator it_tablet =
find(tablet_submitted_compaction.begin(), tablet_submitted_compaction.end(),
tablet_ptr->tablet_id());
if (it_tablet != tablet_submitted_compaction.end()) {
@@ -850,10 +850,10 @@ OLAPStatus TabletManager::load_tablet_from_meta(DataDir* data_dir, TTabletId tab
return OLAP_ERR_TABLE_INDEX_VALIDATE_ERROR;
}
- RETURN_NOT_OK_LOG(tablet->init(), Substitute("tablet init failed. tablet=$0",
+ RETURN_NOT_OK_LOG(tablet->init(), strings::Substitute("tablet init failed. tablet=$0",
tablet->full_name()));
RETURN_NOT_OK_LOG(_add_tablet_unlocked(tablet_id, schema_hash, tablet, update_meta, force),
- Substitute("fail to add tablet. tablet=$0", tablet->full_name()));
+ strings::Substitute("fail to add tablet. tablet=$0", tablet->full_name()));
return OLAP_SUCCESS;
}
@@ -877,7 +877,7 @@ OLAPStatus TabletManager::load_tablet_from_dir(DataDir* store, TTabletId tablet_
int32_t shard = stol(shard_str);
// load dir is called by clone, restore, storage migration
// should change tablet uid when tablet object changed
- RETURN_NOT_OK_LOG(TabletMeta::reset_tablet_uid(header_path), Substitute(
+ RETURN_NOT_OK_LOG(TabletMeta::reset_tablet_uid(header_path), strings::Substitute(
"failed to set tablet uid when copied meta file. header_path=%0", header_path));;
if (!Env::Default()->path_exists(header_path).ok()) {
@@ -897,7 +897,7 @@ OLAPStatus TabletManager::load_tablet_from_dir(DataDir* store, TTabletId tablet_
tablet_meta->serialize(&meta_binary);
RETURN_NOT_OK_LOG(load_tablet_from_meta(store, tablet_id, schema_hash,
meta_binary, true, force, restore),
- Substitute("fail to load tablet. header_path=$0", header_path));
+ strings::Substitute("fail to load tablet. header_path=$0", header_path));
return OLAP_SUCCESS;
}
@@ -1200,7 +1200,7 @@ void TabletManager::get_partition_related_tablets(int64_t partition_id,
}
void TabletManager::do_tablet_meta_checkpoint(DataDir* data_dir) {
- vector<TabletSharedPtr> related_tablets;
+ std::vector<TabletSharedPtr> related_tablets;
{
for (int32 i = 0 ; i < _tablet_map_lock_shard_size; i++) {
ReadLock tablet_map_rdlock(&_tablet_map_lock_array[i]);
diff --git a/be/src/olap/tablet_meta.cpp b/be/src/olap/tablet_meta.cpp
index 5169cfb..b014eaf 100755
--- a/be/src/olap/tablet_meta.cpp
+++ b/be/src/olap/tablet_meta.cpp
@@ -236,7 +236,7 @@ OLAPStatus TabletMeta::reset_tablet_uid(const string& header_file) {
return res;
}
-string TabletMeta::construct_header_file_path(const string& schema_hash_path,
+std::string TabletMeta::construct_header_file_path(const string& schema_hash_path,
int64_t tablet_id) {
std::stringstream header_name_stream;
header_name_stream << schema_hash_path << "/" << tablet_id << ".hdr";
@@ -495,7 +495,7 @@ OLAPStatus TabletMeta::add_rs_meta(const RowsetMetaSharedPtr& rs_meta) {
}
void TabletMeta::delete_rs_meta_by_version(const Version& version,
- vector<RowsetMetaSharedPtr>* deleted_rs_metas) {
+ std::vector<RowsetMetaSharedPtr>* deleted_rs_metas) {
auto it = _rs_metas.begin();
while (it != _rs_metas.end()) {
if ((*it)->version() == version) {
@@ -510,8 +510,8 @@ void TabletMeta::delete_rs_meta_by_version(const Version& version,
}
}
-void TabletMeta::modify_rs_metas(const vector<RowsetMetaSharedPtr>& to_add,
- const vector<RowsetMetaSharedPtr>& to_delete) {
+void TabletMeta::modify_rs_metas(const std::vector<RowsetMetaSharedPtr>& to_add,
+ const std::vector<RowsetMetaSharedPtr>& to_delete) {
// Remove to_delete rowsets from _rs_metas
for (auto rs_to_del : to_delete) {
auto it = _rs_metas.begin();
@@ -691,7 +691,7 @@ OLAPStatus TabletMeta::set_alter_state(AlterTabletState alter_state) {
}
}
-string TabletMeta::full_name() const {
+std::string TabletMeta::full_name() const {
std::stringstream ss;
ss << _tablet_id
<< "." << _schema_hash
diff --git a/be/src/olap/task/engine_alter_tablet_task.cpp b/be/src/olap/task/engine_alter_tablet_task.cpp
index 0e7e117..0baef9c 100644
--- a/be/src/olap/task/engine_alter_tablet_task.cpp
+++ b/be/src/olap/task/engine_alter_tablet_task.cpp
@@ -24,7 +24,7 @@ namespace doris {
using std::to_string;
EngineAlterTabletTask::EngineAlterTabletTask(const TAlterTabletReqV2& request,
- int64_t signature, const TTaskType::type task_type, vector<string>* error_msgs,
+ int64_t signature, const TTaskType::type task_type, std::vector<string>* error_msgs,
const string& process_name):
_alter_tablet_req(request),
_signature(signature),
diff --git a/be/src/olap/task/engine_batch_load_task.cpp b/be/src/olap/task/engine_batch_load_task.cpp
index cf9c5a8..5b9820f 100644
--- a/be/src/olap/task/engine_batch_load_task.cpp
+++ b/be/src/olap/task/engine_batch_load_task.cpp
@@ -286,7 +286,7 @@ AgentStatus EngineBatchLoadTask::_process() {
}
OLAPStatus EngineBatchLoadTask::_push(const TPushReq& request,
- vector<TTabletInfo>* tablet_info_vec) {
+ std::vector<TTabletInfo>* tablet_info_vec) {
OLAPStatus res = OLAP_SUCCESS;
LOG(INFO) << "begin to process push. "
<< " transaction_id=" << request.transaction_id
@@ -350,7 +350,7 @@ OLAPStatus EngineBatchLoadTask::_push(const TPushReq& request,
OLAPStatus EngineBatchLoadTask::_delete_data(
const TPushReq& request,
- vector<TTabletInfo>* tablet_info_vec) {
+ std::vector<TTabletInfo>* tablet_info_vec) {
LOG(INFO) << "begin to process delete data. request=" << ThriftDebugString(request);
DorisMetrics::instance()->delete_requests_total->increment(1);
diff --git a/be/src/olap/task/engine_clone_task.cpp b/be/src/olap/task/engine_clone_task.cpp
index 22d1f82..264d45c 100644
--- a/be/src/olap/task/engine_clone_task.cpp
+++ b/be/src/olap/task/engine_clone_task.cpp
@@ -52,8 +52,8 @@ const uint32_t GET_LENGTH_TIMEOUT = 10;
EngineCloneTask::EngineCloneTask(const TCloneReq& clone_req,
const TMasterInfo& master_info,
int64_t signature,
- vector<string>* error_msgs,
- vector<TTabletInfo>* tablet_infos,
+ std::vector<string>* error_msgs,
+ std::vector<TTabletInfo>* tablet_infos,
AgentStatus* res_status) :
_clone_req(clone_req),
_error_msgs(error_msgs),
@@ -100,7 +100,7 @@ OLAPStatus EngineCloneTask::_do_clone() {
RowsetSharedPtr clone_rowset = tablet->get_rowset_by_version(clone_version);
if (clone_rowset == nullptr) {
// try to incremental clone
- vector<Version> missed_versions;
+ std::vector<Version> missed_versions;
tablet->calc_missed_versions(_clone_req.committed_version, &missed_versions);
LOG(INFO) << "finish to calculate missed versions when clone. "
<< "tablet=" << tablet->full_name()
@@ -169,7 +169,7 @@ OLAPStatus EngineCloneTask::_do_clone() {
_error_msgs->push_back("clone get local root path failed.");
status = DORIS_ERROR;
}
- stringstream tablet_dir_stream;
+ std::stringstream tablet_dir_stream;
tablet_dir_stream << local_shard_root_path
<< "/" << _clone_req.tablet_id
<< "/" << _clone_req.schema_hash;
@@ -187,7 +187,7 @@ OLAPStatus EngineCloneTask::_do_clone() {
if (status == DORIS_SUCCESS) {
LOG(INFO) << "clone copy done. src_host: " << src_host.host
<< " src_file_path: " << src_file_path;
- stringstream schema_hash_path_stream;
+ std::stringstream schema_hash_path_stream;
schema_hash_path_stream << local_shard_root_path
<< "/" << _clone_req.tablet_id
<< "/" << _clone_req.schema_hash;
@@ -215,7 +215,7 @@ OLAPStatus EngineCloneTask::_do_clone() {
}
// Clean useless dir, if failed, ignore it.
if (status != DORIS_SUCCESS && status != DORIS_CREATE_TABLE_EXIST) {
- stringstream local_data_path_stream;
+ std::stringstream local_data_path_stream;
local_data_path_stream << local_shard_root_path
<< "/" << _clone_req.tablet_id;
string local_data_path = local_data_path_stream.str();
@@ -295,8 +295,8 @@ AgentStatus EngineCloneTask::_clone_copy(
const string& local_data_path,
TBackend* src_host,
string* snapshot_path,
- vector<string>* error_msgs,
- const vector<Version>* missed_versions,
+ std::vector<string>* error_msgs,
+ const std::vector<Version>* missed_versions,
bool* allow_incremental_clone) {
AgentStatus status = DORIS_SUCCESS;
@@ -485,7 +485,7 @@ Status EngineCloneTask::_download_files(
return Status::OK();
};
RETURN_IF_ERROR(HttpClient::execute_with_retry(DOWNLOAD_FILE_MAX_RETRY, 1, list_files_cb));
- vector<string> file_name_list = strings::Split(file_list_str, "\n", strings::SkipWhitespace());
+ std::vector<string> file_name_list = strings::Split(file_list_str, "\n", strings::SkipWhitespace());
// If the header file is not exist, the table couldn't loaded by olap engine.
// Avoid of data is not complete, we copy the header file at last.
@@ -609,14 +609,14 @@ OLAPStatus EngineCloneTask::_convert_to_new_snapshot(const string& clone_dir, in
}
OlapSnapshotConverter converter;
TabletMetaPB tablet_meta_pb;
- vector<RowsetMetaPB> pending_rowsets;
+ std::vector<RowsetMetaPB> pending_rowsets;
res = converter.to_new_snapshot(olap_header_msg, clone_dir, clone_dir,
&tablet_meta_pb, &pending_rowsets, false);
if (res != OLAP_SUCCESS) {
LOG(WARNING) << "fail to convert snapshot to new format. dir='" << clone_dir;
return res;
}
- vector<string> files_to_delete;
+ std::vector<string> files_to_delete;
for (auto file_name : clone_files) {
string full_file_path = clone_dir + "/" + file_name;
files_to_delete.push_back(full_file_path);
@@ -638,7 +638,7 @@ OLAPStatus EngineCloneTask::_convert_to_new_snapshot(const string& clone_dir, in
OLAPStatus EngineCloneTask::_finish_clone(Tablet* tablet, const string& clone_dir,
int64_t committed_version, bool is_incremental_clone) {
OLAPStatus res = OLAP_SUCCESS;
- vector<string> linked_success_files;
+ std::vector<string> linked_success_files;
// clone and compaction operation should be performed sequentially
tablet->obtain_base_compaction_lock();
@@ -749,11 +749,11 @@ OLAPStatus EngineCloneTask::_clone_incremental_data(Tablet* tablet, const Tablet
LOG(INFO) << "begin to incremental clone. tablet=" << tablet->full_name()
<< ", committed_version=" << committed_version;
- vector<Version> missed_versions;
+ std::vector<Version> missed_versions;
tablet->calc_missed_versions_unlocked(committed_version, &missed_versions);
- vector<Version> versions_to_delete;
- vector<RowsetMetaSharedPtr> rowsets_to_clone;
+ std::vector<Version> versions_to_delete;
+ std::vector<RowsetMetaSharedPtr> rowsets_to_clone;
VLOG(3) << "get missed versions again when finish incremental clone. "
<< "tablet=" << tablet->full_name()
@@ -783,8 +783,8 @@ OLAPStatus EngineCloneTask::_clone_full_data(Tablet* tablet, TabletMeta* cloned_
LOG(INFO) << "begin to full clone. tablet=" << tablet->full_name()
<< ", cloned_max_version=" << cloned_max_version.first
<< "-" << cloned_max_version.second;
- vector<Version> versions_to_delete;
- vector<RowsetMetaSharedPtr> rs_metas_found_in_src;
+ std::vector<Version> versions_to_delete;
+ std::vector<RowsetMetaSharedPtr> rs_metas_found_in_src;
// check local versions
for (auto& rs_meta : tablet->tablet_meta()->all_rs_metas()) {
Version local_version(rs_meta->start_version(), rs_meta->end_version());
@@ -835,7 +835,7 @@ OLAPStatus EngineCloneTask::_clone_full_data(Tablet* tablet, TabletMeta* cloned_
}
}
}
- vector<RowsetMetaSharedPtr> rowsets_to_clone;
+ std::vector<RowsetMetaSharedPtr> rowsets_to_clone;
for (auto& rs_meta : cloned_tablet_meta->all_rs_metas()) {
rowsets_to_clone.push_back(rs_meta);
LOG(INFO) << "Delta to clone."
diff --git a/be/src/olap/task/engine_publish_version_task.cpp b/be/src/olap/task/engine_publish_version_task.cpp
index 28202ab..7fb1ce2 100644
--- a/be/src/olap/task/engine_publish_version_task.cpp
+++ b/be/src/olap/task/engine_publish_version_task.cpp
@@ -26,7 +26,7 @@ namespace doris {
using std::map;
EnginePublishVersionTask::EnginePublishVersionTask(TPublishVersionRequest& publish_version_req,
- vector<TTabletId>* error_tablet_ids) :
+ std::vector<TTabletId>* error_tablet_ids) :
_publish_version_req(publish_version_req),
_error_tablet_ids(error_tablet_ids) {}
diff --git a/be/src/olap/task/engine_storage_migration_task.cpp b/be/src/olap/task/engine_storage_migration_task.cpp
index 7a47324..44938d0 100644
--- a/be/src/olap/task/engine_storage_migration_task.cpp
+++ b/be/src/olap/task/engine_storage_migration_task.cpp
@@ -77,7 +77,7 @@ OLAPStatus EngineStorageMigrationTask::_migrate() {
}
int32_t end_version = last_version->end_version();
- vector<RowsetSharedPtr> consistent_rowsets;
+ std::vector<RowsetSharedPtr> consistent_rowsets;
res = _tablet->capture_consistent_rowsets(Version(0, end_version), &consistent_rowsets);
if (consistent_rowsets.empty()) {
_tablet->release_header_lock();
@@ -94,7 +94,7 @@ OLAPStatus EngineStorageMigrationTask::_migrate() {
LOG(WARNING) << "fail to get shard from store: " << _dest_store->path();
break;
}
- stringstream root_path_stream;
+ std::stringstream root_path_stream;
root_path_stream << _dest_store->path() << DATA_PREFIX << "/" << shard;
string full_path = SnapshotManager::instance()->get_schema_hash_full_path(_tablet, root_path_stream.str());
// if dir already exist then return err, it should not happen.
@@ -189,7 +189,7 @@ void EngineStorageMigrationTask::_generate_new_header(
TabletMetaSharedPtr new_tablet_meta) {
_tablet->generate_tablet_meta_copy_unlocked(new_tablet_meta);
- vector<RowsetMetaSharedPtr> rs_metas;
+ std::vector<RowsetMetaSharedPtr> rs_metas;
for (auto& rs : consistent_rowsets) {
rs_metas.push_back(rs->rowset_meta());
}
diff --git a/be/src/olap/utils.cpp b/be/src/olap/utils.cpp
index f34108f..255e02f 100644
--- a/be/src/olap/utils.cpp
+++ b/be/src/olap/utils.cpp
@@ -56,7 +56,7 @@
using std::string;
using std::set;
using std::vector;
-using std::unique_ptr;
+
namespace doris {
@@ -1014,12 +1014,12 @@ OLAPStatus read_write_test_file(const string& test_file_path) {
LOG(WARNING) << "fail to allocate write buffer memory. size=" << TEST_FILE_BUF_SIZE;
return OLAP_ERR_MALLOC_ERROR;
}
- unique_ptr<char, decltype(&std::free)> write_buff (write_test_buff, &std::free);
+ std::unique_ptr<char, decltype(&std::free)> 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;
}
- unique_ptr<char, decltype(&std::free)> read_buff (read_test_buff, &std::free);
+ std::unique_ptr<char, decltype(&std::free)> read_buff (read_test_buff, &std::free);
// generate random numbers
uint32_t rand_seed = static_cast<uint32_t>(time(NULL));
for (size_t i = 0; i < TEST_FILE_BUF_SIZE; ++i) {
diff --git a/be/src/plugin/plugin_loader.cpp b/be/src/plugin/plugin_loader.cpp
index 32c0d2a..4f87b20 100644
--- a/be/src/plugin/plugin_loader.cpp
+++ b/be/src/plugin/plugin_loader.cpp
@@ -45,7 +45,7 @@ Status PluginLoader::open_valid() {
Status PluginLoader::close_valid() {
if (_plugin.get() != nullptr && (_plugin->flags & PLUGIN_NOT_DYNAMIC_UNINSTALL)) {
- return Status::InternalError(Substitute("plugin $0 not allow dynamic uninstall", _name));
+ return Status::InternalError(strings::Substitute("plugin $0 not allow dynamic uninstall", _name));
}
return Status::OK();
diff --git a/be/src/plugin/plugin_mgr.cpp b/be/src/plugin/plugin_mgr.cpp
index 7837903..d7b41bb 100644
--- a/be/src/plugin/plugin_mgr.cpp
+++ b/be/src/plugin/plugin_mgr.cpp
@@ -27,7 +27,7 @@ using namespace strings;
#define PLUGIN_TYPE_CHECK(_type) { \
if (_type >= PLUGIN_TYPE_MAX) { \
- return Status::InvalidArgument(Substitute("error plugin type: $0", _type)); \
+ return Status::InvalidArgument(strings::Substitute("error plugin type: $0", _type)); \
} \
}
@@ -92,7 +92,7 @@ Status PluginMgr::get_plugin(const std::string& name, int type, std::shared_ptr<
return Status::OK();
}
- return Status::NotFound(Substitute("not found type $0 plugin $1", type, name));
+ return Status::NotFound(strings::Substitute("not found type $0 plugin $1", type, name));
}
Status PluginMgr::get_plugin(const std::string& name, std::shared_ptr<Plugin>* plugin) {
@@ -107,7 +107,7 @@ Status PluginMgr::get_plugin(const std::string& name, std::shared_ptr<Plugin>* p
}
}
- return Status::NotFound(Substitute("not found plugin $0", name));
+ return Status::NotFound(strings::Substitute("not found plugin $0", name));
}
Status PluginMgr::get_plugin_list(int type, std::vector<std::shared_ptr<Plugin>>* plugin_list) {
@@ -129,7 +129,7 @@ Status PluginMgr::register_builtin_plugin(const std::string& name, int type, con
auto iter = _plugins[type].find(name);
if (iter != _plugins[type].end()) {
- return Status::AlreadyExist(Substitute("the type $0 plugin $1 already register", type, name));
+ return Status::AlreadyExist(strings::Substitute("the type $0 plugin $1 already register", type, name));
}
std::unique_ptr<PluginLoader> loader = std::unique_ptr<PluginLoader>(new BuiltinPluginLoader(name, type, plugin));
diff --git a/be/src/plugin/plugin_zip.cpp b/be/src/plugin/plugin_zip.cpp
index 599e4e5..937aab5 100644
--- a/be/src/plugin/plugin_zip.cpp
+++ b/be/src/plugin/plugin_zip.cpp
@@ -51,10 +51,10 @@ PluginZip::~PluginZip() {
Status PluginZip::extract(const std::string& target_dir, const std::string& plugin_name) {
// check plugin install path
- std::string plugin_install_path = Substitute("$0/$1", target_dir, plugin_name);
+ std::string plugin_install_path = strings::Substitute("$0/$1", target_dir, plugin_name);
if (FileUtils::check_exist(plugin_install_path)) {
- return Status::AlreadyExist(Substitute("plugin $0 already install!", plugin_name));
+ return Status::AlreadyExist(strings::Substitute("plugin $0 already install!", plugin_name));
}
if (!FileUtils::check_exist(target_dir)) {
@@ -63,7 +63,7 @@ Status PluginZip::extract(const std::string& target_dir, const std::string& plug
std::string zip_path = _source;
if (!is_local_source(_source)) {
- zip_path = Substitute("$0/.temp_$1_$2.zip", target_dir, GetCurrentTimeMicros(), plugin_name);
+ zip_path = strings::Substitute("$0/.temp_$1_$2.zip", target_dir, GetCurrentTimeMicros(), plugin_name);
_clean_paths.push_back(zip_path);
RETURN_IF_ERROR(download(zip_path));
@@ -122,7 +122,7 @@ Status PluginZip::download(const std::string& zip_path) {
digest.digest();
if (0 != strncmp(digest.hex().c_str(), expect.c_str(), 32)) {
return Status::InternalError(
- Substitute("plugin install checksum failed. expect: $0, actual:$1", expect, digest.hex()));
+ strings::Substitute("plugin install checksum failed. expect: $0, actual:$1", expect, digest.hex()));
}
return Status::OK();
diff --git a/be/src/runtime/buffered_tuple_stream3.cc b/be/src/runtime/buffered_tuple_stream3.cc
index bddbbc4..43434bc 100644
--- a/be/src/runtime/buffered_tuple_stream3.cc
+++ b/be/src/runtime/buffered_tuple_stream3.cc
@@ -34,7 +34,7 @@
#include "util/pretty_printer.h"
#include "util/runtime_profile.h"
-#include "common/names.h"
+
#ifdef NDEBUG
#define CHECK_CONSISTENCY_FAST()
@@ -51,7 +51,7 @@ using BufferHandle = BufferPool::BufferHandle;
BufferedTupleStream3::BufferedTupleStream3(RuntimeState* state,
const RowDescriptor* row_desc, BufferPool::ClientHandle* buffer_pool_client,
- int64_t default_page_len, int64_t max_page_len, const set<SlotId>& ext_varlen_slots)
+ int64_t default_page_len, int64_t max_page_len, const std::set<SlotId>& ext_varlen_slots)
: state_(state),
desc_(row_desc),
node_id_(-1),
@@ -169,7 +169,7 @@ void BufferedTupleStream3::CheckPageConsistency(const Page* page) const {
}
string BufferedTupleStream3::DebugString() const {
- stringstream ss;
+ std::stringstream ss;
ss << "BufferedTupleStream3 num_rows=" << num_rows_
<< " rows_returned=" << rows_returned_ << " pinned=" << pinned_
<< " delete_on_read=" << delete_on_read_ << " closed=" << closed_ << "\n"
@@ -259,7 +259,7 @@ void BufferedTupleStream3::Close(RowBatch* batch, RowBatch::FlushMode flush) {
BufferPool::BufferHandle buffer;
Status status = buffer_pool_->ExtractBuffer(buffer_pool_client_, &page.handle, &buffer);
DCHECK(status.ok());
- batch->add_buffer(buffer_pool_client_, move(buffer), flush);
+ batch->add_buffer(buffer_pool_client_, std::move(buffer), flush);
} else {
buffer_pool_->DestroyPage(buffer_pool_client_, &page.handle);
}
@@ -393,7 +393,7 @@ Status BufferedTupleStream3::CalcPageLenForRow(int64_t row_size, int64_t* page_l
// (state_->query_options().max_row_size, TUnit::BYTES);
return Status::InternalError(ss.str());
}
- *page_len = max(default_page_len_, BitUtil::RoundUpToPowerOfTwo(row_size));
+ *page_len = std::max(default_page_len_, BitUtil::RoundUpToPowerOfTwo(row_size));
return Status::OK();
}
@@ -695,7 +695,7 @@ void BufferedTupleStream3::UnpinStream(UnpinMode mode) {
}
*/
Status BufferedTupleStream3::GetRows(
- const std::shared_ptr<MemTracker>& tracker, scoped_ptr<RowBatch>* batch, bool* got_rows) {
+ const std::shared_ptr<MemTracker>& tracker, boost::scoped_ptr<RowBatch>* batch, bool* got_rows) {
if (num_rows() > numeric_limits<int>::max()) {
// RowBatch::num_rows_ is a 32-bit int, avoid an overflow.
return Status::InternalError(Substitute("Trying to read $0 rows into in-memory batch failed. Limit "
diff --git a/be/src/runtime/bufferpool/buffer_allocator.cc b/be/src/runtime/bufferpool/buffer_allocator.cc
index 22fe255..e5d0131 100644
--- a/be/src/runtime/bufferpool/buffer_allocator.cc
+++ b/be/src/runtime/bufferpool/buffer_allocator.cc
@@ -28,7 +28,6 @@
#include "util/pretty_printer.h"
#include "util/runtime_profile.h"
-#include "common/names.h"
#include "common/config.h"
//DECLARE_bool(disable_mem_pools);
@@ -72,7 +71,7 @@ class BufferPool::FreeBufferArena : public CacheLineAligned {
///
/// Caller should not hold 'lock_'. If 'arena_lock' is non-null, ownership of the
/// arena lock is transferred to the caller. Uses std::unique_lock instead of
- /// boost::unique_lock because it is movable.
+ /// boost::std::unique_lock because it is movable.
std::pair<int64_t, int64_t> FreeSystemMemory(int64_t target_bytes_to_free,
int64_t target_bytes_to_claim, std::unique_lock<SpinLock>* arena_lock);
@@ -106,7 +105,7 @@ class BufferPool::FreeBufferArena : public CacheLineAligned {
/// it doesn't acquire the arena lock.
int64_t GetNumCleanPages();
- string DebugString();
+ std::string DebugString();
private:
/// The data structures for each power-of-two size of buffers/pages.
@@ -119,7 +118,7 @@ class BufferPool::FreeBufferArena : public CacheLineAligned {
void AddFreeBuffer(BufferHandle&& buffer) {
DCHECK_EQ(num_free_buffers.load(), free_buffers.Size());
num_free_buffers.add(1);
- free_buffers.AddFreeBuffer(move(buffer));
+ free_buffers.AddFreeBuffer(std::move(buffer));
}
/// The number of entries in 'free_buffers'. Can be read without holding a lock to
@@ -178,8 +177,8 @@ int64_t BufferPool::BufferAllocator::CalcMaxBufferLen(
// Find largest power of 2 smaller than 'system_bytes_limit'.
int64_t upper_bound = system_bytes_limit == 0 ? 1L : 1L
<< BitUtil::Log2Floor64(system_bytes_limit);
- upper_bound = min(MAX_BUFFER_BYTES, upper_bound);
- return max(min_buffer_len, upper_bound); // Can't be < min_buffer_len.
+ upper_bound = std::min(MAX_BUFFER_BYTES, upper_bound);
+ return std::max(min_buffer_len, upper_bound); // Can't be < min_buffer_len.
}
BufferPool::BufferAllocator::BufferAllocator(
@@ -202,9 +201,9 @@ BufferPool::BufferAllocator::BufferAllocator(
DCHECK_LE(0, min_buffer_len_);
DCHECK_LE(min_buffer_len_, max_buffer_len_);
DCHECK_LE(max_buffer_len_, MAX_BUFFER_BYTES);
- DCHECK_LE(max_buffer_len_, max(system_bytes_limit_, min_buffer_len_));
+ DCHECK_LE(max_buffer_len_, std::max(system_bytes_limit_, min_buffer_len_));
- for (unique_ptr<FreeBufferArena>& arena : per_core_arenas_) {
+ for (std::unique_ptr<FreeBufferArena>& arena : per_core_arenas_) {
arena.reset(new FreeBufferArena(this));
}
}
@@ -254,7 +253,7 @@ Status BufferPool::BufferAllocator::AllocateInternal(int64_t len, BufferHandle*
int64_t delta = DecreaseBytesRemaining(len, true, &system_bytes_remaining_);
if (delta != len) {
DCHECK_EQ(0, delta);
- const vector<int>& numa_node_cores = CpuInfo::get_cores_of_same_numa_node(current_core);
+ const std::vector<int>& numa_node_cores = CpuInfo::get_cores_of_same_numa_node(current_core);
const int numa_node_core_idx = CpuInfo::get_numa_node_core_idx(current_core);
// Fast-ish path: find a buffer of the right size from another core on the same
@@ -314,7 +313,7 @@ int64_t DecreaseBytesRemaining(
while (true) {
int64_t old_value = bytes_remaining->load();
if (require_full_decrease && old_value < max_decrease) return 0;
- int64_t decrease = min(old_value, max_decrease);
+ int64_t decrease = std::min(old_value, max_decrease);
int64_t new_value = old_value - decrease;
if (bytes_remaining->compare_and_swap(old_value, new_value)) {
return decrease;
@@ -347,7 +346,7 @@ int64_t BufferPool::BufferAllocator::ScavengeBuffers(
// therefore must start at 0 to respect the lock order. Otherwise we start with the
// current core's arena for locality and to avoid excessive contention on arena 0.
int start_core = slow_but_sure ? 0 : current_core;
- vector<std::unique_lock<SpinLock>> arena_locks;
+ std::vector<std::unique_lock<SpinLock>> arena_locks;
if (slow_but_sure) arena_locks.resize(per_core_arenas_.size());
for (int i = 0; i < per_core_arenas_.size(); ++i) {
@@ -378,11 +377,11 @@ void BufferPool::BufferAllocator::Free(BufferHandle&& handle) {
handle.client_ = nullptr; // Buffer is no longer associated with a client.
FreeBufferArena* arena = per_core_arenas_[handle.home_core_].get();
handle.Poison();
- arena->AddFreeBuffer(move(handle));
+ arena->AddFreeBuffer(std::move(handle));
}
void BufferPool::BufferAllocator::AddCleanPage(
- const unique_lock<mutex>& client_lock, Page* page) {
+ const std::unique_lock<std::mutex>& client_lock, Page* page) {
page->client->DCheckHoldsLock(client_lock);
FreeBufferArena* arena = per_core_arenas_[page->buffer.home_core_].get();
arena->AddCleanPage(page);
@@ -390,11 +389,11 @@ void BufferPool::BufferAllocator::AddCleanPage(
bool BufferPool::BufferAllocator::RemoveCleanPage(
- const unique_lock<mutex>& client_lock, bool claim_buffer, Page* page) {
+ const std::unique_lock<std::mutex>& client_lock, bool claim_buffer, Page* page) {
page->client->DCheckHoldsLock(client_lock);
FreeBufferArena* arena;
{
- lock_guard<SpinLock> pl(page->buffer_lock);
+ std::lock_guard<SpinLock> pl(page->buffer_lock);
// Page may be evicted - in which case it has no home core and is not in an arena.
if (!page->buffer.is_open()) return false;
arena = per_core_arenas_[page->buffer.home_core_].get();
@@ -403,7 +402,7 @@ bool BufferPool::BufferAllocator::RemoveCleanPage(
}
void BufferPool::BufferAllocator::Maintenance() {
- for (unique_ptr<FreeBufferArena>& arena : per_core_arenas_) arena->Maintenance();
+ for (std::unique_ptr<FreeBufferArena>& arena : per_core_arenas_) arena->Maintenance();
}
void BufferPool::BufferAllocator::ReleaseMemory(int64_t bytes_to_free) {
@@ -422,13 +421,13 @@ int BufferPool::BufferAllocator::GetFreeListSize(int core, int64_t len) {
return per_core_arenas_[core]->GetFreeListSize(len);
}
-int64_t BufferPool::BufferAllocator::FreeToSystem(vector<BufferHandle>&& buffers) {
+int64_t BufferPool::BufferAllocator::FreeToSystem(std::vector<BufferHandle>&& buffers) {
int64_t bytes_freed = 0;
for (BufferHandle& buffer : buffers) {
bytes_freed += buffer.len();
// Ensure that the memory is unpoisoned when it's next allocated by the system.
buffer.Unpoison();
- system_allocator_->Free(move(buffer));
+ system_allocator_->Free(std::move(buffer));
}
return bytes_freed;
}
@@ -436,7 +435,7 @@ int64_t BufferPool::BufferAllocator::FreeToSystem(vector<BufferHandle>&& buffers
int64_t BufferPool::BufferAllocator::SumOverArenas(
std::function<int64_t(FreeBufferArena* arena)> compute_fn) const {
int64_t total = 0;
- for (const unique_ptr<FreeBufferArena>& arena : per_core_arenas_) {
+ for (const std::unique_ptr<FreeBufferArena>& arena : per_core_arenas_) {
total += compute_fn(arena.get());
}
return total;
@@ -463,8 +462,8 @@ int64_t BufferPool::BufferAllocator::GetCleanPageBytes() const {
return clean_page_bytes_limit_ - clean_page_bytes_remaining_.load();
}
-string BufferPool::BufferAllocator::DebugString() {
- stringstream ss;
+std::string BufferPool::BufferAllocator::DebugString() {
+ std::stringstream ss;
ss << "<BufferAllocator> " << this << " min_buffer_len: " << min_buffer_len_
<< " system_bytes_limit: " << system_bytes_limit_
<< " system_bytes_remaining: " << system_bytes_remaining_.load() << "\n"
@@ -482,8 +481,8 @@ BufferPool::FreeBufferArena::~FreeBufferArena() {
for (int i = 0; i < NumBufferSizes(); ++i) {
// Clear out the free lists.
FreeList* list = &buffer_sizes_[i].free_buffers;
- vector<BufferHandle> buffers = list->GetBuffersToFree(list->Size());
- parent_->system_bytes_remaining_.add(parent_->FreeToSystem(move(buffers)));
+ std::vector<BufferHandle> buffers = list->GetBuffersToFree(list->Size());
+ parent_->system_bytes_remaining_.add(parent_->FreeToSystem(std::move(buffers)));
// All pages should have been destroyed.
DCHECK_EQ(0, buffer_sizes_[i].clean_pages.size());
@@ -491,19 +490,19 @@ BufferPool::FreeBufferArena::~FreeBufferArena() {
}
void BufferPool::FreeBufferArena::AddFreeBuffer(BufferHandle&& buffer) {
- lock_guard<SpinLock> al(lock_);
+ std::lock_guard<SpinLock> al(lock_);
if (config::disable_mem_pools) {
int64_t len = buffer.len();
- parent_->system_allocator_->Free(move(buffer));
+ parent_->system_allocator_->Free(std::move(buffer));
parent_->system_bytes_remaining_.add(len);
return;
}
PerSizeLists* lists = GetListsForSize(buffer.len());
- lists->AddFreeBuffer(move(buffer));
+ lists->AddFreeBuffer(std::move(buffer));
}
bool BufferPool::FreeBufferArena::RemoveCleanPage(bool claim_buffer, Page* page) {
- lock_guard<SpinLock> al(lock_);
+ std::lock_guard<SpinLock> al(lock_);
PerSizeLists* lists = GetListsForSize(page->len);
DCHECK_EQ(lists->num_clean_pages.load(), lists->clean_pages.size());
if (!lists->clean_pages.remove(page)) return false;
@@ -512,10 +511,10 @@ bool BufferPool::FreeBufferArena::RemoveCleanPage(bool claim_buffer, Page* page)
if (!claim_buffer) {
BufferHandle buffer;
{
- lock_guard<SpinLock> pl(page->buffer_lock);
- buffer = move(page->buffer);
+ std::lock_guard<SpinLock> pl(page->buffer_lock);
+ buffer = std::move(page->buffer);
}
- lists->AddFreeBuffer(move(buffer));
+ lists->AddFreeBuffer(std::move(buffer));
}
return true;
}
@@ -526,13 +525,13 @@ bool BufferPool::FreeBufferArena::PopFreeBuffer(
// Check before acquiring lock.
if (lists->num_free_buffers.load() == 0) return false;
- lock_guard<SpinLock> al(lock_);
+ std::lock_guard<SpinLock> al(lock_);
FreeList* list = &lists->free_buffers;
DCHECK_EQ(lists->num_free_buffers.load(), list->Size());
if (!list->PopFreeBuffer(buffer)) return false;
buffer->Unpoison();
lists->num_free_buffers.add(-1);
- lists->low_water_mark = min<int>(lists->low_water_mark, list->Size());
+ lists->low_water_mark = std::min<int>(lists->low_water_mark, list->Size());
return true;
}
/*
@@ -542,14 +541,14 @@ bool BufferPool::FreeBufferArena::EvictCleanPage(
// Check before acquiring lock.
if (lists->num_clean_pages.Load() == 0) return false;
- lock_guard<SpinLock> al(lock_);
+ std::lock_guard<SpinLock> al(lock_);
DCHECK_EQ(lists->num_clean_pages.Load(), lists->clean_pages.size());
Page* page = lists->clean_pages.dequeue();
if (page == nullptr) return false;
lists->num_clean_pages.Add(-1);
parent_->clean_page_bytes_remaining_.Add(buffer_len);
- lock_guard<SpinLock> pl(page->buffer_lock);
- *buffer = move(page->buffer);
+ std::lock_guard<SpinLock> pl(page->buffer_lock);
+ *buffer = std::move(page->buffer);
return true;
}
*/
@@ -565,7 +564,7 @@ std::pair<int64_t, int64_t> BufferPool::FreeBufferArena::FreeSystemMemory(
std::unique_lock<SpinLock> al(lock_, std::defer_lock_t());
if (arena_lock != nullptr) al.lock();
- vector<BufferHandle> buffers;
+ std::vector<BufferHandle> buffers;
// Search from largest to smallest to avoid freeing many small buffers unless
// necessary.
for (int i = NumBufferSizes() - 1; i >= 0; --i) {
@@ -584,7 +583,7 @@ std::pair<int64_t, int64_t> BufferPool::FreeBufferArena::FreeSystemMemory(
// Figure out how many of the buffers in the free list we should free.
DCHECK_GT(target_bytes_to_free, bytes_freed);
const int64_t buffer_len = 1L << (i + parent_->log_min_buffer_len_);
- int64_t buffers_to_free = min(free_buffers->Size(),
+ int64_t buffers_to_free = std::min(free_buffers->Size(),
BitUtil::Ceil(target_bytes_to_free - bytes_freed, buffer_len));
int64_t buffer_bytes_to_free = buffers_to_free * buffer_len;
@@ -598,14 +597,14 @@ std::pair<int64_t, int64_t> BufferPool::FreeBufferArena::FreeSystemMemory(
if (page == nullptr) break;
BufferHandle page_buffer;
{
- lock_guard<SpinLock> pl(page->buffer_lock);
- page_buffer = move(page->buffer);
+ std::lock_guard<SpinLock> pl(page->buffer_lock);
+ page_buffer = std::move(page->buffer);
}
++buffers_to_free;
buffer_bytes_to_free += page_buffer.len();
++num_pages_evicted;
page_bytes_evicted += page_buffer.len();
- free_buffers->AddFreeBuffer(move(page_buffer));
+ free_buffers->AddFreeBuffer(std::move(page_buffer));
}
lists->num_free_buffers.add(num_pages_evicted);
lists->num_clean_pages.add(-num_pages_evicted);
@@ -617,20 +616,20 @@ std::pair<int64_t, int64_t> BufferPool::FreeBufferArena::FreeSystemMemory(
DCHECK_EQ(buffer_bytes_to_free, buffer_bytes_freed);
bytes_freed += buffer_bytes_to_free;
lists->num_free_buffers.add(-buffers_to_free);
- lists->low_water_mark = min<int>(lists->low_water_mark, free_buffers->Size());
+ lists->low_water_mark = std::min<int>(lists->low_water_mark, free_buffers->Size());
if (bytes_freed >= target_bytes_to_free) break;
}
// Should have cleared out all lists if we don't have enough memory at this point.
DCHECK_EQ(0, free_buffers->Size());
DCHECK_EQ(0, clean_pages->size());
}
- int64_t bytes_claimed = min(bytes_freed, target_bytes_to_claim);
+ int64_t bytes_claimed = std::min(bytes_freed, target_bytes_to_claim);
if (bytes_freed > bytes_claimed) {
// Add back the extra for other threads before releasing the lock to avoid race
// where the other thread may not be able to find enough buffers.
parent_->system_bytes_remaining_.add(bytes_freed - bytes_claimed);
}
- if (arena_lock != nullptr) *arena_lock = move(al);
+ if (arena_lock != nullptr) *arena_lock = std::move(al);
return std::make_pair(bytes_freed, bytes_claimed);
}
@@ -638,23 +637,23 @@ void BufferPool::FreeBufferArena::AddCleanPage(Page* page) {
bool eviction_needed = config::disable_mem_pools
|| DecreaseBytesRemaining(
page->len, true, &parent_->clean_page_bytes_remaining_) == 0;
- lock_guard<SpinLock> al(lock_);
+ std::lock_guard<SpinLock> al(lock_);
PerSizeLists* lists = GetListsForSize(page->len);
DCHECK_EQ(lists->num_clean_pages.load(), lists->clean_pages.size());
if (eviction_needed) {
if (lists->clean_pages.empty()) {
// No other pages to evict, must evict 'page' instead of adding it.
- lists->AddFreeBuffer(move(page->buffer));
+ lists->AddFreeBuffer(std::move(page->buffer));
} else {
// Evict an older page (FIFO eviction) to make space for this one.
Page* page_to_evict = lists->clean_pages.dequeue();
lists->clean_pages.enqueue(page);
BufferHandle page_to_evict_buffer;
{
- lock_guard<SpinLock> pl(page_to_evict->buffer_lock);
- page_to_evict_buffer = move(page_to_evict->buffer);
+ std::lock_guard<SpinLock> pl(page_to_evict->buffer_lock);
+ page_to_evict_buffer = std::move(page_to_evict->buffer);
}
- lists->AddFreeBuffer(move(page_to_evict_buffer));
+ lists->AddFreeBuffer(std::move(page_to_evict_buffer));
}
} else {
lists->clean_pages.enqueue(page);
@@ -663,7 +662,7 @@ void BufferPool::FreeBufferArena::AddCleanPage(Page* page) {
}
void BufferPool::FreeBufferArena::Maintenance() {
- lock_guard<SpinLock> al(lock_);
+ std::lock_guard<SpinLock> al(lock_);
for (int i = 0; i < NumBufferSizes(); ++i) {
PerSizeLists* lists = &buffer_sizes_[i];
DCHECK_LE(lists->low_water_mark, lists->free_buffers.Size());
@@ -671,7 +670,7 @@ void BufferPool::FreeBufferArena::Maintenance() {
// We haven't needed the buffers below the low water mark since the previous
// Maintenance() call. Discard half of them to free up memory. By always discarding
// at least one, we guarantee that an idle list will shrink to zero entries.
- int num_to_free = max(1, lists->low_water_mark / 2);
+ int num_to_free = std::max(1, lists->low_water_mark / 2);
parent_->system_bytes_remaining_.add(
parent_->FreeToSystem(lists->free_buffers.GetBuffersToFree(num_to_free)));
lists->num_free_buffers.add(-num_to_free);
@@ -681,7 +680,7 @@ void BufferPool::FreeBufferArena::Maintenance() {
}
int BufferPool::FreeBufferArena::GetFreeListSize(int64_t len) {
- lock_guard<SpinLock> al(lock_);
+ std::lock_guard<SpinLock> al(lock_);
PerSizeLists* lists = GetListsForSize(len);
DCHECK_EQ(lists->num_free_buffers.load(), lists->free_buffers.Size());
return lists->free_buffers.Size();
@@ -715,9 +714,9 @@ int64_t BufferPool::FreeBufferArena::GetNumCleanPages() {
});
}
-string BufferPool::FreeBufferArena::DebugString() {
- lock_guard<SpinLock> al(lock_);
- stringstream ss;
+std::string BufferPool::FreeBufferArena::DebugString() {
+ std::lock_guard<SpinLock> al(lock_);
+ std::stringstream ss;
ss << "<FreeBufferArena> " << this << "\n";
for (int i = 0; i < NumBufferSizes(); ++i) {
int64_t buffer_len = 1L << (parent_->log_min_buffer_len_ + i);
@@ -726,7 +725,7 @@ string BufferPool::FreeBufferArena::DebugString() {
<< " free buffers: " << lists.num_free_buffers.load()
<< " low water mark: " << lists.low_water_mark
<< " clean pages: " << lists.num_clean_pages.load() << " ";
- lists.clean_pages.iterate(bind<bool>(Page::DebugStringCallback, &ss, _1));
+ lists.clean_pages.iterate(boost::bind<bool>(Page::DebugStringCallback, &ss, _1));
ss << "\n";
}
diff --git a/be/src/runtime/bufferpool/buffer_allocator.h b/be/src/runtime/bufferpool/buffer_allocator.h
index 5a8b4bf..185f6c4 100644
--- a/be/src/runtime/bufferpool/buffer_allocator.h
+++ b/be/src/runtime/bufferpool/buffer_allocator.h
@@ -102,7 +102,7 @@ struct BufferPool::BufferAllocator {
/// client's lock via 'client_lock' so that moving the page between the client list and
/// the free page list is atomic. Caller must not hold 'FreeBufferArena::lock_' or any
/// Page::lock.
- void AddCleanPage(const boost::unique_lock<boost::mutex>& client_lock, Page* page);
+ void AddCleanPage(const std::unique_lock<std::mutex>& client_lock, Page* page);
/// Removes a clean page 'page' from a clean page list and returns true, if present in
/// one of the lists. Returns true if it was present. If 'claim_buffer' is true, the
@@ -112,7 +112,7 @@ struct BufferPool::BufferAllocator {
/// client list and the free page list is atomic. Caller must not hold
/// 'FreeBufferArena::lock_' or any Page::lock.
bool RemoveCleanPage(
- const boost::unique_lock<boost::mutex>& client_lock, bool claim_buffer, Page* page);
+ const std::unique_lock<std::mutex>& client_lock, bool claim_buffer, Page* page);
/// Periodically called to release free buffers back to the SystemAllocator. Releases
/// buffers based on recent allocation patterns, trying to minimise the number of
diff --git a/be/src/runtime/bufferpool/buffer_pool.cc b/be/src/runtime/bufferpool/buffer_pool.cc
index da640f6..a09fff0 100644
--- a/be/src/runtime/bufferpool/buffer_pool.cc
+++ b/be/src/runtime/bufferpool/buffer_pool.cc
@@ -21,7 +21,7 @@
#include <sstream>
#include <boost/bind.hpp>
-#include "common/names.h"
+
#include "gutil/strings/substitute.h"
#include "runtime/bufferpool/buffer_allocator.h"
#include "util/bit_util.h"
@@ -145,7 +145,7 @@ Status BufferPool::CreatePage(
BufferHandle new_buffer;
// No changes have been made to state yet, so we can cleanly return on error.
RETURN_IF_ERROR(AllocateBuffer(client, len, &new_buffer));
- Page* page = client->impl_->CreatePinnedPage(move(new_buffer));
+ Page* page = client->impl_->CreatePinnedPage(std::move(new_buffer));
handle->Open(page, client);
if (buffer != nullptr) *buffer = &page->buffer;
return Status::OK();
@@ -243,7 +243,7 @@ void BufferPool::FreeBuffer(ClientHandle* client, BufferHandle* handle) {
if (!handle->is_open()) return; // Should be idempotent.
DCHECK_EQ(client, handle->client_);
int64_t len = handle->len_;
- allocator_->Free(move(*handle));
+ allocator_->Free(std::move(*handle));
client->impl_->FreedBuffer(len);
}
@@ -398,10 +398,10 @@ BufferPool::Client::Client(BufferPool* pool, //TmpFileMgr::FileGroup* file_group
BufferPool::Page* BufferPool::Client::CreatePinnedPage(BufferHandle&& buffer) {
Page* page = new Page(this, buffer.len());
- page->buffer = move(buffer);
+ page->buffer = std::move(buffer);
page->pin_count = 1;
- boost::lock_guard<boost::mutex> lock(lock_);
+ std::lock_guard<std::mutex> lock(lock_);
// The buffer is transferred to the page so will be accounted for in
// pinned_pages_.bytes() instead of buffers_allocated_bytes_.
buffers_allocated_bytes_ -= page->len;
@@ -418,7 +418,7 @@ void BufferPool::Client::DestroyPageInternal(
Page* page = handle->page_;
// Remove the page from the list that it is currently present in (if any).
{
- unique_lock<mutex> cl(lock_);
+ std::unique_lock<std::mutex> cl(lock_);
// First try to remove from the pinned or dirty unpinned lists.
if (!pinned_pages_.remove(page) && !dirty_unpinned_pages_.remove(page)) {
// The page either has a write in flight, is clean, or is evicted.
@@ -441,7 +441,7 @@ void BufferPool::Client::DestroyPageInternal(
*out_buffer = std::move(page->buffer);
buffers_allocated_bytes_ += out_buffer->len();
} else if (page->buffer.is_open()) {
- pool_->allocator_->Free(move(page->buffer));
+ pool_->allocator_->Free(std::move(page->buffer));
}
delete page;
handle->Reset();
@@ -453,7 +453,7 @@ void BufferPool::Client::MoveToDirtyUnpinned(Page* page) {
// DCHECK(spilling_enabled());
DCHECK_EQ(0, page->pin_count);
- unique_lock<mutex> lock(lock_);
+ std::unique_lock<std::mutex> lock(lock_);
DCHECK_CONSISTENCY();
DCHECK(pinned_pages_.contains(page));
pinned_pages_.remove(page);
@@ -464,7 +464,7 @@ void BufferPool::Client::MoveToDirtyUnpinned(Page* page) {
}
Status BufferPool::Client::StartMoveToPinned(ClientHandle* client, Page* page) {
- unique_lock<mutex> cl(lock_);
+ std::unique_lock<std::mutex> cl(lock_);
DCHECK_CONSISTENCY();
// Propagate any write errors that occurred for this client.
//RETURN_IF_ERROR(write_status_i;
@@ -503,7 +503,7 @@ Status BufferPool::Client::StartMoveToPinned(ClientHandle* client, Page* page) {
}
/*
Status BufferPool::Client::StartMoveEvictedToPinned(
- unique_lock<mutex>* client_lock, ClientHandle* client, Page* page) {
+ unique_lock<std::mutex>* client_lock, ClientHandle* client, Page* page) {
DCHECK(!page->buffer.is_open());
// Safe to modify the page's buffer handle without holding the page lock because no
@@ -529,7 +529,7 @@ void BufferPool::Client::UndoMoveEvictedToPinned(Page* page) {
page->write_handle->CancelRead();
page->pin_in_flight = false;
- unique_lock<mutex> lock(lock_);
+ unique_lock<std::mutex> lock(lock_);
DCHECK_CONSISTENCY();
DCHECK(pinned_pages_.contains(page));
pinned_pages_.remove(page);
@@ -553,7 +553,7 @@ Status BufferPool::Client::FinishMoveEvictedToPinned(Page* page) {
}
*/
Status BufferPool::Client::PrepareToAllocateBuffer(int64_t len) {
- unique_lock<mutex> lock(lock_);
+ std::unique_lock<std::mutex> lock(lock_);
// Clean enough pages to allow allocation to proceed without violating our eviction
// policy. This can fail, so only update the accounting once success is ensured.
//RETURN_IF_ERROR(CleanPages(&lock, len));
@@ -564,11 +564,11 @@ Status BufferPool::Client::PrepareToAllocateBuffer(int64_t len) {
}
Status BufferPool::Client::DecreaseReservationTo(int64_t target_bytes) {
- unique_lock<mutex> lock(lock_);
+ std::unique_lock<std::mutex> lock(lock_);
int64_t current_reservation = reservation_.GetReservation();
DCHECK_GE(current_reservation, target_bytes);
int64_t amount_to_free =
- min(reservation_.GetUnusedReservation(), current_reservation - target_bytes);
+ std::min(reservation_.GetUnusedReservation(), current_reservation - target_bytes);
if (amount_to_free == 0) return Status::OK();
// Clean enough pages to allow us to safely release reservation.
//RETURN_IF_ERROR(CleanPages(&lock, amount_to_free));
@@ -576,7 +576,7 @@ Status BufferPool::Client::DecreaseReservationTo(int64_t target_bytes) {
return Status::OK();
}
-Status BufferPool::Client::CleanPages(unique_lock<mutex>* client_lock, int64_t len) {
+Status BufferPool::Client::CleanPages(std::unique_lock<std::mutex>* client_lock, int64_t len) {
DCheckHoldsLock(*client_lock);
DCHECK_CONSISTENCY();
/*
@@ -635,7 +635,7 @@ void BufferPool::Client::WriteDirtyPagesAsync(int64_t min_bytes_to_write) {
Page* page = dirty_unpinned_pages_.tail(); // LIFO.
DCHECK(page != NULL) << "Should have been enough dirty unpinned pages";
{
- lock_guard<SpinLock> pl(page->buffer_lock);
+ std::lock_guard<SpinLock> pl(page->buffer_lock);
DCHECK(file_group_ != NULL);
DCHECK(page->buffer.is_open());
COUNTER_ADD(counters().bytes_written, page->len);
@@ -665,7 +665,7 @@ void BufferPool::Client::WriteCompleteCallback(Page* page, const Status& write_s
if (debug_write_delay_ms_ > 0) SleepForMs(debug_write_delay_ms_);
#endif
{
- unique_lock<mutex> cl(lock_);
+ std::unique_lock<std::mutex> cl(lock_);
DCHECK(in_flight_write_pages_.contains(page));
// The status should always be propagated.
// TODO: if we add cancellation support to TmpFileMgr, consider cancellation path.
@@ -683,7 +683,7 @@ void BufferPool::Client::WriteCompleteCallback(Page* page, const Status& write_s
}
}
-void BufferPool::Client::WaitForWrite(unique_lock<mutex>* client_lock, Page* page) {
+void BufferPool::Client::WaitForWrite(std::unique_lock<std::mutex>* client_lock, Page* page) {
DCheckHoldsLock(*client_lock);
while (in_flight_write_pages_.contains(page)) {
SCOPED_TIMER(counters().write_wait_time);
@@ -692,26 +692,26 @@ void BufferPool::Client::WaitForWrite(unique_lock<mutex>* client_lock, Page* pag
}
void BufferPool::Client::WaitForAllWrites() {
- unique_lock<mutex> cl(lock_);
+ std::unique_lock<std::mutex> cl(lock_);
while (in_flight_write_pages_.size() > 0) {
write_complete_cv_.Wait(cl);
}
}
*/
string BufferPool::Client::DebugString() {
- lock_guard<mutex> lock(lock_);
- stringstream ss;
+ std::lock_guard<std::mutex> lock(lock_);
+ std::stringstream ss;
ss << "<BufferPool::Client> " << this << " name: " << name_ << " write_status: "
<< write_status_.get_error_msg() << " buffers allocated " << buffers_allocated_bytes_
<< " num_pages: " << num_pages_ << " pinned_bytes: " << pinned_pages_.bytes()
<< " dirty_unpinned_bytes: " << dirty_unpinned_pages_.bytes() << " in_flight_write_bytes: "
<< in_flight_write_pages_.bytes() << " reservation: " << reservation_.DebugString();
ss << "\n " << pinned_pages_.size() << " pinned pages: ";
- pinned_pages_.iterate(bind<bool>(Page::DebugStringCallback, &ss, _1));
+ pinned_pages_.iterate(boost::bind<bool>(Page::DebugStringCallback, &ss, _1));
ss << "\n " << dirty_unpinned_pages_.size() << " dirty unpinned pages: ";
- dirty_unpinned_pages_.iterate(bind<bool>(Page::DebugStringCallback, &ss, _1));
+ dirty_unpinned_pages_.iterate(boost::bind<bool>(Page::DebugStringCallback, &ss, _1));
ss << "\n " << in_flight_write_pages_.size() << " in flight write pages: ";
- in_flight_write_pages_.iterate(bind<bool>(Page::DebugStringCallback, &ss, _1));
+ in_flight_write_pages_.iterate(boost::bind<bool>(Page::DebugStringCallback, &ss, _1));
return ss.str();
}
@@ -729,7 +729,7 @@ string BufferPool::ClientHandle::DebugString() const {
/*
string BufferPool::PageHandle::DebugString() const {
if (is_open()) {
- lock_guard<SpinLock> pl(page_->buffer_lock);
+ std::lock_guard<SpinLock> pl(page_->buffer_lock);
return Substitute("<BufferPool::PageHandle> $0 client: $1/$2 page: {$3}", this,
client_, client_->impl_, page_->DebugString());
} else {
@@ -744,8 +744,8 @@ string BufferPool::Page::DebugString() {
return ss.str();
}
-bool BufferPool::Page::DebugStringCallback(stringstream* ss, BufferPool::Page* page) {
- lock_guard<SpinLock> pl(page->buffer_lock);
+bool BufferPool::Page::DebugStringCallback(std::stringstream* ss, BufferPool::Page* page) {
+ std::lock_guard<SpinLock> pl(page->buffer_lock);
(*ss) << page->DebugString() << "\n";
return true;
}
@@ -762,7 +762,7 @@ string BufferPool::BufferHandle::DebugString() const {
}
string BufferPool::DebugString() {
- stringstream ss;
+ std::stringstream ss;
ss << "<BufferPool> " << this << " min_buffer_len: " << min_buffer_len_ << "\n"
<< allocator_->DebugString();
return ss.str();
diff --git a/be/src/runtime/bufferpool/buffer_pool_internal.h b/be/src/runtime/bufferpool/buffer_pool_internal.h
index 1ad3b02..01df1be 100644
--- a/be/src/runtime/bufferpool/buffer_pool_internal.h
+++ b/be/src/runtime/bufferpool/buffer_pool_internal.h
@@ -21,7 +21,7 @@
#include <memory>
#include <sstream>
-#include <boost/thread/mutex.hpp>
+#include <mutex>
#include "runtime/bufferpool/buffer_pool_counters.h"
#include "runtime/bufferpool/buffer_pool.h"
@@ -194,7 +194,7 @@ class BufferPool::Client {
/// internal accounting and release the buffer to the client's reservation. No page or
/// client locks should be held by the caller.
void FreedBuffer(int64_t len) {
- boost::lock_guard<boost::mutex> cl(lock_);
+ std::lock_guard<std::mutex> cl(lock_);
reservation_.ReleaseTo(len);
buffers_allocated_bytes_ -= len;
DCHECK_CONSISTENCY();
@@ -203,14 +203,14 @@ class BufferPool::Client {
/// Wait for the in-flight write for 'page' to complete.
/// 'lock_' must be held by the caller via 'client_lock'. page->buffer_lock should
/// not be held.
- //void WaitForWrite(boost::unique_lock<boost::mutex>* client_lock, Page* page);
+ //void WaitForWrite(boost::unique_lock<std::mutex>* client_lock, Page* page);
/// Test helper: wait for all in-flight writes to complete.
/// 'lock_' must not be held by the caller.
//void WaitForAllWrites();
/// Asserts that 'client_lock' is holding 'lock_'.
- void DCheckHoldsLock(const boost::unique_lock<boost::mutex>& client_lock) {
+ void DCheckHoldsLock(const std::unique_lock<std::mutex>& client_lock) {
DCHECK(client_lock.mutex() == &lock_ && client_lock.owns_lock());
}
@@ -246,7 +246,7 @@ class BufferPool::Client {
/// enough dirty pages are flushed to disk to satisfy the buffer pool's internal
/// invariants after the allocation. 'lock_' should be held by the caller via
/// 'client_lock'
- Status CleanPages(boost::unique_lock<boost::mutex>* client_lock, int64_t len);
+ Status CleanPages(std::unique_lock<std::mutex>* client_lock, int64_t len);
/// Initiates asynchronous writes of dirty unpinned pages to disk. Ensures that at
/// least 'min_bytes_to_write' bytes of writes will be written asynchronously. May
@@ -263,7 +263,7 @@ class BufferPool::Client {
/// locked by the caller via 'client_lock' and handle->page must be unlocked.
/// 'client_lock' is released then reacquired.
//Status StartMoveEvictedToPinned(
- // boost::unique_lock<boost::mutex>* client_lock, ClientHandle* client, Page* page);
+ // std::unique_lock<std::mutex>* client_lock, ClientHandle* client, Page* page);
/// The buffer pool that owns the client.
BufferPool* const pool_;
@@ -287,7 +287,7 @@ class BufferPool::Client {
int debug_write_delay_ms_;
/// Lock to protect the below member variables;
- boost::mutex lock_;
+ std::mutex lock_;
/// All non-OK statuses returned by write operations are merged into this status.
/// All operations that depend on pages being written to disk successfully (e.g.
diff --git a/be/src/runtime/bufferpool/reservation_tracker.cc b/be/src/runtime/bufferpool/reservation_tracker.cc
index 41620f3..fad7ab6 100644
--- a/be/src/runtime/bufferpool/reservation_tracker.cc
+++ b/be/src/runtime/bufferpool/reservation_tracker.cc
@@ -26,7 +26,7 @@
#include "util/dummy_runtime_profile.h"
#include "util/runtime_profile.h"
-#include "common/names.h"
+
#include "olap/utils.h"
namespace doris {
@@ -39,7 +39,7 @@ ReservationTracker::~ReservationTracker() {
void ReservationTracker::InitRootTracker(
RuntimeProfile* profile, int64_t reservation_limit) {
- lock_guard<SpinLock> l(lock_);
+ std::lock_guard<SpinLock> l(lock_);
DCHECK(!initialized_);
parent_ = nullptr;
mem_tracker_ = nullptr;
@@ -60,7 +60,7 @@ void ReservationTracker::InitChildTracker(RuntimeProfile* profile,
DCHECK(parent != nullptr);
DCHECK_GE(reservation_limit, 0);
- lock_guard<SpinLock> l(lock_);
+ std::lock_guard<SpinLock> l(lock_);
DCHECK(!initialized_);
parent_ = parent;
mem_tracker_ = mem_tracker;
@@ -118,7 +118,7 @@ void ReservationTracker::InitCounters(
}
void ReservationTracker::Close() {
- lock_guard<SpinLock> l(lock_);
+ std::lock_guard<SpinLock> l(lock_);
if (!initialized_) return;
CheckConsistency();
DCHECK_EQ(used_reservation_, 0);
@@ -131,12 +131,12 @@ void ReservationTracker::Close() {
}
bool ReservationTracker::IncreaseReservation(int64_t bytes) {
- lock_guard<SpinLock> l(lock_);
+ std::lock_guard<SpinLock> l(lock_);
return IncreaseReservationInternalLocked(bytes, false, false);
}
bool ReservationTracker::IncreaseReservationToFit(int64_t bytes) {
- lock_guard<SpinLock> l(lock_);
+ std::lock_guard<SpinLock> l(lock_);
return IncreaseReservationInternalLocked(bytes, true, false);
}
@@ -144,7 +144,7 @@ bool ReservationTracker::IncreaseReservationInternalLocked(
int64_t bytes, bool use_existing_reservation, bool is_child_reservation) {
DCHECK(initialized_);
int64_t reservation_increase =
- use_existing_reservation ? max<int64_t>(0, bytes - unused_reservation()) : bytes;
+ use_existing_reservation ? std::max<int64_t>(0, bytes - unused_reservation()) : bytes;
DCHECK_GE(reservation_increase, 0);
bool granted;
@@ -163,7 +163,7 @@ bool ReservationTracker::IncreaseReservationInternalLocked(
if (parent_ == nullptr) {
granted = true;
} else {
- lock_guard<SpinLock> l(parent_->lock_);
+ std::lock_guard<SpinLock> l(parent_->lock_);
granted =
parent_->IncreaseReservationInternalLocked(reservation_increase, true, true);
}
@@ -212,7 +212,7 @@ void ReservationTracker::ReleaseToMemTracker(int64_t reservation_decrease) {
}
void ReservationTracker::DecreaseReservation(int64_t bytes, bool is_child_reservation) {
- lock_guard<SpinLock> l(lock_);
+ std::lock_guard<SpinLock> l(lock_);
DecreaseReservationLocked(bytes, is_child_reservation);
}
@@ -232,8 +232,8 @@ void ReservationTracker::DecreaseReservationLocked(
bool ReservationTracker::TransferReservationTo(ReservationTracker* other, int64_t bytes) {
if (other == this) return true;
// Find the path to the root from both. The root is guaranteed to be a common ancestor.
- vector<ReservationTracker*> path_to_common = FindPathToRoot();
- vector<ReservationTracker*> other_path_to_common = other->FindPathToRoot();
+ std::vector<ReservationTracker*> path_to_common = FindPathToRoot();
+ std::vector<ReservationTracker*> other_path_to_common = other->FindPathToRoot();
DCHECK_EQ(path_to_common.back(), other_path_to_common.back());
ReservationTracker* common_ancestor = path_to_common.back();
// Remove any common ancestors - they do not need to be updated for this transfer.
@@ -259,7 +259,7 @@ bool ReservationTracker::TransferReservationTo(ReservationTracker* other, int64_
// Lock all of the trackers so we can do the update atomically. Need to be careful to
// lock subtrees in the correct order.
- vector<unique_lock<SpinLock>> locks;
+ std::vector<std::unique_lock<SpinLock>> locks;
bool lock_first = path_to_common.empty() || other_path_to_common.empty()
|| lock_sibling_subtree_first(path_to_common.back(), other_path_to_common.back());
if (lock_first) {
@@ -298,21 +298,21 @@ bool ReservationTracker::TransferReservationTo(ReservationTracker* other, int64_
// Update the 'child_reservations_' on the common ancestor if needed.
// Case 1: reservation was pushed up to 'other'.
if (common_ancestor == other) {
- lock_guard<SpinLock> l(other->lock_);
+ std::lock_guard<SpinLock> l(other->lock_);
other->child_reservations_ -= bytes;
other->CheckConsistency();
}
// Case 2: reservation was pushed down below 'this'.
if (common_ancestor == this) {
- lock_guard<SpinLock> l(lock_);
+ std::lock_guard<SpinLock> l(lock_);
child_reservations_ += bytes;
CheckConsistency();
}
return true;
}
-vector<ReservationTracker*> ReservationTracker::FindPathToRoot() {
- vector<ReservationTracker*> path_to_root;
+std::vector<ReservationTracker*> ReservationTracker::FindPathToRoot() {
+ std::vector<ReservationTracker*> path_to_root;
ReservationTracker* curr = this;
do {
path_to_root.push_back(curr);
@@ -322,7 +322,7 @@ vector<ReservationTracker*> ReservationTracker::FindPathToRoot() {
}
void ReservationTracker::AllocateFrom(int64_t bytes) {
- lock_guard<SpinLock> l(lock_);
+ std::lock_guard<SpinLock> l(lock_);
DCHECK(initialized_);
DCHECK_GE(bytes, 0);
DCHECK_LE(bytes, unused_reservation());
@@ -331,7 +331,7 @@ void ReservationTracker::AllocateFrom(int64_t bytes) {
}
void ReservationTracker::ReleaseTo(int64_t bytes) {
- lock_guard<SpinLock> l(lock_);
+ std::lock_guard<SpinLock> l(lock_);
DCHECK(initialized_);
DCHECK_GE(bytes, 0);
DCHECK_LE(bytes, used_reservation_);
@@ -340,25 +340,25 @@ void ReservationTracker::ReleaseTo(int64_t bytes) {
}
int64_t ReservationTracker::GetReservation() {
- lock_guard<SpinLock> l(lock_);
+ std::lock_guard<SpinLock> l(lock_);
DCHECK(initialized_);
return reservation_;
}
int64_t ReservationTracker::GetUsedReservation() {
- lock_guard<SpinLock> l(lock_);
+ std::lock_guard<SpinLock> l(lock_);
DCHECK(initialized_);
return used_reservation_;
}
int64_t ReservationTracker::GetUnusedReservation() {
- lock_guard<SpinLock> l(lock_);
+ std::lock_guard<SpinLock> l(lock_);
DCHECK(initialized_);
return unused_reservation();
}
int64_t ReservationTracker::GetChildReservations() {
- lock_guard<SpinLock> l(lock_);
+ std::lock_guard<SpinLock> l(lock_);
DCHECK(initialized_);
return child_reservations_;
}
@@ -397,11 +397,11 @@ void ReservationTracker::UpdateReservation(int64_t delta) {
CheckConsistency();
}
-string ReservationTracker::DebugString() {
- //lock_guard<SpinLock> l(lock_);
+std::string ReservationTracker::DebugString() {
+ //std::lock_guard<SpinLock> l(lock_);
if (!initialized_) return "<ReservationTracker>: uninitialized";
- string parent_debug_string = parent_ == nullptr ? "NULL" : parent_->DebugString();
+ std::string parent_debug_string = parent_ == nullptr ? "NULL" : parent_->DebugString();
std::stringstream ss;
ss << "<ReservationTracker>: reservation_limit " << reservation_limit_
<< " reservation " << reservation_ << " used_reservation " << used_reservation_
diff --git a/be/src/runtime/bufferpool/suballocator.cc b/be/src/runtime/bufferpool/suballocator.cc
index 80e6ae2..a6fc1ae 100644
--- a/be/src/runtime/bufferpool/suballocator.cc
+++ b/be/src/runtime/bufferpool/suballocator.cc
@@ -22,7 +22,7 @@
#include "runtime/bufferpool/reservation_tracker.h"
#include "util/bit_util.h"
-#include "common/names.h"
+
#include "gutil/strings/substitute.h"
namespace doris {
@@ -45,17 +45,17 @@ Suballocator::~Suballocator() {
}
}
-Status Suballocator::Allocate(int64_t bytes, unique_ptr<Suballocation>* result) {
+Status Suballocator::Allocate(int64_t bytes, std::unique_ptr<Suballocation>* result) {
DCHECK_GE(bytes, 0);
if (UNLIKELY(bytes > MAX_ALLOCATION_BYTES)) {
std::stringstream err_stream;
err_stream << "Requested memory allocation of " << bytes
- << " bytes, larger than max " << "supported of " << MAX_ALLOCATION_BYTES
+ << " bytes, larger than std::max " << "supported of " << MAX_ALLOCATION_BYTES
<< " bytes";
return Status::InternalError(err_stream.str());
}
- unique_ptr<Suballocation> free_node;
- bytes = max(bytes, MIN_ALLOCATION_BYTES);
+ std::unique_ptr<Suballocation> free_node;
+ bytes = std::max(bytes, MIN_ALLOCATION_BYTES);
const int target_list_idx = ComputeListIndex(bytes);
for (int i = target_list_idx; i < NUM_FREE_LISTS; ++i) {
free_node = PopFreeListHead(i);
@@ -74,13 +74,13 @@ Status Suballocator::Allocate(int64_t bytes, unique_ptr<Suballocation>* result)
// Free node may be larger than required.
const int free_list_idx = ComputeListIndex(free_node->len_);
if (free_list_idx != target_list_idx) {
- RETURN_IF_ERROR(SplitToSize(move(free_node), bytes, &free_node));
+ RETURN_IF_ERROR(SplitToSize(std::move(free_node), bytes, &free_node));
DCHECK(free_node != nullptr);
}
free_node->in_use_ = true;
allocated_ += free_node->len_;
- *result = move(free_node);
+ *result = std::move(free_node);
return Status::OK();
}
@@ -89,34 +89,34 @@ int Suballocator::ComputeListIndex(int64_t bytes) const {
}
uint64_t Suballocator::ComputeAllocateBufferSize(int64_t bytes) const {
- bytes = max(bytes, MIN_ALLOCATION_BYTES);
+ bytes = std::max(bytes, MIN_ALLOCATION_BYTES);
const int target_list_idx = ComputeListIndex(bytes);
for (int i = target_list_idx; i < NUM_FREE_LISTS; ++i) {
if (CheckFreeListHeadNotNull(i)) return 0;
}
- return max(min_buffer_len_, BitUtil::RoundUpToPowerOfTwo(bytes));
+ return std::max(min_buffer_len_, BitUtil::RoundUpToPowerOfTwo(bytes));
}
-Status Suballocator::AllocateBuffer(int64_t bytes, unique_ptr<Suballocation>* result) {
+Status Suballocator::AllocateBuffer(int64_t bytes, std::unique_ptr<Suballocation>* result) {
DCHECK_LE(bytes, MAX_ALLOCATION_BYTES);
- const int64_t buffer_len = max(min_buffer_len_, BitUtil::RoundUpToPowerOfTwo(bytes));
+ const int64_t buffer_len = std::max(min_buffer_len_, BitUtil::RoundUpToPowerOfTwo(bytes));
if (!client_->IncreaseReservationToFit(buffer_len)) {
*result = nullptr;
return Status::OK();
}
- unique_ptr<Suballocation> free_node;
+ std::unique_ptr<Suballocation> free_node;
RETURN_IF_ERROR(Suballocation::Create(&free_node));
RETURN_IF_ERROR(pool_->AllocateBuffer(client_, buffer_len, &free_node->buffer_));
free_node->data_ = free_node->buffer_.data();
free_node->len_ = buffer_len;
- *result = move(free_node);
+ *result = std::move(free_node);
return Status::OK();
}
-Status Suballocator::SplitToSize(unique_ptr<Suballocation> free_node,
- int64_t target_bytes, unique_ptr<Suballocation>* result) {
+Status Suballocator::SplitToSize(std::unique_ptr<Suballocation> free_node,
+ int64_t target_bytes, std::unique_ptr<Suballocation>* result) {
DCHECK(!free_node->in_use_);
DCHECK_GT(free_node->len_, target_bytes);
@@ -127,12 +127,12 @@ Status Suballocator::SplitToSize(unique_ptr<Suballocation> free_node,
// Need two nodes per level for the left and right children.
const int num_nodes = (free_list_idx - target_list_idx) * 2;
constexpr int MAX_NUM_NODES = NUM_FREE_LISTS * 2;
- unique_ptr<Suballocation> nodes[MAX_NUM_NODES];
+ std::unique_ptr<Suballocation> nodes[MAX_NUM_NODES];
for (int i = 0; i < num_nodes; ++i) {
if (!Suballocation::Create(&nodes[i]).ok()) {
// Add the free node to the free list to restore the allocator to an internally
// consistent state.
- AddToFreeList(move(free_node));
+ AddToFreeList(std::move(free_node));
return Status::InternalError("Failed to allocate list node in Suballocator");
}
}
@@ -142,8 +142,8 @@ Status Suballocator::SplitToSize(unique_ptr<Suballocation> free_node,
int next_node = 0;
for (int i = free_list_idx; i > target_list_idx; --i) {
DCHECK_EQ(free_node->len_, 1LL << (i + LOG_MIN_ALLOCATION_BYTES));
- unique_ptr<Suballocation> left_child = move(nodes[next_node++]);
- unique_ptr<Suballocation> right_child = move(nodes[next_node++]);
+ std::unique_ptr<Suballocation> left_child = std::move(nodes[next_node++]);
+ std::unique_ptr<Suballocation> right_child = std::move(nodes[next_node++]);
DCHECK_LE(next_node, num_nodes);
const int64_t child_len = free_node->len_ / 2;
@@ -153,16 +153,16 @@ Status Suballocator::SplitToSize(unique_ptr<Suballocation> free_node,
left_child->buddy_ = right_child.get();
right_child->buddy_ = left_child.get();
free_node->in_use_ = true;
- left_child->parent_ = move(free_node);
+ left_child->parent_ = std::move(free_node);
- AddToFreeList(move(right_child));
- free_node = move(left_child);
+ AddToFreeList(std::move(right_child));
+ free_node = std::move(left_child);
}
- *result = move(free_node);
+ *result = std::move(free_node);
return Status::OK();
}
-uint64_t Suballocator::Free(unique_ptr<Suballocation> allocation) {
+uint64_t Suballocator::Free(std::unique_ptr<Suballocation> allocation) {
if (allocation == nullptr) return 0;
DCHECK(allocation->in_use_);
@@ -172,15 +172,15 @@ uint64_t Suballocator::Free(unique_ptr<Suballocation> allocation) {
// Iteratively coalesce buddies until the buddy is in use or we get to the root.
// This ensures that all buddies in the free lists are coalesced. I.e. we do not
// have two buddies in the same free list.
- unique_ptr<Suballocation> curr_allocation = move(allocation);
+ std::unique_ptr<Suballocation> curr_allocation = std::move(allocation);
while (curr_allocation->buddy_ != nullptr) {
if (curr_allocation->buddy_->in_use_) {
// If the buddy is not free we can't coalesce, just add it to free list.
- AddToFreeList(move(curr_allocation));
+ AddToFreeList(std::move(curr_allocation));
return 0;
}
- unique_ptr<Suballocation> buddy = RemoveFromFreeList(curr_allocation->buddy_);
- curr_allocation = CoalesceBuddies(move(curr_allocation), move(buddy));
+ std::unique_ptr<Suballocation> buddy = RemoveFromFreeList(curr_allocation->buddy_);
+ curr_allocation = CoalesceBuddies(std::move(curr_allocation), std::move(buddy));
}
// Reached root, which is an entire free buffer. We are not using it, so free up memory.
@@ -191,18 +191,18 @@ uint64_t Suballocator::Free(unique_ptr<Suballocation> allocation) {
return free_len;
}
-void Suballocator::AddToFreeList(unique_ptr<Suballocation> node) {
+void Suballocator::AddToFreeList(std::unique_ptr<Suballocation> node) {
DCHECK(!node->in_use_);
int list_idx = ComputeListIndex(node->len_);
if (free_lists_[list_idx] != nullptr) {
free_lists_[list_idx]->prev_free_ = node.get();
}
- node->next_free_ = move(free_lists_[list_idx]);
+ node->next_free_ = std::move(free_lists_[list_idx]);
DCHECK(node->prev_free_ == nullptr);
- free_lists_[list_idx] = move(node);
+ free_lists_[list_idx] = std::move(node);
}
-unique_ptr<Suballocation> Suballocator::RemoveFromFreeList(Suballocation* node) {
+std::unique_ptr<Suballocation> Suballocator::RemoveFromFreeList(Suballocation* node) {
DCHECK(node != nullptr);
const int list_idx = ComputeListIndex(node->len_);
@@ -210,23 +210,23 @@ unique_ptr<Suballocation> Suballocator::RemoveFromFreeList(Suballocation* node)
node->next_free_->prev_free_ = node->prev_free_;
}
- unique_ptr<Suballocation>* ptr_from_prev = node->prev_free_ == nullptr ?
+ std::unique_ptr<Suballocation>* ptr_from_prev = node->prev_free_ == nullptr ?
&free_lists_[list_idx] :
&node->prev_free_->next_free_;
node->prev_free_ = nullptr;
- unique_ptr<Suballocation> result = move(*ptr_from_prev);
- *ptr_from_prev = move(node->next_free_);
+ std::unique_ptr<Suballocation> result = std::move(*ptr_from_prev);
+ *ptr_from_prev = std::move(node->next_free_);
return result;
}
-unique_ptr<Suballocation> Suballocator::PopFreeListHead(int list_idx) {
+std::unique_ptr<Suballocation> Suballocator::PopFreeListHead(int list_idx) {
if (free_lists_[list_idx] == nullptr) return nullptr;
- unique_ptr<Suballocation> result = move(free_lists_[list_idx]);
+ std::unique_ptr<Suballocation> result = std::move(free_lists_[list_idx]);
DCHECK(result->prev_free_ == nullptr);
if (result->next_free_ != nullptr) {
result->next_free_->prev_free_ = nullptr;
}
- free_lists_[list_idx] = move(result->next_free_);
+ free_lists_[list_idx] = std::move(result->next_free_);
return result;
}
@@ -234,25 +234,25 @@ bool Suballocator::CheckFreeListHeadNotNull(int list_idx) const {
return free_lists_[list_idx] != nullptr;
}
-unique_ptr<Suballocation> Suballocator::CoalesceBuddies(
- unique_ptr<Suballocation> b1, unique_ptr<Suballocation> b2) {
+std::unique_ptr<Suballocation> Suballocator::CoalesceBuddies(
+ std::unique_ptr<Suballocation> b1, std::unique_ptr<Suballocation> b2) {
DCHECK(!b1->in_use_);
DCHECK(!b2->in_use_);
DCHECK_EQ(b1->buddy_, b2.get());
DCHECK_EQ(b2->buddy_, b1.get());
// Only the left child's parent should be present.
DCHECK((b1->parent_ != nullptr) ^ (b2->parent_ != nullptr));
- unique_ptr<Suballocation> parent =
- b1->parent_ != nullptr ? move(b1->parent_) : move(b2->parent_);
+ std::unique_ptr<Suballocation> parent =
+ b1->parent_ != nullptr ? std::move(b1->parent_) : std::move(b2->parent_);
parent->in_use_ = false;
return parent;
}
-Status Suballocation::Create(unique_ptr<Suballocation>* new_suballocation) {
+Status Suballocation::Create(std::unique_ptr<Suballocation>* new_suballocation) {
// Allocate from system allocator for simplicity. We don't expect this to be
// performance critical or to be used for small allocations where CPU/memory
// overhead of these allocations might be a consideration.
- new_suballocation->reset(new (nothrow) Suballocation());
+ new_suballocation->reset(new (std::nothrow) Suballocation());
if (*new_suballocation == nullptr) {
return Status::MemoryAllocFailed("allocate memory failed");
}
diff --git a/be/src/runtime/bufferpool/system_allocator.cc b/be/src/runtime/bufferpool/system_allocator.cc
index 1bbfbb9..f59e3d8 100644
--- a/be/src/runtime/bufferpool/system_allocator.cc
+++ b/be/src/runtime/bufferpool/system_allocator.cc
@@ -24,7 +24,7 @@
#include "gutil/strings/substitute.h"
#include "util/bit_util.h"
-#include "common/names.h"
+
#include "common/config.h"
#include "util/error_util.h"
diff --git a/be/src/runtime/initial_reservations.cc b/be/src/runtime/initial_reservations.cc
index bd2d0e1..76d7a23 100644
--- a/be/src/runtime/initial_reservations.cc
+++ b/be/src/runtime/initial_reservations.cc
@@ -29,7 +29,7 @@
#include "util/uid_util.h"
#include "util/pretty_printer.h"
-#include "common/names.h"
+
using std::numeric_limits;
@@ -62,7 +62,7 @@ Status InitialReservations::Init(
void InitialReservations::Claim(BufferPool::ClientHandle* dst, int64_t bytes) {
DCHECK_GE(bytes, 0);
- lock_guard<SpinLock> l(lock_);
+ std::lock_guard<SpinLock> l(lock_);
DCHECK_LE(bytes, remaining_initial_reservation_claims_);
bool success = dst->TransferReservationFrom(&initial_reservations_, bytes);
DCHECK(success) << "Planner computation should ensure enough initial reservations";
@@ -70,7 +70,7 @@ void InitialReservations::Claim(BufferPool::ClientHandle* dst, int64_t bytes) {
}
void InitialReservations::Return(BufferPool::ClientHandle* src, int64_t bytes) {
- lock_guard<SpinLock> l(lock_);
+ std::lock_guard<SpinLock> l(lock_);
bool success = src->TransferReservationTo(&initial_reservations_, bytes);
// No limits on our tracker - no way this should fail.
DCHECK(success);
diff --git a/be/src/runtime/mem_pool.cpp b/be/src/runtime/mem_pool.cpp
index 61b70c9..3faa173 100644
--- a/be/src/runtime/mem_pool.cpp
+++ b/be/src/runtime/mem_pool.cpp
@@ -25,7 +25,7 @@
#include <stdio.h>
#include <sstream>
-#include "common/names.h"
+
namespace doris {
@@ -114,7 +114,7 @@ bool MemPool::find_chunk(size_t min_size, bool check_limits) {
chunk_size = std::max<size_t>(min_size, alignof(max_align_t));
} else {
DCHECK_GE(next_chunk_size_, INITIAL_CHUNK_SIZE);
- chunk_size = max<size_t>(min_size, next_chunk_size_);
+ chunk_size = std::max<size_t>(min_size, next_chunk_size_);
}
chunk_size = BitUtil::RoundUpToPowerOfTwo(chunk_size);
@@ -141,7 +141,7 @@ bool MemPool::find_chunk(size_t min_size, bool check_limits) {
total_reserved_bytes_ += chunk_size;
// Don't increment the chunk size until the allocation succeeds: if an attempted
// large allocation fails we don't want to increase the chunk size further.
- next_chunk_size_ = static_cast<int>(min<int64_t>(chunk_size * 2, MAX_CHUNK_SIZE));
+ next_chunk_size_ = static_cast<int>(std::min<int64_t>(chunk_size * 2, MAX_CHUNK_SIZE));
DCHECK(check_integrity(true));
return true;
@@ -217,8 +217,8 @@ void MemPool::exchange_data(MemPool* other) {
other->mem_tracker_->Release(delta_size);
}
-string MemPool::debug_string() {
- stringstream out;
+std::string MemPool::debug_string() {
+ std::stringstream out;
char str[16];
out << "MemPool(#chunks=" << chunks_.size() << " [";
for (int i = 0; i < chunks_.size(); ++i) {
diff --git a/be/src/runtime/mem_tracker.cpp b/be/src/runtime/mem_tracker.cpp
index f52befd..1461328 100644
--- a/be/src/runtime/mem_tracker.cpp
+++ b/be/src/runtime/mem_tracker.cpp
@@ -46,17 +46,17 @@ using std::pair;
using std::priority_queue;
using std::shared_ptr;
using std::string;
-using std::unique_ptr;
+
using std::vector;
using std::weak_ptr;
using strings::Substitute;
namespace doris {
-const string MemTracker::COUNTER_NAME = "PeakMemoryUsage";
+const std::string MemTracker::COUNTER_NAME = "PeakMemoryUsage";
// Name for request pool MemTrackers. '$0' is replaced with the pool name.
-const string REQUEST_POOL_MEM_TRACKER_LABEL_FORMAT = "RequestPool=$0";
+const std::string REQUEST_POOL_MEM_TRACKER_LABEL_FORMAT = "RequestPool=$0";
/// Calculate the soft limit for a MemTracker based on the hard limit 'limit'.
static int64_t CalcSoftLimit(int64_t limit) {
@@ -225,7 +225,7 @@ std::shared_ptr<MemTracker> PoolMemTrackerRegistry::GetRequestPoolMemTracker(
if (!create_if_not_present) return nullptr;
// First time this pool_name registered, make a new object.
std::shared_ptr<MemTracker> tracker = MemTracker::CreateTracker(
- -1, Substitute(REQUEST_POOL_MEM_TRACKER_LABEL_FORMAT, pool_name),
+ -1, strings::Substitute(REQUEST_POOL_MEM_TRACKER_LABEL_FORMAT, pool_name),
ExecEnv::GetInstance()->process_mem_tracker());
tracker->pool_name_ = pool_name;
pool_to_mem_trackers_.emplace(pool_name, std::shared_ptr<MemTracker>(tracker));
@@ -272,16 +272,16 @@ void MemTracker::ListTrackers(vector<shared_ptr<MemTracker>>* trackers) {
}
//void MemTracker::RegisterMetrics(MetricGroup* metrics, const string& prefix) {
-// num_gcs_metric_ = metrics->AddCounter(Substitute("$0.num-gcs", prefix), 0);
+// num_gcs_metric_ = metrics->AddCounter(strings::Substitute("$0.num-gcs", prefix), 0);
//
// // TODO: Consider a total amount of bytes freed counter
// bytes_freed_by_last_gc_metric_ = metrics->AddGauge(
-// Substitute("$0.bytes-freed-by-last-gc", prefix), -1);
+// strings::Substitute("$0.bytes-freed-by-last-gc", prefix), -1);
//
// bytes_over_limit_metric_ = metrics->AddGauge(
-// Substitute("$0.bytes-over-limit", prefix), -1);
+// strings::Substitute("$0.bytes-over-limit", prefix), -1);
//
-// limit_metric_ = metrics->AddGauge(Substitute("$0.limit", prefix), limit_);
+// limit_metric_ = metrics->AddGauge(strings::Substitute("$0.limit", prefix), limit_);
//}
void MemTracker::TransferTo(MemTracker* dst, int64_t bytes) {
@@ -324,7 +324,7 @@ void MemTracker::TransferTo(MemTracker* dst, int64_t bytes) {
// TrackerName: Limit=5.00 MB Reservation=5.00 MB OtherMemory=1.04 MB
// Total=6.04 MB Peak=6.45 MB
//
-string MemTracker::LogUsage(int max_recursive_depth, const string& prefix,
+std::string MemTracker::LogUsage(int max_recursive_depth, const string& prefix,
int64_t* logged_consumption) {
// Make sure the consumption is up to date.
if (consumption_metric_ != nullptr) RefreshConsumptionFromMetric();
@@ -334,7 +334,7 @@ string MemTracker::LogUsage(int max_recursive_depth, const string& prefix,
if (!log_usage_if_zero_ && curr_consumption == 0) return "";
- stringstream ss;
+ std::stringstream ss;
ss << prefix << label_ << ":";
if (CheckLimitExceeded(MemLimit::HARD)) ss << " memory limit exceeded.";
if (limit_ > 0) ss << " Limit=" << PrettyPrinter::print(limit_, TUnit::BYTES);
@@ -363,9 +363,9 @@ string MemTracker::LogUsage(int max_recursive_depth, const string& prefix,
if (max_recursive_depth == 0) return ss.str();
// Recurse and get information about the children
- string new_prefix = Substitute(" $0", prefix);
+ std::string new_prefix = strings::Substitute(" $0", prefix);
int64_t child_consumption;
- string child_trackers_usage;
+ std::string child_trackers_usage;
list<weak_ptr<MemTracker>> children;
{
lock_guard<SpinLock> l(child_trackers_lock_);
@@ -387,15 +387,15 @@ string MemTracker::LogUsage(int max_recursive_depth, const string& prefix,
return ss.str();
}
-string MemTracker::LogUsage(int max_recursive_depth, const string& prefix,
+std::string MemTracker::LogUsage(int max_recursive_depth, const string& prefix,
const list<weak_ptr<MemTracker>>& trackers, int64_t* logged_consumption) {
*logged_consumption = 0;
- vector<string> usage_strings;
+ std::vector<string> usage_strings;
for (const auto& tracker_weak : trackers) {
shared_ptr<MemTracker> tracker = tracker_weak.lock();
if (tracker) {
int64_t tracker_consumption;
- string usage_string = tracker->LogUsage(max_recursive_depth, prefix,
+ std::string usage_string = tracker->LogUsage(max_recursive_depth, prefix,
&tracker_consumption);
if (!usage_string.empty()) usage_strings.push_back(usage_string);
*logged_consumption += tracker_consumption;
@@ -404,14 +404,14 @@ string MemTracker::LogUsage(int max_recursive_depth, const string& prefix,
return join(usage_strings, "\n");
}
-string MemTracker::LogTopNQueries(int limit) {
+std::string MemTracker::LogTopNQueries(int limit) {
if (limit == 0) return "";
if (this->is_query_mem_tracker_) return LogUsage(0);
- priority_queue<pair<int64_t, string>, vector<pair<int64_t, string>>,
+ priority_queue<pair<int64_t, string>, std::vector<pair<int64_t, string>>,
std::greater<pair<int64_t, string>>>
min_pq;
GetTopNQueries(min_pq, limit);
- vector<string> usage_strings(min_pq.size());
+ std::vector<string> usage_strings(min_pq.size());
while (!min_pq.empty()) {
usage_strings.push_back(min_pq.top().second);
min_pq.pop();
@@ -421,7 +421,7 @@ string MemTracker::LogTopNQueries(int limit) {
}
void MemTracker::GetTopNQueries(
- priority_queue<pair<int64_t, string>, vector<pair<int64_t, string>>,
+ priority_queue<pair<int64_t, string>, std::vector<pair<int64_t, string>>,
greater<pair<int64_t, string>>>& min_pq,
int limit) {
list<weak_ptr<MemTracker>> children;
@@ -453,22 +453,22 @@ MemTracker* MemTracker::GetQueryMemTracker() {
Status MemTracker::MemLimitExceeded(MemTracker* mtracker, RuntimeState* state,
const std::string& details, int64_t failed_allocation_size) {
DCHECK_GE(failed_allocation_size, 0);
- stringstream ss;
- if (!details.empty()) ss << details << endl;
+ std::stringstream ss;
+ if (!details.empty()) ss << details << std::endl;
if (failed_allocation_size != 0) {
if (mtracker != nullptr) ss << mtracker->label();
ss << " could not allocate "
<< PrettyPrinter::print(failed_allocation_size, TUnit::BYTES)
- << " without exceeding limit." << endl;
+ << " without exceeding limit." << std::endl;
}
ss << "Error occurred on backend " << BackendOptions::get_localhost();
if (state != nullptr) ss << " by fragment " << print_id(state->fragment_instance_id());
- ss << endl;
+ ss << std::endl;
ExecEnv* exec_env = ExecEnv::GetInstance();
MemTracker* process_tracker = exec_env->process_mem_tracker().get();
const int64_t process_capacity = process_tracker->SpareCapacity(MemLimit::HARD);
ss << "Memory left in process limit: "
- << PrettyPrinter::print(process_capacity, TUnit::BYTES) << endl;
+ << PrettyPrinter::print(process_capacity, TUnit::BYTES) << std::endl;
// Always log the query tracker (if available).
MemTracker* query_tracker = nullptr;
@@ -479,7 +479,7 @@ Status MemTracker::MemLimitExceeded(MemTracker* mtracker, RuntimeState* state,
const int64_t query_capacity =
query_tracker->limit() - query_tracker->consumption();
ss << "Memory left in query limit: "
- << PrettyPrinter::print(query_capacity, TUnit::BYTES) << endl;
+ << PrettyPrinter::print(query_capacity, TUnit::BYTES) << std::endl;
}
ss << query_tracker->LogUsage(UNLIMITED_DEPTH);
}
diff --git a/be/src/runtime/raw_value.cpp b/be/src/runtime/raw_value.cpp
index c0fa6fb..eca1a39 100644
--- a/be/src/runtime/raw_value.cpp
+++ b/be/src/runtime/raw_value.cpp
@@ -195,7 +195,7 @@ void RawValue::print_value(const void* value, const TypeDescriptor& type, int sc
std::string tmp;
bool val = false;
- // Special case types that we can print more efficiently without using a stringstream
+ // Special case types that we can print more efficiently without using a std::stringstream
switch (type.type) {
case TYPE_BOOLEAN:
val = *reinterpret_cast<const bool*>(value);
diff --git a/be/src/runtime/row_batch.cpp b/be/src/runtime/row_batch.cpp
index 2fd4fcf..9775ff2 100644
--- a/be/src/runtime/row_batch.cpp
+++ b/be/src/runtime/row_batch.cpp
@@ -130,7 +130,7 @@ RowBatch::RowBatch(const RowDescriptor& row_desc,
if (!_row_desc.has_varlen_slots()) {
return;
}
- const vector<TupleDescriptor*>& tuple_descs = _row_desc.tuple_descriptors();
+ const std::vector<TupleDescriptor*>& tuple_descs = _row_desc.tuple_descriptors();
// For every unique tuple, convert string offsets contained in tuple data into
// pointers. Tuples were serialized in the order we are deserializing them in,
@@ -138,7 +138,7 @@ RowBatch::RowBatch(const RowDescriptor& row_desc,
// we already converted.
for (int i = 0; i < _num_rows; ++i) {
TupleRow* row = get_row(i);
- vector<TupleDescriptor*>::const_iterator desc = tuple_descs.begin();
+ std::vector<TupleDescriptor*>::const_iterator desc = tuple_descs.begin();
for (int j = 0; desc != tuple_descs.end(); ++desc, ++j) {
if ((*desc)->string_slots().empty()) {
continue;
@@ -231,7 +231,7 @@ RowBatch::RowBatch(const RowDescriptor& row_desc, const TRowBatch& input_batch,
if (!_row_desc.has_varlen_slots()) {
return;
}
- const vector<TupleDescriptor*>& tuple_descs = _row_desc.tuple_descriptors();
+ const std::vector<TupleDescriptor*>& tuple_descs = _row_desc.tuple_descriptors();
// For every unique tuple, convert string offsets contained in tuple data into
// pointers. Tuples were serialized in the order we are deserializing them in,
@@ -239,7 +239,7 @@ RowBatch::RowBatch(const RowDescriptor& row_desc, const TRowBatch& input_batch,
// we already converted.
for (int i = 0; i < _num_rows; ++i) {
TupleRow* row = get_row(i);
- vector<TupleDescriptor*>::const_iterator desc = tuple_descs.begin();
+ std::vector<TupleDescriptor*>::const_iterator desc = tuple_descs.begin();
for (int j = 0; desc != tuple_descs.end(); ++desc, ++j) {
if ((*desc)->string_slots().empty()) {
continue;
@@ -250,7 +250,7 @@ RowBatch::RowBatch(const RowDescriptor& row_desc, const TRowBatch& input_batch,
continue;
}
- vector<SlotDescriptor*>::const_iterator slot = (*desc)->string_slots().begin();
+ std::vector<SlotDescriptor*>::const_iterator slot = (*desc)->string_slots().begin();
for (; slot != (*desc)->string_slots().end(); ++slot) {
DCHECK((*slot)->type().is_string_type());
StringValue* string_val = tuple->get_string_slot((*slot)->tuple_offset());
@@ -321,8 +321,8 @@ int RowBatch::serialize(TRowBatch* output_batch) {
for (int i = 0; i < _num_rows; ++i) {
TupleRow* row = get_row(i);
- const vector<TupleDescriptor*>& tuple_descs = _row_desc.tuple_descriptors();
- vector<TupleDescriptor*>::const_iterator desc = tuple_descs.begin();
+ const std::vector<TupleDescriptor*>& tuple_descs = _row_desc.tuple_descriptors();
+ std::vector<TupleDescriptor*>::const_iterator desc = tuple_descs.begin();
for (int j = 0; desc != tuple_descs.end(); ++desc, ++j) {
if (row->get_tuple(j) == NULL) {
@@ -389,8 +389,8 @@ int RowBatch::serialize(PRowBatch* output_batch) {
char* tuple_data = const_cast<char*>(mutable_tuple_data->data());
for (int i = 0; i < _num_rows; ++i) {
TupleRow* row = get_row(i);
- const vector<TupleDescriptor*>& tuple_descs = _row_desc.tuple_descriptors();
- vector<TupleDescriptor*>::const_iterator desc = tuple_descs.begin();
+ const std::vector<TupleDescriptor*>& tuple_descs = _row_desc.tuple_descriptors();
+ std::vector<TupleDescriptor*>::const_iterator desc = tuple_descs.begin();
for (int j = 0; desc != tuple_descs.end(); ++desc, ++j) {
if (row->get_tuple(j) == nullptr) {
// NULLs are encoded as -1
@@ -615,8 +615,8 @@ int RowBatch::total_byte_size() {
// Sum total variable length byte sizes.
for (int i = 0; i < _num_rows; ++i) {
TupleRow* row = get_row(i);
- const vector<TupleDescriptor*>& tuple_descs = _row_desc.tuple_descriptors();
- vector<TupleDescriptor*>::const_iterator desc = tuple_descs.begin();
+ const std::vector<TupleDescriptor*>& tuple_descs = _row_desc.tuple_descriptors();
+ std::vector<TupleDescriptor*>::const_iterator desc = tuple_descs.begin();
for (int j = 0; desc != tuple_descs.end(); ++desc, ++j) {
Tuple* tuple = row->get_tuple(j);
@@ -624,7 +624,7 @@ int RowBatch::total_byte_size() {
continue;
}
result += (*desc)->byte_size();
- vector<SlotDescriptor*>::const_iterator slot = (*desc)->string_slots().begin();
+ std::vector<SlotDescriptor*>::const_iterator slot = (*desc)->string_slots().begin();
for (; slot != (*desc)->string_slots().end(); ++slot) {
DCHECK((*slot)->type().is_string_type());
if (tuple->is_null((*slot)->null_indicator_offset())) {
diff --git a/be/src/tools/meta_tool.cpp b/be/src/tools/meta_tool.cpp
index 916dd92..05ffa09 100644
--- a/be/src/tools/meta_tool.cpp
+++ b/be/src/tools/meta_tool.cpp
@@ -191,7 +191,7 @@ void batch_delete_meta(const std::string& tablet_file) {
std::unordered_map<std::string, std::unique_ptr<DataDir>> dir_map;
while (std::getline(infile, line)) {
total_num++;
- vector<string> v = strings::Split(line, ",");
+ std::vector<string> v = strings::Split(line, ",");
if (v.size() != 3) {
std::cout << "invalid line in tablet_file: " << line << std::endl;
err_num++;
@@ -263,7 +263,7 @@ Status get_segment_footer(RandomAccessFile* input_file, SegmentFooterPB* footer)
RETURN_IF_ERROR(input_file->size(&file_size));
if (file_size < 12) {
- return Status::Corruption(Substitute("Bad segment file $0: file size $1 < 12", file_name, file_size));
+ return Status::Corruption(strings::Substitute("Bad segment file $0: file size $1 < 12", file_name, file_size));
}
uint8_t fixed_buf[12];
@@ -273,14 +273,14 @@ Status get_segment_footer(RandomAccessFile* input_file, SegmentFooterPB* footer)
const char* k_segment_magic = "D0R1";
const uint32_t k_segment_magic_length = 4;
if (memcmp(fixed_buf + 8, k_segment_magic, k_segment_magic_length) != 0) {
- return Status::Corruption(Substitute("Bad segment file $0: magic number not match", file_name));
+ return Status::Corruption(strings::Substitute("Bad segment file $0: magic number not match", file_name));
}
// read footer PB
uint32_t footer_length = doris::decode_fixed32_le(fixed_buf);
if (file_size < 12 + footer_length) {
return Status::Corruption(
- Substitute("Bad segment file $0: file size $1 < $2", file_name, file_size, 12 + footer_length));
+ strings::Substitute("Bad segment file $0: file size $1 < $2", file_name, file_size, 12 + footer_length));
}
std::string footer_buf;
footer_buf.resize(footer_length);
@@ -291,13 +291,13 @@ Status get_segment_footer(RandomAccessFile* input_file, SegmentFooterPB* footer)
uint32_t actual_checksum = doris::crc32c::Value(footer_buf.data(), footer_buf.size());
if (actual_checksum != expect_checksum) {
return Status::Corruption(
- Substitute("Bad segment file $0: footer checksum not match, actual=$1 vs expect=$2",
+ strings::Substitute("Bad segment file $0: footer checksum not match, actual=$1 vs expect=$2",
file_name, actual_checksum, expect_checksum));
}
// deserialize footer PB
if (!footer->ParseFromString(footer_buf)) {
- return Status::Corruption(Substitute("Bad segment file $0: failed to parse SegmentFooterPB", file_name));
+ return Status::Corruption(strings::Substitute("Bad segment file $0: failed to parse SegmentFooterPB", file_name));
}
return Status::OK();
}
diff --git a/be/src/util/arrow/row_batch.cpp b/be/src/util/arrow/row_batch.cpp
index c799e3b..4caef49 100644
--- a/be/src/util/arrow/row_batch.cpp
+++ b/be/src/util/arrow/row_batch.cpp
@@ -83,7 +83,7 @@ Status convert_to_arrow_type(const TypeDescriptor& type,
*result = std::make_shared<arrow::Decimal128Type>(27, 9);
break;
default:
- return Status::InvalidArgument(Substitute("Unknown primitive type($0)", type.type));
+ return Status::InvalidArgument(strings::Substitute("Unknown primitive type($0)", type.type));
}
return Status::OK();
}
@@ -133,7 +133,7 @@ Status convert_to_doris_type(const arrow::DataType& type,
builder->type(TYPE_DOUBLE);
break;
default:
- return Status::InvalidArgument(Substitute("Unknown arrow type id($0)", type.id()));
+ return Status::InvalidArgument(strings::Substitute("Unknown arrow type id($0)", type.id()));
}
return Status::OK();
}
diff --git a/be/src/util/arrow/row_block.cpp b/be/src/util/arrow/row_block.cpp
index b6e60bc..ca78b4a 100644
--- a/be/src/util/arrow/row_block.cpp
+++ b/be/src/util/arrow/row_block.cpp
@@ -59,7 +59,7 @@ Status convert_to_arrow_type(FieldType type, std::shared_ptr<arrow::DataType> *r
*result = arrow::float64();
break;
default:
- return Status::InvalidArgument(Substitute("Unknown FieldType($0)", type));
+ return Status::InvalidArgument(strings::Substitute("Unknown FieldType($0)", type));
}
return Status::OK();
}
@@ -69,7 +69,7 @@ Status convert_to_arrow_field(uint32_t cid,
std::shared_ptr<arrow::Field>* result) {
std::shared_ptr<arrow::DataType> type;
RETURN_IF_ERROR(convert_to_arrow_type(field->type(), &type));
- *result = arrow::field(Substitute("Col$0", cid), type, field->is_nullable());
+ *result = arrow::field(strings::Substitute("Col$0", cid), type, field->is_nullable());
return Status::OK();
}
@@ -108,7 +108,7 @@ Status convert_to_type_name(const arrow::DataType& type,
*name = "DOUBLE";
break;
default:
- return Status::InvalidArgument(Substitute("Unknown arrow type id($0)", type.id()));
+ return Status::InvalidArgument(strings::Substitute("Unknown arrow type id($0)", type.id()));
}
return Status::OK();
}
diff --git a/be/src/util/block_compression.cpp b/be/src/util/block_compression.cpp
index cc631e1..b65119d 100644
--- a/be/src/util/block_compression.cpp
+++ b/be/src/util/block_compression.cpp
@@ -54,7 +54,7 @@ public:
LZ4_compress_default(input.data, output->data, input.size, output->size);
if (compressed_len == 0) {
return Status::InvalidArgument(
- Substitute("Output buffer's capacity is not enough, size=$0", output->size));
+ strings::Substitute("Output buffer's capacity is not enough, size=$0", output->size));
}
output->size = compressed_len;
return Status::OK();
@@ -65,7 +65,7 @@ public:
LZ4_decompress_safe(input.data, output->data, input.size, output->size);
if (decompressed_len < 0) {
return Status::InvalidArgument(
- Substitute("fail to do LZ4 decompress, error=$0", decompressed_len));
+ strings::Substitute("fail to do LZ4 decompress, error=$0", decompressed_len));
}
output->size = decompressed_len;
return Status::OK();
@@ -91,7 +91,7 @@ public:
LZ4F_compressFrame(output->data, output->size, input.data, input.size, &_s_preferences);
if (LZ4F_isError(compressed_len)) {
return Status::InvalidArgument(
- Substitute("Fail to do LZ4F compress frame, msg=$0",
+ strings::Substitute("Fail to do LZ4F compress frame, msg=$0",
LZ4F_getErrorName(compressed_len)));
}
output->size = compressed_len;
@@ -103,7 +103,7 @@ public:
auto lres = LZ4F_createCompressionContext(&ctx, LZ4F_VERSION);
if (lres != 0) {
return Status::InvalidArgument(
- Substitute("Fail to do LZ4F compress, res=$0", LZ4F_getErrorName(lres)));
+ strings::Substitute("Fail to do LZ4F compress, res=$0", LZ4F_getErrorName(lres)));
}
auto st = _compress(ctx, inputs, output);
LZ4F_freeCompressionContext(ctx);
@@ -115,7 +115,7 @@ public:
auto lres = LZ4F_createDecompressionContext(&ctx, LZ4F_VERSION);
if (LZ4F_isError(lres)) {
return Status::InvalidArgument(
- Substitute("Fail to do LZ4F decompress, res=$0", LZ4F_getErrorName(lres)));
+ strings::Substitute("Fail to do LZ4F decompress, res=$0", LZ4F_getErrorName(lres)));
}
auto st = _decompress(ctx, input, output);
LZ4F_freeDecompressionContext(ctx);
@@ -132,7 +132,7 @@ private:
auto wbytes = LZ4F_compressBegin(ctx, output->data, output->size, &_s_preferences);
if (LZ4F_isError(wbytes)) {
return Status::InvalidArgument(
- Substitute("Fail to do LZ4F compress begin, res=$0", LZ4F_getErrorName(wbytes)));
+ strings::Substitute("Fail to do LZ4F compress begin, res=$0", LZ4F_getErrorName(wbytes)));
}
size_t offset = wbytes;
for (auto input : inputs) {
@@ -142,7 +142,7 @@ private:
nullptr);
if (LZ4F_isError(wbytes)) {
return Status::InvalidArgument(
- Substitute("Fail to do LZ4F compress update, res=$0", LZ4F_getErrorName(wbytes)));
+ strings::Substitute("Fail to do LZ4F compress update, res=$0", LZ4F_getErrorName(wbytes)));
}
offset += wbytes;
}
@@ -151,7 +151,7 @@ private:
nullptr);
if (LZ4F_isError(wbytes)) {
return Status::InvalidArgument(
- Substitute("Fail to do LZ4F compress end, res=$0", LZ4F_getErrorName(wbytes)));
+ strings::Substitute("Fail to do LZ4F compress end, res=$0", LZ4F_getErrorName(wbytes)));
}
offset += wbytes;
output->size = offset;
@@ -165,14 +165,14 @@ private:
LZ4F_decompress(ctx, output->data, &output->size, input.data, &input_size, nullptr);
if (LZ4F_isError(lres)) {
return Status::InvalidArgument(
- Substitute("Fail to do LZ4F decompress, res=$0", LZ4F_getErrorName(lres)));
+ strings::Substitute("Fail to do LZ4F decompress, res=$0", LZ4F_getErrorName(lres)));
} else if (input_size != input.size) {
return Status::InvalidArgument(
- Substitute("Fail to do LZ4F decompress: trailing data left in compressed data, read=$0 vs given=$1",
+ strings::Substitute("Fail to do LZ4F decompress: trailing data left in compressed data, read=$0 vs given=$1",
input_size, input.size));
} else if (lres != 0) {
return Status::InvalidArgument(
- Substitute("Fail to do LZ4F decompress: expect more compressed data, expect=$0", lres));
+ strings::Substitute("Fail to do LZ4F decompress: expect more compressed data, expect=$0", lres));
}
return Status::OK();
}
@@ -306,7 +306,7 @@ public:
auto zres = ::compress((Bytef*)output->data, &output->size, (Bytef*)input.data, input.size);
if (zres != Z_OK) {
return Status::InvalidArgument(
- Substitute("Fail to do ZLib compress, error=$0", zError(zres)));
+ strings::Substitute("Fail to do ZLib compress, error=$0", zError(zres)));
}
return Status::OK();
}
@@ -319,7 +319,7 @@ public:
auto zres = deflateInit(&zstrm, Z_DEFAULT_COMPRESSION);
if (zres != Z_OK) {
return Status::InvalidArgument(
- Substitute("Fail to do ZLib stream compress, error=$0, res=$1",
+ strings::Substitute("Fail to do ZLib stream compress, error=$0, res=$1",
zError(zres), zres));
}
// we assume that output is e
@@ -336,7 +336,7 @@ public:
zres = deflate(&zstrm, flush);
if (zres != Z_OK && zres != Z_STREAM_END) {
return Status::InvalidArgument(
- Substitute("Fail to do ZLib stream compress, error=$0, res=$1",
+ strings::Substitute("Fail to do ZLib stream compress, error=$0, res=$1",
zError(zres), zres));
}
}
@@ -345,7 +345,7 @@ public:
zres = deflateEnd(&zstrm);
if (zres != Z_OK) {
return Status::InvalidArgument(
- Substitute("Fail to do deflateEnd on ZLib stream, error=$0, res=$1",
+ strings::Substitute("Fail to do deflateEnd on ZLib stream, error=$0, res=$1",
zError(zres), zres));
}
return Status::OK();
@@ -356,7 +356,7 @@ public:
auto zres = ::uncompress2((Bytef*)output->data, &output->size, (Bytef*)input.data, &input_size);
if (zres != Z_OK) {
return Status::InvalidArgument(
- Substitute("Fail to do ZLib decompress, error=$0", zError(zres)));
+ strings::Substitute("Fail to do ZLib decompress, error=$0", zError(zres)));
}
return Status::OK();
}
@@ -386,7 +386,7 @@ Status get_block_compression_codec(
*codec = ZlibBlockCompression::instance();
break;
default:
- return Status::NotFound(Substitute("unknown compression type($0)", type));
+ return Status::NotFound(strings::Substitute("unknown compression type($0)", type));
}
return Status::OK();
}
diff --git a/be/src/util/cgroup_util.cpp b/be/src/util/cgroup_util.cpp
index 43b0ec1..4fd6316 100644
--- a/be/src/util/cgroup_util.cpp
+++ b/be/src/util/cgroup_util.cpp
@@ -30,7 +30,7 @@
#include "util/file_utils.h"
#include "util/string_parser.hpp"
-#include "common/names.h"
+
using strings::CUnescape;
using strings::Split;
@@ -40,14 +40,14 @@ using std::pair;
namespace doris {
Status CGroupUtil::find_global_cgroup(const string& subsystem, string* path) {
- ifstream proc_cgroups("/proc/self/cgroup", ios::in);
+ std::ifstream proc_cgroups("/proc/self/cgroup", std::ios::in);
string line;
while (true) {
if (proc_cgroups.fail()) {
- return Status::IOError(Substitute("Error reading /proc/self/cgroup: $0", get_str_err_msg()));
+ return Status::IOError(strings::Substitute("Error reading /proc/self/cgroup: $0", get_str_err_msg()));
} else if (proc_cgroups.peek() == std::ifstream::traits_type::eof()) {
return Status::NotFound(
- Substitute("Could not find subsystem $0 in /proc/self/cgroup", subsystem));
+ strings::Substitute("Could not find subsystem $0 in /proc/self/cgroup", subsystem));
}
// The line format looks like this:
// 4:memory:/user.slice
@@ -57,16 +57,16 @@ Status CGroupUtil::find_global_cgroup(const string& subsystem, string* path) {
if (!proc_cgroups.good()) {
continue;
}
- vector<string> fields = Split(line, ":");
+ std::vector<string> fields = Split(line, ":");
// ":" in the path does not appear to be escaped - bail in the unusual case that
// we get too many tokens.
if (fields.size() != 3) {
return Status::InvalidArgument(
- Substitute(
+ strings::Substitute(
"Could not parse line from /proc/self/cgroup - had $0 > 3 tokens: '$1'",
fields.size(), line));
}
- vector<string> subsystems = Split(fields[1], ",");
+ std::vector<string> subsystems = Split(fields[1], ",");
auto it = std::find(subsystems.begin(), subsystems.end(), subsystem);
if (it != subsystems.end()) {
*path = move(fields[2]);
@@ -78,17 +78,17 @@ Status CGroupUtil::find_global_cgroup(const string& subsystem, string* path) {
static Status unescape_path(const string& escaped, string* unescaped) {
string err;
if (!CUnescape(escaped, unescaped, &err)) {
- return Status::InvalidArgument(Substitute("Could not unescape path '$0': $1", escaped, err));
+ return Status::InvalidArgument(strings::Substitute("Could not unescape path '$0': $1", escaped, err));
}
return Status::OK();
}
static Status read_cgroup_value(const string& limit_file_path, int64_t* val) {
- ifstream limit_file(limit_file_path, ios::in);
+ std::ifstream limit_file(limit_file_path, std::ios::in);
string line;
getline(limit_file, line);
if (limit_file.fail() || limit_file.bad()) {
- return Status::IOError(Substitute("Error reading $0: $1", limit_file_path, get_str_err_msg()));
+ return Status::IOError(strings::Substitute("Error reading $0: $1", limit_file_path, get_str_err_msg()));
}
StringParser::ParseResult pr;
// Parse into an an int64_t If it overflows, returning the max value of int64_t is ok because that
@@ -96,21 +96,21 @@ static Status read_cgroup_value(const string& limit_file_path, int64_t* val) {
*val = StringParser::string_to_int<int64_t>(line.c_str(), line.size(), &pr);
if ((pr != StringParser::PARSE_SUCCESS && pr != StringParser::PARSE_OVERFLOW)) {
return Status::InvalidArgument(
- Substitute("Failed to parse $0 as int64: '$1'", limit_file_path, line));
+ strings::Substitute("Failed to parse $0 as int64: '$1'", limit_file_path, line));
}
return Status::OK();
}
Status CGroupUtil::find_cgroup_mounts(
const string& subsystem, pair<string, string>* result) {
- ifstream mountinfo("/proc/self/mountinfo", ios::in);
+ std::ifstream mountinfo("/proc/self/mountinfo", std::ios::in);
string line;
while (true) {
if (mountinfo.fail() || mountinfo.bad()) {
- return Status::IOError(Substitute("Error reading /proc/self/mountinfo: $0", get_str_err_msg()));
+ return Status::IOError(strings::Substitute("Error reading /proc/self/mountinfo: $0", get_str_err_msg()));
} else if (mountinfo.eof()) {
return Status::NotFound(
- Substitute("Could not find subsystem $0 in /proc/self/mountinfo",
+ strings::Substitute("Could not find subsystem $0 in /proc/self/mountinfo",
subsystem));
}
// The relevant lines look like below (see proc manpage for full documentation). The
@@ -123,16 +123,16 @@ Status CGroupUtil::find_cgroup_mounts(
// ro,nosuid,nodev,noexec,relatime master:15 - cgroup cgroup rw,memory
getline(mountinfo, line);
if (!mountinfo.good()) continue;
- vector<string> fields = Split(line, " ", SkipWhitespace());
+ std::vector<string> fields = Split(line, " ", SkipWhitespace());
if (fields.size() < 7) {
return Status::InvalidArgument(
- Substitute(
+ strings::Substitute(
"Could not parse line from /proc/self/mountinfo - had $0 > 7 tokens: '$1'",
fields.size(), line));
}
if (fields[fields.size() - 3] != "cgroup") continue;
// This is a cgroup mount. Check if it's the mount we're looking for.
- vector<string> cgroup_opts = Split(fields[fields.size() - 1], ",", SkipWhitespace());
+ std::vector<string> cgroup_opts = Split(fields[fields.size() - 1], ",", SkipWhitespace());
auto it = std::find(cgroup_opts.begin(), cgroup_opts.end(), subsystem);
if (it == cgroup_opts.end()) {
continue;
@@ -157,7 +157,7 @@ Status CGroupUtil::find_abs_cgroup_path(const string& subsystem, string* path) {
const string& system_path = paths.second;
if (path->compare(0, system_path.size(), system_path) != 0) {
return Status::InvalidArgument(
- Substitute("Expected CGroup path '$0' to start with '$1'",
+ strings::Substitute("Expected CGroup path '$0' to start with '$1'",
*path, system_path));
}
path->replace(0, system_path.size(), mount_path);
@@ -209,7 +209,7 @@ std::string CGroupUtil::debug_string() {
int64_t mem_limit;
Status status = find_cgroup_mem_limit(&mem_limit);
if (status.ok()) {
- mem_limit_str = Substitute("$0", mem_limit);
+ mem_limit_str = strings::Substitute("$0", mem_limit);
} else {
mem_limit_str = status.get_error_msg();
}
@@ -227,7 +227,7 @@ std::string CGroupUtil::debug_string() {
} else {
cpu_limit_str = status.get_error_msg();
}
- return Substitute("Process CGroup Info: memory.limit_in_bytes=$0, cpu cfs limits: $1", mem_limit_str, cpu_limit_str);
+ return strings::Substitute("Process CGroup Info: memory.limit_in_bytes=$0, cpu cfs limits: $1", mem_limit_str, cpu_limit_str);
}
bool CGroupUtil::enable() {
diff --git a/be/src/util/cpu_info.cpp b/be/src/util/cpu_info.cpp
index 650e41a..eceeb32 100755
--- a/be/src/util/cpu_info.cpp
+++ b/be/src/util/cpu_info.cpp
@@ -53,7 +53,7 @@
#include "util/pretty_printer.h"
#include "util/string_parser.hpp"
-#include "common/names.h"
+
using boost::algorithm::contains;
using boost::algorithm::trim;
@@ -70,12 +70,12 @@ namespace doris {
// first line. If the file cannot be opened, no error is reported.
void WarnIfFileNotEqual(
const string& filename, const string& expected, const string& warning_text) {
- ifstream file(filename);
+ std::ifstream file(filename);
if (!file) return;
string line;
getline(file, line);
if (line != expected) {
- LOG(ERROR) << "Expected " << expected << ", actual " << line << endl << warning_text;
+ LOG(ERROR) << "Expected " << expected << ", actual " << line << std::endl << warning_text;
}
}
} // end anonymous namespace
@@ -88,11 +88,11 @@ int64_t CpuInfo::original_hardware_flags_;
int64_t CpuInfo::cycles_per_ms_;
int CpuInfo::num_cores_ = 1;
int CpuInfo::max_num_cores_ = 1;
-string CpuInfo::model_name_ = "unknown";
+std::string CpuInfo::model_name_ = "unknown";
int CpuInfo::max_num_numa_nodes_;
-unique_ptr<int[]> CpuInfo::core_to_numa_node_;
-vector<vector<int>> CpuInfo::numa_node_to_cores_;
-vector<int> CpuInfo::numa_node_core_idx_;
+std::unique_ptr<int[]> CpuInfo::core_to_numa_node_;
+std::vector<vector<int>> CpuInfo::numa_node_to_cores_;
+std::vector<int> CpuInfo::numa_node_core_idx_;
static struct {
string name;
@@ -132,7 +132,7 @@ void CpuInfo::init() {
int num_cores = 0;
// Read from /proc/cpuinfo
- ifstream cpuinfo("/proc/cpuinfo");
+ std::ifstream cpuinfo("/proc/cpuinfo");
while (cpuinfo) {
getline(cpuinfo, line);
size_t colon = line.find(':');
@@ -221,7 +221,7 @@ void CpuInfo::_init_numa() {
for (int core = 0; core < max_num_cores_; ++core) {
bool found_numa_node = false;
for (int node = 0; node < max_num_numa_nodes_; ++node) {
- if (fs::exists(Substitute("/sys/devices/system/cpu/cpu$0/node$1", core, node))) {
+ if (fs::exists(strings::Substitute("/sys/devices/system/cpu/cpu$0/node$1", core, node))) {
core_to_numa_node_[core] = node;
found_numa_node = true;
break;
@@ -237,7 +237,7 @@ void CpuInfo::_init_numa() {
}
void CpuInfo::_init_fake_numa_for_test(
- int max_num_numa_nodes, const vector<int>& core_to_numa_node) {
+ int max_num_numa_nodes, const std::vector<int>& core_to_numa_node) {
DCHECK_EQ(max_num_cores_, core_to_numa_node.size());
max_num_numa_nodes_ = max_num_numa_nodes;
for (int i = 0; i < max_num_cores_; ++i) {
@@ -252,7 +252,7 @@ void CpuInfo::_init_numa_node_to_cores() {
numa_node_to_cores_.resize(max_num_numa_nodes_);
numa_node_core_idx_.resize(max_num_cores_);
for (int core = 0; core < max_num_cores_; ++core) {
- vector<int>* cores_of_node = &numa_node_to_cores_[core_to_numa_node_[core]];
+ std::vector<int>* cores_of_node = &numa_node_to_cores_[core_to_numa_node_[core]];
numa_node_core_idx_[core] = cores_of_node->size();
cores_of_node->push_back(core);
}
@@ -268,8 +268,8 @@ void CpuInfo::verify_cpu_requirements() {
void CpuInfo::verify_performance_governor() {
for (int cpu_id = 0; cpu_id < CpuInfo::num_cores(); ++cpu_id) {
const string governor_file =
- Substitute("/sys/devices/system/cpu/cpu$0/cpufreq/scaling_governor", cpu_id);
- const string warning_text = Substitute(
+ strings::Substitute("/sys/devices/system/cpu/cpu$0/cpufreq/scaling_governor", cpu_id);
+ const string warning_text = strings::Substitute(
"WARNING: CPU $0 is not using 'performance' governor. Note that changing the "
"governor to 'performance' will reset the no_turbo setting to 0.",
cpu_id);
@@ -346,41 +346,41 @@ void CpuInfo::_get_cache_info(long cache_sizes[NUM_CACHE_LEVELS],
#endif
}
-string CpuInfo::debug_string() {
+std::string CpuInfo::debug_string() {
DCHECK(initialized_);
- stringstream stream;
+ std::stringstream stream;
long cache_sizes[NUM_CACHE_LEVELS];
long cache_line_sizes[NUM_CACHE_LEVELS];
_get_cache_info(cache_sizes, cache_line_sizes);
- string L1 = Substitute("L1 Cache: $0 (Line: $1)",
+ string L1 = strings::Substitute("L1 Cache: $0 (Line: $1)",
PrettyPrinter::print(cache_sizes[L1_CACHE], TUnit::BYTES),
PrettyPrinter::print(cache_line_sizes[L1_CACHE], TUnit::BYTES));
- string L2 = Substitute("L2 Cache: $0 (Line: $1)",
+ string L2 = strings::Substitute("L2 Cache: $0 (Line: $1)",
PrettyPrinter::print(cache_sizes[L2_CACHE], TUnit::BYTES),
PrettyPrinter::print(cache_line_sizes[L2_CACHE], TUnit::BYTES));
- string L3 = Substitute("L3 Cache: $0 (Line: $1)",
+ string L3 = strings::Substitute("L3 Cache: $0 (Line: $1)",
PrettyPrinter::print(cache_sizes[L3_CACHE], TUnit::BYTES),
PrettyPrinter::print(cache_line_sizes[L3_CACHE], TUnit::BYTES));
- stream << "Cpu Info:" << endl
- << " Model: " << model_name_ << endl
- << " Cores: " << num_cores_ << endl
- << " Max Possible Cores: " << max_num_cores_ << endl
- << " " << L1 << endl
- << " " << L2 << endl
- << " " << L3 << endl
- << " Hardware Supports:" << endl;
+ stream << "Cpu Info:" << std::endl
+<< " Model: " << model_name_ << std::endl
+<< " Cores: " << num_cores_ << std::endl
+<< " Max Possible Cores: " << max_num_cores_ << std::endl
+<< " " << L1 << std::endl
+<< " " << L2 << std::endl
+<< " " << L3 << std::endl
+<< " Hardware Supports:" << std::endl;
for (int i = 0; i < num_flags; ++i) {
if (is_supported(flag_mappings[i].flag)) {
- stream << " " << flag_mappings[i].name << endl;
+ stream << " " << flag_mappings[i].name << std::endl;
}
}
- stream << " Numa Nodes: " << max_num_numa_nodes_ << endl;
+ stream << " Numa Nodes: " << max_num_numa_nodes_ << std::endl;
stream << " Numa Nodes of Cores:";
for (int core = 0; core < max_num_cores_; ++core) {
stream << " " << core << "->" << core_to_numa_node_[core] << " |";
}
- stream << endl;
+ stream << std::endl;
return stream.str();
}
diff --git a/be/src/util/file_utils.cpp b/be/src/util/file_utils.cpp
index b8db85f..0277fde 100644
--- a/be/src/util/file_utils.cpp
+++ b/be/src/util/file_utils.cpp
@@ -45,7 +45,7 @@ using strings::Substitute;
Status FileUtils::create_dir(const std::string& path, Env* env) {
if (path.empty()) {
- return Status::InvalidArgument(Substitute("Unknown primitive type($0)", path));
+ return Status::InvalidArgument(strings::Substitute("Unknown primitive type($0)", path));
}
boost::filesystem::path p(path);
diff --git a/be/src/util/os_info.cpp b/be/src/util/os_info.cpp
index 33b4096..a37afc8 100755
--- a/be/src/util/os_info.cpp
+++ b/be/src/util/os_info.cpp
@@ -25,12 +25,12 @@
#include <unistd.h>
-#include "common/names.h"
+
namespace doris {
bool OsInfo::initialized_ = false;
-string OsInfo::os_version_ = "Unknown";
+std::string OsInfo::os_version_ = "Unknown";
clockid_t OsInfo::fast_clock_ = CLOCK_MONOTONIC;
std::string OsInfo::clock_name_ =
"Unknown clocksource, clockid_t defaulting to CLOCK_MONOTONIC";
@@ -47,7 +47,7 @@ std::string OsInfo::clock_name_ =
void OsInfo::Init() {
DCHECK(!initialized_);
// Read from /proc/version
- ifstream version("/proc/version", ios::in);
+ std::ifstream version("/proc/version", std::ios::in);
if (version.good()) getline(version, os_version_);
if (version.is_open()) version.close();
@@ -73,11 +73,10 @@ void OsInfo::Init() {
initialized_ = true;
}
-string OsInfo::DebugString() {
+std::string OsInfo::DebugString() {
DCHECK(initialized_);
- stringstream stream;
- stream << "OS version: " << os_version_ << endl
- << "Clock: " << clock_name_ << endl;
+ std::stringstream stream;
+ stream << "OS version: " << os_version_ << std::endl << "Clock: " << clock_name_ << std::endl;
return stream.str();
}
diff --git a/be/src/util/os_util.cpp b/be/src/util/os_util.cpp
index 15aed51..892f7cd 100644
--- a/be/src/util/os_util.cpp
+++ b/be/src/util/os_util.cpp
@@ -79,7 +79,7 @@ Status parse_stat(const std::string& buffer, std::string* name, ThreadStats* sta
}
string extracted_name = buffer.substr(open_paren + 1, close_paren - (open_paren + 1));
string rest = buffer.substr(close_paren + 2);
- vector<string> splits = Split(rest, " ", strings::SkipEmpty());
+ std::vector<string> splits = Split(rest, " ", strings::SkipEmpty());
if (splits.size() < kMaxOffset) {
return Status::IOError("Unrecognised /proc format");
}
@@ -107,7 +107,7 @@ Status get_thread_stats(int64_t tid, ThreadStats* stats) {
}
faststring buf;
RETURN_IF_ERROR(env_util::read_file_to_string(
- Env::Default(), Substitute("/proc/self/task/$0/stat", tid), &buf));
+ Env::Default(), strings::Substitute("/proc/self/task/$0/stat", tid), &buf));
return parse_stat(buf.ToString(), nullptr, stats);
}
@@ -146,7 +146,7 @@ bool is_being_debugged() {
return false;
}
StringPiece buf_sp(reinterpret_cast<const char*>(buf.data()), buf.size());
- vector<StringPiece> lines = Split(buf_sp, "\n");
+ std::vector<StringPiece> lines = Split(buf_sp, "\n");
for (const auto& l : lines) {
if (!HasPrefixString(l, "TracerPid:")) continue;
std::pair<StringPiece, StringPiece> key_val = Split(l, "\t");
diff --git a/be/src/util/path_util.cpp b/be/src/util/path_util.cpp
index 5252618..a04f664 100644
--- a/be/src/util/path_util.cpp
+++ b/be/src/util/path_util.cpp
@@ -37,7 +37,7 @@ namespace path_util {
const string kTmpInfix = ".doristmp";
-string join_path_segments(const string& a, const string& b) {
+std::string join_path_segments(const string& a, const string& b) {
if (a.empty()) {
return b;
} else if (b.empty()) {
@@ -47,23 +47,23 @@ string join_path_segments(const string& a, const string& b) {
}
}
-vector<string> join_path_segments_v(const vector<string>& v, const string& s) {
- vector<string> out;
+std::vector<string> join_path_segments_v(const std::vector<string>& v, const string& s) {
+ std::vector<string> out;
for (const string& path : v) {
out.emplace_back(join_path_segments(path, s));
}
return out;
}
-vector<string> split_path(const string& path) {
+std::vector<string> split_path(const string& path) {
if (path.empty()) {
return {};
}
- vector<string> segments;
+ std::vector<string> segments;
if (path[0] == '/') {
segments.emplace_back("/");
}
- vector<StringPiece> pieces = Split(path, "/", SkipEmpty());
+ std::vector<StringPiece> pieces = Split(path, "/", SkipEmpty());
for (const StringPiece& piece : pieces) {
segments.emplace_back(piece.data(), piece.size());
}
@@ -71,19 +71,19 @@ vector<string> split_path(const string& path) {
}
// strdup use malloc to obtain memory for the new string, it should be freed with free.
-// but unique_ptr use delete to free memory by default, so it should specify free memory using free
+// but std::unique_ptr use delete to free memory by default, so it should specify free memory using free
-string dir_name(const string& path) {
+std::string dir_name(const string& path) {
std::vector<char> path_copy(path.c_str(), path.c_str() + path.size() + 1);
return dirname(&path_copy[0]);
}
-string base_name(const string& path) {
+std::string base_name(const string& path) {
std::vector<char> path_copy(path.c_str(), path.c_str() + path.size() + 1);
return basename(&path_copy[0]);
}
-string file_extension(const string& path) {
+std::string file_extension(const string& path) {
string file_name = base_name(path);
if (file_name == "." || file_name == "..") {
return "";
diff --git a/be/src/util/perf_counters.cpp b/be/src/util/perf_counters.cpp
index 7728970..57f3390 100644
--- a/be/src/util/perf_counters.cpp
+++ b/be/src/util/perf_counters.cpp
@@ -307,7 +307,7 @@ bool PerfCounters::get_sys_counters(vector<int64_t>& buffer) {
// write_bytes: 0
// cancelled_write_bytes: 0
bool PerfCounters::get_proc_self_io_counters(vector<int64_t>& buffer) {
- std::ifstream file("/proc/self/io", ios::in);
+ std::ifstream file("/proc/self/io", std::ios::in);
std::string buf;
int64_t values[PROC_IO_LAST_COUNTER];
int ret = 0;
@@ -347,7 +347,7 @@ bool PerfCounters::get_proc_self_io_counters(vector<int64_t>& buffer) {
}
bool PerfCounters::get_proc_self_status_counters(vector<int64_t>& buffer) {
- ifstream file("/proc/self/status", ios::in);
+ std::ifstream file("/proc/self/status", std::ios::in);
string buf;
while (file) {
@@ -467,12 +467,12 @@ void PerfCounters::snapshot(const string& name) {
string fixed_name = name;
if (fixed_name.size() == 0) {
- stringstream ss;
+ std::stringstream ss;
ss << _snapshots.size() + 1;
fixed_name = ss.str();
}
- vector<int64_t> buffer(_counters.size());
+ std::vector<int64_t> buffer(_counters.size());
get_sys_counters(buffer);
get_proc_self_io_counters(buffer);
@@ -482,7 +482,7 @@ void PerfCounters::snapshot(const string& name) {
_snapshot_names.push_back(fixed_name);
}
-const vector<int64_t>* PerfCounters::counters(int snapshot) const {
+const std::vector<int64_t>* PerfCounters::counters(int snapshot) const {
if (snapshot < 0 || snapshot >= _snapshots.size()) {
return NULL;
}
@@ -498,7 +498,7 @@ void PerfCounters::pretty_print(ostream* s) const {
stream << setw(PRETTY_PRINT_WIDTH) << _counter_names[i];
}
- stream << endl;
+ stream << std::endl;
for (int s = 0; s < _snapshots.size(); s++) {
stream << setw(8) << _snapshot_names[s];
@@ -509,10 +509,10 @@ void PerfCounters::pretty_print(ostream* s) const {
<< PrettyPrinter::print(snapshot[i], _counters[i].type);
}
- stream << endl;
+ stream << std::endl;
}
- stream << endl;
+ stream << std::endl;
}
}
diff --git a/be/src/util/thread.cpp b/be/src/util/thread.cpp
index b7cb631..d2400be 100644
--- a/be/src/util/thread.cpp
+++ b/be/src/util/thread.cpp
@@ -184,7 +184,7 @@ void ThreadMgr::display_thread_callback(const WebPageHandler::ArgumentMap& args,
// The critical section is as short as possible so as to minimize the delay
// imposed on new threads that acquire the lock in write mode.
- vector<ThreadDescriptor> descriptors_to_print;
+ std::vector<ThreadDescriptor> descriptors_to_print;
if (!requested_all) {
MutexLock l(&_lock);
const auto* category = FindOrNull(_thread_categories, *category_name);
@@ -210,7 +210,7 @@ void ThreadMgr::display_thread_callback(const WebPageHandler::ArgumentMap& args,
}
} else {
// List all thread groups and the number of threads running in each.
- vector<pair<string, uint64_t>> thread_categories_info;
+ std::vector<pair<string, uint64_t>> thread_categories_info;
uint64_t running;
{
MutexLock l(&_lock);
diff --git a/be/src/util/threadpool.cpp b/be/src/util/threadpool.cpp
index 582f224..ed5400f 100644
--- a/be/src/util/threadpool.cpp
+++ b/be/src/util/threadpool.cpp
@@ -254,7 +254,7 @@ ThreadPool::ThreadPool(const ThreadPoolBuilder& builder)
ThreadPool::~ThreadPool() {
// There should only be one live token: the one used in tokenless submission.
- CHECK_EQ(1, _tokens.size()) << Substitute(
+ CHECK_EQ(1, _tokens.size()) << strings::Substitute(
"Threadpool $0 destroyed with $1 allocated tokens",
_name, _tokens.size());
shutdown();
@@ -343,7 +343,7 @@ std::unique_ptr<ThreadPoolToken> ThreadPool::new_token(ExecutionMode mode) {
void ThreadPool::release_token(ThreadPoolToken* t) {
MutexLock unique_lock(&_lock);
- CHECK(!t->is_active()) << Substitute("Token with state $0 may not be released",
+ CHECK(!t->is_active()) << strings::Substitute("Token with state $0 may not be released",
ThreadPoolToken::state_to_string(t->state()));
CHECK_EQ(1, _tokens.erase(t));
}
@@ -376,7 +376,7 @@ Status ThreadPool::do_submit(std::shared_ptr<Runnable> r, ThreadPoolToken* token
- _total_queued_tasks;
if (capacity_remaining < 1) {
return Status::ServiceUnavailable(
- Substitute("Thread pool is at capacity ($0/$1 tasks running, $2/$3 tasks queued)",
+ strings::Substitute("Thread pool is at capacity ($0/$1 tasks running, $2/$3 tasks queued)",
_num_threads + _num_threads_pending_start, _max_threads,
_total_queued_tasks, _max_queue_size));
}
@@ -599,14 +599,14 @@ void ThreadPool::dispatch_thread() {
}
Status ThreadPool::create_thread() {
- return Thread::create("thread pool", Substitute("$0 [worker]", _name),
+ return Thread::create("thread pool", strings::Substitute("$0 [worker]", _name),
&ThreadPool::dispatch_thread, this, nullptr);
}
void ThreadPool::check_not_pool_thread_unlocked() {
Thread* current = Thread::current_thread();
if (ContainsKey(_threads, current)) {
- LOG(FATAL) << Substitute("Thread belonging to thread pool '$0' with "
+ LOG(FATAL) << strings::Substitute("Thread belonging to thread pool '$0' with "
"name '$1' called pool function that would result in deadlock",
_name, current->name());
}
diff --git a/be/src/util/time.cpp b/be/src/util/time.cpp
index dce9071..9f0061f 100755
--- a/be/src/util/time.cpp
+++ b/be/src/util/time.cpp
@@ -57,7 +57,7 @@ static string TimepointToString(const chrono::system_clock::time_point& t,
// i.e., times before the Unix epoch.
static string FormatSubSecond(const chrono::system_clock::time_point& t,
TimePrecision p) {
- stringstream ss;
+ std::stringstream ss;
auto frac = t.time_since_epoch();
if (p == TimePrecision::Millisecond) {
auto subsec = chrono::duration_cast<chrono::milliseconds>(frac) % MILLIS_PER_SEC;
@@ -82,7 +82,7 @@ static string FormatSubSecond(const chrono::system_clock::time_point& t,
static string ToString(const chrono::system_clock::time_point& t, TimePrecision p,
bool utc)
{
- stringstream ss;
+ std::stringstream ss;
ss << TimepointToString(t, utc);
ss << FormatSubSecond(t, p);
return ss.str();
@@ -106,32 +106,32 @@ static chrono::system_clock::time_point TimepointFromUnixMicros(int64_t us) {
return chrono::system_clock::time_point(chrono::microseconds(us));
}
-string doris::ToStringFromUnix(int64_t s, TimePrecision p) {
+std::string doris::ToStringFromUnix(int64_t s, TimePrecision p) {
chrono::system_clock::time_point t = TimepointFromUnix(s);
return ToString(t, p, false);
}
-string doris::ToUtcStringFromUnix(int64_t s, TimePrecision p) {
+std::string doris::ToUtcStringFromUnix(int64_t s, TimePrecision p) {
chrono::system_clock::time_point t = TimepointFromUnix(s);
return ToString(t, p, true);
}
-string doris::ToStringFromUnixMillis(int64_t ms, TimePrecision p) {
+std::string doris::ToStringFromUnixMillis(int64_t ms, TimePrecision p) {
chrono::system_clock::time_point t = TimepointFromUnixMillis(ms);
return ToString(t, p, false);
}
-string doris::ToUtcStringFromUnixMillis(int64_t ms, TimePrecision p) {
+std::string doris::ToUtcStringFromUnixMillis(int64_t ms, TimePrecision p) {
chrono::system_clock::time_point t = TimepointFromUnixMillis(ms);
return ToString(t, p, true);
}
-string doris::ToStringFromUnixMicros(int64_t us, TimePrecision p) {
+std::string doris::ToStringFromUnixMicros(int64_t us, TimePrecision p) {
chrono::system_clock::time_point t = TimepointFromUnixMicros(us);
return ToString(t, p, false);
}
-string doris::ToUtcStringFromUnixMicros(int64_t us, TimePrecision p) {
+std::string doris::ToUtcStringFromUnixMicros(int64_t us, TimePrecision p) {
chrono::system_clock::time_point t = TimepointFromUnixMicros(us);
return ToString(t, p, true);
}
diff --git a/be/src/util/trace.cpp b/be/src/util/trace.cpp
index 6033a1b..6b941b0 100644
--- a/be/src/util/trace.cpp
+++ b/be/src/util/trace.cpp
@@ -140,8 +140,8 @@ void Trace::Dump(std::ostream* out, int flags) const {
// enough that we aren't worried about stalling concurrent tracers
// (whereas doing the logging itself while holding the lock might be
// too slow, if the output stream is a file, for example).
- vector<TraceEntry*> entries;
- vector<pair<StringPiece, scoped_refptr<Trace>>> child_traces;
+ std::vector<TraceEntry*> entries;
+ std::vector<pair<StringPiece, scoped_refptr<Trace>>> child_traces;
{
std::lock_guard<SpinLock> l(lock_);
for (TraceEntry* cur = entries_head_;
@@ -193,13 +193,13 @@ void Trace::Dump(std::ostream* out, int flags) const {
out->flags(save_flags);
}
-string Trace::DumpToString(int flags) const {
+std::string Trace::DumpToString(int flags) const {
std::ostringstream s;
Dump(&s, flags);
return s.str();
}
-string Trace::MetricsAsJSON() const {
+std::string Trace::MetricsAsJSON() const {
// TODO(yingchun): simplify implement here, we could import JsonWriter in the future.
rapidjson::StringBuffer buf;
rapidjson::Writer<rapidjson::StringBuffer> jw(buf);
@@ -220,7 +220,7 @@ void Trace::MetricsToJSON(rapidjson::Writer<rapidjson::StringBuffer>* jw) const
jw->String(e.first.c_str());
jw->Int64(e.second);
}
- vector<pair<StringPiece, scoped_refptr<Trace>>> child_traces;
+ std::vector<pair<StringPiece, scoped_refptr<Trace>>> child_traces;
{
std::lock_guard<SpinLock> l(lock_);
child_traces = child_traces_;
diff --git a/be/src/util/zlib.cpp b/be/src/util/zlib.cpp
index fe0c325..980e841 100644
--- a/be/src/util/zlib.cpp
+++ b/be/src/util/zlib.cpp
@@ -30,7 +30,7 @@
using std::ostream;
using std::string;
-using std::unique_ptr;
+
#define ZRETURN_NOT_OK(call) \
RETURN_IF_ERROR(ZlibResultToStatus(call))
@@ -81,7 +81,7 @@ Status CompressLevel(Slice input, int level, ostream* out) {
zs.avail_in = input.get_size();
zs.next_in = (unsigned char*)(input.mutable_data());
const int kChunkSize = 256 * 1024;
- unique_ptr<unsigned char[]> chunk(new unsigned char[kChunkSize]);
+ std::unique_ptr<unsigned char[]> chunk(new unsigned char[kChunkSize]);
int flush;
do {
zs.avail_out = kChunkSize;
diff --git a/be/test/agent/agent_server_test.cpp b/be/test/agent/agent_server_test.cpp
index b10463d..fd2d519 100644
--- a/be/test/agent/agent_server_test.cpp
+++ b/be/test/agent/agent_server_test.cpp
@@ -34,7 +34,7 @@ namespace doris {
TEST(SubmitTasksTest, TestSubmitTasks){
TAgentResult return_value;
- vector<TAgentTaskRequest> tasks;
+ std::vector<TAgentTaskRequest> tasks;
ExecEnv env;
TMasterInfo master_info;
diff --git a/be/test/exec/hash_table_test.cpp b/be/test/exec/hash_table_test.cpp
index c01aca3..4e5f0d4 100644
--- a/be/test/exec/hash_table_test.cpp
+++ b/be/test/exec/hash_table_test.cpp
@@ -44,8 +44,8 @@ public:
protected:
ObjectPool _pool;
MemPool _mem_pool;
- vector<Expr*> _build_expr;
- vector<Expr*> _probe_expr;
+ std::vector<Expr*> _build_expr;
+ std::vector<Expr*> _probe_expr;
virtual void SetUp() {
RowDescriptor desc;
@@ -106,7 +106,7 @@ protected:
struct ProbeTestData {
TupleRow* probe_row;
- vector<TupleRow*> expected_build_rows;
+ std::vector<TupleRow*> expected_build_rows;
};
void probe_test(HashTable* table, ProbeTestData* data, int num_data, bool scan) {
@@ -234,7 +234,7 @@ TEST_F(HashTableTest, BasicTest) {
TEST_F(HashTableTest, ScanTest) {
HashTable hash_table(_build_expr, _probe_expr, 1, false, 0);
// Add 1 row with val 1, 2 with val 2, etc
- vector<TupleRow*> build_rows;
+ std::vector<TupleRow*> build_rows;
ProbeTestData probe_rows[15];
probe_rows[0].probe_row = create_tuple_row(0);
diff --git a/be/test/exec/new_olap_scan_node_test.cpp b/be/test/exec/new_olap_scan_node_test.cpp
index a9e3982..8e1b9d4 100644
--- a/be/test/exec/new_olap_scan_node_test.cpp
+++ b/be/test/exec/new_olap_scan_node_test.cpp
@@ -237,13 +237,13 @@ public:
}
}
- void read_data(int version, vector<string>* data) {
+ void read_data(int version, std::vector<string>* data) {
data->clear();
int row[21];
for (int i = 0; i <= version; ++i) {
- stringstream ss;
+ std::stringstream ss;
ss << "./testrun/case3/_fc_dayhour" << i << ".txt";
fstream f(ss.str());
@@ -256,7 +256,7 @@ public:
break;
}
- stringstream str;
+ std::stringstream str;
str << "[(";
str << row[0] << " ";
str << row[2] << " ";
@@ -277,7 +277,7 @@ private:
ObjectPool _obj_pool;
DescriptorTbl* _desc_tbl;
RuntimeState _runtime_stat;
- vector<TScanRangeParams> _scan_ranges;
+ std::vector<TScanRangeParams> _scan_ranges;
};
TEST_F(TestOlapScanNode, SimpleTest) {
@@ -307,7 +307,7 @@ TEST_F(TestOlapScanNode, SimpleTest) {
TEST_F(TestOlapScanNode, MultiColumnSingleVersionTest) {
_scan_ranges[0].scan_range.doris_scan_range.__set_version("0");
_scan_ranges[0].scan_range.doris_scan_range.__set_version_hash("0");
- vector<string> data;
+ std::vector<string> data;
read_data(0, &data);
OlapScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl);
@@ -345,7 +345,7 @@ TEST_F(TestOlapScanNode, MultiColumnSingleVersionTest) {
TEST_F(TestOlapScanNode, MultiColumnMultiVersionTest) {
_scan_ranges[0].scan_range.doris_scan_range.__set_version("9");
_scan_ranges[0].scan_range.doris_scan_range.__set_version_hash("0");
- vector<string> data;
+ std::vector<string> data;
read_data(9, &data);
OlapScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl);
diff --git a/be/test/olap/delete_handler_test.cpp b/be/test/olap/delete_handler_test.cpp
index 12db222..0bf0d6e 100644
--- a/be/test/olap/delete_handler_test.cpp
+++ b/be/test/olap/delete_handler_test.cpp
@@ -850,7 +850,7 @@ TEST_F(TestDeleteHandler, InitSuccess) {
res = _delete_handler.init(tablet->tablet_schema(), tablet->delete_predicates(), 4);
ASSERT_EQ(OLAP_SUCCESS, res);
ASSERT_EQ(4, _delete_handler.conditions_num());
- vector<int32_t> conds_version = _delete_handler.get_conds_version();
+ std::vector<int32_t> conds_version = _delete_handler.get_conds_version();
EXPECT_EQ(4, conds_version.size());
sort(conds_version.begin(), conds_version.end());
EXPECT_EQ(1, conds_version[0]);
@@ -894,7 +894,7 @@ TEST_F(TestDeleteHandler, FilterDataSubconditions) {
ASSERT_EQ(1, _delete_handler.conditions_num());
// 构造一行测试数据
- vector<string> data_str;
+ std::vector<string> data_str;
data_str.push_back("1");
data_str.push_back("6");
data_str.push_back("8");
@@ -980,7 +980,7 @@ TEST_F(TestDeleteHandler, FilterDataConditions) {
ASSERT_EQ(OLAP_SUCCESS, res);
ASSERT_EQ(3, _delete_handler.conditions_num());
- vector<string> data_str;
+ std::vector<string> data_str;
data_str.push_back("4");
data_str.push_back("5");
data_str.push_back("8");
@@ -1046,7 +1046,7 @@ TEST_F(TestDeleteHandler, FilterDataVersion) {
ASSERT_EQ(2, _delete_handler.conditions_num());
// 构造一行测试数据
- vector<string> data_str;
+ std::vector<string> data_str;
data_str.push_back("1");
data_str.push_back("6");
data_str.push_back("8");
diff --git a/be/test/olap/fs/file_block_manager_test.cpp b/be/test/olap/fs/file_block_manager_test.cpp
index 6c99253..4be0c7d 100644
--- a/be/test/olap/fs/file_block_manager_test.cpp
+++ b/be/test/olap/fs/file_block_manager_test.cpp
@@ -31,7 +31,7 @@ namespace doris {
class FileBlockManagerTest : public testing::Test {
protected:
- const string kBlockManagerDir = "./ut_dir/file_block_manager";
+ const std::string kBlockManagerDir = "./ut_dir/file_block_manager";
void SetUp() override {
if (FileUtils::check_exist(kBlockManagerDir)) {
@@ -55,12 +55,12 @@ TEST_F(FileBlockManagerTest, NormalTest) {
std::unique_ptr<fs::FileBlockManager> fbm(new fs::FileBlockManager(env, std::move(bm_opts)));
std::unique_ptr<fs::WritableBlock> wblock;
- string fname = kBlockManagerDir + "/test_file";
+ std::string fname = kBlockManagerDir + "/test_file";
fs::CreateBlockOptions wblock_opts({ fname });
Status st = fbm->create_block(wblock_opts, &wblock);
ASSERT_TRUE(st.ok()) << st.get_error_msg();
- string data = "abcdefghijklmnopqrstuvwxyz";
+ std::string data = "abcdefghijklmnopqrstuvwxyz";
wblock->append(data);
wblock->close();
@@ -69,7 +69,7 @@ TEST_F(FileBlockManagerTest, NormalTest) {
uint64_t file_size = 0;
ASSERT_TRUE(rblock->size(&file_size).ok());
ASSERT_EQ(data.size(), file_size);
- string read_buff(data.size(), 'a');
+ std::string read_buff(data.size(), 'a');
Slice read_slice(read_buff);
rblock->read(0, read_slice);
ASSERT_EQ(data, read_buff);
diff --git a/be/test/olap/memory/column_delta_test.cpp b/be/test/olap/memory/column_delta_test.cpp
index 9a31ae8..2193e09 100644
--- a/be/test/olap/memory/column_delta_test.cpp
+++ b/be/test/olap/memory/column_delta_test.cpp
@@ -40,7 +40,7 @@ TEST(ColumnDelta, Index) {
size_t nblock = num_block(BaseSize, Column::BLOCK_SIZE);
ASSERT_TRUE(delta->alloc(nblock, updates.size(), sizeof(uint32_t), false).ok());
DeltaIndex* index = delta->index();
- vector<uint32_t>& block_ends = index->block_ends();
+ std::vector<uint32_t>& block_ends = index->block_ends();
Buffer& idxdata = index->_data;
Buffer& data = delta->data();
uint32_t cidx = 0;
diff --git a/be/test/olap/memory/column_test.cpp b/be/test/olap/memory/column_test.cpp
index 83accd0..90411ed 100644
--- a/be/test/olap/memory/column_test.cpp
+++ b/be/test/olap/memory/column_test.cpp
@@ -38,7 +38,7 @@ struct ColumnTest {
scoped_refptr<Column> c(new Column(cs, CT, 1));
std::unique_ptr<ColumnWriter> writer;
ASSERT_TRUE(c->create_writer(&writer).ok());
- vector<CppType> values(InsertCount, 0);
+ std::vector<CppType> values(InsertCount, 0);
for (size_t i = 0; i < values.size(); i++) {
values[i] = (CppType)rand();
EXPECT_TRUE(writer->insert((uint32_t)i, &values[i]).ok());
@@ -60,7 +60,7 @@ struct ColumnTest {
scoped_refptr<Column> c(new Column(cs, CT, 1));
std::unique_ptr<ColumnWriter> writer;
ASSERT_TRUE(c->create_writer(&writer).ok());
- vector<CppType> values(InsertCount, 0);
+ std::vector<CppType> values(InsertCount, 0);
for (size_t i = 0; i < values.size(); i++) {
values[i] = (CppType)rand();
if (is_null(values[i])) {
@@ -94,7 +94,7 @@ struct ColumnTest {
scoped_refptr<Column> c(new Column(cs, CT, 1));
std::unique_ptr<ColumnWriter> writer;
ASSERT_TRUE(c->create_writer(&writer).ok());
- vector<CppType> values(InsertCount, 0);
+ std::vector<CppType> values(InsertCount, 0);
for (size_t i = 0; i < values.size(); i++) {
values[i] = (CppType)rand();
EXPECT_TRUE(writer->insert((uint32_t)i, &values[i]).ok());
@@ -105,7 +105,7 @@ struct ColumnTest {
scoped_refptr<Column> oldc = c;
for (size_t u = 0; u < UpdateTime; u++) {
ASSERT_TRUE(c->create_writer(&writer).ok());
- vector<uint32_t> update_idxs;
+ std::vector<uint32_t> update_idxs;
for (size_t i = 0; i < UpdateCount; i++) {
uint32_t idx = rand() % values.size();
//CppType oldv = values[idx];
@@ -138,7 +138,7 @@ struct ColumnTest {
scoped_refptr<Column> c(new Column(cs, CT, 1));
std::unique_ptr<ColumnWriter> writer;
ASSERT_TRUE(c->create_writer(&writer).ok());
- vector<CppType> values(InsertCount, 0);
+ std::vector<CppType> values(InsertCount, 0);
for (size_t i = 0; i < values.size(); i++) {
values[i] = (CppType)rand();
if (is_null(values[i])) {
@@ -154,7 +154,7 @@ struct ColumnTest {
scoped_refptr<Column> oldc = c;
for (size_t u = 0; u < UpdateTime; u++) {
ASSERT_TRUE(c->create_writer(&writer).ok());
- vector<uint32_t> update_idxs;
+ std::vector<uint32_t> update_idxs;
for (size_t i = 0; i < UpdateCount; i++) {
uint32_t idx = rand() % values.size();
//CppType oldv = values[idx];
diff --git a/be/test/olap/memory/mem_tablet_test.cpp b/be/test/olap/memory/mem_tablet_test.cpp
index 979f462..9f0bff9 100644
--- a/be/test/olap/memory/mem_tablet_test.cpp
+++ b/be/test/olap/memory/mem_tablet_test.cpp
@@ -73,7 +73,7 @@ TEST(MemTablet, writescan) {
ASSERT_TRUE(tablet->init().ok());
uint64_t cur_version = 0;
- vector<TData> alldata(num_insert);
+ std::vector<TData> alldata(num_insert);
// insert
srand(1);
@@ -101,7 +101,7 @@ TEST(MemTablet, writescan) {
EXPECT_TRUE(writer.set("city", city % 2 == 0 ? nullptr : &city).ok());
EXPECT_TRUE(writer.end_row().ok());
}
- vector<uint8_t> wtxn_buff;
+ std::vector<uint8_t> wtxn_buff;
EXPECT_TRUE(writer.finish_batch(&wtxn_buff).ok());
PartialRowBatch* batch = wtx->new_batch();
EXPECT_TRUE(batch->load(std::move(wtxn_buff)).ok());
@@ -131,7 +131,7 @@ TEST(MemTablet, writescan) {
EXPECT_TRUE(writer.set("city", city % 2 == 0 ? nullptr : &city).ok());
EXPECT_TRUE(writer.end_row().ok());
}
- vector<uint8_t> wtxn_buff;
+ std::vector<uint8_t> wtxn_buff;
EXPECT_TRUE(writer.finish_batch(&wtxn_buff).ok());
PartialRowBatch* batch = wtx->new_batch();
EXPECT_TRUE(batch->load(std::move(wtxn_buff)).ok());
diff --git a/be/test/olap/memory/partial_row_batch_test.cpp b/be/test/olap/memory/partial_row_batch_test.cpp
index f031cc9..33861dd 100644
--- a/be/test/olap/memory/partial_row_batch_test.cpp
+++ b/be/test/olap/memory/partial_row_batch_test.cpp
@@ -50,7 +50,7 @@ TEST(PartialRowbatch, write) {
}
EXPECT_TRUE(writer.end_row().ok());
}
- vector<uint8_t> buffer;
+ std::vector<uint8_t> buffer;
writer.finish_batch(&buffer);
PartialRowBatch rb(&sc);
diff --git a/be/test/olap/olap_snapshot_converter_test.cpp b/be/test/olap/olap_snapshot_converter_test.cpp
index 112756c..1237b2a 100644
--- a/be/test/olap/olap_snapshot_converter_test.cpp
+++ b/be/test/olap/olap_snapshot_converter_test.cpp
@@ -129,7 +129,7 @@ TEST_F(OlapSnapshotConverterTest, ToNewAndToOldSnapshot) {
ASSERT_TRUE(ret);
OlapSnapshotConverter converter;
TabletMetaPB tablet_meta_pb;
- vector<RowsetMetaPB> pending_rowsets;
+ std::vector<RowsetMetaPB> pending_rowsets;
OLAPStatus status = converter.to_new_snapshot(header_msg, _tablet_data_path, _tablet_data_path,
&tablet_meta_pb, &pending_rowsets, true);
ASSERT_TRUE(status == OLAP_SUCCESS);
diff --git a/be/test/olap/rowset/beta_rowset_test.cpp b/be/test/olap/rowset/beta_rowset_test.cpp
index 43f0ac6..05862e8 100644
--- a/be/test/olap/rowset/beta_rowset_test.cpp
+++ b/be/test/olap/rowset/beta_rowset_test.cpp
@@ -70,7 +70,7 @@ protected:
ExecEnv* exec_env = doris::ExecEnv::GetInstance();
exec_env->set_storage_engine(k_engine);
- const string rowset_dir = "./data_test/data/beta_rowset_test";
+ const std::string rowset_dir = "./data_test/data/beta_rowset_test";
ASSERT_TRUE(FileUtils::create_dir(rowset_dir).ok());
}
diff --git a/be/test/olap/rowset/segment_v2/column_reader_writer_test.cpp b/be/test/olap/rowset/segment_v2/column_reader_writer_test.cpp
index c0481af..39ebaa7 100644
--- a/be/test/olap/rowset/segment_v2/column_reader_writer_test.cpp
+++ b/be/test/olap/rowset/segment_v2/column_reader_writer_test.cpp
@@ -38,7 +38,7 @@ using std::string;
namespace doris {
namespace segment_v2 {
-static const string TEST_DIR = "./ut_dir/column_reader_writer_test";
+static const std::string TEST_DIR = "./ut_dir/column_reader_writer_test";
class ColumnReaderWriterTest : public testing::Test {
public:
@@ -65,14 +65,14 @@ private:
};
template<FieldType type, EncodingTypePB encoding>
-void test_nullable_data(uint8_t* src_data, uint8_t* src_is_null, int num_rows, string test_name) {
+void test_nullable_data(uint8_t* src_data, uint8_t* src_is_null, int num_rows, std::string test_name) {
using Type = typename TypeTraits<type>::CppType;
Type* src = (Type*)src_data;
ColumnMetaPB meta;
// write data
- string fname = TEST_DIR + "/" + test_name;
+ std::string fname = TEST_DIR + "/" + test_name;
{
std::unique_ptr<fs::WritableBlock> wblock;
fs::CreateBlockOptions opts({ fname });
@@ -217,7 +217,7 @@ void test_nullable_data(uint8_t* src_data, uint8_t* src_is_null, int num_rows, s
}
template<FieldType item_type, EncodingTypePB item_encoding, EncodingTypePB array_encoding>
-void test_array_nullable_data(Collection* src_data, uint8_t* src_is_null, int num_rows, string test_name) {
+void test_array_nullable_data(Collection* src_data, uint8_t* src_is_null, int num_rows, std::string test_name) {
Collection* src = src_data;
ColumnMetaPB meta;
TabletColumn list_column(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_ARRAY);
@@ -230,7 +230,7 @@ void test_array_nullable_data(Collection* src_data, uint8_t* src_is_null, int nu
Field* field = FieldFactory::create(list_column);
// write data
- string fname = TEST_DIR + "/" + test_name;
+ std::string fname = TEST_DIR + "/" + test_name;
{
std::unique_ptr<fs::WritableBlock> wblock;
fs::CreateBlockOptions opts({ fname });
@@ -603,48 +603,48 @@ TEST_F(ColumnReaderWriterTest, test_types) {
}
TEST_F(ColumnReaderWriterTest, test_default_value) {
- string v_int("1");
+ std::string v_int("1");
int32_t result = 1;
test_read_default_value<OLAP_FIELD_TYPE_TINYINT>(v_int, &result);
test_read_default_value<OLAP_FIELD_TYPE_SMALLINT>(v_int, &result);
test_read_default_value<OLAP_FIELD_TYPE_INT>(v_int, &result);
- string v_bigint("9223372036854775807");
+ std::string v_bigint("9223372036854775807");
int64_t result_bigint = std::numeric_limits<int64_t>::max();
test_read_default_value<OLAP_FIELD_TYPE_BIGINT>(v_bigint, &result_bigint);
int128_t result_largeint = std::numeric_limits<int64_t>::max();
test_read_default_value<OLAP_FIELD_TYPE_LARGEINT>(v_bigint, &result_largeint);
- string v_float("1.00");
+ std::string v_float("1.00");
float result2 = 1.00;
test_read_default_value<OLAP_FIELD_TYPE_FLOAT>(v_float, &result2);
- string v_double("1.00");
+ std::string v_double("1.00");
double result3 = 1.00;
test_read_default_value<OLAP_FIELD_TYPE_DOUBLE>(v_double, &result3);
- string v_varchar("varchar");
+ std::string v_varchar("varchar");
test_read_default_value<OLAP_FIELD_TYPE_VARCHAR>(v_varchar, &v_varchar);
- string v_char("char");
+ std::string v_char("char");
test_read_default_value<OLAP_FIELD_TYPE_CHAR>(v_char, &v_char);
char* c = (char *)malloc(1);
c[0] = 0;
- string v_object(c, 1);
+ std::string v_object(c, 1);
test_read_default_value<OLAP_FIELD_TYPE_HLL>(v_object, &v_object);
test_read_default_value<OLAP_FIELD_TYPE_OBJECT>(v_object, &v_object);
free(c);
- string v_date("2019-11-12");
+ std::string v_date("2019-11-12");
uint24_t result_date(1034092);
test_read_default_value<OLAP_FIELD_TYPE_DATE>(v_date, &result_date);
- string v_datetime("2019-11-12 12:01:08");
+ std::string v_datetime("2019-11-12 12:01:08");
int64_t result_datetime = 20191112120108;
test_read_default_value<OLAP_FIELD_TYPE_DATETIME>(v_datetime, &result_datetime);
- string v_decimal("102418.000000002");
+ std::string v_decimal("102418.000000002");
decimal12_t decimal(102418, 2);
test_read_default_value<OLAP_FIELD_TYPE_DECIMAL>(v_decimal, &decimal);
}
diff --git a/be/test/olap/rowset/segment_v2/segment_test.cpp b/be/test/olap/rowset/segment_v2/segment_test.cpp
index 1d12365..5f327ac 100644
--- a/be/test/olap/rowset/segment_v2/segment_test.cpp
+++ b/be/test/olap/rowset/segment_v2/segment_test.cpp
@@ -47,7 +47,7 @@ namespace segment_v2 {
using std::string;
using std::shared_ptr;
-using std::unique_ptr;
+
using std::vector;
using ValueGenerator = std::function<void(size_t rid, int cid, int block_id, RowCursorCell& cell)>;
@@ -84,7 +84,7 @@ protected:
}
}
- TabletSchema create_schema(const vector<TabletColumn>& columns, int num_short_key_columns = -1) {
+ TabletSchema create_schema(const std::vector<TabletColumn>& columns, int num_short_key_columns = -1) {
TabletSchema res;
int num_key_columns = 0;
for (auto& col : columns) {
@@ -108,7 +108,7 @@ protected:
static int seg_id = 0;
// must use unique filename for each segment, otherwise page cache kicks in and produces
// the wrong answer (it use (filename,offset) as cache key)
- string filename = strings::Substitute("$0/seg_$1.dat", kSegmentDir, seg_id++);
+ std::string filename = strings::Substitute("$0/seg_$1.dat", kSegmentDir, seg_id++);
std::unique_ptr<fs::WritableBlock> wblock;
fs::CreateBlockOptions block_opts({ filename });
Status st = fs::fs_util::block_manager()->create_block(block_opts, &wblock);
@@ -140,7 +140,7 @@ protected:
ASSERT_EQ(nrows, (*res)->num_rows());
}
private:
- const string kSegmentDir = "./ut_dir/segment_test";
+ const std::string kSegmentDir = "./ut_dir/segment_test";
};
TEST_F(SegmentReaderWriterTest, normal) {
@@ -300,15 +300,15 @@ TEST_F(SegmentReaderWriterTest, LazyMaterialization) {
// lazy enabled when predicate is subset of returned columns:
// select c1, c2 where c2 = 30;
Schema read_schema(tablet_schema);
- unique_ptr<ColumnPredicate> predicate(new EqualPredicate<int32_t>(1, 30));
- const vector<ColumnPredicate*> predicates = {predicate.get()};
+ std::unique_ptr<ColumnPredicate> predicate(new EqualPredicate<int32_t>(1, 30));
+ const std::vector<ColumnPredicate*> predicates = {predicate.get()};
OlapReaderStatistics stats;
StorageReadOptions read_opts;
read_opts.column_predicates = &predicates;
read_opts.stats = &stats;
- unique_ptr<RowwiseIterator> iter;
+ std::unique_ptr<RowwiseIterator> iter;
ASSERT_TRUE(segment->new_iterator(read_schema, read_opts, &iter).ok());
RowBlockV2 block(read_schema, 1024);
@@ -323,16 +323,16 @@ TEST_F(SegmentReaderWriterTest, LazyMaterialization) {
// lazy disabled when all return columns have predicates:
// select c1, c2 where c1 = 10 and c2 = 100;
Schema read_schema(tablet_schema);
- unique_ptr<ColumnPredicate> p0(new EqualPredicate<int32_t>(0, 10));
- unique_ptr<ColumnPredicate> p1(new EqualPredicate<int32_t>(1, 100));
- const vector<ColumnPredicate*> predicates = {p0.get(), p1.get()};
+ std::unique_ptr<ColumnPredicate> p0(new EqualPredicate<int32_t>(0, 10));
+ std::unique_ptr<ColumnPredicate> p1(new EqualPredicate<int32_t>(1, 100));
+ const std::vector<ColumnPredicate*> predicates = {p0.get(), p1.get()};
OlapReaderStatistics stats;
StorageReadOptions read_opts;
read_opts.column_predicates = &predicates;
read_opts.stats = &stats;
- unique_ptr<RowwiseIterator> iter;
+ std::unique_ptr<RowwiseIterator> iter;
ASSERT_TRUE(segment->new_iterator(read_schema, read_opts, &iter).ok());
RowBlockV2 block(read_schema, 1024);
@@ -346,13 +346,13 @@ TEST_F(SegmentReaderWriterTest, LazyMaterialization) {
{
// lazy disabled when no predicate:
// select c2
- vector<ColumnId> read_cols = {1};
+ std::vector<ColumnId> read_cols = {1};
Schema read_schema(tablet_schema.columns(), read_cols);
OlapReaderStatistics stats;
StorageReadOptions read_opts;
read_opts.stats = &stats;
- unique_ptr<RowwiseIterator> iter;
+ std::unique_ptr<RowwiseIterator> iter;
ASSERT_TRUE(segment->new_iterator(read_schema, read_opts, &iter).ok());
RowBlockV2 block(read_schema, 1024);
@@ -376,15 +376,15 @@ TEST_F(SegmentReaderWriterTest, LazyMaterialization) {
// lazy disabled when all predicates are removed by bitmap index:
// select c1, c2 where c2 = 30;
Schema read_schema(tablet_schema);
- unique_ptr<ColumnPredicate> predicate(new EqualPredicate<int32_t>(0, 20));
- const vector<ColumnPredicate*> predicates = { predicate.get() };
+ std::unique_ptr<ColumnPredicate> predicate(new EqualPredicate<int32_t>(0, 20));
+ const std::vector<ColumnPredicate*> predicates = { predicate.get() };
OlapReaderStatistics stats;
StorageReadOptions read_opts;
read_opts.column_predicates = &predicates;
read_opts.stats = &stats;
- unique_ptr<RowwiseIterator> iter;
+ std::unique_ptr<RowwiseIterator> iter;
ASSERT_TRUE(segment->new_iterator(read_schema, read_opts, &iter).ok());
RowBlockV2 block(read_schema, 1024);
@@ -649,12 +649,12 @@ TEST_F(SegmentReaderWriterTest, estimate_segment_size) {
}
TEST_F(SegmentReaderWriterTest, TestDefaultValueColumn) {
- vector<TabletColumn> columns = { create_int_key(1), create_int_key(2), create_int_value(3), create_int_value(4) };
+ std::vector<TabletColumn> columns = { create_int_key(1), create_int_key(2), create_int_value(3), create_int_value(4) };
TabletSchema build_schema = create_schema(columns);
// add a column with null default value
{
- vector<TabletColumn> read_columns = columns;
+ std::vector<TabletColumn> read_columns = columns;
read_columns.push_back(create_int_value(5, OLAP_FIELD_AGGREGATION_SUM, true, "NULL"));
TabletSchema query_schema = create_schema(read_columns);
@@ -703,7 +703,7 @@ TEST_F(SegmentReaderWriterTest, TestDefaultValueColumn) {
// add a column with non-null default value
{
- vector<TabletColumn> read_columns = columns;
+ std::vector<TabletColumn> read_columns = columns;
read_columns.push_back(create_int_value(5, OLAP_FIELD_AGGREGATION_SUM, true, "10086"));
TabletSchema query_schema = create_schema(read_columns);
diff --git a/be/test/olap/tablet_mgr_test.cpp b/be/test/olap/tablet_mgr_test.cpp
index aaf18c5..ea99d9a 100644
--- a/be/test/olap/tablet_mgr_test.cpp
+++ b/be/test/olap/tablet_mgr_test.cpp
@@ -119,7 +119,7 @@ TEST_F(TabletMgrTest, CreateTablet) {
create_tablet_req.__set_tablet_id(111);
create_tablet_req.__set_version(2);
create_tablet_req.__set_version_hash(3333);
- vector<DataDir*> data_dirs;
+ std::vector<DataDir*> data_dirs;
data_dirs.push_back(_data_dir);
OLAPStatus create_st = _tablet_mgr->create_tablet(create_tablet_req, data_dirs);
ASSERT_TRUE(create_st == OLAP_SUCCESS);
@@ -180,7 +180,7 @@ TEST_F(TabletMgrTest, CreateTabletWithSequence) {
create_tablet_req.__set_tablet_id(111);
create_tablet_req.__set_version(2);
create_tablet_req.__set_version_hash(3333);
- vector<DataDir*> data_dirs;
+ std::vector<DataDir*> data_dirs;
data_dirs.push_back(_data_dir);
OLAPStatus create_st = _tablet_mgr->create_tablet(create_tablet_req, data_dirs);
ASSERT_TRUE(create_st == OLAP_SUCCESS);
@@ -215,7 +215,7 @@ TEST_F(TabletMgrTest, DropTablet) {
create_tablet_req.__set_tablet_id(111);
create_tablet_req.__set_version(2);
create_tablet_req.__set_version_hash(3333);
- vector<DataDir*> data_dirs;
+ std::vector<DataDir*> data_dirs;
data_dirs.push_back(_data_dir);
OLAPStatus create_st = _tablet_mgr->create_tablet(create_tablet_req, data_dirs);
ASSERT_TRUE(create_st == OLAP_SUCCESS);
diff --git a/be/test/runtime/buffered_block_mgr2_test.cpp b/be/test/runtime/buffered_block_mgr2_test.cpp
index 94ca7a0..81810e9 100644
--- a/be/test/runtime/buffered_block_mgr2_test.cpp
+++ b/be/test/runtime/buffered_block_mgr2_test.cpp
@@ -85,10 +85,10 @@ protected:
}
// Reinitialize _test_env to have multiple temporary directories.
- vector<string> InitMultipleTmpDirs(int num_dirs) {
- vector<string> tmp_dirs;
+ std::vector<string> InitMultipleTmpDirs(int num_dirs) {
+ std::vector<string> tmp_dirs;
for (int i = 0; i < num_dirs; ++i) {
- stringstream dir_str;
+ std::stringstream dir_str;
dir_str << "/tmp/buffered-block-mgr-test." << i;
const string& dir = dir_str.str();
// Fix permissions in case old directories were left from previous runs of test.
@@ -159,8 +159,8 @@ protected:
void CreateMgrsAndClients(int64_t start_query_id, int num_mgrs, int buffers_per_mgr,
int block_size, int reserved_blocks_per_client, const std::shared_ptr<MemTracker>& tracker,
- vector<BufferedBlockMgr2*>* mgrs,
- vector<BufferedBlockMgr2::Client*>* clients) {
+ std::vector<BufferedBlockMgr2*>* mgrs,
+ std::vector<BufferedBlockMgr2::Client*>* clients) {
for (int i = 0; i < num_mgrs; ++i) {
BufferedBlockMgr2::Client* client;
BufferedBlockMgr2* mgr =
@@ -179,7 +179,7 @@ protected:
}
void AllocateBlocks(BufferedBlockMgr2* block_mgr, BufferedBlockMgr2::Client* client,
- int num_blocks, vector<BufferedBlockMgr2::Block*>* blocks) {
+ int num_blocks, std::vector<BufferedBlockMgr2::Block*>* blocks) {
int32_t* data = NULL;
Status status;
BufferedBlockMgr2::Block* new_block;
@@ -194,7 +194,7 @@ protected:
}
// Pin all blocks, expecting they are pinned successfully.
- void PinBlocks(const vector<BufferedBlockMgr2::Block*>& blocks) {
+ void PinBlocks(const std::vector<BufferedBlockMgr2::Block*>& blocks) {
for (int i = 0; i < blocks.size(); ++i) {
bool pinned = false;
EXPECT_TRUE(blocks[i]->pin(&pinned).ok());
@@ -203,20 +203,20 @@ protected:
}
// Pin all blocks, expecting no errors from unpin() calls.
- void UnpinBlocks(const vector<BufferedBlockMgr2::Block*>& blocks) {
+ void UnpinBlocks(const std::vector<BufferedBlockMgr2::Block*>& blocks) {
for (int i = 0; i < blocks.size(); ++i) {
EXPECT_TRUE(blocks[i]->unpin().ok());
}
}
static void WaitForWrites(BufferedBlockMgr2* block_mgr) {
- vector<BufferedBlockMgr2*> block_mgrs;
+ std::vector<BufferedBlockMgr2*> block_mgrs;
block_mgrs.push_back(block_mgr);
WaitForWrites(block_mgrs);
}
// Wait for writes issued through block managers to complete.
- static void WaitForWrites(const vector<BufferedBlockMgr2*>& block_mgrs) {
+ static void WaitForWrites(const std::vector<BufferedBlockMgr2*>& block_mgrs) {
int max_attempts = WRITE_WAIT_MILLIS / WRITE_CHECK_INTERVAL_MILLIS;
for (int i = 0; i < max_attempts; ++i) {
SleepFor(MonoDelta::FromMilliseconds(WRITE_CHECK_INTERVAL_MILLIS));
@@ -227,7 +227,7 @@ protected:
EXPECT_TRUE(false) << "Writes did not complete after " << WRITE_WAIT_MILLIS << "ms";
}
- static bool AllWritesComplete(const vector<BufferedBlockMgr2*>& block_mgrs) {
+ static bool AllWritesComplete(const std::vector<BufferedBlockMgr2*>& block_mgrs) {
for (int i = 0; i < block_mgrs.size(); ++i) {
RuntimeProfile::Counter* writes_outstanding =
block_mgrs[i]->profile()->get_counter("BlockWritesOutstanding");
@@ -255,7 +255,7 @@ protected:
// Find a block in the list that is backed by a file with the given directory as prefix
// of its path.
static BufferedBlockMgr2::Block* FindBlockForDir(
- const vector<BufferedBlockMgr2::Block*>& blocks, const string& dir) {
+ const std::vector<BufferedBlockMgr2::Block*>& blocks, const string& dir) {
for (int i = 0; i < blocks.size(); ++i) {
if (BlockInDir(blocks[i], dir)) {
return blocks[i];
@@ -321,7 +321,7 @@ protected:
RuntimeProfile* profile = block_mgr->profile();
RuntimeProfile::Counter* buffered_pin = profile->get_counter("BufferedPins");
- vector<BufferedBlockMgr2::Block*> blocks;
+ std::vector<BufferedBlockMgr2::Block*> blocks;
AllocateBlocks(block_mgr, client, max_num_buffers, &blocks);
EXPECT_EQ(block_mgr->bytes_allocated(), max_num_buffers * block_size);
@@ -385,9 +385,9 @@ protected:
const int iters_before_close = num_iterations - 5000;
bool close_called = false;
unordered_map<BufferedBlockMgr2::Block*, int> pinned_block_map;
- vector<std::pair<BufferedBlockMgr2::Block*, int32_t>> pinned_blocks;
+ std::vector<std::pair<BufferedBlockMgr2::Block*, int32_t>> pinned_blocks;
unordered_map<BufferedBlockMgr2::Block*, int> unpinned_block_map;
- vector<std::pair<BufferedBlockMgr2::Block*, int32_t>> unpinned_blocks;
+ std::vector<std::pair<BufferedBlockMgr2::Block*, int32_t>> unpinned_blocks;
typedef enum { Pin, New, Unpin, Delete, Close } ApiFunction;
ApiFunction api_function;
@@ -563,9 +563,9 @@ protected:
workers.join_all();
}
- scoped_ptr<TestEnv> _test_env;
+ boost::scoped_ptr<TestEnv> _test_env;
std::shared_ptr<MemTracker> _client_tracker;
- vector<string> _created_tmp_dirs;
+ std::vector<string> _created_tmp_dirs;
};
TEST_F(BufferedBlockMgrTest, get_new_block) {
@@ -584,7 +584,7 @@ TEST_F(BufferedBlockMgrTest, GetNewBlockSmallBlocks) {
CreateMgrAndClient(0, max_num_blocks, block_size, 0, _client_tracker, &client);
EXPECT_EQ(0, _test_env->block_mgr_parent_tracker()->consumption());
- vector<BufferedBlockMgr2::Block*> blocks;
+ std::vector<BufferedBlockMgr2::Block*> blocks;
// Allocate a small block.
BufferedBlockMgr2::Block* new_block = NULL;
@@ -644,7 +644,7 @@ TEST_F(BufferedBlockMgrTest, Pin) {
block_mgr =
CreateMgrAndClient(0, max_num_blocks, block_size, 0, _client_tracker, &client);
- vector<BufferedBlockMgr2::Block*> blocks;
+ std::vector<BufferedBlockMgr2::Block*> blocks;
AllocateBlocks(block_mgr, client, max_num_blocks, &blocks);
// Unpin them all.
@@ -704,7 +704,7 @@ TEST_F(BufferedBlockMgrTest, Deletion) {
RuntimeProfile::Counter* recycled_cnt = profile->get_counter("BlocksRecycled");
RuntimeProfile::Counter* created_cnt = profile->get_counter("BlocksCreated");
- vector<BufferedBlockMgr2::Block*> blocks;
+ std::vector<BufferedBlockMgr2::Block*> blocks;
AllocateBlocks(block_mgr, client, max_num_buffers, &blocks);
EXPECT_TRUE(created_cnt->value() == max_num_buffers);
@@ -776,7 +776,7 @@ TEST_F(BufferedBlockMgrTest, Close) {
block_mgr =
CreateMgrAndClient(0, max_num_buffers, block_size, 0, _client_tracker, &client);
- vector<BufferedBlockMgr2::Block*> blocks;
+ std::vector<BufferedBlockMgr2::Block*> blocks;
AllocateBlocks(block_mgr, client, max_num_buffers, &blocks);
block_mgr->cancel();
@@ -818,7 +818,7 @@ TEST_F(BufferedBlockMgrTest, WriteError) {
block_mgr =
CreateMgrAndClient(0, max_num_buffers, block_size, 0, _client_tracker, &client);
- vector<BufferedBlockMgr2::Block*> blocks;
+ std::vector<BufferedBlockMgr2::Block*> blocks;
AllocateBlocks(block_mgr, client, max_num_buffers, &blocks);
// Unpin two blocks here, to ensure that backing storage is allocated in tmp file.
for (int i = 0; i < 2; ++i) {
@@ -862,7 +862,7 @@ TEST_F(BufferedBlockMgrTest, TmpFileAllocateError) {
BufferedBlockMgr2* block_mgr =
CreateMgrAndClient(0, max_num_buffers, _block_size, 0, _client_tracker, &client);
- vector<BufferedBlockMgr2::Block*> blocks;
+ std::vector<BufferedBlockMgr2::Block*> blocks;
AllocateBlocks(block_mgr, client, max_num_buffers, &blocks);
// Unpin a block, forcing a write.
status = blocks[0]->unpin();
@@ -887,21 +887,21 @@ TEST_F(BufferedBlockMgrTest, TmpFileAllocateError) {
TEST_F(BufferedBlockMgrTest, DISABLED_WriteErrorBlacklist) {
// TEST_F(BufferedBlockMgrTest, WriteErrorBlacklist) {
// Set up two buffered block managers with two temporary dirs.
- vector<string> tmp_dirs = InitMultipleTmpDirs(2);
+ std::vector<string> tmp_dirs = InitMultipleTmpDirs(2);
// Simulate two concurrent queries.
const int NUM_BLOCK_MGRS = 2;
const int MAX_NUM_BLOCKS = 4;
int blocks_per_mgr = MAX_NUM_BLOCKS / NUM_BLOCK_MGRS;
- vector<BufferedBlockMgr2*> block_mgrs;
- vector<BufferedBlockMgr2::Client*> clients;
+ std::vector<BufferedBlockMgr2*> block_mgrs;
+ std::vector<BufferedBlockMgr2::Client*> clients;
CreateMgrsAndClients(0, NUM_BLOCK_MGRS, blocks_per_mgr, _block_size, 0, _client_tracker,
&block_mgrs, &clients);
// Allocate files for all 2x2 combinations by unpinning blocks.
- vector<vector<BufferedBlockMgr2::Block*>> blocks;
- vector<BufferedBlockMgr2::Block*> all_blocks;
+ std::vector<vector<BufferedBlockMgr2::Block*>> blocks;
+ std::vector<BufferedBlockMgr2::Block*> all_blocks;
for (int i = 0; i < NUM_BLOCK_MGRS; ++i) {
- vector<BufferedBlockMgr2::Block*> mgr_blocks;
+ std::vector<BufferedBlockMgr2::Block*> mgr_blocks;
AllocateBlocks(block_mgrs[i], clients[i], blocks_per_mgr, &mgr_blocks);
UnpinBlocks(mgr_blocks);
for (int j = 0; j < blocks_per_mgr; ++j) {
@@ -926,7 +926,7 @@ TEST_F(BufferedBlockMgrTest, DISABLED_WriteErrorBlacklist) {
EXPECT_TRUE(block_mgrs[error_mgr]->is_cancelled());
EXPECT_FALSE(block_mgrs[no_error_mgr]->is_cancelled());
// Temporary device with error should no longer be active.
- vector<TmpFileMgr::DeviceId> active_tmp_devices =
+ std::vector<TmpFileMgr::DeviceId> active_tmp_devices =
_test_env->tmp_file_mgr()->active_tmp_devices();
EXPECT_EQ(tmp_dirs.size() - 1, active_tmp_devices.size());
for (int i = 0; i < active_tmp_devices.size(); ++i) {
@@ -942,7 +942,7 @@ TEST_F(BufferedBlockMgrTest, DISABLED_WriteErrorBlacklist) {
EXPECT_TRUE(FindBlockForDir(blocks[no_error_mgr], good_dir) != NULL);
EXPECT_TRUE(FindBlockForDir(blocks[no_error_mgr], error_dir) != NULL);
// The second block manager should avoid using bad directory for new blocks.
- vector<BufferedBlockMgr2::Block*> no_error_new_blocks;
+ std::vector<BufferedBlockMgr2::Block*> no_error_new_blocks;
AllocateBlocks(block_mgrs[no_error_mgr], clients[no_error_mgr], blocks_per_mgr,
&no_error_new_blocks);
UnpinBlocks(no_error_new_blocks);
@@ -955,7 +955,7 @@ TEST_F(BufferedBlockMgrTest, DISABLED_WriteErrorBlacklist) {
BufferedBlockMgr2::Client* new_client;
BufferedBlockMgr2* new_block_mgr = CreateMgrAndClient(9999, blocks_per_mgr, _block_size, 0,
_client_tracker, &new_client);
- vector<BufferedBlockMgr2::Block*> new_mgr_blocks;
+ std::vector<BufferedBlockMgr2::Block*> new_mgr_blocks;
AllocateBlocks(new_block_mgr, new_client, blocks_per_mgr, &new_mgr_blocks);
UnpinBlocks(new_mgr_blocks);
for (int i = 0; i < blocks_per_mgr; ++i) {
@@ -969,21 +969,21 @@ TEST_F(BufferedBlockMgrTest, DISABLED_WriteErrorBlacklist) {
/// being allocated in other directories.
TEST_F(BufferedBlockMgrTest, AllocationErrorHandling) {
// Set up two buffered block managers with two temporary dirs.
- vector<string> tmp_dirs = InitMultipleTmpDirs(2);
+ std::vector<string> tmp_dirs = InitMultipleTmpDirs(2);
// Simulate two concurrent queries.
int num_block_mgrs = 2;
int max_num_blocks = 4;
int blocks_per_mgr = max_num_blocks / num_block_mgrs;
- // vector<RuntimeState*> runtime_states;
- vector<BufferedBlockMgr2*> block_mgrs;
- vector<BufferedBlockMgr2::Client*> clients;
+ // std::vector<RuntimeState*> runtime_states;
+ std::vector<BufferedBlockMgr2*> block_mgrs;
+ std::vector<BufferedBlockMgr2::Client*> clients;
CreateMgrsAndClients(0, num_block_mgrs, blocks_per_mgr, _block_size, 0, _client_tracker,
&block_mgrs, &clients);
// Allocate files for all 2x2 combinations by unpinning blocks.
- vector<vector<BufferedBlockMgr2::Block*>> blocks;
+ std::vector<vector<BufferedBlockMgr2::Block*>> blocks;
for (int i = 0; i < num_block_mgrs; ++i) {
- vector<BufferedBlockMgr2::Block*> mgr_blocks;
+ std::vector<BufferedBlockMgr2::Block*> mgr_blocks;
LOG(INFO) << "Iter " << i;
AllocateBlocks(block_mgrs[i], clients[i], blocks_per_mgr, &mgr_blocks);
blocks.push_back(mgr_blocks);
@@ -1012,12 +1012,12 @@ TEST_F(BufferedBlockMgrTest, AllocationErrorHandling) {
// Test that block manager fails cleanly when all directories are inaccessible at runtime.
TEST_F(BufferedBlockMgrTest, NoDirsAllocationError) {
- vector<string> tmp_dirs = InitMultipleTmpDirs(2);
+ std::vector<string> tmp_dirs = InitMultipleTmpDirs(2);
int max_num_buffers = 2;
BufferedBlockMgr2::Client* client;
BufferedBlockMgr2* block_mgr =
CreateMgrAndClient(0, max_num_buffers, _block_size, 0, _client_tracker, &client);
- vector<BufferedBlockMgr2::Block*> blocks;
+ std::vector<BufferedBlockMgr2::Block*> blocks;
AllocateBlocks(block_mgr, client, max_num_buffers, &blocks);
for (int i = 0; i < tmp_dirs.size(); ++i) {
const string& tmp_scratch_subdir = tmp_dirs[i] + SCRATCH_SUFFIX;
@@ -1055,7 +1055,7 @@ TEST_F(BufferedBlockMgrTest, MultipleClients) {
reserved = block_mgr->try_acquire_tmp_reservation(client2, 1);
EXPECT_TRUE(reserved);
- vector<BufferedBlockMgr2::Block*> client1_blocks;
+ std::vector<BufferedBlockMgr2::Block*> client1_blocks;
// Allocate all of client1's reserved blocks, they should all succeed.
AllocateBlocks(block_mgr, client1, client1_buffers, &client1_blocks);
@@ -1070,7 +1070,7 @@ TEST_F(BufferedBlockMgrTest, MultipleClients) {
EXPECT_FALSE(reserved);
// Allocate all of client2's reserved blocks, these should succeed.
- vector<BufferedBlockMgr2::Block*> client2_blocks;
+ std::vector<BufferedBlockMgr2::Block*> client2_blocks;
AllocateBlocks(block_mgr, client2, client2_buffers, &client2_blocks);
// Try allocating one more from client 2, that should fail.
@@ -1162,12 +1162,12 @@ TEST_F(BufferedBlockMgrTest, MultipleClientsExtraBuffers) {
EXPECT_TRUE(status.ok());
EXPECT_TRUE(client2 != NULL);
- vector<BufferedBlockMgr2::Block*> client1_blocks;
+ std::vector<BufferedBlockMgr2::Block*> client1_blocks;
// Allocate all of client1's reserved blocks, they should all succeed.
AllocateBlocks(block_mgr, client1, client1_buffers, &client1_blocks);
// Allocate all of client2's reserved blocks, these should succeed.
- vector<BufferedBlockMgr2::Block*> client2_blocks;
+ std::vector<BufferedBlockMgr2::Block*> client2_blocks;
AllocateBlocks(block_mgr, client2, client2_buffers, &client2_blocks);
// We have two spare buffers now. Each client should be able to allocate it.
diff --git a/be/test/runtime/buffered_tuple_stream2_test.cpp b/be/test/runtime/buffered_tuple_stream2_test.cpp
index 251e537..46317c4 100644
--- a/be/test/runtime/buffered_tuple_stream2_test.cpp
+++ b/be/test/runtime/buffered_tuple_stream2_test.cpp
@@ -75,8 +75,8 @@ protected:
}
virtual void create_descriptors() {
- vector<bool> nullable_tuples(1, false);
- vector<TTupleId> tuple_ids(1, static_cast<TTupleId>(0));
+ std::vector<bool> nullable_tuples(1, false);
+ std::vector<TTupleId> tuple_ids(1, static_cast<TTupleId>(0));
DescriptorTblBuilder int_builder(&_pool);
int_builder.declare_tuple() << TYPE_INT;
@@ -170,7 +170,7 @@ protected:
return batch;
}
- void AppendRowTuples(TupleRow* row, vector<int>* results) {
+ void AppendRowTuples(TupleRow* row, std::vector<int>* results) {
DCHECK(row != NULL);
const int int_tuples = _int_desc->tuple_descriptors().size();
for (int i = 0; i < int_tuples; ++i) {
@@ -178,7 +178,7 @@ protected:
}
}
- void AppendRowTuples(TupleRow* row, vector<StringValue>* results) {
+ void AppendRowTuples(TupleRow* row, std::vector<StringValue>* results) {
DCHECK(row != NULL);
const int string_tuples = _string_desc->tuple_descriptors().size();
for (int i = 0; i < string_tuples; ++i) {
@@ -186,7 +186,7 @@ protected:
}
}
- void AppendValue(Tuple* t, vector<int>* results) {
+ void AppendValue(Tuple* t, std::vector<int>* results) {
if (t == NULL) {
// For the tests indicate null-ability using the max int value
results->push_back(std::numeric_limits<int>::max());
@@ -195,7 +195,7 @@ protected:
}
}
- void AppendValue(Tuple* t, vector<StringValue>* results) {
+ void AppendValue(Tuple* t, std::vector<StringValue>* results) {
if (t == NULL) {
results->push_back(StringValue());
} else {
@@ -209,7 +209,7 @@ protected:
}
template <typename T>
- void ReadValues(BufferedTupleStream2* stream, RowDescriptor* desc, vector<T>* results,
+ void ReadValues(BufferedTupleStream2* stream, RowDescriptor* desc, std::vector<T>* results,
int num_batches = -1) {
bool eos = false;
RowBatch batch(*desc, BATCH_SIZE, _tracker.get());
@@ -225,7 +225,7 @@ protected:
} while (!eos && (num_batches < 0 || batches_read <= num_batches));
}
- virtual void VerifyResults(const vector<int>& results, int exp_rows, bool gen_null) {
+ virtual void VerifyResults(const std::vector<int>& results, int exp_rows, bool gen_null) {
const int int_tuples = _int_desc->tuple_descriptors().size();
EXPECT_EQ(results.size(), exp_rows * int_tuples);
for (int i = 0; i < exp_rows; ++i) {
@@ -244,7 +244,7 @@ protected:
}
}
- virtual void VerifyResults(const vector<StringValue>& results, int exp_rows,
+ virtual void VerifyResults(const std::vector<StringValue>& results, int exp_rows,
bool gen_null) {
const int string_tuples = _string_desc->tuple_descriptors().size();
EXPECT_EQ(results.size(), exp_rows * string_tuples);
@@ -308,7 +308,7 @@ protected:
ASSERT_TRUE(status.ok());
// Read all the rows back
- vector<T> results;
+ std::vector<T> results;
ReadValues(&stream, desc, &results);
// Verify result
@@ -329,7 +329,7 @@ protected:
status = stream.unpin_stream();
ASSERT_TRUE(status.ok());
- vector<int> results;
+ std::vector<int> results;
for (int i = 0; i < num_batches; ++i) {
RowBatch* batch = CreateIntBatch(i * BATCH_SIZE, BATCH_SIZE, false);
@@ -353,7 +353,7 @@ protected:
}
}
- scoped_ptr<TestEnv> _test_env;
+ boost::scoped_ptr<TestEnv> _test_env;
RuntimeState* _runtime_state;
BufferedBlockMgr2::Client* _client;
@@ -361,7 +361,7 @@ protected:
ObjectPool _pool;
RowDescriptor* _int_desc;
RowDescriptor* _string_desc;
- scoped_ptr<MemPool> _mem_pool;
+ boost::scoped_ptr<MemPool> _mem_pool;
};
@@ -369,8 +369,8 @@ protected:
class SimpleNullStreamTest : public SimpleTupleStreamTest {
protected:
virtual void create_descriptors() {
- vector<bool> nullable_tuples(1, true);
- vector<TTupleId> tuple_ids(1, static_cast<TTupleId>(0));
+ std::vector<bool> nullable_tuples(1, true);
+ std::vector<TTupleId> tuple_ids(1, static_cast<TTupleId>(0));
DescriptorTblBuilder int_builder(&_pool);
int_builder.declare_tuple() << TYPE_INT;
@@ -388,12 +388,12 @@ protected:
class MultiTupleStreamTest : public SimpleTupleStreamTest {
protected:
virtual void create_descriptors() {
- vector<bool> nullable_tuples;
+ std::vector<bool> nullable_tuples;
nullable_tuples.push_back(false);
nullable_tuples.push_back(false);
nullable_tuples.push_back(false);
- vector<TTupleId> tuple_ids;
+ std::vector<TTupleId> tuple_ids;
tuple_ids.push_back(static_cast<TTupleId>(0));
tuple_ids.push_back(static_cast<TTupleId>(1));
tuple_ids.push_back(static_cast<TTupleId>(2));
@@ -418,12 +418,12 @@ protected:
class MultiNullableTupleStreamTest : public SimpleTupleStreamTest {
protected:
virtual void create_descriptors() {
- vector<bool> nullable_tuples;
+ std::vector<bool> nullable_tuples;
nullable_tuples.push_back(false);
nullable_tuples.push_back(true);
nullable_tuples.push_back(true);
- vector<TTupleId> tuple_ids;
+ std::vector<TTupleId> tuple_ids;
tuple_ids.push_back(static_cast<TTupleId>(0));
tuple_ids.push_back(static_cast<TTupleId>(1));
tuple_ids.push_back(static_cast<TTupleId>(2));
@@ -452,8 +452,8 @@ protected:
virtual void create_descriptors() {
// tuples: (array<string>, array<array<int>>) (array<int>)
- vector<bool> nullable_tuples(2, true);
- vector<TTupleId> tuple_ids;
+ std::vector<bool> nullable_tuples(2, true);
+ std::vector<TTupleId> tuple_ids;
tuple_ids.push_back(static_cast<TTupleId>(0));
tuple_ids.push_back(static_cast<TTupleId>(1));
TypeDescriptor string_array_type;
@@ -555,7 +555,7 @@ TEST_F(SimpleTupleStreamTest, UnpinPin) {
ASSERT_TRUE(status.ok());
ASSERT_TRUE(pinned);
- vector<int> results;
+ std::vector<int> results;
// Read and verify result a few times. We should be able to reread the stream if
// we don't use delete on read mode.
@@ -727,7 +727,7 @@ TEST_F(ArrayTupleStreamTest, TestArrayDeepCopy) {
const int NUM_ROWS = 4000;
BufferedTupleStream2 stream(_runtime_state, *_array_desc, _runtime_state->block_mgr2(),
_client, false, false);
- const vector<TupleDescriptor*>& tuple_descs = _array_desc->tuple_descriptors();
+ const std::vector<TupleDescriptor*>& tuple_descs = _array_desc->tuple_descriptors();
// Write out a predictable pattern of data by iterating over arrays of constants.
int strings_index = 0; // we take the mod of this as index into STRINGS.
int array_lens[] = { 0, 1, 5, 10, 1000, 2, 49, 20 };
@@ -741,11 +741,11 @@ TEST_F(ArrayTupleStreamTest, TestArrayDeepCopy) {
// malloc(tuple_descs[0]->byte_size())));
// gscoped_ptr<Tuple, FreeDeleter> tuple1(reinterpret_cast<Tuple*>(
// malloc(tuple_descs[1]->byte_size())));
- scoped_ptr<TupleRow> row(reinterpret_cast<TupleRow*>(
+ boost::scoped_ptr<TupleRow> row(reinterpret_cast<TupleRow*>(
malloc(tuple_descs.size() * sizeof(Tuple*))));
- scoped_ptr<Tuple> tuple0(reinterpret_cast<Tuple*>(
+ boost::scoped_ptr<Tuple> tuple0(reinterpret_cast<Tuple*>(
malloc(tuple_descs[0]->byte_size())));
- scoped_ptr<Tuple> tuple1(reinterpret_cast<Tuple*>(
+ boost::scoped_ptr<Tuple> tuple1(reinterpret_cast<Tuple*>(
malloc(tuple_descs[1]->byte_size())));
memset(tuple0.get(), 0, tuple_descs[0]->byte_size());
memset(tuple1.get(), 0, tuple_descs[1]->byte_size());
diff --git a/be/test/runtime/data_stream_test.cpp b/be/test/runtime/data_stream_test.cpp
index 527d2fd..1134e0b 100644
--- a/be/test/runtime/data_stream_test.cpp
+++ b/be/test/runtime/data_stream_test.cpp
@@ -220,7 +220,7 @@ protected:
string _stmt;
// RowBatch generation
- scoped_ptr<RowBatch> _batch;
+ boost::scoped_ptr<RowBatch> _batch;
int _next_val;
int64_t* _tuple_mem;
@@ -232,7 +232,7 @@ protected:
TDataStreamSink _broadcast_sink;
TDataStreamSink _random_sink;
TDataStreamSink _hash_sink;
- vector<TPlanFragmentDestination> _dest;
+ std::vector<TPlanFragmentDestination> _dest;
struct SenderInfo {
thread* thread_handle;
@@ -241,7 +241,7 @@ protected:
SenderInfo() : thread_handle(NULL), num_bytes_sent(0) {}
};
- vector<SenderInfo> _sender_info;
+ std::vector<SenderInfo> _sender_info;
struct ReceiverInfo {
TPartitionType::type stream_type;
@@ -267,7 +267,7 @@ protected:
stream_recvr.reset();
}
};
- vector<ReceiverInfo> _receiver_info;
+ std::vector<ReceiverInfo> _receiver_info;
// Create an instance id and add it to _dest
void get_next_instance_id(TUniqueId* instance_id) {
@@ -308,10 +308,10 @@ protected:
EXPECT_TRUE(DescriptorTbl::create(&_obj_pool, thrift_desc_tbl, &_desc_tbl).ok());
_runtime_state.set_desc_tbl(_desc_tbl);
- vector<TTupleId> row_tids;
+ std::vector<TTupleId> row_tids;
row_tids.push_back(0);
- vector<bool> nullable_tuples;
+ std::vector<bool> nullable_tuples;
nullable_tuples.push_back(false);
_row_desc = _obj_pool.add(new RowDescriptor(*_desc_tbl, row_tids, nullable_tuples));
}
@@ -339,9 +339,9 @@ protected:
_rhs_slot_ctx->open(NULL);
SortExecExprs* sort_exprs = _obj_pool.add(new SortExecExprs());
sort_exprs->init(vector<ExprContext*>(1, _lhs_slot_ctx),
- vector<ExprContext*>(1, _rhs_slot_ctx));
+ std::vector<ExprContext*>(1, _rhs_slot_ctx));
_less_than = _obj_pool.add(
- new TupleRowComparator(*sort_exprs, vector<bool>(1, true), vector<bool>(1, false)));
+ new TupleRowComparator(*sort_exprs, std::vector<bool>(1, true), std::vector<bool>(1, false)));
}
// Create _batch, but don't fill it with data yet. Assumes we created _row_desc.
@@ -562,7 +562,7 @@ protected:
EXPECT_TRUE(sender.prepare(&state).ok());
EXPECT_TRUE(sender.open(&state).ok());
- scoped_ptr<RowBatch> batch(create_row_batch());
+ boost::scoped_ptr<RowBatch> batch(create_row_batch());
SenderInfo& info = _sender_info[sender_num];
int next_val = 0;
diff --git a/be/test/runtime/disk_io_mgr_test.cpp b/be/test/runtime/disk_io_mgr_test.cpp
index b6f99ef..0590ba0 100644
--- a/be/test/runtime/disk_io_mgr_test.cpp
+++ b/be/test/runtime/disk_io_mgr_test.cpp
@@ -175,7 +175,7 @@ protected:
return range;
}
- scoped_ptr<ObjectPool> _pool;
+ boost::scoped_ptr<ObjectPool> _pool;
mutex _written_mutex;
condition_variable _writes_done;
@@ -200,7 +200,7 @@ TEST_F(DiskIoMgrTest, SingleWriter) {
EXPECT_TRUE(false);
}
- scoped_ptr<DiskIoMgr> read_io_mgr(new DiskIoMgr(1, 1, 1, 10));
+ boost::scoped_ptr<DiskIoMgr> read_io_mgr(new DiskIoMgr(1, 1, 1, 10));
std::shared_ptr<MemTracker> reader_mem_tracker(new MemTracker(LARGE_MEM_LIMIT));
Status status = read_io_mgr->init(reader_mem_tracker);
ASSERT_TRUE(status.ok());
@@ -318,7 +318,7 @@ TEST_F(DiskIoMgrTest, SingleWriterCancel) {
EXPECT_TRUE(false);
}
- scoped_ptr<DiskIoMgr> read_io_mgr(new DiskIoMgr(1, 1, 1, 10));
+ boost::scoped_ptr<DiskIoMgr> read_io_mgr(new DiskIoMgr(1, 1, 1, 10));
std::shared_ptr<MemTracker> reader_mem_tracker(new MemTracker(LARGE_MEM_LIMIT));
Status status = read_io_mgr->init(reader_mem_tracker);
ASSERT_TRUE(status.ok());
@@ -403,7 +403,7 @@ TEST_F(DiskIoMgrTest, SingleReader) {
status = io_mgr.register_context(&reader, reader_mem_tracker);
ASSERT_TRUE(status.ok());
- vector<DiskIoMgr::ScanRange*> ranges;
+ std::vector<DiskIoMgr::ScanRange*> ranges;
for (int i = 0; i < len; ++i) {
int disk_id = i % num_disks;
ranges.push_back(init_range(num_buffers, tmp_file, 0, len, disk_id,
@@ -460,8 +460,8 @@ TEST_F(DiskIoMgrTest, AddScanRangeTest) {
status = io_mgr.register_context(&reader, reader_mem_tracker);
ASSERT_TRUE(status.ok());
- vector<DiskIoMgr::ScanRange*> ranges_first_half;
- vector<DiskIoMgr::ScanRange*> ranges_second_half;
+ std::vector<DiskIoMgr::ScanRange*> ranges_first_half;
+ std::vector<DiskIoMgr::ScanRange*> ranges_second_half;
for (int i = 0; i < len; ++i) {
int disk_id = i % num_disks;
if (i > len / 2) {
@@ -546,7 +546,7 @@ TEST_F(DiskIoMgrTest, SyncReadTest) {
validate_sync_read(&io_mgr, reader, complete_range, data);
validate_sync_read(&io_mgr, reader, complete_range, data);
- vector<DiskIoMgr::ScanRange*> ranges;
+ std::vector<DiskIoMgr::ScanRange*> ranges;
for (int i = 0; i < len; ++i) {
int disk_id = i % num_disks;
ranges.push_back(init_range(num_buffers, tmp_file, 0, len, disk_id,
@@ -612,7 +612,7 @@ TEST_F(DiskIoMgrTest, SingleReaderCancel) {
status = io_mgr.register_context(&reader, reader_mem_tracker);
ASSERT_TRUE(status.ok());
- vector<DiskIoMgr::ScanRange*> ranges;
+ std::vector<DiskIoMgr::ScanRange*> ranges;
for (int i = 0; i < len; ++i) {
int disk_id = i % num_disks;
ranges.push_back(init_range(num_buffers, tmp_file, 0, len, disk_id,
@@ -682,7 +682,7 @@ TEST_F(DiskIoMgrTest, MemTrackers) {
status = io_mgr.register_context(&reader, reader_mem_tracker);
ASSERT_TRUE(status.ok());
- vector<DiskIoMgr::ScanRange*> ranges;
+ std::vector<DiskIoMgr::ScanRange*> ranges;
for (int i = 0; i < num_buffers; ++i) {
ranges.push_back(init_range(num_buffers, tmp_file, 0, len, 0,
stat_val.st_mtime));
@@ -691,7 +691,7 @@ TEST_F(DiskIoMgrTest, MemTrackers) {
ASSERT_TRUE(status.ok());
// Don't return buffers to force memory pressure
- vector<DiskIoMgr::BufferDescriptor*> buffers;
+ std::vector<DiskIoMgr::BufferDescriptor*> buffers;
AtomicInt<int> num_ranges_processed;
scan_range_thread(&io_mgr, reader, data, strlen(data), Status::MemoryLimitExceeded("Mem"),
@@ -767,7 +767,7 @@ TEST_F(DiskIoMgrTest, CachedReads) {
validate_sync_read(&io_mgr, reader, complete_range, data);
validate_sync_read(&io_mgr, reader, complete_range, data);
- vector<DiskIoMgr::ScanRange*> ranges;
+ std::vector<DiskIoMgr::ScanRange*> ranges;
for (int i = 0; i < len; ++i) {
int disk_id = i % num_disks;
ranges.push_back(init_range(num_buffers, tmp_file, 0, len, disk_id,
@@ -824,7 +824,7 @@ TEST_F(DiskIoMgrTest, MultipleReaderWriter) {
stat(file_name.c_str(), &stat_val);
int64_t iters = 0;
- vector<DiskIoMgr::RequestContext*> contexts(num_contexts);
+ std::vector<DiskIoMgr::RequestContext*> contexts(num_contexts);
Status status;
for (int iteration = 0; iteration < ITERATIONS; ++iteration) {
for (int threads_per_disk = 1; threads_per_disk <= 5; ++threads_per_disk) {
@@ -845,7 +845,7 @@ TEST_F(DiskIoMgrTest, MultipleReaderWriter) {
}
AtomicInt<int> num_ranges_processed;
thread_group threads;
- vector<DiskIoMgr::ScanRange*> ranges;
+ std::vector<DiskIoMgr::ScanRange*> ranges;
int num_scan_ranges = std::min<int>(num_reads_queued, write_offset - read_offset);
for (int i = 0; i < num_scan_ranges; ++i) {
ranges.push_back(init_range(1, file_name.c_str(), read_offset, 1,
@@ -900,11 +900,11 @@ TEST_F(DiskIoMgrTest, MultipleReader) {
const int ITERATIONS = 25;
const int NUM_THREADS_PER_READER = 3;
- vector<string> file_names;
- vector<int64_t> mtimes;
- vector<string> data;
- vector<DiskIoMgr::RequestContext*> readers;
- vector<char*> results;
+ std::vector<string> file_names;
+ std::vector<int64_t> mtimes;
+ std::vector<string> data;
+ std::vector<DiskIoMgr::RequestContext*> readers;
+ std::vector<char*> results;
file_names.resize(NUM_READERS);
readers.resize(NUM_READERS);
@@ -922,7 +922,7 @@ TEST_F(DiskIoMgrTest, MultipleReader) {
}
data[i] = string(buf, DATA_LEN);
- stringstream ss;
+ std::stringstream ss;
ss << "/tmp/disk_io_mgr_test" << i << ".txt";
file_names[i] = ss.str();
CreateTempFile(ss.str().c_str(), data[i].c_str());
@@ -955,7 +955,7 @@ TEST_F(DiskIoMgrTest, MultipleReader) {
status = io_mgr.register_context(&readers[i], NULL);
ASSERT_TRUE(status.ok());
- vector<DiskIoMgr::ScanRange*> ranges;
+ std::vector<DiskIoMgr::ScanRange*> ranges;
for (int j = 0; j < DATA_LEN; ++j) {
int disk_id = j % num_disks;
ranges.push_back(
@@ -1067,7 +1067,7 @@ TEST_F(DiskIoMgrTest, PartialRead) {
stat(tmp_file, &stat_val);
_pool.reset(new ObjectPool);
- scoped_ptr<DiskIoMgr> io_mgr(new DiskIoMgr(1, 1, read_len, read_len));
+ boost::scoped_ptr<DiskIoMgr> io_mgr(new DiskIoMgr(1, 1, read_len, read_len));
Status status = io_mgr->init(mem_tracker);
ASSERT_TRUE(status.ok());
diff --git a/be/test/runtime/memory_scratch_sink_test.cpp b/be/test/runtime/memory_scratch_sink_test.cpp
index a7b2321..d607e7f 100644
--- a/be/test/runtime/memory_scratch_sink_test.cpp
+++ b/be/test/runtime/memory_scratch_sink_test.cpp
@@ -179,10 +179,10 @@ void MemoryScratchSinkTest::init_desc_tbl() {
DescriptorTbl::create(&_obj_pool, _t_desc_table, &_desc_tbl);
- vector<TTupleId> row_tids;
+ std::vector<TTupleId> row_tids;
row_tids.push_back(0);
- vector<bool> nullable_tuples;
+ std::vector<bool> nullable_tuples;
nullable_tuples.push_back(false);
_row_desc = _obj_pool.add(new RowDescriptor(*_desc_tbl, row_tids, nullable_tuples));
diff --git a/be/test/runtime/tmp_file_mgr_test.cpp b/be/test/runtime/tmp_file_mgr_test.cpp
index 62fec4d..1b4e7f7 100644
--- a/be/test/runtime/tmp_file_mgr_test.cpp
+++ b/be/test/runtime/tmp_file_mgr_test.cpp
@@ -42,7 +42,7 @@ protected:
// Check that metric values are consistent with TmpFileMgr state.
void check_metrics(TmpFileMgr* tmp_file_mgr) {
- vector<TmpFileMgr::DeviceId> active = tmp_file_mgr->active_tmp_devices();
+ std::vector<TmpFileMgr::DeviceId> active = tmp_file_mgr->active_tmp_devices();
int64_t active_metric =
DorisMetrics::instance()->metric_registry()->get_entity("server")->get_metric("active_scratch_dirs").value();
EXPECT_EQ(active.size(), active_metric);
@@ -56,7 +56,7 @@ TEST_F(TmpFileMgrTest, TestFileAllocation) {
EXPECT_TRUE(tmp_file_mgr.init().ok());
// Default configuration should give us one temporary device.
EXPECT_EQ(1, tmp_file_mgr.num_active_tmp_devices());
- vector<TmpFileMgr::DeviceId> tmp_devices = tmp_file_mgr.active_tmp_devices();
+ std::vector<TmpFileMgr::DeviceId> tmp_devices = tmp_file_mgr.active_tmp_devices();
EXPECT_EQ(1, tmp_devices.size());
TUniqueId id;
TmpFileMgr::File *file;
@@ -86,7 +86,7 @@ TEST_F(TmpFileMgrTest, TestFileAllocation) {
// Test that we can do initialization with two directories on same device and
// that validations prevents duplication of directories.
TEST_F(TmpFileMgrTest, TestOneDirPerDevice) {
- vector<string> tmp_dirs;
+ std::vector<string> tmp_dirs;
tmp_dirs.push_back("/tmp/tmp-file-mgr-test.1");
tmp_dirs.push_back("/tmp/tmp-file-mgr-test.2");
for (int i = 0; i < tmp_dirs.size(); ++i) {
@@ -97,7 +97,7 @@ TEST_F(TmpFileMgrTest, TestOneDirPerDevice) {
// Only the first directory should be used.
EXPECT_EQ(1, tmp_file_mgr.num_active_tmp_devices());
- vector<TmpFileMgr::DeviceId> devices = tmp_file_mgr.active_tmp_devices();
+ std::vector<TmpFileMgr::DeviceId> devices = tmp_file_mgr.active_tmp_devices();
EXPECT_EQ(1, devices.size());
TUniqueId id;
TmpFileMgr::File *file;
@@ -110,7 +110,7 @@ TEST_F(TmpFileMgrTest, TestOneDirPerDevice) {
// Test that we can do custom initialization with two dirs on same device.
TEST_F(TmpFileMgrTest, TestMultiDirsPerDevice) {
- vector<string> tmp_dirs;
+ std::vector<string> tmp_dirs;
tmp_dirs.push_back("/tmp/tmp-file-mgr-test.1");
tmp_dirs.push_back("/tmp/tmp-file-mgr-test.2");
for (int i = 0; i < tmp_dirs.size(); ++i) {
@@ -121,7 +121,7 @@ TEST_F(TmpFileMgrTest, TestMultiDirsPerDevice) {
// Both directories should be used.
EXPECT_EQ(2, tmp_file_mgr.num_active_tmp_devices());
- vector<TmpFileMgr::DeviceId> devices = tmp_file_mgr.active_tmp_devices();
+ std::vector<TmpFileMgr::DeviceId> devices = tmp_file_mgr.active_tmp_devices();
EXPECT_EQ(2, devices.size());
for (int i = 0; i < tmp_dirs.size(); ++i) {
EXPECT_EQ(0, tmp_file_mgr.get_tmp_dir_path(devices[i]).find(tmp_dirs[i]));
@@ -138,7 +138,7 @@ TEST_F(TmpFileMgrTest, TestMultiDirsPerDevice) {
// Test that reporting a write error is possible but does not result in
// blacklisting, which is disabled.
TEST_F(TmpFileMgrTest, TestReportError) {
- vector<string> tmp_dirs;
+ std::vector<string> tmp_dirs;
tmp_dirs.push_back("/tmp/tmp-file-mgr-test.1");
tmp_dirs.push_back("/tmp/tmp-file-mgr-test.2");
for (int i = 0; i < tmp_dirs.size(); ++i) {
@@ -148,7 +148,7 @@ TEST_F(TmpFileMgrTest, TestReportError) {
tmp_file_mgr.init_custom(tmp_dirs, false);
// Both directories should be used.
- vector<TmpFileMgr::DeviceId> devices = tmp_file_mgr.active_tmp_devices();
+ std::vector<TmpFileMgr::DeviceId> devices = tmp_file_mgr.active_tmp_devices();
EXPECT_EQ(2, devices.size());
// check_metrics(&tmp_file_mgr);
@@ -166,7 +166,7 @@ TEST_F(TmpFileMgrTest, TestReportError) {
EXPECT_FALSE(bad_file->is_blacklisted());
// The second device should still be active.
EXPECT_EQ(2, tmp_file_mgr.num_active_tmp_devices());
- vector<TmpFileMgr::DeviceId> devices_after = tmp_file_mgr.active_tmp_devices();
+ std::vector<TmpFileMgr::DeviceId> devices_after = tmp_file_mgr.active_tmp_devices();
EXPECT_EQ(2, devices_after.size());
// check_metrics(&tmp_file_mgr);
@@ -188,7 +188,7 @@ TEST_F(TmpFileMgrTest, TestReportError) {
TEST_F(TmpFileMgrTest, TestAllocateFails) {
string tmp_dir("/tmp/tmp-file-mgr-test.1");
string scratch_subdir = tmp_dir + "/doris-scratch";
- vector<string> tmp_dirs(1, tmp_dir);
+ std::vector<string> tmp_dirs(1, tmp_dir);
EXPECT_TRUE(FileSystemUtil::create_directory(tmp_dir).ok());
TmpFileMgr tmp_file_mgr;
tmp_file_mgr.init_custom(tmp_dirs, false);
diff --git a/be/test/util/arrow/arrow_work_flow_test.cpp b/be/test/util/arrow/arrow_work_flow_test.cpp
index 05806f8..7e665d0 100644
--- a/be/test/util/arrow/arrow_work_flow_test.cpp
+++ b/be/test/util/arrow/arrow_work_flow_test.cpp
@@ -247,10 +247,10 @@ void ArrowWorkFlowTest::init_desc_tbl() {
DescriptorTbl::create(&_obj_pool, _t_desc_table, &_desc_tbl);
- vector<TTupleId> row_tids;
+ std::vector<TTupleId> row_tids;
row_tids.push_back(0);
- vector<bool> nullable_tuples;
+ std::vector<bool> nullable_tuples;
nullable_tuples.push_back(false);
// node
diff --git a/be/test/util/decompress_test.cpp b/be/test/util/decompress_test.cpp
index fd0c957..6d130b9 100644
--- a/be/test/util/decompress_test.cpp
+++ b/be/test/util/decompress_test.cpp
@@ -46,8 +46,8 @@ protected:
}
void RunTest(THdfsCompression::type format) {
- scoped_ptr<Codec> compressor;
- scoped_ptr<Codec> decompressor;
+ boost::scoped_ptr<Codec> compressor;
+ boost::scoped_ptr<Codec> decompressor;
MemPool* mem_pool = new MemPool;
EXPECT_TRUE(
diff --git a/be/test/util/internal_queue_test.cpp b/be/test/util/internal_queue_test.cpp
index 6cb8176..a8942e2 100644
--- a/be/test/util/internal_queue_test.cpp
+++ b/be/test/util/internal_queue_test.cpp
@@ -121,7 +121,7 @@ TEST(InternalQueue, TestBasic) {
// Add all the nodes and then remove every other one.
TEST(InternalQueue, TestRemove) {
- vector<IntNode> nodes;
+ std::vector<IntNode> nodes;
nodes.resize(100);
InternalQueue<IntNode> queue;
@@ -158,7 +158,7 @@ const int VALIDATE_INTERVAL = 10000;
void ProducerThread(
InternalQueue<IntNode>* queue,
int num_inserts,
- vector<IntNode>* nodes,
+ std::vector<IntNode>* nodes,
AtomicInt<int32_t>* counter,
bool* failed) {
for (int i = 0; i < num_inserts && !*failed; ++i) {
@@ -178,7 +178,7 @@ void ConsumerThread(
InternalQueue<IntNode>* queue,
int num_consumes,
int delta,
- vector<int>* results,
+ std::vector<int>* results,
bool* failed) {
// Dequeued nodes should be strictly increasing.
int previous_value = -1;
@@ -208,7 +208,7 @@ void ConsumerThread(
}
TEST(InternalQueue, TestClear) {
- vector<IntNode> nodes;
+ std::vector<IntNode> nodes;
nodes.resize(100);
InternalQueue<IntNode> queue;
queue.enqueue(&nodes[0]);
@@ -227,10 +227,10 @@ TEST(InternalQueue, TestClear) {
}
TEST(InternalQueue, TestSingleProducerSingleConsumer) {
- vector<IntNode> nodes;
+ std::vector<IntNode> nodes;
AtomicInt<int32_t> counter;
nodes.resize(1000000);
- vector<int> results;
+ std::vector<int> results;
InternalQueue<IntNode> queue;
bool failed = false;
@@ -252,7 +252,7 @@ TEST(InternalQueue, TestSingleProducerSingleConsumer) {
}
TEST(InternalQueue, TestMultiProducerMultiConsumer) {
- vector<IntNode> nodes;
+ std::vector<IntNode> nodes;
nodes.resize(1000000);
bool failed = false;
@@ -264,7 +264,7 @@ TEST(InternalQueue, TestMultiProducerMultiConsumer) {
const int num_per_consumer = nodes.size() / NUM_CONSUMERS;
const int num_per_producer = nodes.size() / num_producers;
- vector<vector<int>> results;
+ std::vector<vector<int>> results;
results.resize(NUM_CONSUMERS);
int expected_delta = -1;
@@ -301,7 +301,7 @@ TEST(InternalQueue, TestMultiProducerMultiConsumer) {
ASSERT_TRUE(queue.empty());
ASSERT_TRUE(!failed);
- vector<int> all_results;
+ std::vector<int> all_results;
for (int i = 0; i < NUM_CONSUMERS; ++i) {
ASSERT_EQ(results[i].size(), num_per_consumer);
all_results.insert(all_results.end(), results[i].begin(), results[i].end());
diff --git a/be/test/util/path_util_test.cpp b/be/test/util/path_util_test.cpp
index 62c1839..132ea80 100644
--- a/be/test/util/path_util_test.cpp
+++ b/be/test/util/path_util_test.cpp
@@ -70,7 +70,7 @@ TEST(TestPathUtil, DirNameTest) {
}
TEST(TestPathUtil, SplitPathTest) {
- using Vec = vector<string>;
+ using Vec = std::vector<string>;
ASSERT_EQ(Vec({"/"}), path_util::split_path("/"));
ASSERT_EQ(Vec({"/", "a", "b"}), path_util::split_path("/a/b"));
ASSERT_EQ(Vec({"/", "a", "b"}), path_util::split_path("/a/b/"));
diff --git a/be/test/util/perf_counters_test.cpp b/be/test/util/perf_counters_test.cpp
index 92c0da2..4ac307c 100644
--- a/be/test/util/perf_counters_test.cpp
+++ b/be/test/util/perf_counters_test.cpp
@@ -60,10 +60,10 @@ TEST(CpuInfoTest, Basic) {
TEST(DiskInfoTest, Basic) {
cout << DiskInfo::DebugString();
- cout << "Device name for disk 0: " << DiskInfo::device_name(0) << endl;
+ cout << "Device name for disk 0: " << DiskInfo::device_name(0) << std::endl;
int disk_id_home_dir = DiskInfo::disk_id("/home");
- cout << "Device name for '/home': " << DiskInfo::device_name(disk_id_home_dir) << endl;
+ cout << "Device name for '/home': " << DiskInfo::device_name(disk_id_home_dir) << std::endl;
}
}
diff --git a/be/test/util/rle_encoding_test.cpp b/be/test/util/rle_encoding_test.cpp
index 8c8491c..458067b 100644
--- a/be/test/util/rle_encoding_test.cpp
+++ b/be/test/util/rle_encoding_test.cpp
@@ -49,7 +49,7 @@ class TestRle : public testing::Test {};
// exactly 'expected_encoding'.
// if expected_len is not -1, it will validate the encoded size is correct.
template<typename T>
-void ValidateRle(const vector<T>& values, int bit_width,
+void ValidateRle(const std::vector<T>& values, int bit_width,
uint8_t* expected_encoding, int expected_len) {
faststring buffer;
RleEncoder<T> encoder(&buffer, bit_width);
@@ -82,7 +82,7 @@ void ValidateRle(const vector<T>& values, int bit_width,
TEST(Rle, SpecificSequences) {
const int kTestLen = 1024;
uint8_t expected_buffer[kTestLen];
- vector<uint64_t> values;
+ std::vector<uint64_t> values;
// Test 50 0' followed by 50 1's
values.resize(100);
@@ -129,7 +129,7 @@ TEST(Rle, SpecificSequences) {
// is used, otherwise alternating values are used.
void TestRleValues(int bit_width, int num_vals, int value = -1) {
const uint64_t mod = bit_width == 64 ? 1ULL : 1ULL << bit_width;
- vector<uint64_t> values;
+ std::vector<uint64_t> values;
for (uint64_t v = 0; v < num_vals; ++v) {
values.push_back((value != -1) ? value : (bit_width == 64 ? v : (v % mod)));
}
@@ -157,7 +157,7 @@ public:
// Tests all true/false values
TEST_F(BitRle, AllSame) {
const int kTestLen = 1024;
- vector<bool> values;
+ std::vector<bool> values;
for (int v = 0; v < 2; ++v) {
values.clear();
@@ -172,7 +172,7 @@ TEST_F(BitRle, AllSame) {
// Test that writes out a repeated group and then a literal
// group but flush before finishing.
TEST_F(BitRle, Flush) {
- vector<bool> values;
+ std::vector<bool> values;
for (int i = 0; i < 16; ++i) values.push_back(1);
values.push_back(false);
ValidateRle(values, 1, nullptr, -1);
@@ -191,7 +191,7 @@ TEST_F(BitRle, RandomBools) {
while (iters < n_iters) {
srand(iters++);
if (iters % 10000 == 0) LOG(ERROR) << "Seed: " << iters;
- vector<uint64_t > values;
+ std::vector<uint64_t > values;
bool parity = 0;
for (int i = 0; i < 1000; ++i) {
int group_size = rand() % 20 + 1; // NOLINT(*)
@@ -214,7 +214,7 @@ TEST_F(BitRle, Random64Bit) {
while (iters < n_iters) {
srand(iters++);
if (iters % 10000 == 0) LOG(ERROR) << "Seed: " << iters;
- vector<uint64_t > values;
+ std::vector<uint64_t > values;
for (int i = 0; i < 1000; ++i) {
int group_size = rand() % 20 + 1; // NOLINT(*)
uint64_t cur_value = (static_cast<uint64_t>(rand()) << 32) + static_cast<uint64_t>(rand());
@@ -233,7 +233,7 @@ TEST_F(BitRle, Random64Bit) {
// Test a sequence of 1 0's, 2 1's, 3 0's. etc
// e.g. 011000111100000
TEST_F(BitRle, RepeatedPattern) {
- vector<bool> values;
+ std::vector<bool> values;
const int min_run = 1;
const int max_run = 32;
@@ -344,10 +344,10 @@ TEST_F(TestRle, TestRoundTripRandomSequencesWithRuns) {
// through the encode/decode sequence.
for (int rep = 0; rep < 100; rep++) {
faststring buf;
- string string_rep;
+ std::string string_rep;
int num_bits = GenerateRandomBitString(10, &buf, &string_rep);
RleDecoder<bool> decoder(buf.data(), buf.size(), 1);
- string roundtrip_str;
+ std::string roundtrip_str;
int rem_to_read = num_bits;
size_t run_len;
bool val;
diff --git a/be/test/util/runtime_profile_test.cpp b/be/test/util/runtime_profile_test.cpp
index c06591e..0a8e494 100644
--- a/be/test/util/runtime_profile_test.cpp
+++ b/be/test/util/runtime_profile_test.cpp
@@ -159,7 +159,7 @@ TEST(CountersTest, MergeAndUpdate) {
ValidateCounter(merged_profile, "Parent 1 Only", 2);
ValidateCounter(merged_profile, "Parent 2 Only", 5);
- vector<RuntimeProfile*> children;
+ std::vector<RuntimeProfile*> children;
merged_profile->GetChildren(&children);
EXPECT_EQ(children.size(), 3);
@@ -183,7 +183,7 @@ TEST(CountersTest, MergeAndUpdate) {
}
// make sure we can print
- stringstream dummy;
+ std::stringstream dummy;
merged_profile->PrettyPrint(&dummy);
// Update profile2 w/ profile1 and validate
@@ -330,7 +330,7 @@ TEST(CountersTest, BucketCounters) {
unit_counter->Set(1L);
// Create the bucket counters and start sampling
- vector<RuntimeProfile::Counter*> buckets;
+ std::vector<RuntimeProfile::Counter*> buckets;
profile.AddBucketingCounters("BucketCounters", "", unit_counter, 2, &buckets);
// Wait two seconds.
diff --git a/be/test/util/threadpool_test.cpp b/be/test/util/threadpool_test.cpp
index f3ea989..13c2bc0 100644
--- a/be/test/util/threadpool_test.cpp
+++ b/be/test/util/threadpool_test.cpp
@@ -54,7 +54,7 @@ using std::atomic;
using std::shared_ptr;
using std::string;
using std::thread;
-using std::unique_ptr;
+
using std::vector;
using strings::Substitute;
@@ -83,7 +83,7 @@ public:
}
protected:
- unique_ptr<ThreadPool> _pool;
+ std::unique_ptr<ThreadPool> _pool;
};
TEST_F(ThreadPoolTest, TestNoTaskOpenClose) {
@@ -194,8 +194,8 @@ TEST_F(ThreadPoolTest, TestThreadPoolWithNoMaxThreads) {
ASSERT_EQ((kNumCPUs * 2), _pool->num_threads());
// submit tasks on two tokens. Only two threads should be created.
- unique_ptr<ThreadPoolToken> t1 = _pool->new_token(ThreadPool::ExecutionMode::SERIAL);
- unique_ptr<ThreadPoolToken> t2 = _pool->new_token(ThreadPool::ExecutionMode::SERIAL);
+ std::unique_ptr<ThreadPoolToken> t1 = _pool->new_token(ThreadPool::ExecutionMode::SERIAL);
+ std::unique_ptr<ThreadPoolToken> t2 = _pool->new_token(ThreadPool::ExecutionMode::SERIAL);
for (int i = 0; i < kNumCPUs * 2; i++) {
ThreadPoolToken* t = (i % 2 == 0) ? t1.get() : t2.get();
ASSERT_TRUE(t->submit(SlowTask::new_slow_task(&latch)).ok());
@@ -363,7 +363,7 @@ INSTANTIATE_TEST_CASE_P(Tokens, ThreadPoolTestTokenTypes,
ThreadPool::ExecutionMode::CONCURRENT));
TEST_P(ThreadPoolTestTokenTypes, TestTokenSubmitAndWait) {
- unique_ptr<ThreadPoolToken> t = _pool->new_token(GetParam());
+ std::unique_ptr<ThreadPoolToken> t = _pool->new_token(GetParam());
int i = 0;
Status status = t->submit_func([&]() {
SleepFor(MonoDelta::FromMilliseconds(1));
@@ -375,7 +375,7 @@ TEST_P(ThreadPoolTestTokenTypes, TestTokenSubmitAndWait) {
}
TEST_F(ThreadPoolTest, TestTokenSubmitsProcessedSerially) {
- unique_ptr<ThreadPoolToken> t = _pool->new_token(ThreadPool::ExecutionMode::SERIAL);
+ std::unique_ptr<ThreadPoolToken> t = _pool->new_token(ThreadPool::ExecutionMode::SERIAL);
int32_t seed = static_cast<int32_t>(GetCurrentTimeMicros());
srand(seed);
Random r(seed);
@@ -398,7 +398,7 @@ TEST_P(ThreadPoolTestTokenTypes, TestTokenSubmitsProcessedConcurrently) {
const int kNumTokens = 5;
ASSERT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName)
.set_max_threads(kNumTokens)).ok());
- vector<unique_ptr<ThreadPoolToken>> tokens;
+ std::vector<std::unique_ptr<ThreadPoolToken>> tokens;
// A violation to the tested invariant would yield a deadlock, so let's set
// up an alarm to bail us out.
@@ -430,7 +430,7 @@ TEST_F(ThreadPoolTest, TestTokenSubmitsNonSequential) {
alarm(0); // Disable alarm on test exit.
});
shared_ptr<Barrier> b = std::make_shared<Barrier>(kNumSubmissions + 1);
- unique_ptr<ThreadPoolToken> t = _pool->new_token(ThreadPool::ExecutionMode::CONCURRENT);
+ std::unique_ptr<ThreadPoolToken> t = _pool->new_token(ThreadPool::ExecutionMode::CONCURRENT);
for (int i = 0; i < kNumSubmissions; i++) {
ASSERT_TRUE(t->submit_func([b]() {
b->wait();
@@ -445,8 +445,8 @@ TEST_P(ThreadPoolTestTokenTypes, TestTokenShutdown) {
ASSERT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName)
.set_max_threads(4)).ok());
- unique_ptr<ThreadPoolToken> t1(_pool->new_token(GetParam()));
- unique_ptr<ThreadPoolToken> t2(_pool->new_token(GetParam()));
+ std::unique_ptr<ThreadPoolToken> t1(_pool->new_token(GetParam()));
+ std::unique_ptr<ThreadPoolToken> t2(_pool->new_token(GetParam()));
CountDownLatch l1(1);
CountDownLatch l2(1);
@@ -489,7 +489,7 @@ TEST_P(ThreadPoolTestTokenTypes, TestTokenWaitForAll) {
int32_t seed = static_cast<int32_t>(GetCurrentTimeMicros());
srand(seed);
Random r(seed);
- vector<unique_ptr<ThreadPoolToken>> tokens;
+ std::vector<std::unique_ptr<ThreadPoolToken>> tokens;
for (int i = 0; i < kNumTokens; i++) {
tokens.emplace_back(_pool->new_token(GetParam()));
}
@@ -522,7 +522,7 @@ TEST_F(ThreadPoolTest, TestFuzz) {
int32_t seed = static_cast<int32_t>(GetCurrentTimeMicros());
srand(seed);
Random r(seed);
- vector<unique_ptr<ThreadPoolToken>> tokens;
+ std::vector<std::unique_ptr<ThreadPoolToken>> tokens;
for (int i = 0; i < kNumOperations; i++) {
// Operation distribution:
@@ -605,7 +605,7 @@ TEST_P(ThreadPoolTestTokenTypes, TestTokenSubmissionsAdhereToMaxQueueSize) {
.set_max_queue_size(1)).ok());
CountDownLatch latch(1);
- unique_ptr<ThreadPoolToken> t = _pool->new_token(GetParam());
+ std::unique_ptr<ThreadPoolToken> t = _pool->new_token(GetParam());
SCOPED_CLEANUP({
latch.count_down();
});
@@ -625,7 +625,7 @@ TEST_F(ThreadPoolTest, TestTokenConcurrency) {
const int kWaitThreads = 2;
const int kSubmitThreads = 8;
- vector<shared_ptr<ThreadPoolToken>> tokens;
+ std::vector<shared_ptr<ThreadPoolToken>> tokens;
int32_t seed = static_cast<int32_t>(GetCurrentTimeMicros());
srand(seed);
Random rng(seed);
@@ -658,7 +658,7 @@ TEST_F(ThreadPoolTest, TestTokenConcurrency) {
atomic<int64_t> total_num_tokens_submitted(0);
CountDownLatch latch(1);
- vector<thread> threads;
+ std::vector<thread> threads;
for (int i = 0; i < kCycleThreads; i++) {
// Pick a token at random and replace it.
@@ -737,13 +737,13 @@ TEST_F(ThreadPoolTest, TestTokenConcurrency) {
t.join();
}
- LOG(INFO) << Substitute("Tokens cycled ($0 threads): $1",
+ LOG(INFO) << strings::Substitute("Tokens cycled ($0 threads): $1",
kCycleThreads, total_num_tokens_cycled.load());
- LOG(INFO) << Substitute("Tokens shutdown ($0 threads): $1",
+ LOG(INFO) << strings::Substitute("Tokens shutdown ($0 threads): $1",
kShutdownThreads, total_num_tokens_shutdown.load());
- LOG(INFO) << Substitute("Tokens waited ($0 threads): $1",
+ LOG(INFO) << strings::Substitute("Tokens waited ($0 threads): $1",
kWaitThreads, total_num_tokens_waited.load());
- LOG(INFO) << Substitute("Tokens submitted ($0 threads): $1",
+ LOG(INFO) << strings::Substitute("Tokens submitted ($0 threads): $1",
kSubmitThreads, total_num_tokens_submitted.load());
}
diff --git a/be/test/util/trace_test.cpp b/be/test/util/trace_test.cpp
index 0d5a954..c6295ed 100644
--- a/be/test/util/trace_test.cpp
+++ b/be/test/util/trace_test.cpp
@@ -55,8 +55,8 @@ class TraceTest : public ::testing::Test {
};
// Replace all digits in 's' with the character 'X'.
-static string XOutDigits(const string& s) {
- string ret;
+static std::string XOutDigits(const string& s) {
+ std::string ret;
ret.reserve(s.size());
for (char c : s) {
if (isdigit(c)) {
@@ -73,7 +73,7 @@ TEST_F(TraceTest, TestBasic) {
TRACE_TO(t, "hello $0, $1", "world", 12345);
TRACE_TO(t, "goodbye $0, $1", "cruel world", 54321);
- string result = XOutDigits(t->DumpToString(Trace::NO_FLAGS));
+ std::string result = XOutDigits(t->DumpToString(Trace::NO_FLAGS));
ASSERT_EQ("XXXX XX:XX:XX.XXXXXX trace_test.cpp:XX] hello world, XXXXX\n"
"XXXX XX:XX:XX.XXXXXX trace_test.cpp:XX] goodbye cruel world, XXXXX\n",
result);
diff --git a/be/test/util/url_coding_test.cpp b/be/test/util/url_coding_test.cpp
index 3845602..9e0a4b0 100644
--- a/be/test/util/url_coding_test.cpp
+++ b/be/test/util/url_coding_test.cpp
@@ -29,7 +29,7 @@ namespace doris {
void test_url(const string& input, const string& expected_encoded, bool hive_compat) {
std::string intermediate;
url_encode(input, &intermediate, hive_compat);
- string output;
+ std::string output;
if (!expected_encoded.empty()) {
EXPECT_EQ(intermediate, expected_encoded);
@@ -39,18 +39,18 @@ void test_url(const string& input, const string& expected_encoded, bool hive_com
EXPECT_EQ(input, output);
// Convert string to vector and try that also
- vector<uint8_t> input_vector;
+ std::vector<uint8_t> input_vector;
input_vector.resize(input.size());
memcpy(&input_vector[0], input.c_str(), input.size());
- string intermediate2;
+ std::string intermediate2;
url_encode(input_vector, &intermediate2, hive_compat);
EXPECT_EQ(intermediate, intermediate2);
}
void test_base64(const string& input, const string& expected_encoded) {
- string intermediate;
+ std::string intermediate;
Base64Encode(input, &intermediate);
- string output;
+ std::string output;
if (!expected_encoded.empty()) {
EXPECT_EQ(intermediate, expected_encoded);
@@ -60,10 +60,10 @@ void test_base64(const string& input, const string& expected_encoded) {
EXPECT_EQ(input, output);
// Convert string to vector and try that also
- vector<uint8_t> input_vector;
+ std::vector<uint8_t> input_vector;
input_vector.resize(input.size());
memcpy(&input_vector[0], input.c_str(), input.size());
- string intermediate2;
+ std::string intermediate2;
Base64Encode(input_vector, &intermediate2);
EXPECT_EQ(intermediate, intermediate2);
}
@@ -100,8 +100,8 @@ TEST(Base64Test, Basic) {
}
TEST(HtmlEscapingTest, Basic) {
- string before = "<html><body>&";
- stringstream after;
+ std::string before = "<html><body>&";
+ std::stringstream after;
EscapeForHtml(before, &after);
EXPECT_EQ(after.str(), "<html><body>&amp");
}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@doris.apache.org
For additional commands, e-mail: commits-help@doris.apache.org