allow read snapshot less than transfer in commit version if start transfer in tx committed

2023-07-17 09:18:10 +00:00
parent 0a3d3976b9
commit b6083d27be
6 changed files with 340 additions and 133 deletions
--- a/mittest/mtlenv/storage/test_tablet_status_cache.cpp
+++ b/mittest/mtlenv/storage/test_tablet_status_cache.cpp
@ -51,6 +51,7 @@ public:
  int create_tablet(
      const common::ObTabletID &tablet_id,
      ObTabletHandle &tablet_handle,
+      const ObTabletStatus::Status &tablet_status = ObTabletStatus::NORMAL,
      const share::SCN &create_commit_scn = share::SCN::min_scn());
 public:
  static constexpr uint64_t TENANT_ID = 1001;
@ -116,6 +117,7 @@ int TestTabletStatusCache::remove_ls(const share::ObLSID &ls_id)
 int TestTabletStatusCache::create_tablet(
    const common::ObTabletID &tablet_id,
    ObTabletHandle &tablet_handle,
+    const ObTabletStatus::Status &tablet_status,
    const share::SCN &create_commit_scn)
 {
  int ret = OB_SUCCESS;
@ -133,10 +135,8 @@ int TestTabletStatusCache::create_tablet(
  } else if (OB_FAIL(build_test_schema(table_schema, table_id))) {
    LOG_WARN("failed to build table schema");
  } else if (OB_FAIL(TestTabletHelper::create_tablet(ls_handle, tablet_id, table_schema, allocator_,
-      ObTabletStatus::Status::NORMAL, create_commit_scn))) {
-    LOG_WARN("failed to create tablet", K(ret), K(ls->get_ls_id()), K(tablet_id), K(create_commit_scn));
-  } else if (OB_FAIL(ls->get_tablet(tablet_id, tablet_handle))) {
-    LOG_WARN("failed to get tablet", K(ret));
+      tablet_status, create_commit_scn, tablet_handle))) {
+    LOG_WARN("failed to create tablet", K(ret), K(LS_ID), K(tablet_id), K(create_commit_scn));
  } else if (OB_FAIL(tablet_handle.get_obj()->inner_get_mds_table(mds_table, true/*not_exist_create*/))) {
    LOG_WARN("failed to get mds table", K(ret));
  }
@ -154,12 +154,24 @@ TEST_F(TestTabletStatusCache, weak_read)
  // create commit scn: 50
  share::SCN min_scn;
  min_scn.set_min();
-  ret = create_tablet(tablet_id, tablet_handle, share::SCN::plus(min_scn, 50));
+  ret = create_tablet(tablet_id, tablet_handle, ObTabletStatus::NORMAL, share::SCN::plus(min_scn, 50));
  ASSERT_EQ(OB_SUCCESS, ret);

  ObTablet *tablet = tablet_handle.get_obj();
  ASSERT_NE(nullptr, tablet);

