fix virtual_table bug

src/observer/virtual_table/ob_all_virtual_tablet_buffer_info.cpp

@@ -66,25 +66,10 @@ int ObAllVirtualTabletBufferInfo::inner_get_next_row(common::ObNewRow *&row)
 int ObAllVirtualTabletBufferInfo::get_tablet_pool_infos()
 {
   int ret = OB_SUCCESS;
-  buffer_infos_.reuse();
   ObMemAttr attr(MTL_ID(), "TabletBuffer");
   buffer_infos_.set_attr(attr);
-  ObTenantMetaMemMgr *t3m = MTL(ObTenantMetaMemMgr*);
+  if (OB_FAIL(MTL(ObTenantMetaMemMgr*)->get_tablet_buffer_infos(buffer_infos_))) {
-  if (ObTabletPoolType::TP_MAX == pool_type_) {
+    SERVER_LOG(WARN, "fail to get tablet buffer infos", K(ret));
-    pool_type_ = ObTabletPoolType::TP_NORMAL;
-  } else if (ObTabletPoolType::TP_NORMAL == pool_type_) {
-    pool_type_ = ObTabletPoolType::TP_LARGE;
-  } else {
-    pool_type_ = ObTabletPoolType::TP_MAX;
-    ret = OB_ITER_END;
-  }
-
-  if (OB_FAIL(ret)) {
-    // do nothing
-  } else if (OB_FAIL(t3m->get_tablet_buffer_infos(pool_type_, buffer_infos_))) {
-    SERVER_LOG(WARN, "fail to get tablet buffer infos", K_(pool_type));
-  } else {
-    index_ = 0;
   }
   return ret;
 }
@@ -101,35 +86,26 @@ bool ObAllVirtualTabletBufferInfo::is_need_process(uint64_t tenant_id)
 
 int ObAllVirtualTabletBufferInfo::process_curr_tenant(common::ObNewRow *&row)
 {
-  /**
   int ret = OB_SUCCESS;
   if (OB_ISNULL(cur_row_.cells_)) {
     ret = OB_ERR_UNEXPECTED;
     SERVER_LOG(ERROR, "cur row cell is nullptr", K(ret));
+  } else if (0 == buffer_infos_.size() && OB_FAIL(get_tablet_pool_infos())) {
+    SERVER_LOG(WARN, "fail to get tablet pool infos", K(ret));
   } else if (buffer_infos_.size() <= index_) {
-    if (OB_FAIL(get_tablet_pool_infos())) {
+    ret = OB_ITER_END;
-      if (OB_ITER_END != ret) {
-        SERVER_LOG(WARN, "fail to get tablet pool infos", K(ret));
-      }
-    }
-  }
-
-  if (OB_FAIL(ret)) {
-    // do nothing
   } else if (OB_FAIL(gen_row(buffer_infos_[index_], row))) {
     SERVER_LOG(WARN, "fail to gen_row", K(ret));
   } else {
     index_++;
   }
   return ret;
-  */
-  UNUSED(row);
-  return OB_ITER_END;
 }
 
 void ObAllVirtualTabletBufferInfo::release_last_tenant()
 {
   buffer_infos_.reset();
+  index_ = 0;
 }
 
 int ObAllVirtualTabletBufferInfo::gen_row(

src/storage/meta_mem/ob_tenant_meta_mem_mgr.cpp

@@ -1547,46 +1547,43 @@ int ObTenantMetaMemMgr::get_tablet_with_allocator(
   return ret;
 }
 
-int ObTenantMetaMemMgr::get_tablet_buffer_infos(
+int ObTenantMetaMemMgr::get_tablet_buffer_infos(ObIArray<ObTabletBufferInfo> &buffer_infos)
-    const ObTabletPoolType &pool_type,
-    ObIArray<ObTabletBufferInfo> &buffer_infos)
 {
   int ret = OB_SUCCESS;
-  int64_t size = 0;
   if (OB_UNLIKELY(!is_inited_)) {
     ret = OB_NOT_INIT;
     LOG_WARN("ObTenantMetaMemMgr hasn't been initialized", K(ret));
   } else {
-    ObMetaObjBufferNode *tablet_buffer_node = nullptr;
-    ObMetaObjBufferNode *header = nullptr;
     SpinRLockGuard guard(wash_lock_);
-    if (pool_type == ObTabletPoolType::TP_LARGE) {
+    const int64_t size = normal_tablet_header_.get_size() + large_tablet_header_.get_size();
-      tablet_buffer_node = large_tablet_header_.get_first();
+    if (OB_FAIL(buffer_infos.reserve(size))) {
-      header = large_tablet_header_.get_header();
-      size = large_tablet_header_.get_size();
-    } else if (pool_type == ObTabletPoolType::TP_NORMAL) {
-      tablet_buffer_node = normal_tablet_header_.get_first();
-      header = normal_tablet_header_.get_header();
-      size = normal_tablet_header_.get_size();
-    } else {
-      ret = OB_ERR_UNEXPECTED;
-      LOG_WARN("tablet pool type is invalid", K(ret), K(pool_type));
-    }
-    if (OB_FAIL(ret)) {
-      // do nothing
-    } else if (OB_FAIL(buffer_infos.reserve(size))) {
       LOG_WARN("fail to reserve memory for buffer_infos", K(ret), K(size));
+    } else if (OB_FAIL(fill_buffer_infos(
+        ObTabletPoolType::TP_NORMAL, normal_tablet_header_.get_header(), buffer_infos))) {
+      LOG_WARN("fail to fill normal buffer infos", K(ret), KP(normal_tablet_header_.get_first()));
+    } else if (OB_FAIL(fill_buffer_infos(
+        ObTabletPoolType::TP_LARGE, large_tablet_header_.get_header(), buffer_infos))) {
+      LOG_WARN("fail to fill large buffer infos", K(ret), KP(large_tablet_header_.get_header()));
+    }
+  }
+  return ret;
+}
+
+int ObTenantMetaMemMgr::fill_buffer_infos(
+    const ObTabletPoolType pool_type,
+    ObMetaObjBufferNode *tablet_buffer_node,
+    ObIArray<ObTabletBufferInfo> &buffer_infos)
+{
+  int ret = OB_SUCCESS;
+  ObMetaObjBufferNode *cur_node = tablet_buffer_node->get_next();
+  while (OB_SUCC(ret) && cur_node != tablet_buffer_node) {
+    ObTabletBufferInfo buffer_info;
+    if (OB_FAIL(buffer_info.fill_info(pool_type, cur_node))) {
+      LOG_WARN("fail to fill tablet buffer info", K(ret), K(pool_type), KP(tablet_buffer_node), KP(cur_node));
+    } else if (OB_FAIL(buffer_infos.push_back(buffer_info))) {
+      LOG_WARN("fail to push back buffer info", K(ret), K(buffer_info));
     } else {
-      while (OB_SUCC(ret) && header != tablet_buffer_node) {
+      cur_node = cur_node->get_next();
-        ObTabletBufferInfo buffer_info;
-        if (OB_FAIL(buffer_info.fill_info(pool_type, tablet_buffer_node))) {
-          LOG_WARN("fail to fill tablet buffer info", K(ret));
-        } else if (OB_FAIL(buffer_infos.push_back(buffer_info))) {
-          LOG_WARN("fail to push back buffer info", K(ret), K(buffer_info));
-        } else {
-          tablet_buffer_node = tablet_buffer_node->get_next();
-        }
-      }
     }
   }
   return ret;

src/storage/meta_mem/ob_tenant_meta_mem_mgr.h

@@ -245,7 +245,7 @@ public:
       common::ObArenaAllocator &allocator,
       ObTabletHandle &handle,
       const bool force_alloc_new = false);
-  int get_tablet_buffer_infos(const ObTabletPoolType &pool_type, ObIArray<ObTabletBufferInfo> &buffer_infos);
+  int get_tablet_buffer_infos(ObIArray<ObTabletBufferInfo> &buffer_infos);
   int get_tablet_addr(const ObTabletMapKey &key, ObMetaDiskAddr &addr);
   int has_tablet(const ObTabletMapKey &key, bool &is_exist);
   int del_tablet(const ObTabletMapKey &key);
@@ -275,6 +275,10 @@ public:
 
   TO_STRING_KV(K_(tenant_id), K_(is_inited), "tablet count", tablet_map_.count());
 private:
+  int fill_buffer_infos(
+      const ObTabletPoolType pool_type,
+      ObMetaObjBufferNode *tablet_buffer_node,
+      ObIArray<ObTabletBufferInfo> &buffer_infos);
   int64_t cal_adaptive_bucket_num();
   int push_tablet_into_gc_queue(ObTablet *tablet);
   void push_tablet_list_into_gc_queue(ObTablet *tablet);