Not release empty memtable before mini-merge

src/storage/memtable/ob_memtable.cpp

@@ -1425,13 +1425,7 @@ void ObMemtable::dec_unsubmitted_and_unsynced_cnt()
 
 bool ObMemtable::can_be_minor_merged()
 {
-  bool bool_ret = false;
+  return is_in_prepare_list_of_data_checkpoint();
-
-  if (!is_empty() || get_is_force_freeze()) {
-    bool_ret = is_in_prepare_list_of_data_checkpoint();
-  }
-
-  return bool_ret;
 }
 
 int ObMemtable::get_frozen_schema_version(int64_t &schema_version) const
@@ -1849,19 +1843,6 @@ int ObMemtable::flush(share::ObLSID ls_id)
                        "ready for flush time:",
                        mt_stat_.ready_for_flush_time_);
     }
-
-    if (is_empty() && !get_is_force_freeze()) {
-      if (OB_FAIL(memtable_mgr_->release_head_empty_memtable(this))) {
-        if (OB_EAGAIN != ret) {
-          TRANS_LOG(WARN, "fail to release empty memtable", K(ret), K(ls_id), KPC(this));
-        } else {
-          // wait next time flush
-          ret = OB_SUCCESS;
-        }
-      } else {
-        TRANS_LOG(INFO, "release head empty memtable", K(ret), KPC(this));
-      }
-    } else {
     ObTabletMergeDagParam param;
     param.ls_id_ = ls_id;
     param.tablet_id_ = key_.tablet_id_;
@@ -1877,7 +1858,6 @@ int ObMemtable::flush(share::ObLSID ls_id)
       TRANS_LOG(INFO, "schedule tablet merge dag successfully", K(ret), K(param), KPC(this));
     }
   }
-  }
 
   return ret;
 }

src/storage/ob_i_memtable_mgr.cpp

@@ -128,11 +128,7 @@ int ObIMemtableMgr::release_memtables(const int64_t log_ts)
         ret = OB_ERR_UNEXPECTED;
         STORAGE_LOG(WARN, "memtable is nullptr", K(ret), KP(memtable), K(i));
       } else {
-        if (memtable->is_data_memtable()
+        if (memtable->get_end_log_ts() <= log_ts
-            && memtable->is_empty()
-            && !memtable->get_is_force_freeze()) {
-          break;
-        } else if (memtable->get_end_log_ts() <= log_ts
             && memtable->can_be_minor_merged()) {
           if (OB_FAIL(release_head_memtable_(memtable))) {
             STORAGE_LOG(WARN, "fail to release memtable", K(ret), KPC(memtable));

src/storage/tablet/ob_tablet_memtable_mgr.cpp

@@ -554,44 +554,6 @@ int ObTabletMemtableMgr::get_all_memtables(ObTableHdlArray &handle)
   return ret;
 }
 
-int ObTabletMemtableMgr::release_head_empty_memtable(memtable::ObIMemtable *flush_memtable)
-{
-  int ret = OB_SUCCESS;
-  const share::ObLSID ls_id = ls_->get_ls_id();
-
-  if (lock_.try_wrlock()) {
-    if (IS_NOT_INIT) {
-      ret = OB_NOT_INIT;
-      TRANS_LOG(WARN, "not inited", K(ret));
-    } else {
-      memtable::ObIMemtable *imemtable = tables_[get_memtable_idx(memtable_head_)];
-      if (OB_ISNULL(imemtable)) {
-        ret = OB_ERR_UNEXPECTED;
-        STORAGE_LOG(WARN, "memtable is nullptr", K(ret), KP(imemtable), K(memtable_head_));
-      } else if (flush_memtable == imemtable) {
-        memtable::ObMemtable *memtable = static_cast<memtable::ObMemtable *>(imemtable);
-        if (memtable->is_empty()) {
-          if (!memtable->is_frozen_memtable() ||
-              0 != memtable->get_write_ref() ||
-              0 != memtable->get_unsubmitted_cnt() ||
-              0 != memtable->get_unsynced_cnt()) {
-            STORAGE_LOG(WARN, "The empty memtable cannot be released!", K(ls_id), K(tablet_id_), KPC(memtable));
-          } else if (OB_FAIL(release_head_memtable_(imemtable))) {
-            STORAGE_LOG(WARN, "fail to release empty memtable", K(ret), K(ls_id), K(tablet_id_));
-          } else {
-            STORAGE_LOG(INFO, "succeed to release empty memtable", K(ret), K(ls_id), K(tablet_id_));
-          }
-        }
-      }
-    }
-    lock_.unlock();
-  } else {
-    ret = OB_EAGAIN;
-  }
-
-  return ret;
-}
-
 int ObTabletMemtableMgr::release_head_memtable_(memtable::ObIMemtable *imemtable,
                                                 const bool force)
 {

src/storage/tablet/ob_tablet_memtable_mgr.h

@@ -86,7 +86,6 @@ public:
   int unset_logging_blocked_for_active_memtable(memtable::ObIMemtable *memtable);
   int set_is_tablet_freeze_for_active_memtable(memtable::ObIMemtable *&memtable,
                                                bool is_force_freeze = false);
-  int release_head_empty_memtable(memtable::ObIMemtable *flush_memtable);
 
   ObStorageSchemaRecorder &get_storage_schema_recorder()
   {

src/storage/tablet/ob_tablet_table_store.cpp

@@ -312,30 +312,17 @@ int ObTabletTableStore::prepare_memtables()
   return memtables_.prepare_allocate();
 }
 
-// fix issue 41619224
 int ObTabletTableStore::update_memtables()
 {
   int ret = OB_SUCCESS;
-  ObTableHandleArray inc_memtables;
+  if (OB_FAIL(pull_memtables())) {
-
+    LOG_WARN("failed to update memtables from memtable_mgr", K(ret));
-  if (OB_ISNULL(tablet_ptr_) || OB_ISNULL(tablet_ptr_->get_memtable_mgr())) {
-    ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("get unexpected tablet_ptr or memtable_mgr", K(ret), KP(tablet_ptr_));
-  } else if (!tablet_ptr_->get_memtable_mgr()->has_memtable()) {
-    LOG_INFO("no memtable in memtable mgr", K(ret));
-  } else if (OB_FAIL(tablet_ptr_->get_memtable_mgr()->get_all_memtables(inc_memtables))) {
-    LOG_WARN("failed to get all memtables from memtable_mgr", K(ret));
-  } else if (OB_FAIL(memtables_.rebuild(inc_memtables))) {
-    LOG_ERROR("failed to rebuild table store memtables", K(ret), K(inc_memtables), KPC(this));
   } else {
     int tmp_ret = OB_SUCCESS;
     if (OB_SUCCESS != (tmp_ret = init_read_cache())) {
-      if (OB_SNAPSHOT_DISCARDED != tmp_ret) {
       LOG_WARN("failed to rebuild read cache", K(tmp_ret));
     }
   }
-  }
-
   return ret;
 }