+  ObTabletCreateDeleteMdsUserData user_data;
+  user_data.tablet_status_ = ObTabletStatus::NORMAL;
+  user_data.data_type_ = ObTabletMdsUserDataType::CREATE_TABLET;
+  user_data.create_commit_scn_ = share::SCN::plus(min_scn, 50);
+  user_data.create_commit_version_ = 50;
+
+  mds::MdsCtx ctx(mds::MdsWriter(transaction::ObTransID(111)));
+  ret = tablet->set(user_data, ctx);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  share::SCN commit_scn = share::SCN::plus(min_scn, 50);
+  ctx.single_log_commit(commit_scn, commit_scn);
+
  // disable cache
  {
    SpinWLockGuard guard(tablet->mds_cache_lock_);
@ -169,19 +181,19 @@ TEST_F(TestTabletStatusCache, weak_read)
  const ObTabletMapKey key(LS_ID, tablet_id);
  tablet_handle.reset();
  // mode is READ_READABLE_COMMITED, snapshot version is smaller than create commit version, return OB_SNAPSHOT_DISCARDED
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_READABLE_COMMITED, 20/*snapshot*/);
  ASSERT_EQ(OB_SNAPSHOT_DISCARDED, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // mode is READ_ALL_COMMITED, but snapshot is not max scn, not supported
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_ALL_COMMITED, 20/*snapshot*/);
  ASSERT_EQ(OB_NOT_SUPPORTED, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // mode is READ_READABLE_COMMITED, snapshot version is bigger than create commit version, return OB_SUCCESS
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_READABLE_COMMITED, 60/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
  ASSERT_TRUE(tablet->tablet_status_cache_.is_valid());
@ -226,27 +238,27 @@ TEST_F(TestTabletStatusCache, get_transfer_out_tablet)
  const ObTabletMapKey key(LS_ID, tablet_id);
  tablet_handle.reset();
  // mode is READ_READABLE_COMMITED, can not get tablet
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_READABLE_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  //ASSERT_EQ(OB_SCHEMA_EAGAIN, ret);
  ASSERT_EQ(OB_TABLET_NOT_EXIST, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // mode is READ_ALL_COMMITED, allow to get TRANSFER_OUT status tablet
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  tablet_handle.reset();
  // read snapshot: 80. not max scn, return OB_NOT_SUPPORTED
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_ALL_COMMITED, 80/*snapshot*/);
  ASSERT_EQ(OB_NOT_SUPPORTED, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // read snapshot: 80. less than transfer scn
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());
@ -268,32 +280,32 @@ TEST_F(TestTabletStatusCache, get_transfer_out_tablet)

  tablet_handle.reset();
  // mode is READ_READABLE_COMMITED, read snapshot is max scn, greater than transfer scn 100, not allow to get tablet
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_READABLE_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_TABLET_NOT_EXIST, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // mode is READ_ALL_COMMITED, allow to get tablet
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  tablet_handle.reset();
  // mode is READ_READABLE_COMMITED, read snapshot 80 less than transfer scn 100, allow to get tablet
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_READABLE_COMMITED, 80/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // mode is READ_ALL_COMMITED, snapshot is not max scn, return OB_NOT_SUPPORTED
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_ALL_COMMITED, 80/*snapshot*/);
  ASSERT_EQ(OB_NOT_SUPPORTED, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // mode is READ_ALL_COMMITED, allow to get tablet
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());
@ -319,13 +331,13 @@ TEST_F(TestTabletStatusCache, get_transfer_out_tablet)
  }

  // mode is READ_READABLE_COMMITED, snpashot status is transfer out, not allow to get
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_READABLE_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_TABLET_NOT_EXIST, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // mode is READ_ALL_COMMITED, allow to get tablet whose snapshot status is transfer out
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());
@ -335,13 +347,13 @@ TEST_F(TestTabletStatusCache, get_transfer_out_tablet)
  ctx2.single_log_commit(commit_scn, commit_scn);

  // mode is READ_READABLE_COMMITED, snapshot status is transfer out deleted, not allow to get
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_READABLE_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_TABLET_NOT_EXIST, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // mode is READ_ALL_COMMITED, snapshot status is transfer out deleted, not allow to get
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());
@ -365,7 +377,7 @@ TEST_F(TestTabletStatusCache, get_transfer_out_tablet)
    SpinWLockGuard guard(tablet->mds_cache_lock_);
    tablet->tablet_status_cache_.reset();
  }
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_READABLE_COMMITED, 100/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());
@ -379,7 +391,7 @@ TEST_F(TestTabletStatusCache, get_transfer_out_tablet)
  ret = ls->get_tablet_svr()->update_tablet_to_empty_shell(tablet_id);
  ASSERT_EQ(OB_SUCCESS, ret);

-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_READABLE_COMMITED, 100/*snapshot*/);
  ASSERT_EQ(OB_TABLET_NOT_EXIST, ret);
 }
@ -433,7 +445,7 @@ TEST_F(TestTabletStatusCache, get_transfer_deleted)

  const ObTabletMapKey key(LS_ID, tablet_id);
  tablet_handle.reset();
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_READABLE_COMMITED, 100/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());
@ -441,7 +453,7 @@ TEST_F(TestTabletStatusCache, get_transfer_deleted)
  ret = ls->get_tablet_svr()->update_tablet_to_empty_shell(tablet_id);
  ASSERT_EQ(OB_SUCCESS, ret);

-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_READABLE_COMMITED, 100/*snapshot*/);
  ASSERT_EQ(OB_TABLET_NOT_EXIST, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());
@ -467,7 +479,7 @@ TEST_F(TestTabletStatusCache, get_transfer_out_deleted)

  const ObTabletMapKey key(LS_ID, tablet_id);
  tablet_handle.reset();
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_READABLE_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
  ASSERT_TRUE(tablet->tablet_status_cache_.is_valid());
@ -486,13 +498,12 @@ TEST_F(TestTabletStatusCache, get_transfer_out_deleted)
  user_data.data_type_ = ObTabletMdsUserDataType::FINISH_TRANSFER_OUT;
  user_data.create_commit_scn_ = share::SCN::plus(min_scn, 50);
  user_data.create_commit_version_ = 50;
-  user_data.delete_commit_scn_ = share::SCN::plus(min_scn, 200);
-  user_data.delete_commit_version_ = 200;
+  user_data.transfer_out_commit_version_ = 200;

  mds::MdsCtx ctx(mds::MdsWriter(transaction::ObTransID(789)));
  ret = tablet->set(user_data, ctx);
  ASSERT_EQ(OB_SUCCESS, ret);
-  share::SCN commit_scn = share::SCN::plus(min_scn, 120);
+  share::SCN commit_scn = share::SCN::plus(min_scn, 200);
  ctx.single_log_commit(commit_scn, commit_scn);

  // disable cache
