diff --git a/be/src/exec/hash_join_node.cpp b/be/src/exec/hash_join_node.cpp
index d03dd3e49c..72db1be8bf 100644
--- a/be/src/exec/hash_join_node.cpp
+++ b/be/src/exec/hash_join_node.cpp
@@ -46,7 +46,7 @@ HashJoinNode::HashJoinNode(
     _is_push_down = tnode.hash_join_node.is_push_down;
     _build_unique = _join_op == TJoinOp::LEFT_ANTI_JOIN|| _join_op == TJoinOp::RIGHT_ANTI_JOIN
         || _join_op == TJoinOp::RIGHT_SEMI_JOIN || _join_op == TJoinOp::LEFT_SEMI_JOIN 
-        || _join_op == TJoinOp::NULL_AWARE_LEFT_ANTI_JOIN
+        || _join_op == TJoinOp::NULL_AWARE_LEFT_ANTI_JOIN;
 }
 
 HashJoinNode::~HashJoinNode() {
diff --git a/be/src/olap/olap_snapshot_converter.cpp b/be/src/olap/olap_snapshot_converter.cpp
index 035a27fe64..2986f160bc 100755
--- a/be/src/olap/olap_snapshot_converter.cpp
+++ b/be/src/olap/olap_snapshot_converter.cpp
@@ -446,7 +446,7 @@ OLAPStatus OlapSnapshotConverter::to_new_snapshot(const OLAPHeaderMessage& olap_
     RETURN_NOT_OK(to_tablet_meta_pb(olap_header, tablet_meta_pb, pending_rowsets));
 
     TabletSchema tablet_schema;
-    RETURN_NOT_OK(tablet_schema.init_from_pb(tablet_meta_pb->schema()));
+    tablet_schema.init_from_pb(tablet_meta_pb->schema());
 
     // convert visible pdelta file to rowsets
     for (auto& visible_rowset : tablet_meta_pb->rs_metas()) {
@@ -505,7 +505,7 @@ OLAPStatus OlapSnapshotConverter::to_old_snapshot(const TabletMetaPB& tablet_met
     RETURN_NOT_OK(to_olap_header(tablet_meta_pb, olap_header));
 
     TabletSchema tablet_schema;
-    RETURN_NOT_OK(tablet_schema.init_from_pb(tablet_meta_pb.schema()));
+    tablet_schema.init_from_pb(tablet_meta_pb.schema());
 
     // convert visible pdelta file to rowsets
     for (auto& visible_rowset : tablet_meta_pb.rs_metas()) {
diff --git a/be/src/olap/snapshot_manager.cpp b/be/src/olap/snapshot_manager.cpp
index 64f5807d96..4e6872f474 100644
--- a/be/src/olap/snapshot_manager.cpp
+++ b/be/src/olap/snapshot_manager.cpp
@@ -146,12 +146,7 @@ OLAPStatus SnapshotManager::convert_rowset_ids(const string& clone_dir, int64_t
         return res;
     }
     TabletMetaPB cloned_tablet_meta_pb;
-    res = cloned_tablet_meta.to_meta_pb(&cloned_tablet_meta_pb);
-    if (res != OLAP_SUCCESS) {
-        LOG(WARNING) << "fail to serialize tablet meta to pb object. "
-                     << " , cloned_meta_file=" << cloned_meta_file;
-        return res;
-    }
+    cloned_tablet_meta.to_meta_pb(&cloned_tablet_meta_pb);
 
     TabletMetaPB new_tablet_meta_pb;
     new_tablet_meta_pb = cloned_tablet_meta_pb;
@@ -162,7 +157,7 @@ OLAPStatus SnapshotManager::convert_rowset_ids(const string& clone_dir, int64_t
     new_tablet_meta_pb.set_tablet_id(tablet_id);
     new_tablet_meta_pb.set_schema_hash(schema_hash);
     TabletSchema tablet_schema;
-    RETURN_NOT_OK(tablet_schema.init_from_pb(new_tablet_meta_pb.schema()));
+    tablet_schema.init_from_pb(new_tablet_meta_pb.schema());
 
     std::unordered_map<Version, RowsetMetaPB*, HashOfVersion> _rs_version_map;
     for (auto& visible_rowset : cloned_tablet_meta_pb.rs_metas()) {
@@ -377,13 +372,7 @@ OLAPStatus SnapshotManager::_create_snapshot_files(
             if (res != OLAP_SUCCESS) {
                 break;
             }
-            res = ref_tablet->generate_tablet_meta_copy(new_tablet_meta);
-            if (res != OLAP_SUCCESS) {
-                LOG(WARNING) << "fail to load header. res=" << res
-                             << " tablet_id=" << ref_tablet->tablet_id()
-                             << " schema_hash=" << ref_tablet->schema_hash();
-                break;
-            }
+            ref_tablet->generate_tablet_meta_copy(new_tablet_meta);
         } else {
             ReadLock rdlock(ref_tablet->get_header_lock_ptr());
             // get latest version
@@ -415,13 +404,7 @@ OLAPStatus SnapshotManager::_create_snapshot_files(
                 break;
             }
 
-            res = ref_tablet->generate_tablet_meta_copy(new_tablet_meta);
-            if (res != OLAP_SUCCESS) {
-                LOG(WARNING) << "fail to load header. res=" << res
-                             << " tablet_id=" << ref_tablet->tablet_id()
-                             << " schema_hash=" << ref_tablet->schema_hash();
-                break;
-            }
+            ref_tablet->generate_tablet_meta_copy(new_tablet_meta);
         }
 
         vector<RowsetMetaSharedPtr> rs_metas;
@@ -443,15 +426,13 @@ OLAPStatus SnapshotManager::_create_snapshot_files(
         new_tablet_meta->delete_alter_task();
 
         if (request.__isset.missing_version) {
-            new_tablet_meta->revise_inc_rs_metas(rs_metas);
-            vector<RowsetMetaSharedPtr> empty_rowsets;
-            new_tablet_meta->revise_rs_metas(empty_rowsets);
+            new_tablet_meta->revise_inc_rs_metas(std::move(rs_metas));
+            new_tablet_meta->revise_rs_metas(vector<RowsetMetaSharedPtr>());
         } else {
             // If this is a full clone, then should clear inc rowset metas because
             // related files is not created
-            vector<RowsetMetaSharedPtr> empty_rowsets;
-            new_tablet_meta->revise_inc_rs_metas(empty_rowsets);
-            new_tablet_meta->revise_rs_metas(rs_metas);
+            new_tablet_meta->revise_inc_rs_metas(vector<RowsetMetaSharedPtr>());
+            new_tablet_meta->revise_rs_metas(std::move(rs_metas));
         }
 
         if (snapshot_version == g_Types_constants.TSNAPSHOT_REQ_VERSION1) {
@@ -558,9 +539,9 @@ OLAPStatus SnapshotManager::_convert_beta_rowsets_to_alpha(const TabletMetaShare
     }
     if (res == OLAP_SUCCESS && modified) {
         if (is_incremental) {
-            res = new_tablet_meta->revise_inc_rs_metas(new_rowset_metas);
+            new_tablet_meta->revise_inc_rs_metas(std::move(new_rowset_metas));
         } else {
-            res = new_tablet_meta->revise_rs_metas(new_rowset_metas);
+            new_tablet_meta->revise_rs_metas(std::move(new_rowset_metas));
         }
     }
     return res;
diff --git a/be/src/olap/tablet.cpp b/be/src/olap/tablet.cpp
index 95afc3626b..4ff6def8a5 100644
--- a/be/src/olap/tablet.cpp
+++ b/be/src/olap/tablet.cpp
@@ -128,7 +128,7 @@ OLAPStatus Tablet::set_tablet_state(TabletState state) {
         LOG(WARNING) << "could not change tablet state from shutdown to " << state;
         return OLAP_ERR_META_INVALID_ARGUMENT;
     }
-    RETURN_NOT_OK(_tablet_meta->set_tablet_state(state));
+    _tablet_meta->set_tablet_state(state);
     _state = state;
     return OLAP_SUCCESS;
 }
@@ -157,18 +157,11 @@ OLAPStatus Tablet::revise_tablet_meta(
     do {
         // load new local tablet_meta to operate on
         TabletMetaSharedPtr new_tablet_meta(new (nothrow) TabletMeta());
-        RETURN_NOT_OK(generate_tablet_meta_copy(new_tablet_meta));
+        generate_tablet_meta_copy(new_tablet_meta);
 
         // delete versions from new local tablet_meta
         for (const Version& version : versions_to_delete) {
-            res = new_tablet_meta->delete_rs_meta_by_version(version, nullptr);
-            if (res != OLAP_SUCCESS) {
-                // TODO(lingbin): should we stop and return an non-ok status?
-                // Actually, this func always return Status::OK
-                LOG(WARNING) << "failed to delete version from new local tablet meta. tablet="
-                        << full_name() << ", version=" << version;
-                break;
-            }
+            new_tablet_meta->delete_rs_meta_by_version(version, nullptr);
             if (new_tablet_meta->version_for_delete_predicate(version)) {
                 new_tablet_meta->remove_delete_predicate_by_version(version);
             }
@@ -522,9 +515,9 @@ OLAPStatus Tablet::capture_rs_readers(const vector<Version>& version_path,
     return OLAP_SUCCESS;
 }
 
-OLAPStatus Tablet::add_delete_predicate(
+void Tablet::add_delete_predicate(
         const DeletePredicatePB& delete_predicate, int64_t version) {
-    return _tablet_meta->add_delete_predicate(delete_predicate, version);
+    _tablet_meta->add_delete_predicate(delete_predicate, version);
 }
 
 // TODO(lingbin): what is the difference between version_for_delete_predicate() and
@@ -551,7 +544,7 @@ OLAPStatus Tablet::add_alter_task(int64_t related_tablet_id,
     alter_task.set_related_tablet_id(related_tablet_id);
     alter_task.set_related_schema_hash(related_schema_hash);
     alter_task.set_alter_type(alter_type);
-    RETURN_NOT_OK(_tablet_meta->add_alter_task(alter_task));
+    _tablet_meta->add_alter_task(alter_task);
     LOG(INFO) << "successfully add alter task for tablet_id:" << this->tablet_id()
               << ", schema_hash:" << this->schema_hash()
               << ", related_tablet_id " << related_tablet_id
@@ -560,9 +553,9 @@ OLAPStatus Tablet::add_alter_task(int64_t related_tablet_id,
     return OLAP_SUCCESS;
 }
 
-OLAPStatus Tablet::delete_alter_task() {
+void Tablet::delete_alter_task() {
     LOG(INFO) << "delete alter task from table. tablet=" << full_name();
-    return _tablet_meta->delete_alter_task();
+    _tablet_meta->delete_alter_task();
 }
 
 OLAPStatus Tablet::set_alter_state(AlterTabletState state) {
@@ -1120,18 +1113,16 @@ void Tablet::build_tablet_report_info(TTabletInfo* tablet_info) {
     tablet_info->__set_version_count(_tablet_meta->version_count());
     tablet_info->__set_path_hash(_data_dir->path_hash());
     tablet_info->__set_is_in_memory(_tablet_meta->tablet_schema().is_in_memory());
-    return;
 }
 
 // should use this method to get a copy of current tablet meta
 // there are some rowset meta in local meta store and in in-memory tablet meta
 // but not in tablet meta in local meta store
 // TODO(lingbin): do we need _meta_lock?
-OLAPStatus Tablet::generate_tablet_meta_copy(TabletMetaSharedPtr new_tablet_meta) {
+void Tablet::generate_tablet_meta_copy(TabletMetaSharedPtr new_tablet_meta) {
     TabletMetaPB tablet_meta_pb;
-    RETURN_NOT_OK(_tablet_meta->to_meta_pb(&tablet_meta_pb));
-    RETURN_NOT_OK(new_tablet_meta->init_from_pb(tablet_meta_pb));
-    return OLAP_SUCCESS;
+    _tablet_meta->to_meta_pb(&tablet_meta_pb);
+    new_tablet_meta->init_from_pb(tablet_meta_pb);
 }
 
 }  // namespace doris
diff --git a/be/src/olap/tablet.h b/be/src/olap/tablet.h
index a668a84eec..02c676bafd 100644
--- a/be/src/olap/tablet.h
+++ b/be/src/olap/tablet.h
@@ -48,7 +48,7 @@ using TabletSharedPtr = std::shared_ptr<Tablet>;
 class Tablet : public std::enable_shared_from_this<Tablet> {
 public:
     static TabletSharedPtr create_tablet_from_meta(TabletMetaSharedPtr tablet_meta,
-                                                   DataDir* data_dir  = nullptr);
+                                                   DataDir* data_dir = nullptr);
 
     Tablet(TabletMetaSharedPtr tablet_meta, DataDir* data_dir);
     ~Tablet();
@@ -138,7 +138,7 @@ public:
                                   vector<RowsetReaderSharedPtr>* rs_readers) const;
 
     DelPredicateArray delete_predicates() { return _tablet_meta->delete_predicates(); }
-    OLAPStatus add_delete_predicate(const DeletePredicatePB& delete_predicate, int64_t version);
+    void add_delete_predicate(const DeletePredicatePB& delete_predicate, int64_t version);
     bool version_for_delete_predicate(const Version& version);
     bool version_for_load_deletion(const Version& version);
 
@@ -147,7 +147,7 @@ public:
     OLAPStatus add_alter_task(int64_t related_tablet_id, int32_t related_schema_hash,
                         const vector<Version>& versions_to_alter,
                         const AlterTabletType alter_type);
-    OLAPStatus delete_alter_task();
+    void delete_alter_task();
     OLAPStatus set_alter_state(AlterTabletState state);
 
     // meta lock
@@ -242,7 +242,7 @@ public:
 
     void build_tablet_report_info(TTabletInfo* tablet_info);
 
-    OLAPStatus generate_tablet_meta_copy(TabletMetaSharedPtr new_tablet_meta);
+    void generate_tablet_meta_copy(TabletMetaSharedPtr new_tablet_meta);
 
     // return a json string to show the compaction status of this tablet
     OLAPStatus get_compaction_status(std::string* json_result);
diff --git a/be/src/olap/tablet_meta.cpp b/be/src/olap/tablet_meta.cpp
index e7f0d0ef84..4a75eb32b3 100755
--- a/be/src/olap/tablet_meta.cpp
+++ b/be/src/olap/tablet_meta.cpp
@@ -34,20 +34,18 @@ using std::vector;
 
 namespace doris {
 
-OLAPStatus AlterTabletTask::init_from_pb(const AlterTabletPB& alter_task) {
+void AlterTabletTask::init_from_pb(const AlterTabletPB& alter_task) {
     _alter_state = alter_task.alter_state();
     _related_tablet_id = alter_task.related_tablet_id();
     _related_schema_hash = alter_task.related_schema_hash();
     _alter_type = alter_task.alter_type();
-    return OLAP_SUCCESS;
 }
 
-OLAPStatus AlterTabletTask::to_alter_pb(AlterTabletPB* alter_task) {
+void AlterTabletTask::to_alter_pb(AlterTabletPB* alter_task) {
     alter_task->set_alter_state(_alter_state);
     alter_task->set_related_tablet_id(_related_tablet_id);
     alter_task->set_related_schema_hash(_related_schema_hash);
     alter_task->set_alter_type(_alter_type);
-    return OLAP_SUCCESS;
 }
 
 OLAPStatus AlterTabletTask::set_alter_state(AlterTabletState alter_state) {
@@ -198,7 +196,7 @@ OLAPStatus TabletMeta::create_from_file(const string& file_path) {
     FileHeader<TabletMetaPB> file_header;
     FileHandler file_handler;
 
-    if (file_handler.open(file_path.c_str(), O_RDONLY) != OLAP_SUCCESS) {
+    if (file_handler.open(file_path, O_RDONLY) != OLAP_SUCCESS) {
         LOG(WARNING) << "fail to open ordinal file. file=" << file_path;
         return OLAP_ERR_IO_ERROR;
     }
@@ -217,7 +215,8 @@ OLAPStatus TabletMeta::create_from_file(const string& file_path) {
         return OLAP_ERR_PARSE_PROTOBUF_ERROR;
     }
 
-    return init_from_pb(tablet_meta_pb);
+    init_from_pb(tablet_meta_pb);
+    return OLAP_SUCCESS;
 }
 
 OLAPStatus TabletMeta::reset_tablet_uid(const string& file_path) {
@@ -229,12 +228,7 @@ OLAPStatus TabletMeta::reset_tablet_uid(const string& file_path) {
         return res;
     }
     TabletMetaPB tmp_tablet_meta_pb;
-    res = tmp_tablet_meta.to_meta_pb(&tmp_tablet_meta_pb);
-    if (res != OLAP_SUCCESS) {
-        LOG(WARNING) << "fail to serialize tablet meta to pb object. "
-                     << " , meta_file=" << file_path;
-        return res;
-    }
+    tmp_tablet_meta.to_meta_pb(&tmp_tablet_meta_pb);
     *(tmp_tablet_meta_pb.mutable_tablet_uid()) = TabletUid::gen_uid().to_proto();
     res = save(file_path, tmp_tablet_meta_pb);
     if (res != OLAP_SUCCESS) {
@@ -246,7 +240,7 @@ OLAPStatus TabletMeta::reset_tablet_uid(const string& file_path) {
 }
 
 string TabletMeta::construct_header_file_path(const string& schema_hash_path,
-                                                   const int64_t tablet_id) {
+                                             int64_t tablet_id) {
     std::stringstream header_name_stream;
     header_name_stream << schema_hash_path << "/" << tablet_id << ".hdr";
     return header_name_stream.str();
@@ -254,17 +248,17 @@ string TabletMeta::construct_header_file_path(const string& schema_hash_path,
 
 OLAPStatus TabletMeta::save(const string& file_path) {
     TabletMetaPB tablet_meta_pb;
-    RETURN_NOT_OK(to_meta_pb(&tablet_meta_pb));
+    to_meta_pb(&tablet_meta_pb);
     return TabletMeta::save(file_path, tablet_meta_pb);
 }
 
-OLAPStatus TabletMeta::save(const string& file_path, TabletMetaPB& tablet_meta_pb) {
+OLAPStatus TabletMeta::save(const string& file_path, const TabletMetaPB& tablet_meta_pb) {
     DCHECK(!file_path.empty());
 
     FileHeader<TabletMetaPB> file_header;
     FileHandler file_handler;
 
-    if (file_handler.open_with_mode(file_path.c_str(),
+    if (file_handler.open_with_mode(file_path,
             O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR) != OLAP_SUCCESS) {
         LOG(WARNING) << "fail to open header file. file='" << file_path;
         return OLAP_ERR_IO_ERROR;
@@ -311,7 +305,7 @@ OLAPStatus TabletMeta::_save_meta(DataDir* data_dir) {
 
 OLAPStatus TabletMeta::serialize(string* meta_binary) {
     TabletMetaPB tablet_meta_pb;
-    RETURN_NOT_OK(to_meta_pb(&tablet_meta_pb));
+    to_meta_pb(&tablet_meta_pb);
     bool serialize_success = tablet_meta_pb.SerializeToString(meta_binary);
     if (!serialize_success) {
         LOG(FATAL) << "failed to serialize meta " << full_name();
@@ -332,10 +326,11 @@ OLAPStatus TabletMeta::deserialize(const string& meta_binary) {
         LOG(WARNING) << "parse tablet meta failed";
         return OLAP_ERR_INIT_FAILED;
     }
-    return init_from_pb(tablet_meta_pb);
+    init_from_pb(tablet_meta_pb);
+    return OLAP_SUCCESS;
 }
 
-OLAPStatus TabletMeta::init_from_pb(const TabletMetaPB& tablet_meta_pb) {
+void TabletMeta::init_from_pb(const TabletMetaPB& tablet_meta_pb) {
     _table_id = tablet_meta_pb.table_id();
     _partition_id = tablet_meta_pb.partition_id();
     _tablet_id = tablet_meta_pb.tablet_id();
@@ -368,7 +363,7 @@ OLAPStatus TabletMeta::init_from_pb(const TabletMetaPB& tablet_meta_pb) {
     }
 
     // init _schema
-    RETURN_NOT_OK(_schema.init_from_pb(tablet_meta_pb.schema()));
+    _schema.init_from_pb(tablet_meta_pb.schema());
 
     // init _rs_metas
     for (auto& it : tablet_meta_pb.rs_metas()) {
@@ -388,7 +383,7 @@ OLAPStatus TabletMeta::init_from_pb(const TabletMetaPB& tablet_meta_pb) {
     // generate AlterTabletTask
     if (tablet_meta_pb.has_alter_task()) {
         AlterTabletTask* alter_tablet_task = new AlterTabletTask();
-        RETURN_NOT_OK(alter_tablet_task->init_from_pb(tablet_meta_pb.alter_task()));
+        alter_tablet_task->init_from_pb(tablet_meta_pb.alter_task());
         _alter_task.reset(alter_tablet_task);
     }
 
@@ -399,10 +394,9 @@ OLAPStatus TabletMeta::init_from_pb(const TabletMetaPB& tablet_meta_pb) {
     if (tablet_meta_pb.has_preferred_rowset_type()) {
         _preferred_rowset_type = tablet_meta_pb.preferred_rowset_type();
     }
-    return OLAP_SUCCESS;
 }
 
-OLAPStatus TabletMeta::to_meta_pb(TabletMetaPB* tablet_meta_pb) {
+void TabletMeta::to_meta_pb(TabletMetaPB* tablet_meta_pb) {
     tablet_meta_pb->set_table_id(table_id());
     tablet_meta_pb->set_partition_id(partition_id());
     tablet_meta_pb->set_tablet_id(tablet_id());
@@ -446,14 +440,12 @@ OLAPStatus TabletMeta::to_meta_pb(TabletMetaPB* tablet_meta_pb) {
     if (_preferred_rowset_type == BETA_ROWSET) {
         tablet_meta_pb->set_preferred_rowset_type(_preferred_rowset_type);
     }
-    return OLAP_SUCCESS;
 }
 
-OLAPStatus TabletMeta::to_json(string* json_string, json2pb::Pb2JsonOptions& options) {
+void TabletMeta::to_json(string* json_string, json2pb::Pb2JsonOptions& options) {
     TabletMetaPB tablet_meta_pb;
-    RETURN_NOT_OK(to_meta_pb(&tablet_meta_pb));
+    to_meta_pb(&tablet_meta_pb);
     json2pb::ProtoMessageToJson(tablet_meta_pb, json_string, options);
-    return OLAP_SUCCESS;
 }
 
 Version TabletMeta::max_version() const {
@@ -482,7 +474,7 @@ OLAPStatus TabletMeta::add_rs_meta(const RowsetMetaSharedPtr& rs_meta) {
         }
     }
 
-    _rs_metas.push_back(std::move(rs_meta));
+    _rs_metas.push_back(rs_meta);
     if (rs_meta->has_delete_predicate()) {
         add_delete_predicate(rs_meta->delete_predicate(), rs_meta->version().first);
     }
@@ -490,31 +482,28 @@ OLAPStatus TabletMeta::add_rs_meta(const RowsetMetaSharedPtr& rs_meta) {
     return OLAP_SUCCESS;
 }
 
-OLAPStatus TabletMeta::delete_rs_meta_by_version(const Version& version,
-                                                 vector<RowsetMetaSharedPtr>* deleted_rs_metas) {
+void TabletMeta::delete_rs_meta_by_version(const Version& version,
+                                           vector<RowsetMetaSharedPtr>* deleted_rs_metas) {
     auto it = _rs_metas.begin();
     while (it != _rs_metas.end()) {
-        if ((*it)->version().first == version.first
-              && (*it)->version().second == version.second) {
+        if ((*it)->version() == version) {
             if (deleted_rs_metas != nullptr) {
                 deleted_rs_metas->push_back(*it);
             }
             _rs_metas.erase(it);
+            return;
         } else {
             ++it;
         }
     }
-
-    return OLAP_SUCCESS;
 }
 
-OLAPStatus TabletMeta::modify_rs_metas(const vector<RowsetMetaSharedPtr>& to_add,
-                                       const vector<RowsetMetaSharedPtr>& to_delete) {
+void TabletMeta::modify_rs_metas(const vector<RowsetMetaSharedPtr>& to_add,
+                                 const vector<RowsetMetaSharedPtr>& to_delete) {
     for (auto rs_to_del : to_delete) {
         auto it = _rs_metas.begin();
         while (it != _rs_metas.end()) {
-            if (rs_to_del->version().first == (*it)->version().first
-                  && rs_to_del->version().second == (*it)->version().second) {
+            if (rs_to_del->version() == (*it)->version()) {
                 if ((*it)->has_delete_predicate()) {
                     remove_delete_predicate_by_version((*it)->version());
                 }
@@ -522,75 +511,43 @@ OLAPStatus TabletMeta::modify_rs_metas(const vector<RowsetMetaSharedPtr>& to_add
                 // there should be only one rowset match the version
                 break;
             } else {
-                it++;
+                ++it;
             }
         }
     }
-
-    for (auto rs : to_add) {
-        _rs_metas.push_back(std::move(rs));
-    }
-
-    return OLAP_SUCCESS;
+    _rs_metas.insert(_rs_metas.end(), to_add.begin(), to_add.end());
 }
 
-OLAPStatus TabletMeta::revise_rs_metas(const std::vector<RowsetMetaSharedPtr>& rs_metas) {
+void TabletMeta::revise_rs_metas(std::vector<RowsetMetaSharedPtr>&& rs_metas) {
     WriteLock wrlock(&_meta_lock);
     // delete alter task
     _alter_task.reset();
 
-    // remove all old rs_meta and add new rs_meta
-    _rs_metas.clear();
-
-    for (auto& rs_meta : rs_metas) {
-        _rs_metas.push_back(rs_meta);
-    }
-
-    return OLAP_SUCCESS;
+    _rs_metas = std::move(rs_metas);
 }
 
-OLAPStatus TabletMeta::revise_inc_rs_metas(const std::vector<RowsetMetaSharedPtr>& rs_metas) {
+void TabletMeta::revise_inc_rs_metas(std::vector<RowsetMetaSharedPtr>&& rs_metas) {
     WriteLock wrlock(&_meta_lock);
     // delete alter task
     _alter_task.reset();
 
-    // remove all old rs_meta and add new rs_meta
-    _inc_rs_metas.clear();
-
-    for (auto& rs_meta : rs_metas) {
-        _inc_rs_metas.push_back(rs_meta);
-    }
-
-    return OLAP_SUCCESS;
+    _inc_rs_metas = std::move(rs_metas);
 }
 
 OLAPStatus TabletMeta::add_inc_rs_meta(const RowsetMetaSharedPtr& rs_meta) {
     // check RowsetMeta is valid
     for (auto rs : _inc_rs_metas) {
-        if (rs->start_version() == rs_meta->start_version()
-            && rs->end_version() == rs_meta->end_version()) {
+        if (rs->version() == rs_meta->version()) {
             LOG(WARNING) << "rowset already exist. rowset_id=" << rs->rowset_id();
             return OLAP_ERR_ROWSET_ALREADY_EXIST;
         }
     }
 
-    _inc_rs_metas.push_back(std::move(rs_meta));
+    _inc_rs_metas.push_back(rs_meta);
     return OLAP_SUCCESS;
 }
 
-RowsetMetaSharedPtr TabletMeta::acquire_rs_meta_by_version(const Version& version) const {
-    RowsetMetaSharedPtr rs_meta = nullptr;
-    for (int i = 0; i < _rs_metas.size(); ++i) {
-        if (_rs_metas[i]->version().first == version.first
-              && _rs_metas[i]->version().second == version.second) {
-            rs_meta = _rs_metas[i];
-            break;
-        }
-    }
-    return rs_meta;
-}
-
-OLAPStatus TabletMeta::delete_inc_rs_meta_by_version(const Version& version) {
+void TabletMeta::delete_inc_rs_meta_by_version(const Version& version) {
     auto it = _inc_rs_metas.begin();
     while (it != _inc_rs_metas.end()) {
         if ((*it)->version() == version) {
@@ -600,63 +557,39 @@ OLAPStatus TabletMeta::delete_inc_rs_meta_by_version(const Version& version) {
             it++;
         }
     }
-
-    return OLAP_SUCCESS;
 }
 
 RowsetMetaSharedPtr TabletMeta::acquire_inc_rs_meta_by_version(const Version& version) const {
-    RowsetMetaSharedPtr rs_meta = nullptr;
-    for (int i = 0; i < _inc_rs_metas.size(); ++i) {
-        if (_inc_rs_metas[i]->version() == version) {
-            rs_meta = _inc_rs_metas[i];
-            break;
+    for (auto it : _inc_rs_metas) {
+        if (it->version() == version) {
+            return it;
         }
     }
-    return rs_meta;
+    return nullptr;
 }
 
-OLAPStatus TabletMeta::add_delete_predicate(
-            const DeletePredicatePB& delete_predicate, int64_t version) {
-    int ordinal = 0;
+void TabletMeta::add_delete_predicate(const DeletePredicatePB& delete_predicate, int64_t version) {
     for (auto& del_pred : _del_pred_array) {
         if (del_pred.version() == version) {
-            break;
-        }
-        ordinal++;
-    }
-
-    if (ordinal < _del_pred_array.size()) {
-        // clear existed predicate
-        DeletePredicatePB* del_pred = &(_del_pred_array[ordinal]);
-        del_pred->clear_sub_predicates();
-        for (const string& predicate : delete_predicate.sub_predicates()) {
-            del_pred->add_sub_predicates(predicate);
-        }
-    } else {
-        DeletePredicatePB* del_pred = _del_pred_array.Add();
-        del_pred->set_version(version);
-        for (const string& predicate : delete_predicate.sub_predicates()) {
-            del_pred->add_sub_predicates(predicate);
+            *del_pred.mutable_sub_predicates() = delete_predicate.sub_predicates();
+            return;
         }
     }
-    return OLAP_SUCCESS;
+    DeletePredicatePB* del_pred = _del_pred_array.Add();
+    del_pred->set_version(version);
+    *del_pred->mutable_sub_predicates() = delete_predicate.sub_predicates();
 }
 
-OLAPStatus TabletMeta::remove_delete_predicate_by_version(const Version& version) {
-    DCHECK(version.first == version.second)
-        << "version=" << version.first << "-" << version.second;
-    int ordinal = 0;
-    for (; ordinal < _del_pred_array.size(); ++ordinal) {
+void TabletMeta::remove_delete_predicate_by_version(const Version& version) {
+    DCHECK(version.first == version.second) << "version=" << version;
+    for (int ordinal = 0; ordinal < _del_pred_array.size(); ++ordinal) {
         const DeletePredicatePB& temp = _del_pred_array.Get(ordinal);
         if (temp.version() == version.first) {
-            // log delete condtion
+            // log delete condition
             string del_cond_str;
-            const google::protobuf::RepeatedPtrField<string>& sub_predicates = temp.sub_predicates();
-
-            for (int i = 0; i != sub_predicates.size(); ++i) {
-                del_cond_str += sub_predicates.Get(i) + ";";
+            for (const auto& it : temp.sub_predicates()) {
+                del_cond_str += it + ";";
             }
-
             LOG(INFO) << "remove one del_pred. version=" << temp.version()
                       << ", condition=" << del_cond_str;
 
@@ -665,7 +598,6 @@ OLAPStatus TabletMeta::remove_delete_predicate_by_version(const Version& version
             _del_pred_array.RemoveLast();
         }
     }
-    return OLAP_SUCCESS;
 }
 
 DelPredicateArray TabletMeta::delete_predicates() const {
@@ -688,23 +620,19 @@ bool TabletMeta::version_for_delete_predicate(const Version& version) {
 
 // return value not reference
 // MVCC modification for alter task, upper application get a alter task mirror
-AlterTabletTaskSharedPtr TabletMeta::TabletMeta::alter_task() {
+AlterTabletTaskSharedPtr TabletMeta::alter_task() {
     ReadLock rlock(&_meta_lock);
     return _alter_task;
 }
 
-OLAPStatus TabletMeta::add_alter_task(const AlterTabletTask& alter_task) {
+void TabletMeta::add_alter_task(const AlterTabletTask& alter_task) {
     WriteLock wrlock(&_meta_lock);
-    AlterTabletTask* new_alter_task = new AlterTabletTask();
-    *new_alter_task = alter_task;
-    _alter_task.reset(new_alter_task);
-    return OLAP_SUCCESS;
+    _alter_task.reset(new AlterTabletTask(alter_task));
 }
 
-OLAPStatus TabletMeta::delete_alter_task() {
+void TabletMeta::delete_alter_task() {
     WriteLock wrlock(&_meta_lock);
     _alter_task.reset();
-    return OLAP_SUCCESS;
 }
 
 // if alter task is nullptr, return error?
@@ -716,8 +644,7 @@ OLAPStatus TabletMeta::set_alter_state(AlterTabletState alter_state) {
         LOG(WARNING) << "original alter task is null, could not set state";
         return OLAP_ERR_ALTER_STATUS_ERR;
     } else {
-        AlterTabletTask* alter_tablet_task = new AlterTabletTask();
-        *alter_tablet_task = *_alter_task;
+        auto alter_tablet_task = new AlterTabletTask(*_alter_task);
         OLAPStatus reset_status = alter_tablet_task->set_alter_state(alter_state);
         if (reset_status != OLAP_SUCCESS) {
             return reset_status;
diff --git a/be/src/olap/tablet_meta.h b/be/src/olap/tablet_meta.h
index 99fe745818..1a24d1680d 100644
--- a/be/src/olap/tablet_meta.h
+++ b/be/src/olap/tablet_meta.h
@@ -71,8 +71,8 @@ using TabletMetaSharedPtr = std::shared_ptr<TabletMeta>;
 class AlterTabletTask {
 public:
     AlterTabletTask() {}
-    OLAPStatus init_from_pb(const AlterTabletPB& alter_task);
-    OLAPStatus to_alter_pb(AlterTabletPB* alter_task);
+    void init_from_pb(const AlterTabletPB& alter_task);
+    void to_alter_pb(AlterTabletPB* alter_task);
 
     inline const AlterTabletState& alter_state() const { return _alter_state; }
     OLAPStatus set_alter_state(AlterTabletState alter_state);
@@ -122,42 +122,42 @@ public:
     // Previous tablet_meta is a physical file in tablet dir, which is not stored in rocksdb.
     OLAPStatus create_from_file(const std::string& file_path);
     OLAPStatus save(const std::string& file_path);
-    static OLAPStatus save(const std::string& file_path, TabletMetaPB& tablet_meta_pb);
+    static OLAPStatus save(const std::string& file_path, const TabletMetaPB& tablet_meta_pb);
     static OLAPStatus reset_tablet_uid(const std::string& file_path);
     static std::string construct_header_file_path(const std::string& schema_hash_path,
-                                                  const int64_t tablet_id);
+                                                  int64_t tablet_id);
     OLAPStatus save_meta(DataDir* data_dir);
 
     OLAPStatus serialize(std::string* meta_binary);
     OLAPStatus deserialize(const std::string& meta_binary);
-    OLAPStatus init_from_pb(const TabletMetaPB& tablet_meta_pb);
+    void init_from_pb(const TabletMetaPB& tablet_meta_pb);
 
-    OLAPStatus to_meta_pb(TabletMetaPB* tablet_meta_pb);
-    OLAPStatus to_json(std::string* json_string, json2pb::Pb2JsonOptions& options);
+    void to_meta_pb(TabletMetaPB* tablet_meta_pb);
+    void to_json(std::string* json_string, json2pb::Pb2JsonOptions& options);
 
-    inline const TabletUid tablet_uid() const;
-    inline const int64_t table_id() const;
-    inline const int64_t partition_id() const;
-    inline const int64_t tablet_id() const;
-    inline const int32_t schema_hash() const;
-    inline const int16_t shard_id() const;
+    inline TabletUid tablet_uid() const;
+    inline int64_t table_id() const;
+    inline int64_t partition_id() const;
+    inline int64_t tablet_id() const;
+    inline int32_t schema_hash() const;
+    inline int16_t shard_id() const;
     inline void set_shard_id(int32_t shard_id);
     inline int64_t creation_time() const;
     inline void set_creation_time(int64_t creation_time);
     inline int64_t cumulative_layer_point() const;
     inline void set_cumulative_layer_point(int64_t new_point);
 
-    inline const size_t num_rows() const;
+    inline size_t num_rows() const;
     // disk space occupied by tablet
-    inline const size_t tablet_footprint() const;
-    inline const size_t version_count() const;
+    inline size_t tablet_footprint() const;
+    inline size_t version_count() const;
     Version max_version() const;
 
-    inline const TabletState tablet_state() const;
-    inline OLAPStatus set_tablet_state(TabletState state);
+    inline TabletState tablet_state() const;
+    inline void set_tablet_state(TabletState state);
 
-    inline const bool in_restore_mode() const;
-    inline OLAPStatus set_in_restore_mode(bool in_restore_mode);
+    inline bool in_restore_mode() const;
+    inline void set_in_restore_mode(bool in_restore_mode);
 
     inline const TabletSchema& tablet_schema() const;
 
@@ -165,26 +165,26 @@ public:
 
     inline const std::vector<RowsetMetaSharedPtr>& all_rs_metas() const;
     OLAPStatus add_rs_meta(const RowsetMetaSharedPtr& rs_meta);
-    RowsetMetaSharedPtr acquire_rs_meta_by_version(const Version& version) const;
-    OLAPStatus delete_rs_meta_by_version(const Version& version,
-                                         std::vector<RowsetMetaSharedPtr>* deleted_rs_metas);
-    OLAPStatus modify_rs_metas(const std::vector<RowsetMetaSharedPtr>& to_add,
-                               const std::vector<RowsetMetaSharedPtr>& to_delete);
-    OLAPStatus revise_rs_metas(const std::vector<RowsetMetaSharedPtr>& rs_metas);
-    OLAPStatus revise_inc_rs_metas(const std::vector<RowsetMetaSharedPtr>& rs_metas);
+    void delete_rs_meta_by_version(const Version& version,
+                                   std::vector<RowsetMetaSharedPtr>* deleted_rs_metas);
+    void modify_rs_metas(const std::vector<RowsetMetaSharedPtr>& to_add,
+                         const std::vector<RowsetMetaSharedPtr>& to_delete);
+    void revise_rs_metas(std::vector<RowsetMetaSharedPtr>&& rs_metas);
 
+
+    void revise_inc_rs_metas(std::vector<RowsetMetaSharedPtr>&& rs_metas);
     inline const std::vector<RowsetMetaSharedPtr>& all_inc_rs_metas() const;
     OLAPStatus add_inc_rs_meta(const RowsetMetaSharedPtr& rs_meta);
-    OLAPStatus delete_inc_rs_meta_by_version(const Version& version);
+    void delete_inc_rs_meta_by_version(const Version& version);
     RowsetMetaSharedPtr acquire_inc_rs_meta_by_version(const Version& version) const;
 
-    OLAPStatus add_delete_predicate(const DeletePredicatePB& delete_predicate, int64_t version);
-    OLAPStatus remove_delete_predicate_by_version(const Version& version);
+    void add_delete_predicate(const DeletePredicatePB& delete_predicate, int64_t version);
+    void remove_delete_predicate_by_version(const Version& version);
     DelPredicateArray delete_predicates() const;
     bool version_for_delete_predicate(const Version& version);
     AlterTabletTaskSharedPtr alter_task();
-    OLAPStatus add_alter_task(const AlterTabletTask& alter_task);
-    OLAPStatus delete_alter_task();
+    void add_alter_task(const AlterTabletTask& alter_task);
+    void delete_alter_task();
     OLAPStatus set_alter_state(AlterTabletState alter_state);
 
     std::string full_name() const;
@@ -203,16 +203,16 @@ private:
     OLAPStatus _save_meta(DataDir* data_dir);
 
 private:
-    int64_t _table_id;
-    int64_t _partition_id;
-    int64_t _tablet_id;
-    int32_t _schema_hash;
-    int32_t _shard_id;
-    int64_t _creation_time;
-    int64_t _cumulative_layer_point;
+    int64_t _table_id = 0;
+    int64_t _partition_id = 0;
+    int64_t _tablet_id = 0;
+    int32_t _schema_hash = 0;
+    int32_t _shard_id = 0;
+    int64_t _creation_time = 0;
+    int64_t _cumulative_layer_point = 0;
     TabletUid _tablet_uid;
 
-    TabletState _tablet_state;
+    TabletState _tablet_state = TABLET_NOTREADY;
     TabletSchema _schema;
     std::vector<RowsetMetaSharedPtr> _rs_metas;
     std::vector<RowsetMetaSharedPtr> _inc_rs_metas;
@@ -224,27 +224,27 @@ private:
     RWMutex _meta_lock;
 };
 
-inline const TabletUid TabletMeta::tablet_uid() const {
+inline TabletUid TabletMeta::tablet_uid() const {
     return _tablet_uid;
 }
 
-inline const int64_t TabletMeta::table_id() const {
+inline int64_t TabletMeta::table_id() const {
     return _table_id;
 }
 
-inline const int64_t TabletMeta::partition_id() const {
+inline int64_t TabletMeta::partition_id() const {
     return _partition_id;
 }
 
-inline const int64_t TabletMeta::tablet_id() const {
+inline int64_t TabletMeta::tablet_id() const {
     return _tablet_id;
 }
 
-inline const int32_t TabletMeta::schema_hash() const {
+inline int32_t TabletMeta::schema_hash() const {
     return _schema_hash;
 }
 
-inline const int16_t TabletMeta::shard_id() const {
+inline int16_t TabletMeta::shard_id() const {
     return _shard_id;
 }
 
@@ -268,7 +268,7 @@ inline void TabletMeta::set_cumulative_layer_point(int64_t new_point) {
     _cumulative_layer_point = new_point;
 }
 
-inline const size_t TabletMeta::num_rows() const {
+inline size_t TabletMeta::num_rows() const {
     size_t num_rows = 0;
     for (auto& rs : _rs_metas) {
         num_rows += rs->num_rows();
@@ -276,7 +276,7 @@ inline const size_t TabletMeta::num_rows() const {
     return num_rows;
 }
 
-inline const size_t TabletMeta::tablet_footprint() const {
+inline size_t TabletMeta::tablet_footprint() const {
     size_t total_size = 0;
     for (auto& rs : _rs_metas) {
         total_size += rs->data_disk_size();
@@ -284,26 +284,24 @@ inline const size_t TabletMeta::tablet_footprint() const {
     return total_size;
 }
 
-inline const size_t TabletMeta::version_count() const {
+inline size_t TabletMeta::version_count() const {
     return _rs_metas.size();
 }
 
-inline const TabletState TabletMeta::tablet_state() const {
+inline TabletState TabletMeta::tablet_state() const {
     return _tablet_state;
 }
 
-inline OLAPStatus TabletMeta::set_tablet_state(TabletState state) {
+inline void TabletMeta::set_tablet_state(TabletState state) {
     _tablet_state = state;
-    return OLAP_SUCCESS;
 }
 
-inline const bool TabletMeta::in_restore_mode() const {
+inline bool TabletMeta::in_restore_mode() const {
     return _in_restore_mode;
 }
 
-inline OLAPStatus TabletMeta::set_in_restore_mode(bool in_restore_mode) {
+inline void TabletMeta::set_in_restore_mode(bool in_restore_mode) {
     _in_restore_mode = in_restore_mode;
-    return OLAP_SUCCESS;
 }
 
 inline const TabletSchema& TabletMeta::tablet_schema() const {
diff --git a/be/src/olap/tablet_schema.cpp b/be/src/olap/tablet_schema.cpp
index 2406bd5110..ac20d57a15 100644
--- a/be/src/olap/tablet_schema.cpp
+++ b/be/src/olap/tablet_schema.cpp
@@ -268,7 +268,7 @@ TabletColumn::TabletColumn(FieldAggregationMethod agg, FieldType filed_type, boo
     _is_nullable = is_nullable;
 }
 
-OLAPStatus TabletColumn::init_from_pb(const ColumnPB& column) {
+void TabletColumn::init_from_pb(const ColumnPB& column) {
     _unique_id = column.unique_id();
     _col_name = column.name();
     _type = TabletColumn::get_field_type_by_string(column.type());
@@ -308,10 +308,9 @@ OLAPStatus TabletColumn::init_from_pb(const ColumnPB& column) {
     if (column.has_aggregation()) {
         _aggregation = get_aggregation_type_by_string(column.aggregation());
     }
-    return OLAP_SUCCESS;
 }
 
-OLAPStatus TabletColumn::to_schema_pb(ColumnPB* column) {
+void TabletColumn::to_schema_pb(ColumnPB* column) {
     column->set_unique_id(_unique_id);
     column->set_name(_col_name);
     column->set_type(get_string_by_field_type(_type));
@@ -336,7 +335,6 @@ OLAPStatus TabletColumn::to_schema_pb(ColumnPB* column) {
     if (_has_bitmap_index) {
         column->set_has_bitmap_index(_has_bitmap_index);
     }
-    return OLAP_SUCCESS;
 }
 
 TabletSchema::TabletSchema()
@@ -345,7 +343,7 @@ TabletSchema::TabletSchema()
       _num_null_columns(0),
       _num_short_key_columns(0) { }
 
-OLAPStatus TabletSchema::init_from_pb(const TabletSchemaPB& schema) {
+void TabletSchema::init_from_pb(const TabletSchemaPB& schema) {
     _keys_type = schema.keys_type();
     for (auto& column_pb : schema.column()) {
         TabletColumn column;
@@ -371,10 +369,9 @@ OLAPStatus TabletSchema::init_from_pb(const TabletSchemaPB& schema) {
         _bf_fpp = BLOOM_FILTER_DEFAULT_FPP;
     }
     _is_in_memory = schema.is_in_memory();
-    return OLAP_SUCCESS;
 }
 
-OLAPStatus TabletSchema::to_schema_pb(TabletSchemaPB* tablet_meta_pb) {
+void TabletSchema::to_schema_pb(TabletSchemaPB* tablet_meta_pb) {
     tablet_meta_pb->set_keys_type(_keys_type);
     for (auto& col : _cols) {
         ColumnPB* column = tablet_meta_pb->add_column();
@@ -388,8 +385,6 @@ OLAPStatus TabletSchema::to_schema_pb(TabletSchemaPB* tablet_meta_pb) {
     }
     tablet_meta_pb->set_next_column_unique_id(_next_column_unique_id);
     tablet_meta_pb->set_is_in_memory(_is_in_memory);
-
-    return OLAP_SUCCESS;
 }
 
 size_t TabletSchema::row_size() const {
diff --git a/be/src/olap/tablet_schema.h b/be/src/olap/tablet_schema.h
index f96f039245..4dbfae5929 100644
--- a/be/src/olap/tablet_schema.h
+++ b/be/src/olap/tablet_schema.h
@@ -31,8 +31,8 @@ public:
     TabletColumn();
     TabletColumn(FieldAggregationMethod agg, FieldType type);
     TabletColumn(FieldAggregationMethod agg, FieldType filed_type, bool is_nullable);
-    OLAPStatus init_from_pb(const ColumnPB& column);
-    OLAPStatus to_schema_pb(ColumnPB* column);
+    void init_from_pb(const ColumnPB& column);
+    void to_schema_pb(ColumnPB* column);
 
     inline int32_t unique_id() const { return _unique_id; }
     inline std::string name() const { return _col_name; }
@@ -88,8 +88,8 @@ private:
 class TabletSchema {
 public:
     TabletSchema();
-    OLAPStatus init_from_pb(const TabletSchemaPB& schema);
-    OLAPStatus to_schema_pb(TabletSchemaPB* tablet_meta_pb);
+    void init_from_pb(const TabletSchemaPB& schema);
+    void to_schema_pb(TabletSchemaPB* tablet_meta_pb);
     size_t row_size() const;
     size_t field_index(const std::string& field_name) const;
     const TabletColumn& column(size_t ordinal) const;
@@ -118,8 +118,8 @@ private:
     CompressKind _compress_kind;
     size_t _next_column_unique_id;
 
-    bool _has_bf_fpp;
-    double _bf_fpp;
+    bool _has_bf_fpp = false;
+    double _bf_fpp = 0;
     bool _is_in_memory = false;
 };
 
diff --git a/be/src/olap/task/engine_clone_task.cpp b/be/src/olap/task/engine_clone_task.cpp
index bf9450b8f9..0b04a8c0d4 100644
--- a/be/src/olap/task/engine_clone_task.cpp
+++ b/be/src/olap/task/engine_clone_task.cpp
@@ -812,17 +812,10 @@ OLAPStatus EngineCloneTask::_clone_full_data(Tablet* tablet, TabletMeta* cloned_
             }
 
             if (existed_in_src) {
-                OLAPStatus delete_res = cloned_tablet_meta->delete_rs_meta_by_version(local_version,
-                    &rs_metas_found_in_src);
-                if (delete_res != OLAP_SUCCESS) {
-                    LOG(WARNING) << "failed to delete existed version from clone src when full clone. "
-                                    << ", version=" << local_version.first << "-" << local_version.second;
-                    return delete_res;
-                } else {
-                    LOG(INFO) << "Delta has already existed in local header, no need to clone."
-                        << "tablet=" << tablet->full_name()
-                        << ", version='" << local_version.first<< "-" << local_version.second;
-                }
+                cloned_tablet_meta->delete_rs_meta_by_version(local_version, &rs_metas_found_in_src);
+                LOG(INFO) << "Delta has already existed in local header, no need to clone."
+                    << "tablet=" << tablet->full_name()
+                    << ", version='" << local_version.first<< "-" << local_version.second;
             } else {
                 // Delta labeled in local_version is not existed in clone header,
                 // some overlapping delta will be cloned to replace it.
diff --git a/be/src/olap/task/engine_storage_migration_task.cpp b/be/src/olap/task/engine_storage_migration_task.cpp
index 9475a1fd14..8e26fc71d2 100644
--- a/be/src/olap/task/engine_storage_migration_task.cpp
+++ b/be/src/olap/task/engine_storage_migration_task.cpp
@@ -30,12 +30,10 @@ EngineStorageMigrationTask::EngineStorageMigrationTask(TStorageMediumMigrateReq&
 }
 
 OLAPStatus EngineStorageMigrationTask::execute() {
-    OLAPStatus res = OLAP_SUCCESS;
-    res = _storage_medium_migrate(
+    return _storage_medium_migrate(
         _storage_medium_migrate_req.tablet_id,
         _storage_medium_migrate_req.schema_hash,
         _storage_medium_migrate_req.storage_medium);
-    return res;
 }
 
 OLAPStatus EngineStorageMigrationTask::_storage_medium_migrate(
@@ -156,14 +154,12 @@ OLAPStatus EngineStorageMigrationTask::_storage_medium_migrate(
         }
         
         Status st = FileUtils::create_dir(schema_hash_path);
-
         if (!st.ok()) {
             res = OLAP_ERR_CANNOT_CREATE_DIR;
             LOG(WARNING) << "fail to create path. path=" << schema_hash_path << ", error:" << st.to_string();
             break;
         }
 
-
         // migrate all index and data files but header file
         res = _copy_index_and_data_files(schema_hash_path, tablet, consistent_rowsets);
         if (res != OLAP_SUCCESS) {
@@ -171,17 +167,12 @@ OLAPStatus EngineStorageMigrationTask::_storage_medium_migrate(
             break;
         }
         tablet->obtain_header_rdlock();
-        res = _generate_new_header(stores[0], shard, tablet, consistent_rowsets, new_tablet_meta);
-        if (res != OLAP_SUCCESS) {
-            tablet->release_header_lock();
-            LOG(WARNING) << "fail to generate new header file from the old. res=" << res;
-            break;
-        }
+        _generate_new_header(stores[0], shard, tablet, consistent_rowsets, new_tablet_meta);
         tablet->release_header_lock();
         std::string new_meta_file = schema_hash_path + "/" + std::to_string(tablet_id) + ".hdr";
         res = new_tablet_meta->save(new_meta_file);
         if (res != OLAP_SUCCESS) {
-            LOG(WARNING) << "failed to save met to path" << new_meta_file;
+            LOG(WARNING) << "failed to save meta to path" << new_meta_file;
             break;
         }
 
@@ -234,40 +225,31 @@ OLAPStatus EngineStorageMigrationTask::_storage_medium_migrate(
 }
 
 // TODO(ygl): lost some infomation here, such as cumulative layer point
-OLAPStatus EngineStorageMigrationTask::_generate_new_header(
+void EngineStorageMigrationTask::_generate_new_header(
         DataDir* store, const uint64_t new_shard,
         const TabletSharedPtr& tablet,
         const std::vector<RowsetSharedPtr>& consistent_rowsets,
         TabletMetaSharedPtr new_tablet_meta) {
-    if (store == nullptr) {
-        LOG(WARNING) << "fail to generate new header for store is null";
-        return OLAP_ERR_HEADER_INIT_FAILED;
-    }
-    OLAPStatus res = tablet->generate_tablet_meta_copy(new_tablet_meta);
-    if (res != OLAP_SUCCESS) {
-        LOG(WARNING) << "could not generate new tablet meta. "
-                     << "tablet:" << tablet->full_name();
-        return res;
-    }
+    DCHECK(store != nullptr);
+    tablet->generate_tablet_meta_copy(new_tablet_meta);
 
     vector<RowsetMetaSharedPtr> rs_metas;
     for (auto& rs : consistent_rowsets) {
         rs_metas.push_back(rs->rowset_meta());
     }
-    new_tablet_meta->revise_rs_metas(rs_metas);
+    new_tablet_meta->revise_rs_metas(std::move(rs_metas));
     new_tablet_meta->set_shard_id(new_shard);
     // should not save new meta here, because new tablet may failed
     // should not remove the old meta here, because the new header maybe not valid
     // remove old meta after the new tablet is loaded successfully
-    return res;
 }
 
 OLAPStatus EngineStorageMigrationTask::_copy_index_and_data_files(
         const string& schema_hash_path,
         const TabletSharedPtr& ref_tablet,
-        std::vector<RowsetSharedPtr>& consistent_rowsets) {
+        const std::vector<RowsetSharedPtr>& consistent_rowsets) const {
     OLAPStatus status = OLAP_SUCCESS;
-    for (auto& rs : consistent_rowsets) {
+    for (const auto& rs : consistent_rowsets) {
         status = rs->copy_files_to(schema_hash_path);
         if (status != OLAP_SUCCESS) {
             Status ret = FileUtils::remove_all(schema_hash_path);
diff --git a/be/src/olap/task/engine_storage_migration_task.h b/be/src/olap/task/engine_storage_migration_task.h
index cfcc13d420..7a449f2d6e 100644
--- a/be/src/olap/task/engine_storage_migration_task.h
+++ b/be/src/olap/task/engine_storage_migration_task.h
@@ -40,17 +40,17 @@ private:
                 TTabletId tablet_id, TSchemaHash schema_hash,
                 TStorageMedium::type storage_medium);
     
-    OLAPStatus _generate_new_header(DataDir* store, const uint64_t new_shard,
-                                    const TabletSharedPtr& tablet,
-                                    const std::vector<RowsetSharedPtr>& consistent_rowsets,
-                                    TabletMetaSharedPtr new_tablet_meta);
+    void _generate_new_header(DataDir* store, const uint64_t new_shard,
+                              const TabletSharedPtr& tablet,
+                              const std::vector<RowsetSharedPtr>& consistent_rowsets,
+                              TabletMetaSharedPtr new_tablet_meta);
     
     // TODO: hkp
     // rewrite this function
     OLAPStatus _copy_index_and_data_files(
             const std::string& header_path,
             const TabletSharedPtr& ref_tablet,
-            std::vector<RowsetSharedPtr>& consistent_rowsets);
+            const std::vector<RowsetSharedPtr>& consistent_rowsets) const;
 
 private:
     const TStorageMediumMigrateReq& _storage_medium_migrate_req;
diff --git a/be/test/olap/delete_handler_test.cpp b/be/test/olap/delete_handler_test.cpp
index ef8b2ba0fd..f78b329631 100644
--- a/be/test/olap/delete_handler_test.cpp
+++ b/be/test/olap/delete_handler_test.cpp
@@ -668,8 +668,7 @@ TEST_F(TestDeleteHandler, InitSuccess) {
     DeletePredicatePB del_pred;
     res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred);
     ASSERT_EQ(OLAP_SUCCESS, res);
-    res = tablet->add_delete_predicate(del_pred, 1);
-    ASSERT_EQ(OLAP_SUCCESS, res);
+    tablet->add_delete_predicate(del_pred, 1);
 
     conditions.clear();
     condition.column_name = "k1";
@@ -681,8 +680,7 @@ TEST_F(TestDeleteHandler, InitSuccess) {
     DeletePredicatePB del_pred_2;
     res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_2);
     ASSERT_EQ(OLAP_SUCCESS, res);
-    res = tablet->add_delete_predicate(del_pred_2, 2);
-    ASSERT_EQ(OLAP_SUCCESS, res);
+    tablet->add_delete_predicate(del_pred_2, 2);
 
     conditions.clear();
     condition.column_name = "k2";
@@ -694,8 +692,7 @@ TEST_F(TestDeleteHandler, InitSuccess) {
     DeletePredicatePB del_pred_3;
     res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_3);
     ASSERT_EQ(OLAP_SUCCESS, res);
-    res = tablet->add_delete_predicate(del_pred_3, 3);
-    ASSERT_EQ(OLAP_SUCCESS, res);
+    tablet->add_delete_predicate(del_pred_3, 3);
 
     conditions.clear();
     condition.column_name = "k2";
@@ -707,8 +704,7 @@ TEST_F(TestDeleteHandler, InitSuccess) {
     DeletePredicatePB del_pred_4;
     res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_4);
     ASSERT_EQ(OLAP_SUCCESS, res);
-    res = tablet->add_delete_predicate(del_pred_4, 4);
-    ASSERT_EQ(OLAP_SUCCESS, res);
+    tablet->add_delete_predicate(del_pred_4, 4);
 
     // 从header文件中取出版本号小于等于7的过滤条件
     res = _delete_handler.init(tablet->tablet_schema(), tablet->delete_predicates(), 4);
@@ -750,7 +746,7 @@ TEST_F(TestDeleteHandler, FilterDataSubconditions) {
     DeletePredicatePB del_pred;
     res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred);
     ASSERT_EQ(OLAP_SUCCESS, res);
-    res = tablet->add_delete_predicate(del_pred, 1);
+    tablet->add_delete_predicate(del_pred, 1);
 
     // 指定版本号为10以载入Header中的所有过滤条件(在这个case中，只有过滤条件1)
     res = _delete_handler.init(tablet->tablet_schema(), tablet->delete_predicates(), 4);
@@ -811,7 +807,7 @@ TEST_F(TestDeleteHandler, FilterDataConditions) {
     DeletePredicatePB del_pred;
     res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred);
     ASSERT_EQ(OLAP_SUCCESS, res);
-    res = tablet->add_delete_predicate(del_pred, 1);
+    tablet->add_delete_predicate(del_pred, 1);
 
     // 过滤条件2
     conditions.clear();
@@ -824,7 +820,7 @@ TEST_F(TestDeleteHandler, FilterDataConditions) {
     DeletePredicatePB del_pred_2;
     res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_2);
     ASSERT_EQ(OLAP_SUCCESS, res);
-    res = tablet->add_delete_predicate(del_pred_2, 2);
+    tablet->add_delete_predicate(del_pred_2, 2);
 
     // 过滤条件3
     conditions.clear();
@@ -837,7 +833,7 @@ TEST_F(TestDeleteHandler, FilterDataConditions) {
     DeletePredicatePB del_pred_3;
     res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_3);
     ASSERT_EQ(OLAP_SUCCESS, res);
-    res = tablet->add_delete_predicate(del_pred_3, 3);
+    tablet->add_delete_predicate(del_pred_3, 3);
 
     // 指定版本号为4以载入meta中的所有过滤条件(在这个case中，只有过滤条件1)
     res = _delete_handler.init(tablet->tablet_schema(), tablet->delete_predicates(), 4);
@@ -889,7 +885,7 @@ TEST_F(TestDeleteHandler, FilterDataVersion) {
     DeletePredicatePB del_pred;
     res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred);
     ASSERT_EQ(OLAP_SUCCESS, res);
-    res = tablet->add_delete_predicate(del_pred, 3);
+    tablet->add_delete_predicate(del_pred, 3);
 
     // 过滤条件2
     conditions.clear();
@@ -902,7 +898,7 @@ TEST_F(TestDeleteHandler, FilterDataVersion) {
     DeletePredicatePB del_pred_2;
     res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_2);
     ASSERT_EQ(OLAP_SUCCESS, res);
-    res = tablet->add_delete_predicate(del_pred_2, 4);
+    tablet->add_delete_predicate(del_pred_2, 4);
 
     // 指定版本号为4以载入meta中的所有过滤条件(过滤条件1，过滤条件2)
     res = _delete_handler.init(tablet->tablet_schema(), tablet->delete_predicates(), 4);