change recorder destroy when offline

src/storage/ls/ob_ls_tablet_service.cpp

@@ -5583,7 +5583,7 @@ int ObLSTabletService::DestroyMemtableAndMemberOperator::operator()(const common
     }
   } else if (OB_FAIL(handle.get_obj()->release_memtables())) {
     LOG_WARN("failed to release memtables", K(tenant_id), K(tablet_id));
-  } else if (!tablet_id.is_ls_inner_tablet() && OB_FAIL(handle.get_obj()->destroy_storage_related_member())) {
+  } else if (!tablet_id.is_ls_inner_tablet() && OB_FAIL(handle.get_obj()->reset_storage_related_member())) {
     LOG_WARN("failed to destroy storage related member", K(ret), K(tenant_id), K(tablet_id));
   }
   return ret;

src/storage/ob_i_memtable_mgr.h

@@ -123,7 +123,7 @@ public:
     UNUSED(log_handler);
     return OB_NOT_SUPPORTED;
   }
-  virtual int destroy_storage_schema_recorder()
+  virtual int reset_storage_schema_recorder()
   { // do nothing
     return OB_NOT_SUPPORTED;
   }

src/storage/ob_storage_schema_recorder.cpp

@@ -103,6 +103,15 @@ ObStorageSchemaRecorder::~ObStorageSchemaRecorder()
 }
 
 void ObStorageSchemaRecorder::reset()
+{
+  if (is_inited_) {
+    wait_to_lock(OB_INVALID_VERSION); // lock
+    max_saved_table_version_ = 0;
+    ATOMIC_STORE(&lock_, false); // unlock
+  }
+}
+
+void ObStorageSchemaRecorder::destroy()
 {
   is_inited_ = false;
   max_saved_table_version_ = OB_INVALID_VERSION;

src/storage/ob_storage_schema_recorder.h

@@ -58,6 +58,7 @@ public:
       const int64_t saved_schema_version,
       logservice::ObLogHandler *log_handler);
   void reset();
+  void destroy();
   bool is_inited() const { return is_inited_; }
   bool is_valid() const
   {

src/storage/tablet/ob_tablet.cpp

@@ -282,10 +282,6 @@ int ObTablet::init(
       || OB_ISNULL(log_handler_)) {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(memtable_mgr), K_(log_handler));
-  } else if (is_update
-      && !tablet_id.is_ls_inner_tablet()
-      && OB_FAIL(init_storage_related_member(ls_id, tablet_id, param.max_sync_storage_schema_version_))) {
-    LOG_WARN("failed to init storage related member", K(ret), K(ls_id), K(tablet_id));
   } else if (!is_update && OB_FAIL(init_shared_params(ls_id, tablet_id, param.max_sync_storage_schema_version_, freezer))) {
     LOG_WARN("failed to init shared params", K(ret), K(ls_id), K(tablet_id), KP(freezer));
   } else if (OB_FAIL(tablet_meta_.init(*allocator_, param))) {
@@ -1632,7 +1628,7 @@ int ObTablet::release_memtables()
   return ret;
 }
 
-int ObTablet::destroy_storage_related_member()
+int ObTablet::reset_storage_related_member()
 {
   int ret = OB_SUCCESS;
   ObIMemtableMgr *memtable_mgr = nullptr;
@@ -1644,7 +1640,7 @@ int ObTablet::destroy_storage_related_member()
     // do nothing
   } else if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
     LOG_WARN("failed to get memtable mgr", K(ret));
-  } else if (OB_FAIL(memtable_mgr->destroy_storage_schema_recorder())) {
+  } else if (OB_FAIL(memtable_mgr->reset_storage_schema_recorder())) {
     LOG_WARN("failed to destroy storage schema recorder", K(ret), KPC(memtable_mgr));
   }
   return ret;
@@ -1732,30 +1728,6 @@ int ObTablet::init_shared_params(
   return ret;
 }
 
-int ObTablet::init_storage_related_member(
-    const share::ObLSID &ls_id,
-    const common::ObTabletID &tablet_id,
-    const int64_t max_saved_schema_version) // for init storage_schema_recorder on MemtableMgr
-{
-  int ret = OB_SUCCESS;
-  if (OB_UNLIKELY(!pointer_hdl_.is_valid())) {
-    ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl));
-  } else if (is_ls_inner_tablet()) {
-    // do nothing
-  } else {
-    ObIMemtableMgr *memtable_mgr = nullptr;
-    ObTabletMemtableMgr *data_memtable_mgr = nullptr;
-    if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
-      LOG_WARN("failed to get memtable mgr", K(ret));
-    } else if (FALSE_IT(data_memtable_mgr = static_cast<ObTabletMemtableMgr *>(memtable_mgr))) {
-    } else if (OB_FAIL(data_memtable_mgr->init_storage_schema_recorder(tablet_id, ls_id, max_saved_schema_version, log_handler_))) {
-      LOG_WARN("failed to init storage schema recorder", K(ret), K(tablet_id), K(ls_id), KP(max_saved_schema_version));
-    }
-  }
-  return ret;
-}
-
 int ObTablet::build_read_info(common::ObIAllocator &allocator)
 {
   int ret = OB_SUCCESS;

src/storage/tablet/ob_tablet.h

@@ -218,7 +218,7 @@ public:
   // force release all memtables
   // just for rebuild or migrate retry.
   int release_memtables();
-  int destroy_storage_related_member();
+  int reset_storage_related_member();
 
   // multi-source data operation
   int check_tx_data(bool &is_valid) const;
@@ -367,10 +367,6 @@ private:
       const common::ObTabletID &tablet_id,
       const int64_t max_saved_schema_version,
       ObFreezer *freezer);
-  int init_storage_related_member(
-      const share::ObLSID &ls_id,
-      const common::ObTabletID &tablet_id,
-      const int64_t max_saved_schema_version);
   int build_read_info(common::ObIAllocator &allocator);
   int create_memtable(const int64_t schema_version, const bool for_replay=false);
   int try_update_start_scn();

src/storage/tablet/ob_tablet_memtable_mgr.cpp

@@ -125,10 +125,13 @@ int ObTabletMemtableMgr::init_storage_schema_recorder(
   return ret;
 }
 
-int ObTabletMemtableMgr::destroy_storage_schema_recorder()
+int ObTabletMemtableMgr::reset_storage_schema_recorder()
 {
   int ret = OB_SUCCESS;
-  if (schema_recorder_.is_inited()) {
+  if (OB_UNLIKELY(!schema_recorder_.is_inited())) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("schema recorder is not init", K(ret));
+  } else {
     schema_recorder_.reset();
   }
   return ret;

src/storage/tablet/ob_tablet_memtable_mgr.h

@@ -96,7 +96,7 @@ public:
       const share::ObLSID &ls_id,
       const int64_t max_saved_schema_version,
       logservice::ObLogHandler *log_handler) override;
-  virtual int destroy_storage_schema_recorder() override;
+  virtual int reset_storage_schema_recorder() override;
   DECLARE_VIRTUAL_TO_STRING;
 
 protected: