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>&amp";
-    stringstream after;
+    std::string before = "<html><body>&amp";
+    std::stringstream after;
     EscapeForHtml(before, &after);
     EXPECT_EQ(after.str(), "&lt;html&gt;&lt;body&gt;&amp;amp");
 }


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@doris.apache.org
For additional commands, e-mail: commits-help@doris.apache.org