@ -502,17 +513,17 @@ TEST_F(TestTabletStatusCache, get_transfer_out_deleted)
  }

  // mock weak read
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_READABLE_COMMITED, 210/*snapshot*/);
  ASSERT_EQ(OB_TABLET_NOT_EXIST, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
-      ObMDSGetTabletMode::READ_READABLE_COMMITED, 100/*snapshot*/);
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
+      ObMDSGetTabletMode::READ_READABLE_COMMITED, 90/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_READABLE_COMMITED, INT64_MAX/*snapshot*/);
  ASSERT_EQ(OB_TABLET_NOT_EXIST, ret);
  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());
@ -545,19 +556,19 @@ TEST_F(TestTabletStatusCache, get_empty_result_tablet)
  ASSERT_EQ(OB_SUCCESS, ret);

  // test READ_WITHOUT_CHECK
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_WITHOUT_CHECK, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
  ASSERT_FALSE(tablet_handle.get_obj()->tablet_status_cache_.is_valid());

  // test READ_READABLE_COMMITED
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_READABLE_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_TABLET_NOT_EXIST, ret);
  ASSERT_FALSE(tablet_handle.get_obj()->tablet_status_cache_.is_valid());

  // test READ_ALL_COMMITED
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
      ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_TABLET_NOT_EXIST, ret);
  ASSERT_FALSE(tablet_handle.get_obj()->tablet_status_cache_.is_valid());
@ -571,7 +582,7 @@ TEST_F(TestTabletStatusCache, get_read_all_committed_tablet)
  const common::ObTabletID tablet_id(ObTimeUtility::fast_current_time() % 10000000000000);
  const ObTabletMapKey key(LS_ID, tablet_id);
  ObTabletHandle tablet_handle;
-  ret = create_tablet(tablet_id, tablet_handle);
+  ret = create_tablet(tablet_id, tablet_handle, ObTabletStatus::MAX, share::SCN::invalid_scn());
  ASSERT_EQ(OB_SUCCESS, ret);

  ObTablet *tablet = tablet_handle.get_obj();
@ -588,77 +599,92 @@ TEST_F(TestTabletStatusCache, get_read_all_committed_tablet)
  min_scn.set_min();
  share::SCN commit_scn;

-  // creation commited
-  user_data.tablet_status_ = ObTabletStatus::NORMAL;
-  user_data.data_type_ = ObTabletMdsUserDataType::CREATE_TABLET;
-  user_data.create_commit_scn_ = share::SCN::plus(min_scn, 50);
-  user_data.create_commit_version_ = 50;
-  mds::MdsCtx ctx2(mds::MdsWriter(transaction::ObTransID(2023062802)));
-  ret = tablet->set(user_data, ctx2);
-  ASSERT_EQ(OB_SUCCESS, ret);
-  commit_scn = share::SCN::plus(min_scn, 200);
-  ctx2.single_log_commit(commit_scn, commit_scn);
-
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
-    ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
-  ASSERT_EQ(OB_SUCCESS, ret);
-
  // start transfer in not commited
  user_data.tablet_status_ = ObTabletStatus::TRANSFER_IN;
  user_data.data_type_ = ObTabletMdsUserDataType::START_TRANSFER_IN;
  user_data.create_commit_scn_ = share::SCN::plus(min_scn, 50);
  user_data.create_commit_version_ = 50;
+  user_data.transfer_scn_ = share::SCN::plus(min_scn, 90);
+
  mds::MdsCtx ctx3(mds::MdsWriter(transaction::ObTransID(2023062803)));
  ret = tablet->set(user_data, ctx3);
  ASSERT_EQ(OB_SUCCESS, ret);
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
    ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
-  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_EQ(OB_TABLET_NOT_EXIST, ret);
+  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());
+
+  // get tablet
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
+    ObMDSGetTabletMode::READ_READABLE_COMMITED, 100/*snapshot*/);
+  ASSERT_EQ(OB_TABLET_NOT_EXIST, ret);
+  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // start transfer in commited
  commit_scn = share::SCN::plus(min_scn, 300);
  ctx3.single_log_commit(commit_scn, commit_scn);
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
    ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());
+
+  // get tablet
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
+    ObMDSGetTabletMode::READ_READABLE_COMMITED, 100/*snapshot*/);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());
+
+  // get tablet
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
+    ObMDSGetTabletMode::READ_READABLE_COMMITED, 10/*snapshot*/);
+  ASSERT_EQ(OB_SNAPSHOT_DISCARDED, ret);
+  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // finish transfer in not commited
  user_data.tablet_status_ = ObTabletStatus::NORMAL;
  user_data.data_type_ = ObTabletMdsUserDataType::FINISH_TRANSFER_IN;
  user_data.create_commit_scn_ = share::SCN::plus(min_scn, 50);
  user_data.create_commit_version_ = 50;
