fix copy medium info filter logic and enhance continuity check

src/storage/tablet/ob_tablet_dumped_medium_info.cpp

@@ -174,18 +174,14 @@ bool ObTabletDumpedMediumInfo::is_valid() const
   bool valid = true;
   int ret = OB_SUCCESS;
 
-  if (medium_info_list_.empty()) {
+  for (int64_t i = 0; OB_SUCC(ret) && valid && i < medium_info_list_.count(); ++i) {
-    valid = false;
+    const compaction::ObMediumCompactionInfo *medium_info = medium_info_list_.at(i);
-  } else {
+    if (OB_ISNULL(medium_info)) {
-    for (int64_t i = 0; OB_SUCC(ret) && valid && i < medium_info_list_.count(); ++i) {
+      ret = OB_ERR_UNEXPECTED;
-      const compaction::ObMediumCompactionInfo *medium_info = medium_info_list_.at(i);
+      valid = false;
-      if (OB_ISNULL(medium_info)) {
+      LOG_ERROR("medium info is null", K(ret), KP(medium_info), K(i));
-        ret = OB_ERR_UNEXPECTED;
+    } else if (!medium_info->is_valid()) {
-        valid = false;
+      valid = false;
-        LOG_ERROR("mds dump kv is null", K(ret), KP(medium_info), K(i));
-      } else if (!medium_info->is_valid()) {
-        valid = false;
-      }
     }
   }
 
@@ -257,6 +253,24 @@ int64_t ObTabletDumpedMediumInfo::get_max_medium_snapshot() const
   return medium_info_list_.empty() ? 0 : medium_info_list_.at(medium_info_list_.count() - 1)->medium_snapshot_;
 }
 
+int ObTabletDumpedMediumInfo::is_contain(const compaction::ObMediumCompactionInfo &info, bool &contain) const
+{
+  int ret = OB_SUCCESS;
+  contain = false;
+
+  for (int64_t i = 0; OB_SUCC(ret) && !contain && i < medium_info_list_.count(); ++i) {
+    const compaction::ObMediumCompactionInfo *medium_info = medium_info_list_.at(i);
+    if (OB_ISNULL(medium_info)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("medium info should no be null", K(ret), K(i), KP(medium_info));
+    } else if (info.medium_snapshot_ == medium_info->medium_snapshot_) {
+      contain = true;
+    }
+  }
+
+  return ret;
+}
+
 int ObTabletDumpedMediumInfo::serialize(char *buf, const int64_t buf_len, int64_t &pos) const
 {
   int ret = OB_SUCCESS;

src/storage/tablet/ob_tablet_dumped_medium_info.h

@@ -35,6 +35,8 @@ struct MdsDumpNode;
 
 class ObTabletDumpedMediumInfo
 {
+public:
+  typedef common::ObSEArray<compaction::ObMediumCompactionInfo*, 1>::iterator iterator;
 public:
   ObTabletDumpedMediumInfo();
   ~ObTabletDumpedMediumInfo();
@@ -58,6 +60,8 @@ public:
   int64_t get_min_medium_snapshot() const;
   int64_t get_max_medium_snapshot() const;
 
+  int is_contain(const compaction::ObMediumCompactionInfo &info, bool &contain) const;
+
   int serialize(char *buf, const int64_t buf_len, int64_t &pos) const;
   int deserialize(common::ObIAllocator &allocator, const char *buf, const int64_t data_len, int64_t &pos);
   int64_t get_serialize_size() const;

src/storage/tablet/ob_tablet_mds_data.cpp

@@ -10,6 +10,7 @@
  * See the Mulan PubL v2 for more details.
  */
 
+#include <algorithm>
 #include "storage/tablet/ob_tablet_mds_data.h"
 #include "lib/ob_errno.h"
 #include "lib/oblog/ob_log_module.h"
@@ -540,6 +541,8 @@ int ObTabletMdsData::init_medium_info_list(
     extra_medium_info_.reset();
   } else if (OB_FAIL(copy_medium_info_list(finish_medium_scn, *old_medium_info_list, *cur_medium_info_list))) {
     LOG_WARN("failed to copy medium info list", K(ret), K(finish_medium_scn), KPC(old_medium_info_list));
+  } else if (OB_FAIL(check_medium_info_continuity(*cur_medium_info_list))) {
+    LOG_WARN("failed to check medium info cotinuity", K(ret));
   } else if (is_major_merge_type(merge_type)) {
     extra_medium_info_.last_compaction_type_ = is_major_merge(merge_type) ? compaction::ObMediumCompactionInfo::MAJOR_COMPACTION : compaction::ObMediumCompactionInfo::MEDIUM_COMPACTION;
     extra_medium_info_.last_medium_scn_ = finish_medium_scn;
@@ -573,10 +576,14 @@ int ObTabletMdsData::init_medium_info_list(
     LOG_WARN("medium info list is null", K(ret), KP(cur_medium_info_list));
   } else if (OB_FAIL(cur_medium_info_list->init(allocator))) {
     LOG_WARN("failed to init medium info list", K(ret));
-  } else if (nullptr != old_medium_info_list && OB_FAIL(copy_medium_info_list(finish_medium_scn, *old_medium_info_list, *cur_medium_info_list))) {
+  } else if (nullptr != old_medium_info_list
+      && OB_FAIL(copy_medium_info_list(finish_medium_scn, *old_medium_info_list, full_memory_medium_info_list.medium_info_list_, *cur_medium_info_list))) {
     LOG_WARN("failed to copy medium info", K(ret));
-  } else if (OB_FAIL(copy_medium_info_list(finish_medium_scn, full_memory_medium_info_list.medium_info_list_, *cur_medium_info_list))) {
+  } else if (nullptr == old_medium_info_list
+      && OB_FAIL(copy_medium_info_list(finish_medium_scn, full_memory_medium_info_list.medium_info_list_, *cur_medium_info_list))) {
     LOG_WARN("failed to copy medium info", K(ret));
+  } else if (OB_FAIL(check_medium_info_continuity(*cur_medium_info_list))) {
+    LOG_WARN("failed to check medium info cotinuity", K(ret));
   } else {
     /*
      * finish_medium_scn = last_major->get_snapshot_version()
@@ -621,6 +628,8 @@ int ObTabletMdsData::init_with_update_medium_info(
     LOG_WARN("failed to init medium info list", K(ret));
   } else if (OB_FAIL(copy_medium_info_list(finish_medium_scn, *old_medium_info_list, *cur_medium_info_list))) {
     LOG_WARN("failed to copy medium info", K(ret));
+  } else if (OB_FAIL(check_medium_info_continuity(*cur_medium_info_list))) {
+    LOG_WARN("failed to check medium info cotinuity", K(ret));
   } else {
     extra_medium_info_.last_compaction_type_ = old_extra_medium_info.last_compaction_type_;
     extra_medium_info_.last_medium_scn_ = old_extra_medium_info.last_medium_scn_;
@@ -648,11 +657,133 @@ int ObTabletMdsData::copy_medium_info_list(
     if (OB_ISNULL(input_medium_info)) {
       ret = OB_ERR_UNEXPECTED;
       LOG_WARN("unexpected error, medium info is null", K(ret), K(i), KP(input_medium_info));
-    } else if (input_medium_info->medium_snapshot_ > finish_medium_scn) {
+    } else if (input_medium_info->medium_snapshot_ <= finish_medium_scn) {
-      if (input_medium_info->medium_snapshot_ <= medium_info_list.get_max_medium_snapshot()) {
+      // medium snapshot no bigger than finish medium scn(which is from last major sstable),
+      // no need to copy it
+    } else if (OB_FAIL(medium_info_list.append(*input_medium_info))) {
+      LOG_WARN("failed to append medium info", K(ret), K(i), KPC(input_medium_info));
+    }
+  }
+
+  return ret;
+}
+
+int ObTabletMdsData::copy_medium_info_list(
+    const int64_t finish_medium_scn,
+    const ObTabletDumpedMediumInfo &input_medium_info_list1,
+    const ObTabletDumpedMediumInfo &input_medium_info_list2,
+    ObTabletDumpedMediumInfo &medium_info_list)
+{
+  int ret = OB_SUCCESS;
+  common::ObSEArray<compaction::ObMediumCompactionInfo*, 1> array1;
+  common::ObSEArray<compaction::ObMediumCompactionInfo*, 1> array2;
+
+  if (OB_FAIL(array1.assign(input_medium_info_list1.medium_info_list_))) {
+    LOG_WARN("failed to assign", K(ret));
+  } else if (OB_FAIL(array2.assign(input_medium_info_list2.medium_info_list_))) {
+    LOG_WARN("failed to assign", K(ret));
+  } else {
+    // sort first
+    std::sort(array1.begin(), array1.end(), ObTabletDumpedMediumInfo::compare);
+    std::sort(array2.begin(), array2.end(), ObTabletDumpedMediumInfo::compare);
+
+    // merge
+    bool contain = false;
+    int64_t i = 0;
+    int64_t j = 0;
+    while (OB_SUCC(ret) && i < array1.count() && j < array2.count()) {
+      const compaction::ObMediumCompactionInfo *info1 = array1.at(i);
+      const compaction::ObMediumCompactionInfo *info2 = array2.at(j);
+      const compaction::ObMediumCompactionInfo *chosen_info = nullptr;
+
+      if (OB_ISNULL(info1) || OB_ISNULL(info2)) {
+        LOG_WARN("medium info is null", K(ret), K(i), K(j), KP(info1), KP(info2));
+      } else if (info1->medium_snapshot_ < info2->medium_snapshot_) {
+        chosen_info = info1;
+        ++i;
+      } else if (info1->medium_snapshot_ > info2->medium_snapshot_) {
+        chosen_info = info2;
+        ++j;
+      } else {
+        chosen_info = info2;
+        ++i;
+        ++j;
+      }
+
+      if (OB_FAIL(ret)) {
+      } else if (chosen_info->medium_snapshot_ <= finish_medium_scn) {
+        // medium snapshot no bigger than finish medium scn(which is from last major sstable),
+        // no need to copy it
+      } else if (OB_FAIL(medium_info_list.is_contain(*chosen_info, contain))) {
+        LOG_WARN("failed to check medium info existence", K(ret));
+      } else if (contain) {
         // do nothing
-      } else if (OB_FAIL(medium_info_list.append(*input_medium_info))) {
+      } else if (OB_FAIL(medium_info_list.append(*chosen_info))) {
-        LOG_WARN("failed to append medium info", K(ret), KPC(input_medium_info));
+        LOG_WARN("failed to append medium info", K(ret), K(i), K(j), KPC(chosen_info));
+      }
+    }
+
+    for (; OB_SUCC(ret) && i < array1.count(); ++i) {
+      const compaction::ObMediumCompactionInfo *info = array1.at(i);
+      if (info->medium_snapshot_ <= finish_medium_scn) {
+        // medium snapshot no bigger than finish medium scn(which is from last major sstable),
+        // no need to copy it
+      } else if (OB_FAIL(medium_info_list.is_contain(*info, contain))) {
+        LOG_WARN("failed to check medium info existence", K(ret));
+      } else if (contain) {
+        // do nothing
+      } else if (OB_FAIL(medium_info_list.append(*info))) {
+        LOG_WARN("failed to append medium info", K(ret), K(i), KPC(info));
+      }
+    }
+
+    for (; OB_SUCC(ret) && j < array2.count(); ++j) {
+      const compaction::ObMediumCompactionInfo *info = array2.at(j);
+      if (info->medium_snapshot_ <= finish_medium_scn) {
+        // medium snapshot no bigger than finish medium scn(which is from last major sstable),
+        // no need to copy it
+      } else if (OB_FAIL(medium_info_list.is_contain(*info, contain))) {
+        LOG_WARN("failed to check medium info existence", K(ret));
+      } else if (contain) {
+        // do nothing
+      } else if (OB_FAIL(medium_info_list.append(*info))) {
+        LOG_WARN("failed to append medium info", K(ret), K(j), KPC(info));
+      }
+    }
+  }
+
+  return ret;
+}
+
+int ObTabletMdsData::check_medium_info_continuity(
+    const ObTabletDumpedMediumInfo &medium_info_list)
+{
+  int ret = OB_SUCCESS;
+  const common::ObIArray<compaction::ObMediumCompactionInfo*> &array = medium_info_list.medium_info_list_;
+
+  if (array.empty()) {
+    // do nothing
+  } else {
+    const compaction::ObMediumCompactionInfo *first_info = array.at(0);
+    if (OB_ISNULL(first_info)) {
+      ret = OB_ERR_UNEXPECTED;
+      LOG_WARN("medium info ist null", K(ret), KP(first_info));
+    } else if (!first_info->from_cur_cluster()) {
+      // not from current cluster, maybe standby cluster,
+      // no need to check medium info continuity
+    } else {
+      int64_t prev_medium_snapshot = first_info->medium_snapshot_;
+      for (int64_t i = 1; OB_SUCC(ret) && i < array.count(); ++i) {
+        const compaction::ObMediumCompactionInfo *info = array.at(i);
+        if (OB_ISNULL(info)) {
+          ret = OB_ERR_UNEXPECTED;
+          LOG_WARN("medium info ist null", K(ret), K(i), KP(info));
+        } else if (OB_UNLIKELY(prev_medium_snapshot != info->last_medium_snapshot_)) {
+          ret = OB_ERR_UNEXPECTED;
+          LOG_WARN("medium info list is not continuous", K(ret), K(i), K(prev_medium_snapshot), KPC(info));
+        } else {
+          prev_medium_snapshot = info->medium_snapshot_;
+        }
       }
     }
   }
@@ -801,6 +932,8 @@ int ObTabletMdsData::fuse_mds_dump_node(
       LOG_WARN("failed to copy base medium info list", K(ret));
     } else if (OB_FAIL(copy_medium_info_list(finish_medium_scn, *mds_table_medium_info_list, *fused_medium_info_list))) {
       LOG_WARN("failed to copy mds table medium info list", K(ret));
+    } else if (OB_FAIL(check_medium_info_continuity(*fused_medium_info_list))) {
+      LOG_WARN("failed to check medium info cotinuity", K(ret));
     }
 
     ObTabletMdsData::free_medium_info_list(allocator, base_medium_info_list);

src/storage/tablet/ob_tablet_mds_data.h

@@ -210,6 +210,13 @@ private:
       const int64_t finish_medium_scn,
       const ObTabletDumpedMediumInfo &input_medium_info_list,
       ObTabletDumpedMediumInfo &medium_info_list);
+  static int copy_medium_info_list(
+      const int64_t finish_medium_scn,
+      const ObTabletDumpedMediumInfo &input_medium_info_list1,
+      const ObTabletDumpedMediumInfo &input_medium_info_list2,
+      ObTabletDumpedMediumInfo &medium_info_list);
+  static int check_medium_info_continuity(
+      const ObTabletDumpedMediumInfo &medium_info_list);
   template <typename T>
   static int update_user_data_from_complex_addr(
       const ObTabletComplexAddr<mds::MdsDumpKV> &complex_addr,

unittest/storage/CMakeLists.txt

@@ -67,6 +67,7 @@ storage_unittest(test_storage_logger_manager slog/test_storage_logger_manager.cp
 storage_unittest(test_storage_log_read_write slog/test_storage_log_read_write.cpp)
 storage_unittest(test_storage_log_replay slog/test_storage_log_replay.cpp)
 storage_unittest(test_linked_macro_block slog_ckpt/test_linked_macro_block.cpp)
+storage_unittest(test_tablet_dumped_medium_info test_tablet_dumped_medium_info.cpp)
 #storage_unittest(test_log_stream_backup backup/test_log_stream_backup.cpp)
 #storage_unittest(test_backup_ctx backup/test_backup_ctx.cpp)
 storage_unittest(test_backup_utils backup/test_backup_utils.cpp)

unittest/storage/test_table_scan_pure_index_table.cpp

@@ -1,109 +0,0 @@
-/**
- * Copyright (c) 2021 OceanBase
- * OceanBase CE is licensed under Mulan PubL v2.
- * You can use this software according to the terms and conditions of the Mulan PubL v2.
- * You may obtain a copy of Mulan PubL v2 at:
- *          http://license.coscl.org.cn/MulanPubL-2.0
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PubL v2 for more details.
- */
-
-#define USING_LOG_PREFIX STORAGE
-
-#include <gtest/gtest.h>
-
-#include "test_dml_common.h"
-#include "share/schema/ob_table_dml_param.h"
-
-namespace oceanbase
-{
-namespace storage
-{
-class TestTableScanPureIndexTable : public ::testing::Test
-{
-public:
-  TestTableScanPureIndexTable();
-  virtual ~TestTableScanPureIndexTable() = default;
-public:
-  static void SetUpTestCase();
-  static void TearDownTestCase();
-  void SetUp()
-  {
-    ASSERT_TRUE(MockTenantModuleEnv::get_instance().is_inited());
-  }
-public:
-  void insert_data_to_tablet(MockObAccessService *access_service);
-  void table_scan(
-      ObAccessService *access_service,
-      const share::schema::ObTableSchema &table_schema,
-      ObNewRowIterator *&result);
-protected:
-  uint64_t tenant_id_;
-  share::ObLSID ls_id_;
-  common::ObTabletID tablet_id_;
-};
-
-TestTableScanPureIndexTable::TestTableScanPureIndexTable()
-  : tenant_id_(OB_SYS_TENANT_ID),
-    ls_id_(TestDmlCommon::TEST_LS_ID),
-    tablet_id_(TestDmlCommon::TEST_TABLE_ID)
-{
-
-}
-
-void TestTableScanPureIndexTable::SetUpTestCase()
-{
-  ASSERT_EQ(OB_SUCCESS, MockTenantModuleEnv::get_instance().init());
-}
-
-void TestTableScanPureIndexTable::TearDownTestCase()
-{
-  MockTenantModuleEnv::get_instance().destroy();
-}
-
-void TestTableScanPureIndexTable::insert_data_to_tablet(MockObAccessService *access_service)
-{
-
-}
-
-TEST_F(TestTableScanPureIndexTable, table_scan_pure_index_table)
-{
-  int ret = OB_SUCCESS;
-
-  ret = TestDmlCommon::create_data_tablet(tenant_id_, ls_id_, tablet_id_);
-  ASSERT_EQ(OB_SUCCESS, ret);
-
-  // mock ls tablet service and access service
-  ObLSTabletService *tablet_service = nullptr;
-  ret = TestDmlCommon::mock_ls_tablet_service(ls_id_, tablet_service);
-  ASSERT_EQ(OB_SUCCESS, ret);
-  ASSERT_NE(nullptr, tablet_service);
-
-  MockObAccessService *access_service = nullptr;
-  ret = TestDmlCommon::mock_access_service(tablet_service, access_service);
-  ASSERT_EQ(OB_SUCCESS, ret);
-  ASSERT_NE(nullptr, access_service);
-
-  insert_data_to_tablet(access_service);
-
-  // table scan
-  ObNewRowIterator *iter = nullptr;
-  table_scan(access_service, table_schema, iter);
-
-  // clean env
-  TestDmlCommon::delete_mocked_access_service(access_service);
-  TestDmlCommon::delete_mocked_ls_tablet_service(tablet_service);
-}
-} // namespace storage
-} // namespace oceanbase
-
-int main(int argc, char **argv)
-{
-  system("rm -f test_table_scan_pure_index_table.log*");
-  OB_LOGGER.set_file_name("test_table_scan_pure_index_table.log", true);
-  OB_LOGGER.set_log_level(OB_LOG_LEVEL_INFO);
-  testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}

unittest/storage/test_tablet_dumped_medium_info.cpp

@@ -0,0 +1,309 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#include <gtest/gtest.h>
+
+#define private public
+#define protected public
+
+#include "lib/ob_errno.h"
+#include "lib/allocator/page_arena.h"
+#include "share/config/ob_server_config.h"
+#include "unittest/storage/init_basic_struct.h"
+#include "storage/compaction/ob_medium_compaction_info.h"
+#include "storage/tablet/ob_tablet_mds_data.h"
+#include "storage/tablet/ob_tablet_dumped_medium_info.h"
+
+using namespace oceanbase::common;
+using namespace oceanbase::share;
+using namespace oceanbase::unittest;
+
+#define USING_LOG_PREFIX STORAGE
+
+#define APPEND_MEDIUM_INFO(dumped_medium_info, allocator, medium_snapshot, last_medium_snapshot, from_cur_cluster, info) \
+    ret = create_medium_info(allocator, medium_snapshot, last_medium_snapshot, from_cur_cluster, info); \
+    ASSERT_EQ(OB_SUCCESS, ret); \
+    ret = dumped_medium_info.append(*info); \
+    ASSERT_EQ(OB_SUCCESS, ret);
+
+namespace oceanbase
+{
+namespace unittest
+{
+class TestTabletDumpedMediumInfo : public ::testing::Test
+{
+public:
+  TestTabletDumpedMediumInfo() = default;
+  virtual ~TestTabletDumpedMediumInfo() = default;
+public:
+  static int create_medium_info(
+      common::ObIAllocator &allocator,
+      const int64_t medium_snapshot,
+      const int64_t last_medium_snapshot,
+      const bool from_cur_cluster,
+      compaction::ObMediumCompactionInfo *&info);
+};
+
+int TestTabletDumpedMediumInfo::create_medium_info(
+    common::ObIAllocator &allocator,
+    const int64_t medium_snapshot,
+    const int64_t last_medium_snapshot,
+    const bool from_cur_cluster,
+    compaction::ObMediumCompactionInfo *&info)
+{
+  int ret = OB_SUCCESS;
+  constexpr int64_t size = sizeof(compaction::ObMediumCompactionInfo);
+  void *buffer = allocator.alloc(size);
+  if (OB_ISNULL(buffer)) {
+    ret = OB_ALLOCATE_MEMORY_FAILED;
+    LOG_WARN("failed to alloc memory", K(ret), K(size));
+  } else {
+    info = new (buffer) compaction::ObMediumCompactionInfo();
+
+    info->compaction_type_ = compaction::ObMediumCompactionInfo::ObCompactionType::MEDIUM_COMPACTION;
+    info->medium_snapshot_ = medium_snapshot;
+    info->last_medium_snapshot_ = last_medium_snapshot;
+    info->data_version_ = 100;
+    info->cluster_id_ = from_cur_cluster ? GCONF.cluster_id : 9527;
+
+    // storage schema
+    const uint64_t table_id = 1234567;
+    share::schema::ObTableSchema table_schema;
+    build_test_schema(table_schema, table_id);
+    ret = info->storage_schema_.init(allocator, table_schema, lib::Worker::CompatMode::MYSQL);
+  }
+
+  return ret;
+}
+
+TEST_F(TestTabletDumpedMediumInfo, overlap)
+{
+  int ret = OB_SUCCESS;
+  ObArenaAllocator allocator;
+  compaction::ObMediumCompactionInfo *info = nullptr;
+
+  ObTabletDumpedMediumInfo input_medium_info1;
+  ret = input_medium_info1.init(allocator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 5, 4, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 6, 5, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 7, 6, true, info);
+
+  ObTabletDumpedMediumInfo input_medium_info2;
+  ret = input_medium_info2.init(allocator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  APPEND_MEDIUM_INFO(input_medium_info2, allocator, 2, 1, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info2, allocator, 3, 2, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info2, allocator, 4, 3, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 5, 4, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 6, 5, true, info);
+
+  ObTabletDumpedMediumInfo result;
+  ret = result.init(allocator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  const int64_t finish_medium_scn = 3;
+  ret = ObTabletMdsData::copy_medium_info_list(finish_medium_scn, input_medium_info1, input_medium_info2, result);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_EQ(4, result.medium_info_list_.count());
+  ASSERT_EQ(4, result.medium_info_list_.at(0)->medium_snapshot_);
+  ASSERT_EQ(5, result.medium_info_list_.at(1)->medium_snapshot_);
+  ASSERT_EQ(6, result.medium_info_list_.at(2)->medium_snapshot_);
+  ASSERT_EQ(7, result.medium_info_list_.at(3)->medium_snapshot_);
+
+  ret = ObTabletMdsData::check_medium_info_continuity(result);
+  ASSERT_EQ(OB_SUCCESS, ret);
+}
+
+TEST_F(TestTabletDumpedMediumInfo, no_overlap)
+{
+  int ret = OB_SUCCESS;
+  ObArenaAllocator allocator;
+  compaction::ObMediumCompactionInfo *info = nullptr;
+
+  ObTabletDumpedMediumInfo input_medium_info1;
+  ret = input_medium_info1.init(allocator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 5, 4, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 6, 5, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 7, 6, true, info);
+
+  ObTabletDumpedMediumInfo input_medium_info2;
+  ret = input_medium_info2.init(allocator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  APPEND_MEDIUM_INFO(input_medium_info2, allocator, 2, 1, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info2, allocator, 3, 2, true, info);
+
+  {
+    ObTabletDumpedMediumInfo result;
+    ret = result.init(allocator);
+    ASSERT_EQ(OB_SUCCESS, ret);
+
+    const int64_t finish_medium_scn = 1;
+    ret = ObTabletMdsData::copy_medium_info_list(finish_medium_scn, input_medium_info1, input_medium_info2, result);
+    ASSERT_EQ(OB_SUCCESS, ret);
+    ASSERT_EQ(5, result.medium_info_list_.count());
+    ASSERT_EQ(2, result.medium_info_list_.at(0)->medium_snapshot_);
+    ASSERT_EQ(3, result.medium_info_list_.at(1)->medium_snapshot_);
+    ASSERT_EQ(5, result.medium_info_list_.at(2)->medium_snapshot_);
+    ASSERT_EQ(6, result.medium_info_list_.at(3)->medium_snapshot_);
+    ASSERT_EQ(7, result.medium_info_list_.at(4)->medium_snapshot_);
+
+    ret = ObTabletMdsData::check_medium_info_continuity(result);
+    ASSERT_EQ(OB_ERR_UNEXPECTED, ret);
+  }
+
+  APPEND_MEDIUM_INFO(input_medium_info2, allocator, 4, 3, true, info);
+  {
+    ObTabletDumpedMediumInfo result;
+    ret = result.init(allocator);
+    ASSERT_EQ(OB_SUCCESS, ret);
+
+    const int64_t finish_medium_scn = 1;
+    ret = ObTabletMdsData::copy_medium_info_list(finish_medium_scn, input_medium_info1, input_medium_info2, result);
+    ASSERT_EQ(OB_SUCCESS, ret);
+    ASSERT_EQ(6, result.medium_info_list_.count());
+    ASSERT_EQ(2, result.medium_info_list_.at(0)->medium_snapshot_);
+    ASSERT_EQ(3, result.medium_info_list_.at(1)->medium_snapshot_);
+    ASSERT_EQ(4, result.medium_info_list_.at(2)->medium_snapshot_);
+    ASSERT_EQ(5, result.medium_info_list_.at(3)->medium_snapshot_);
+    ASSERT_EQ(6, result.medium_info_list_.at(4)->medium_snapshot_);
+    ASSERT_EQ(7, result.medium_info_list_.at(5)->medium_snapshot_);
+
+    ret = ObTabletMdsData::check_medium_info_continuity(result);
+    ASSERT_EQ(OB_SUCCESS, ret);
+  }
+}
+
+TEST_F(TestTabletDumpedMediumInfo, overlap_and_filter)
+{
+  int ret = OB_SUCCESS;
+  ObArenaAllocator allocator;
+  compaction::ObMediumCompactionInfo *info = nullptr;
+
+  ObTabletDumpedMediumInfo input_medium_info1;
+  ret = input_medium_info1.init(allocator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 5, 4, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 6, 5, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 7, 6, true, info);
+
+  ObTabletDumpedMediumInfo input_medium_info2;
+  ret = input_medium_info2.init(allocator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  APPEND_MEDIUM_INFO(input_medium_info2, allocator, 2, 1, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info2, allocator, 3, 2, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info2, allocator, 4, 3, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 5, 4, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 6, 5, true, info);
+
+  ObTabletDumpedMediumInfo result;
+  ret = result.init(allocator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  const int64_t finish_medium_scn = 6;
+  ret = ObTabletMdsData::copy_medium_info_list(finish_medium_scn, input_medium_info1, input_medium_info2, result);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_EQ(1, result.medium_info_list_.count());
+  ASSERT_EQ(7, result.medium_info_list_.at(0)->medium_snapshot_);
+
+  ret = ObTabletMdsData::check_medium_info_continuity(result);
+  ASSERT_EQ(OB_SUCCESS, ret);
+}
+
+TEST_F(TestTabletDumpedMediumInfo, no_overlap_and_filter)
+{
+  int ret = OB_SUCCESS;
+  ObArenaAllocator allocator;
+  compaction::ObMediumCompactionInfo *info = nullptr;
+
+  ObTabletDumpedMediumInfo input_medium_info1;
+  ret = input_medium_info1.init(allocator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 5, 4, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 6, 5, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 7, 6, true, info);
+
+  ObTabletDumpedMediumInfo input_medium_info2;
+  ret = input_medium_info2.init(allocator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  APPEND_MEDIUM_INFO(input_medium_info2, allocator, 2, 1, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info2, allocator, 3, 2, true, info);
+  APPEND_MEDIUM_INFO(input_medium_info2, allocator, 4, 3, true, info);
+
+  ObTabletDumpedMediumInfo result;
+  ret = result.init(allocator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  const int64_t finish_medium_scn = 7;
+  ret = ObTabletMdsData::copy_medium_info_list(finish_medium_scn, input_medium_info1, input_medium_info2, result);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_EQ(0, result.medium_info_list_.count());
+
+  ret = ObTabletMdsData::check_medium_info_continuity(result);
+  ASSERT_EQ(OB_SUCCESS, ret);
+}
+
+TEST_F(TestTabletDumpedMediumInfo, standby_cluster)
+{
+  int ret = OB_SUCCESS;
+  ObArenaAllocator allocator;
+  compaction::ObMediumCompactionInfo *info = nullptr;
+
+  ObTabletDumpedMediumInfo input_medium_info1;
+  ret = input_medium_info1.init(allocator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 7, 5, false, info);
+  APPEND_MEDIUM_INFO(input_medium_info1, allocator, 9, 8, false, info);
+
+  ObTabletDumpedMediumInfo input_medium_info2;
+  ret = input_medium_info2.init(allocator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  APPEND_MEDIUM_INFO(input_medium_info2, allocator, 2, 1, false, info);
+  APPEND_MEDIUM_INFO(input_medium_info2, allocator, 4, 2, false, info);
+
+  ObTabletDumpedMediumInfo result;
+  ret = result.init(allocator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  const int64_t finish_medium_scn = 3;
+  ret = ObTabletMdsData::copy_medium_info_list(finish_medium_scn, input_medium_info1, input_medium_info2, result);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_EQ(3, result.medium_info_list_.count());
+  ASSERT_EQ(4, result.medium_info_list_.at(0)->medium_snapshot_);
+  ASSERT_EQ(7, result.medium_info_list_.at(1)->medium_snapshot_);
+  ASSERT_EQ(9, result.medium_info_list_.at(2)->medium_snapshot_);
+
+  ret = ObTabletMdsData::check_medium_info_continuity(result);
+  ASSERT_EQ(OB_SUCCESS, ret);
+}
+} // namespace unittest
+} // namespace oceanbase
+
+int main(int argc, char **argv)
+{
+  system("rm -rf test_tablet_dumped_medium_info.log*");
+  OB_LOGGER.set_file_name("test_tablet_dumped_medium_info.log", true);
+  OB_LOGGER.set_log_level("INFO");
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}