iterate ddl kv mgr using tablet pointer

src/observer/virtual_table/ob_all_virtual_tablet_ddl_kv_info.cpp

@@ -90,11 +90,11 @@ int ObAllVirtualTabletDDLKVInfo::get_next_ls(ObLS *&ls)
   return ret;
 }
 
-int ObAllVirtualTabletDDLKVInfo::get_next_tablet(ObTabletHandle &tablet_handle)
+int ObAllVirtualTabletDDLKVInfo::get_next_ddl_kv_mgr(ObDDLKvMgrHandle &ddl_kv_mgr_handle)
 {
   int ret = OB_SUCCESS;
   while (OB_SUCC(ret)) {
-    if (OB_FAIL(ls_tablet_iter_.get_next_tablet(tablet_handle))) {
+    if (OB_FAIL(ls_tablet_iter_.get_next_ddl_kv_mgr(ddl_kv_mgr_handle))) {
       if (!ls_tablet_iter_.is_valid() || OB_ITER_END == ret) {
         ret = OB_SUCCESS; // continue to next ls
         ObLS *ls = nullptr;
@@ -106,10 +106,10 @@ int ObAllVirtualTabletDDLKVInfo::get_next_tablet(ObTabletHandle &tablet_handle)
           SERVER_LOG(WARN, "fail to get tablet iter", K(ret));
         }
       } else {
-        SERVER_LOG(WARN, "fail to get next tablet", K(ret));
+        SERVER_LOG(WARN, "fail to get next ddl kv mgr", K(ret));
       }
     } else {
-      curr_tablet_id_ = tablet_handle.get_obj()->get_tablet_meta().tablet_id_;
+      curr_tablet_id_ = ddl_kv_mgr_handle.get_obj()->get_tablet_id();
       break;
     }
   }
@@ -123,16 +123,9 @@ int ObAllVirtualTabletDDLKVInfo::get_next_ddl_kv(ObDDLKV *&ddl_kv)
   while (OB_SUCC(ret)) {
     if (ddl_kv_idx_ < 0 || ddl_kv_idx_ >= ddl_kvs_handle_.get_count()) {
       ObDDLKvMgrHandle ddl_kv_mgr_handle;
-      if (OB_FAIL(get_next_tablet(tablet_handle))) {
+      if (OB_FAIL(get_next_ddl_kv_mgr(ddl_kv_mgr_handle))) {
         if (OB_ITER_END != ret) {
-          SERVER_LOG(WARN, "get_next_tablet failed", K(ret));
-        }
-      } else if (OB_FAIL(tablet_handle.get_obj()->get_ddl_kv_mgr(ddl_kv_mgr_handle))) {
-        if (OB_ENTRY_NOT_EXIST != ret) {
-          SERVER_LOG(WARN, "fail to get freezed ddl kv", K(ret));
-        } else {
-          ddl_kv_idx_ = -1; // to get next tablet
-          ret = OB_SUCCESS;
+          SERVER_LOG(WARN, "get_next_ddl_kv_mgr failed", K(ret));
         }
       } else if (OB_FAIL(ddl_kv_mgr_handle.get_obj()->get_ddl_kvs(false/*frozen_only*/, ddl_kvs_handle_))) {
         SERVER_LOG(WARN, "fail to get ddl kvs", K(ret));

src/observer/virtual_table/ob_all_virtual_tablet_ddl_kv_info.h

@@ -41,7 +41,7 @@ private:
   virtual void release_last_tenant() override;
 
   int get_next_ls(ObLS *&ls);
-  int get_next_tablet(storage::ObTabletHandle &tablet_handle);
+  int get_next_ddl_kv_mgr(storage::ObDDLKvMgrHandle &ddl_kv_mgr_handle);
   int get_next_ddl_kv(ObDDLKV *&ddl_kv);
 private:
   common::ObAddr addr_;

src/storage/ddl/ob_tablet_ddl_kv_mgr.h

@@ -52,6 +52,7 @@ public:
   bool is_started() const { return 0 != start_log_ts_; }
   int set_commit_success();
   bool is_commit_success() const { return is_commit_success_; }
+  common::ObTabletID get_tablet_id() const { return tablet_id_; }
   int cleanup();
   OB_INLINE void inc_ref() { ATOMIC_INC(&ref_cnt_); }
   OB_INLINE int64_t dec_ref() { return ATOMIC_SAF(&ref_cnt_, 1 /* just sub 1 */); }

src/storage/ls/ob_ls_ddl_log_handler.cpp

@@ -74,28 +74,19 @@ int ObLSDDLLogHandler::offline()
     LOG_WARN("failed to build ls tablet iter", K(ret), K(ls_));
   } else {
     while (OB_SUCC(ret)) {
-      ObTabletHandle tablet_handle;
-      if (OB_FAIL(tablet_iter.get_next_tablet(tablet_handle))) {
+      ObDDLKvMgrHandle ddl_kv_mgr_handle;
+      if (OB_FAIL(tablet_iter.get_next_ddl_kv_mgr(ddl_kv_mgr_handle))) {
         if (OB_ITER_END == ret) {
           ret = OB_SUCCESS;
           break;
         } else {
-          LOG_WARN("failed to get tablet", K(ret), K(tablet_handle));
+          LOG_WARN("failed to get ddl kv mgr", K(ret), K(ddl_kv_mgr_handle));
         }
-      } else if (OB_UNLIKELY(!tablet_handle.is_valid())) {
+      } else if (OB_UNLIKELY(!ddl_kv_mgr_handle.is_valid())) {
         ret = OB_ERR_UNEXPECTED;
-        LOG_WARN("invalid tablet handle", K(ret), K(tablet_handle));
-      } else {
-        ObDDLKvMgrHandle ddl_kv_mgr_handle;
-        if (OB_FAIL(tablet_handle.get_obj()->get_ddl_kv_mgr(ddl_kv_mgr_handle))) {
-          if (OB_ENTRY_NOT_EXIST != ret) {
-            LOG_WARN("get ddl kv mgr failed", K(ret), "ls_meta", ls_->get_ls_meta(), "tablet_meta", tablet_handle.get_obj()->get_tablet_meta());
-          } else {
-            ret = OB_SUCCESS;
-          }
-        } else if (OB_FAIL(ddl_kv_mgr_handle.get_obj()->cleanup())) {
-          LOG_WARN("ddl kv mgr cleanup failed", K(ret), "ls_meta", ls_->get_ls_meta(), "tablet_meta", tablet_handle.get_obj()->get_tablet_meta());
-        }
+        LOG_WARN("invalid tablet handle", K(ret), K(ddl_kv_mgr_handle));
+      } else if (OB_FAIL(ddl_kv_mgr_handle.get_obj()->cleanup())) {
+        LOG_WARN("ddl kv mgr cleanup failed", K(ret), "ls_meta", ls_->get_ls_meta(), "tablet_id", ddl_kv_mgr_handle.get_obj()->get_tablet_id());
       }
     }
   }
@@ -226,24 +217,24 @@ int ObLSDDLLogHandler::flush(int64_t rec_log_ts)
     } else {
       bool has_ddl_kv = false;
       while (OB_SUCC(ret)) {
-        ObTabletHandle tablet_handle;
-        if (OB_FAIL(tablet_iter.get_next_tablet(tablet_handle))) {
+        ObDDLKvMgrHandle ddl_kv_mgr_handle;
+        if (OB_FAIL(tablet_iter.get_next_ddl_kv_mgr(ddl_kv_mgr_handle))) {
           if (OB_ITER_END == ret) {
             ret = OB_SUCCESS;
             break;
           } else {
-            LOG_WARN("failed to get tablet", K(ret), K(tablet_handle));
+            LOG_WARN("failed to get ddl kv mgr", K(ret), K(ddl_kv_mgr_handle));
           }
-        } else if (OB_UNLIKELY(!tablet_handle.is_valid())) {
+        } else if (OB_UNLIKELY(!ddl_kv_mgr_handle.is_valid())) {
           ret = OB_ERR_UNEXPECTED;
-          LOG_WARN("invalid tablet handle", K(ret), K(tablet_handle));
-        } else if (OB_FAIL(tablet_handle.get_obj()->check_has_effective_ddl_kv(has_ddl_kv))) {
+          LOG_WARN("invalid ddl kv mgr handle", K(ret), K(ddl_kv_mgr_handle));
+        } else if (OB_FAIL(ddl_kv_mgr_handle.get_obj()->check_has_effective_ddl_kv(has_ddl_kv))) {
           LOG_WARN("failed to check ddl kv", K(ret));
         } else if (has_ddl_kv) {
           DEBUG_SYNC(BEFORE_DDL_CHECKPOINT);
           ObDDLTableMergeDagParam param;
           param.ls_id_ = ls_->get_ls_id();
-          param.tablet_id_ = tablet_handle.get_obj()->get_tablet_meta().tablet_id_;
+          param.tablet_id_ = ddl_kv_mgr_handle.get_obj()->get_tablet_id();
           param.rec_log_ts_ = rec_log_ts;
           if (OB_FAIL(compaction::ObScheduleDagFunc::schedule_ddl_table_merge_dag(param))) {
             if (OB_EAGAIN != ret && OB_SIZE_OVERFLOW != ret) {
@@ -267,22 +258,22 @@ int64_t ObLSDDLLogHandler::get_rec_log_ts()
     LOG_WARN("failed to build ls tablet iter", K(ret), K(ls_));
   } else {
     while (OB_SUCC(ret)) {
-      ObTabletHandle tablet_handle;
+      ObDDLKvMgrHandle ddl_kv_mgr_handle;
       int64_t min_log_ts = INT64_MAX;
-      if (OB_FAIL(tablet_iter.get_next_tablet(tablet_handle))) {
+      if (OB_FAIL(tablet_iter.get_next_ddl_kv_mgr(ddl_kv_mgr_handle))) {
         if (OB_ITER_END == ret) {
           ret = OB_SUCCESS;
           break;
         } else {
-          LOG_WARN("failed to get tablet", K(ret), K(tablet_handle));
+          LOG_WARN("failed to get ddl kv mgr", K(ret), K(ddl_kv_mgr_handle));
         }
-      } else if (OB_UNLIKELY(!tablet_handle.is_valid())) {
+      } else if (OB_UNLIKELY(!ddl_kv_mgr_handle.is_valid())) {
         ret = OB_ERR_UNEXPECTED;
-        LOG_WARN("invalid tablet handle", K(ret), K(tablet_handle));
-      } else if (OB_FAIL(tablet_handle.get_obj()->check_has_effective_ddl_kv(has_ddl_kv))) {
+        LOG_WARN("invalid ddl kv mgr handle", K(ret), K(ddl_kv_mgr_handle));
+      } else if (OB_FAIL(ddl_kv_mgr_handle.get_obj()->check_has_effective_ddl_kv(has_ddl_kv))) {
         LOG_WARN("failed to check ddl kv", K(ret));
       } else if (has_ddl_kv) {
-        if (OB_FAIL(tablet_handle.get_obj()->get_ddl_kv_min_log_ts(min_log_ts))) {
+        if (OB_FAIL(ddl_kv_mgr_handle.get_obj()->get_ddl_kv_min_log_ts(min_log_ts))) {
           LOG_WARN("fail to get ddl kv min log ts", K(ret));
         } else {
           rec_log_ts = MIN(rec_log_ts, min_log_ts);

src/storage/meta_mem/ob_tenant_meta_mem_mgr.cpp

@@ -1032,6 +1032,36 @@ int ObTenantMetaMemMgr::set_tablet_pointer_tx_data(
   return ret;
 }
 
+int ObTenantMetaMemMgr::get_tablet_ddl_kv_mgr(
+    const ObTabletMapKey &key,
+    ObDDLKvMgrHandle &ddl_kv_mgr_handle)
+{
+  int ret = OB_SUCCESS;
+  ObTabletPointerHandle ptr_handle(tablet_map_);
+  if (OB_UNLIKELY(!is_inited_)) {
+    ret = OB_NOT_INIT;
+    LOG_WARN("ObTenantMetaMemMgr hasn't been initialized", K(ret));
+  } else if (OB_UNLIKELY(!key.is_valid())) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid argument", K(ret), K(key));
+  } else if (OB_FAIL(tablet_map_.get(key, ptr_handle))) {
+    LOG_WARN("failed to get ptr handle", K(ret), K(key));
+  } else {
+    ObTabletPointer *tablet_ptr = static_cast<ObTabletPointer*>(ptr_handle.get_resource_ptr());
+    if (OB_ISNULL(tablet_ptr)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("tablet ptr is NULL", K(ret), K(ptr_handle));
+    } else {
+      tablet_ptr->get_ddl_kv_mgr(ddl_kv_mgr_handle);
+      if (!ddl_kv_mgr_handle.is_valid()) {
+        ret = OB_ENTRY_NOT_EXIST;
+        LOG_DEBUG("ddl kv mgr not exist", K(ret), K(ddl_kv_mgr_handle));
+      }
+    }
+  }
+  return ret;
+}
+
 int ObTenantMetaMemMgr::get_meta_mem_status(common::ObIArray<ObTenantMetaMemStatus> &info) const
 {
   int ret = OB_SUCCESS;

src/storage/meta_mem/ob_tenant_meta_mem_mgr.h

@@ -190,6 +190,7 @@ public:
   int set_tablet_pointer_tx_data(const ObTabletMapKey &key, const ObTabletTxMultiSourceDataUnit &tx_data);
   int insert_pinned_tablet(const ObTabletMapKey &key);
   int erase_pinned_tablet(const ObTabletMapKey &key);
+  int get_tablet_ddl_kv_mgr(const ObTabletMapKey &key, ObDDLKvMgrHandle &ddl_kv_mgr_handle);
 
   // TIPS:
   //  - only for allocating variable meta object in storage meta.

src/storage/tablet/ob_tablet_iterator.cpp

@@ -109,6 +109,35 @@ int ObLSTabletIterator::get_next_tablet_addr(ObTabletMapKey &key, ObMetaDiskAddr
   return ret;
 }
 
+int ObLSTabletIterator::get_next_ddl_kv_mgr(ObDDLKvMgrHandle &ddl_kv_mgr_handle)
+{
+  int ret = OB_SUCCESS;
+  if (OB_ISNULL(ls_tablet_service_)) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("ls tablet service is nullptr", K(ret), KP(ls_tablet_service_));
+  } else {
+    ObTenantMetaMemMgr *t3m = MTL(ObTenantMetaMemMgr*);
+    do {
+      ObTabletMapKey key;
+      key.ls_id_ = ls_tablet_service_->ls_->get_ls_id();
+      if (OB_UNLIKELY(tablet_ids_.count() == idx_)) {
+        ret = OB_ITER_END;
+      } else {
+        key.tablet_id_ = tablet_ids_.at(idx_);
+
+        if (OB_FAIL(t3m->get_tablet_ddl_kv_mgr(key, ddl_kv_mgr_handle))
+            && OB_ENTRY_NOT_EXIST != ret) {
+          LOG_WARN("fail to get tablet ddl kv mgr", K(ret), K(idx_), K(key));
+        } else {
+          ++idx_;
+        }
+      }
+    } while (OB_ENTRY_NOT_EXIST == ret);
+  }
+  
+  return ret;
+}
+
 
 ObLSTabletIDIterator::ObLSTabletIDIterator(const share::ObLSID &ls_id)
   : ls_id_(ls_id),

src/storage/tablet/ob_tablet_iterator.h

@@ -19,6 +19,7 @@
 #include "common/ob_tablet_id.h"
 #include "share/ob_ls_id.h"
 #include "storage/tablet/ob_tablet_common.h"
+#include "storage/meta_mem/ob_tablet_pointer.h"
 
 namespace oceanbase
 {
@@ -40,6 +41,7 @@ public:
 public:
   int get_next_tablet(ObTabletHandle &handle);
   int get_next_tablet_addr(ObTabletMapKey &key, ObMetaDiskAddr &addr);
+  int get_next_ddl_kv_mgr(ObDDLKvMgrHandle &handle);
 
   void reset();
   bool is_valid() const;