+  user_data.transfer_scn_ = share::SCN::plus(min_scn, 90);
+
  mds::MdsCtx ctx4(mds::MdsWriter(transaction::ObTransID(2023062804)));
  ret = tablet->set(user_data, ctx4);
  ASSERT_EQ(OB_SUCCESS, ret);
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
    ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // finish transfer in commited
  commit_scn = share::SCN::plus(min_scn, 400);
  ctx4.single_log_commit(commit_scn, commit_scn);
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
    ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // start transfer out not commited
  user_data.tablet_status_ = ObTabletStatus::TRANSFER_OUT;
  user_data.data_type_ = ObTabletMdsUserDataType::START_TRANSFER_OUT;
  user_data.create_commit_scn_ = share::SCN::plus(min_scn, 50);
  user_data.create_commit_version_ = 50;
+  user_data.transfer_scn_ = share::SCN::plus(min_scn, 90);
+
  mds::MdsCtx ctx5(mds::MdsWriter(transaction::ObTransID(2023062805)));
  ret = tablet->set(user_data, ctx5);
  ASSERT_EQ(OB_SUCCESS, ret);
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
    ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // start transfer out commited
  commit_scn = share::SCN::plus(min_scn, 500);
  ctx5.single_log_commit(commit_scn, commit_scn);
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
    ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // finish transfer out not commited
  user_data.tablet_status_ = ObTabletStatus::TRANSFER_OUT_DELETED;
@ -668,16 +694,18 @@ TEST_F(TestTabletStatusCache, get_read_all_committed_tablet)
  mds::MdsCtx ctx6(mds::MdsWriter(transaction::ObTransID(2023062806)));
  ret = tablet->set(user_data, ctx6);
  ASSERT_EQ(OB_SUCCESS, ret);
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
    ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());

  // finish transfer out commited
  commit_scn = share::SCN::plus(min_scn, 600);
  ctx6.single_log_commit(commit_scn, commit_scn);
-  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1 * 1000 * 1000/*timeout_us*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
    ObMDSGetTabletMode::READ_ALL_COMMITED, ObTransVersion::MAX_TRANS_VERSION/*snapshot*/);
  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_TRUE(!tablet->tablet_status_cache_.is_valid());
 }

 // TODO(@bowen.gbw): refactor test cases to cover all scene
--- a/src/storage/compaction/ob_tenant_tablet_scheduler.cpp
+++ b/src/storage/compaction/ob_tenant_tablet_scheduler.cpp
@ -1312,7 +1312,7 @@ int ObTenantTabletScheduler::schedule_all_tablets_medium()
        int tmp_ret = update_report_scn_as_ls_leader(*ls);

 #ifndef ERRSIM
-        LOG_INFO("try to update report scn as ls leader", K(tmp_ret), "ls_id:", ls->get_ls_id()); // low printing frequency
+        LOG_INFO("try to update report scn as ls leader", K(tmp_ret), "ls_id", ls->get_ls_id()); // low printing frequency
 #endif
      }
    } // end while
--- a/src/storage/tablet/ob_tablet.cpp
+++ b/src/storage/tablet/ob_tablet.cpp
@ -4432,7 +4432,7 @@ int ObTablet::check_and_set_initial_state()
    if (OB_FAIL(set_initial_state(false/*initial_state*/))) {
      LOG_WARN("failed to set initial state", K(ret));
    } else {
-      FLOG_INFO("set initial state to false", K(ret), K(ls_id), K(tablet_id));
+      LOG_DEBUG("set initial state to false", K(ret), K(ls_id), K(tablet_id));
    }
  }

@ -5638,9 +5638,6 @@ int ObTablet::check_new_mds_with_cache(
        if (OB_TABLET_NOT_EXIST != ret) {
          LOG_WARN("failed to check status for new mds", KR(ret), K(ls_id), K(tablet_id), K(snapshot_version), K(timeout));
        }
-      } else {
-        LOG_INFO("refresh tablet status cache", K(ret), K(ls_id), K(tablet_id), K(tablet_status_cache_),
-            K(snapshot_version), KP(this));
      }
    }
  }
--- a/src/storage/tablet/ob_tablet_create_delete_helper.cpp
+++ b/src/storage/tablet/ob_tablet_create_delete_helper.cpp
@ -137,9 +137,7 @@ int ObTabletCreateDeleteHelper::check_status_for_new_mds(
  int ret = OB_SUCCESS;
  const ObLSID &ls_id = tablet.get_tablet_meta().ls_id_;
  const ObTabletID &tablet_id = tablet.get_tablet_meta().tablet_id_;
-  share::SCN snapshot;
  ObTabletCreateDeleteMdsUserData user_data;
-  ObTabletStatus tablet_status(ObTabletStatus::MAX);
  bool is_committed = false;

  auto func = [&user_data](const ObTabletCreateDeleteMdsUserData &data) -> int {
@ -150,73 +148,43 @@ int ObTabletCreateDeleteHelper::check_status_for_new_mds(
    return ret;
  };

-  // get latest, then check transfer scn
-  // if read snapshot > transfer scn:
-  // if tx is not committed, we will return OB_SCHEMA_EAGAIN and let upper layer retry
-  // if tx is committed, tablet is deleted for sure and we will return OB_TABLET_NOT_EXIST
-  if (OB_FAIL(tablet.get_latest<ObTabletCreateDeleteMdsUserData>(func, is_committed, 0/*read_seq*/))) {
+  if (OB_UNLIKELY(tablet.is_empty_shell())) {
+    ret = OB_TABLET_NOT_EXIST;
+    LOG_WARN("tablet is empty shell", K(ret), K(ls_id), K(tablet_id), K(user_data));
+  } else if (OB_FAIL(tablet.get_latest<ObTabletCreateDeleteMdsUserData>(func, is_committed, 0))) {
    if (OB_EMPTY_RESULT == ret) {
      ret = OB_TABLET_NOT_EXIST;
      LOG_WARN("tablet creation has not been committed, or has been roll backed", K(ret), K(ls_id), K(tablet_id));
    } else {
      LOG_WARN("failed to get snapshot", KR(ret), K(ls_id), K(tablet_id));
    }
-  } else if (FALSE_IT(tablet_status = user_data.tablet_status_)) {
-  } else if (OB_FAIL(snapshot.convert_for_tx(snapshot_version))) {
-    LOG_WARN("failed to convert snapshot", K(ret), K(snapshot_version));
-  } else if (ObTabletStatus::TRANSFER_OUT == tablet_status
-      && OB_FAIL(check_read_snapshot_by_transfer_scn(user_data.transfer_scn_, is_committed, snapshot))) {
-    LOG_WARN("failed to check read snapshot by transfer scn", K(ret), K(ls_id), K(tablet_id), K(user_data), K(is_committed), K(snapshot));
-  } else if (OB_FAIL(tablet.get_snapshot<ObTabletCreateDeleteMdsUserData>(
-      func,
-      snapshot,
-      0/*read_seq*/,
-      timeout_us))) {
-    if (OB_EMPTY_RESULT == ret) {
-      ret = OB_TABLET_NOT_EXIST;
-      LOG_WARN("tablet creation has not been committed, or has been roll backed", K(ret), K(ls_id), K(tablet_id));
-    } else if (OB_ERR_SHARED_LOCK_CONFLICT == ret) {
-      LOG_WARN("tablet transaction is in commit progress", K(ret), K(ls_id), K(tablet_id), K(snapshot), K(timeout_us));
  } else {
-      LOG_WARN("failed to get snapshot", KR(ret), K(ls_id), K(tablet_id), K(snapshot), K(timeout_us));
-    }
-  } else if (OB_FAIL(check_read_snapshot_by_commit_version(tablet,
-      user_data.create_commit_version_,
-      user_data.delete_commit_version_,
-      snapshot_version,
-      user_data.tablet_status_))) {
-    LOG_WARN("failed to check read snapshot by commit version", K(ret), K(ls_id), K(tablet_id), K(snapshot_version), K(user_data));
+    const ObTabletStatus::Status &status = user_data.tablet_status_.get_status();
+    switch (status) {
+      case ObTabletStatus::NORMAL:
+        ret = check_read_snapshot_for_normal(tablet, snapshot_version, timeout_us, user_data, is_committed);
+        break;
+      case ObTabletStatus::DELETED:
+        ret = check_read_snapshot_for_deleted(tablet, snapshot_version, user_data, is_committed);
+        break;
+      case ObTabletStatus::TRANSFER_IN:
+        ret = check_read_snapshot_for_transfer_in(tablet, snapshot_version, user_data, is_committed);
+        break;
+      case ObTabletStatus::TRANSFER_OUT:
+        ret = check_read_snapshot_for_transfer_out(tablet, snapshot_version, user_data, is_committed);
+        break;
+      case ObTabletStatus::TRANSFER_OUT_DELETED:
+        ret = check_read_snapshot_for_transfer_out_deleted(tablet, snapshot_version, user_data, is_committed);
+        break;
+      default:
+        ret = OB_ERR_UNEXPECTED;
+        LOG_WARN("unexpected tablet status", K(ret), K(ls_id), K(tablet_id), K(user_data));
    }

    if (OB_FAIL(ret)) {
-  } else if (ObTabletStatus::NORMAL == tablet_status
-      && user_data.is_valid()
-      && ObTabletStatus::NORMAL == user_data.tablet_status_) {
-    // we only set tablet status cache when current status NORMAL and create transaction is COMIITTED
+    } else if (ObTabletStatus::NORMAL == user_data.tablet_status_ && is_committed) {
      tablet_status_cache.set_value(user_data);
-  }
-
-  return ret;
-}
-
-int ObTabletCreateDeleteHelper::check_read_snapshot_by_transfer_scn(
-    const share::SCN &transfer_scn,
-    const bool is_committed,
-    const share::SCN &snapshot)
-{
-  int ret = OB_SUCCESS;
-
-  if (!is_committed) {
-    if (snapshot > transfer_scn) {
-      // TODO(@bowen.gbw): temp solution
-      ret = OB_TABLET_NOT_EXIST;
-      LOG_WARN("read snapshot is bigger than transfer scn, should retry", K(ret), K(snapshot), K(transfer_scn));
-    }
-  } else if (is_committed) {
-    if (snapshot > transfer_scn) {
-      ret = OB_TABLET_NOT_EXIST;
-      LOG_WARN("read snapshot is bigger than transfer scn after transfer out committed, should retry on target ls",
-          K(ret), K(snapshot), K(transfer_scn));
+      LOG_INFO("refresh tablet status cache", K(ret), K(ls_id), K(tablet_id), K(tablet_status_cache), K(snapshot_version));
    }
  }

@ -273,6 +241,166 @@ int ObTabletCreateDeleteHelper::check_read_snapshot_by_commit_version(
  return ret;
 }

+int ObTabletCreateDeleteHelper::check_read_snapshot_for_normal(
+    ObTablet &tablet,
+    const int64_t snapshot_version,
+    const int64_t timeout_us,
+    const ObTabletCreateDeleteMdsUserData &user_data,
+    const bool is_committed)
+{
+  int ret = OB_SUCCESS;
+  const share::ObLSID &ls_id = tablet.get_tablet_meta().ls_id_;
+  const common::ObTabletID &tablet_id = tablet.get_tablet_meta().tablet_id_;
+  const ObTabletStatus &tablet_status = user_data.tablet_status_;
+  share::SCN read_snapshot;
+
+  auto func = [](const ObTabletCreateDeleteMdsUserData &) -> int {
+    return OB_SUCCESS;
+  };
+
+  if (OB_UNLIKELY(ObTabletStatus::NORMAL != tablet_status)) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid args", K(ret), K(ls_id), K(tablet_id), K(user_data));
+  } else if (is_committed) {
+    if (snapshot_version < user_data.create_commit_version_) {
+      ret = OB_SNAPSHOT_DISCARDED;
+      LOG_WARN("read snapshot smaller than create commit version",
+          K(ret), K(ls_id), K(tablet_id), K(snapshot_version), K(user_data));
+    }
+  } else if (OB_FAIL(read_snapshot.convert_for_tx(snapshot_version))) {
+    LOG_WARN("failed to convert from int64_t to SCN", K(ret), K(snapshot_version));
+  } else if (OB_FAIL(tablet.get_snapshot<ObTabletCreateDeleteMdsUserData>(
+      func, read_snapshot, 0/*read_seq*/, timeout_us))) {
+    if (OB_EMPTY_RESULT == ret) {
+      ret = OB_TABLET_NOT_EXIST;
+      LOG_WARN("tablet creation has not been committed, or has been roll backed", K(ret), K(ls_id), K(tablet_id));
+    } else if (OB_ERR_SHARED_LOCK_CONFLICT == ret) {
+      LOG_WARN("tablet transaction is in commit progress", K(ret), K(ls_id), K(tablet_id), K(read_snapshot), K(timeout_us));
+    } else {
+      LOG_WARN("failed to get snapshot", KR(ret), K(ls_id), K(tablet_id), K(read_snapshot), K(timeout_us));
+    }
+  } else {
+    // status is normal, transaction finally committed, do nothing
+  }
+
+  return ret;
+}
+
+int ObTabletCreateDeleteHelper::check_read_snapshot_for_deleted(
+    ObTablet &tablet,
+    const int64_t snapshot_version,
+    const ObTabletCreateDeleteMdsUserData &user_data,
+    const bool is_committed)
+{
+  int ret = OB_SUCCESS;
+  const share::ObLSID &ls_id = tablet.get_tablet_meta().ls_id_;
+  const common::ObTabletID &tablet_id = tablet.get_tablet_meta().tablet_id_;
+  const ObTabletStatus &tablet_status = user_data.tablet_status_;
+
+  if (OB_UNLIKELY(ObTabletStatus::DELETED != tablet_status)) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid args", K(ret), K(ls_id), K(tablet_id), K(user_data));
+  } else if (snapshot_version < user_data.create_commit_version_) {
+    ret = OB_SNAPSHOT_DISCARDED;
+    LOG_WARN("read snapshot smaller than create commit version",
+        K(ret), K(ls_id), K(tablet_id), K(snapshot_version), K(user_data));
+  } else if (is_committed && snapshot_version >= user_data.delete_commit_version_) {
+    ret = OB_TABLET_NOT_EXIST;
+    LOG_WARN("tablet does not exist", K(ret), K(ls_id), K(tablet_id), K(snapshot_version), K(user_data));
+  }
+
+  return ret;
+}
+
+int ObTabletCreateDeleteHelper::check_read_snapshot_for_transfer_in(
+    ObTablet &tablet,
+    const int64_t snapshot_version,
+    const ObTabletCreateDeleteMdsUserData &user_data,
+    const bool is_committed)
+{
+  int ret = OB_SUCCESS;
+  const share::ObLSID &ls_id = tablet.get_tablet_meta().ls_id_;
+  const common::ObTabletID &tablet_id = tablet.get_tablet_meta().tablet_id_;
+  const ObTabletStatus &tablet_status = user_data.tablet_status_;
+
+  if (OB_UNLIKELY(ObTabletStatus::TRANSFER_IN != tablet_status)) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid args", K(ret), K(ls_id), K(tablet_id), K(user_data));
+  } else if (OB_UNLIKELY(!is_committed)) {
+    // if start transfer in transaction has not committed, we ensure that location cache will not choose
+    // the dst ls for read operations, so here it won't happen
+    ret = OB_TABLET_NOT_EXIST;
+    LOG_WARN("start transfer in transaction has not committed, should retry",
+        K(ret), K(ls_id), K(tablet_id), K(snapshot_version), K(tablet_status));
+  } else if (is_committed) {
+    // check create commit version
+    if (snapshot_version < user_data.create_commit_version_) {
+      ret = OB_SNAPSHOT_DISCARDED;
+      LOG_WARN("read snapshot smaller than create commit version",
+          K(ret), K(ls_id), K(tablet_id), K(snapshot_version), K(user_data));
+    }
+  }
+
+  return ret;
+}
+
+int ObTabletCreateDeleteHelper::check_read_snapshot_for_transfer_out(
+    ObTablet &tablet,
+    const int64_t snapshot_version,
+    const ObTabletCreateDeleteMdsUserData &user_data,
+    const bool is_committed)
+{
+  int ret = OB_SUCCESS;
+  const share::ObLSID &ls_id = tablet.get_tablet_meta().ls_id_;
+  const common::ObTabletID &tablet_id = tablet.get_tablet_meta().tablet_id_;
+  const ObTabletStatus &tablet_status = user_data.tablet_status_;
+  const share::SCN &transfer_scn = user_data.transfer_scn_;
+  share::SCN read_snapshot;
+
+  if (OB_UNLIKELY(ObTabletStatus::TRANSFER_OUT != tablet_status)) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid args", K(ret), K(ls_id), K(tablet_id), K(user_data));
+  } else if (OB_FAIL(read_snapshot.convert_for_tx(snapshot_version))) {
+    LOG_WARN("failed to convert from int64_t to SCN", K(ret), K(snapshot_version));
+  } else if (read_snapshot >= transfer_scn) {
+    // TODO(@bowen.gbw): TEMP SOLUTION,
+    // return OB_TABLET_NOT_EXIST if read snapshot is no smaller than transfer scn,
+    // no matter start transfer out transaction is committed or not.
+    ret = OB_TABLET_NOT_EXIST;
+    LOG_WARN("read snapshot is no smaller than transfer scn under transfer out status, should retry on dst ls",
+        K(ret), K(read_snapshot), K(transfer_scn), K(tablet_status));
+  }
+
+  return ret;
+}
+
+int ObTabletCreateDeleteHelper::check_read_snapshot_for_transfer_out_deleted(
+    ObTablet &tablet,
+    const int64_t snapshot_version,
+    const ObTabletCreateDeleteMdsUserData &user_data,
+    const bool is_committed)
+{
+  int ret = OB_SUCCESS;
+  const share::ObLSID &ls_id = tablet.get_tablet_meta().ls_id_;
+  const common::ObTabletID &tablet_id = tablet.get_tablet_meta().tablet_id_;
+  const ObTabletStatus &tablet_status = user_data.tablet_status_;
+  const share::SCN &transfer_scn = user_data.transfer_scn_;
+  share::SCN read_snapshot;
+
+  if (OB_UNLIKELY(ObTabletStatus::TRANSFER_OUT_DELETED != tablet_status)) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid args", K(ret), K(ls_id), K(tablet_id), K(user_data));
+  } else if (OB_FAIL(read_snapshot.convert_for_tx(snapshot_version))) {
+    LOG_WARN("failed to convert from int64_t to SCN", K(ret), K(snapshot_version));
+  } else if (read_snapshot >= transfer_scn) {
+    ret = OB_TABLET_NOT_EXIST;
+    LOG_WARN("read snapshot is no smaller than transfer scn after transfer out deleted status, should retry on dst ls",
+        K(ret), K(read_snapshot), K(transfer_scn), K(tablet_status));
+  }
+
+  return ret;
+}
+
 int ObTabletCreateDeleteHelper::create_tmp_tablet(
    const ObTabletMapKey &key,
    common::ObArenaAllocator &allocator,
--- a/src/storage/tablet/ob_tablet_create_delete_helper.h
+++ b/src/storage/tablet/ob_tablet_create_delete_helper.h
@ -72,16 +72,41 @@ public:
      const int64_t snapshot_version,
      const int64_t timeout_us,
      ObTabletStatusCache &tablet_status_cache);
-  static int check_read_snapshot_by_transfer_scn(
-      const share::SCN &transfer_scn,
-      const bool is_committed,
-      const  share::SCN &snapshot);
  static int check_read_snapshot_by_commit_version(
      ObTablet &tablet,
      const int64_t create_commit_version,
      const int64_t delete_commit_version,
      const int64_t snapshot_version,
      const ObTabletStatus &tablet_status);
+  static int check_read_snapshot_for_normal(
+      ObTablet &tablet,
+      const int64_t snapshot_version,
+      const int64_t timeout_us,
+      const ObTabletCreateDeleteMdsUserData &user_data,
+      const bool is_committed);
+  static int check_read_snapshot_for_deleted(
+      ObTablet &tablet,
+      const int64_t snapshot_version,
+      const ObTabletCreateDeleteMdsUserData &user_data,
+      const bool is_committed);
+  static int check_read_snapshot_for_transfer_in(
+      ObTablet &tablet,
+      const int64_t snapshot_version,
+      const ObTabletCreateDeleteMdsUserData &user_data,
+      const bool is_committed);
+  static int check_read_snapshot_for_transfer_out(
+      ObTablet &tablet,
+      const int64_t snapshot_version,
+      const ObTabletCreateDeleteMdsUserData &user_data,
+      const bool is_committed);
+  static int check_read_snapshot_for_transfer_out_deleted(
+      ObTablet &tablet,
+      const int64_t snapshot_version,
+      const ObTabletCreateDeleteMdsUserData &user_data,
+      const bool is_committed);
+  static int check_read_snapshot_by_commit_version(
+      const int64_t snapshot_version,
+      const ObTabletCreateDeleteMdsUserData &user_data);
  static int create_tmp_tablet(
      const ObTabletMapKey &key,
      common::ObArenaAllocator &allocator,
--- a/unittest/storage/test_tablet_helper.h
+++ b/unittest/storage/test_tablet_helper.h
@ -44,7 +44,15 @@ public:
      const common::ObTabletID &tablet_id,
      const share::schema::ObTableSchema &table_schema,
      common::ObArenaAllocator &allocator,
-      const ObTabletStatus::Status tablet_status = ObTabletStatus::Status::NORMAL,
+      const ObTabletStatus::Status tablet_status,
+      const share::SCN &create_commit_scn,
+      ObTabletHandle &handle);
+  static int create_tablet(
+      ObLSHandle &ls_handle,
+      const common::ObTabletID &tablet_id,
+      const share::schema::ObTableSchema &table_schema,
+      common::ObArenaAllocator &allocator,
+      const ObTabletStatus::Status tablet_status = ObTabletStatus::NORMAL,
      const share::SCN &create_commit_scn = share::SCN::min_scn());
  static int remove_tablet(
      const ObLSHandle &ls_handle,
@ -95,7 +103,8 @@ inline int TestTabletHelper::create_tablet(
    const share::schema::ObTableSchema &table_schema,
    common::ObArenaAllocator &allocator,
    const ObTabletStatus::Status tablet_status,
-    const share::SCN &create_commit_scn)
+    const share::SCN &create_commit_scn,
+    ObTabletHandle &handle)
 {
  int ret = OB_SUCCESS;
  ObTenantMetaMemMgr *t3m = MTL(ObTenantMetaMemMgr*);
@ -150,11 +159,31 @@ inline int TestTabletHelper::create_tablet(
      STORAGE_LOG(WARN, "failed to compare and swap tablet", K(ret), K(ls_id), K(tablet_id));
    } else if (OB_FAIL(ls_tablet_svr->tablet_id_set_.set(tablet_id))){
      STORAGE_LOG(WARN, "set tablet id failed", K(ret), K(tablet_id));
+    } else {
+      handle = tablet_handle;
    }
  }
  return ret;
 }

+inline int TestTabletHelper::create_tablet(
+    ObLSHandle &ls_handle,
+    const common::ObTabletID &tablet_id,
+    const share::schema::ObTableSchema &table_schema,
+    common::ObArenaAllocator &allocator,
+    const ObTabletStatus::Status tablet_status,
+    const share::SCN &create_commit_scn)
+{
+  int ret = OB_SUCCESS;
+  ObTabletHandle tablet_handle;
+
+  if (OB_FAIL(create_tablet(ls_handle, tablet_id, table_schema, allocator, tablet_status, create_commit_scn, tablet_handle))) {
+    STORAGE_LOG(WARN, "failed to create tablet", K(ret), K(tablet_id));
+  }
+
+  return ret;
+}
+
 inline int TestTabletHelper::remove_tablet(const ObLSHandle &ls_handle, const ObTabletID &tablet_id)
 {
  int ret = OB_SUCCESS;