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

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))) {
+      tablet_status, create_commit_scn, tablet_handle))) {
-    LOG_WARN("failed to create tablet", K(ret), K(ls->get_ls_id()), K(tablet_id), K(create_commit_scn));
+    LOG_WARN("failed to create tablet", K(ret), K(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));
   } 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.transfer_out_commit_version_ = 200;
-  user_data.delete_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*/,
+  ret = ObTabletCreateDeleteHelper::check_and_get_tablet(key, tablet_handle, 1_s,
-      ObMDSGetTabletMode::READ_READABLE_COMMITED, 100/*snapshot*/);
+      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

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

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));
       }
     }
   }

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 (OB_UNLIKELY(tablet.is_empty_shell())) {
-  // if read snapshot > transfer scn:
+    ret = OB_TABLET_NOT_EXIST;
-  // if tx is not committed, we will return OB_SCHEMA_EAGAIN and let upper layer retry
+    LOG_WARN("tablet is empty shell", K(ret), K(ls_id), K(tablet_id), K(user_data));
-  // if tx is committed, tablet is deleted for sure and we will return OB_TABLET_NOT_EXIST
+  } else if (OB_FAIL(tablet.get_latest<ObTabletCreateDeleteMdsUserData>(func, is_committed, 0))) {
-  if (OB_FAIL(tablet.get_latest<ObTabletCreateDeleteMdsUserData>(func, is_committed, 0/*read_seq*/))) {
     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 {
-  } else if (OB_FAIL(snapshot.convert_for_tx(snapshot_version))) {
+    const ObTabletStatus::Status &status = user_data.tablet_status_.get_status();
-    LOG_WARN("failed to convert snapshot", K(ret), K(snapshot_version));
+    switch (status) {
-  } else if (ObTabletStatus::TRANSFER_OUT == tablet_status
+      case ObTabletStatus::NORMAL:
-      && OB_FAIL(check_read_snapshot_by_transfer_scn(user_data.transfer_scn_, is_committed, snapshot))) {
+        ret = check_read_snapshot_for_normal(tablet, snapshot_version, timeout_us, user_data, is_committed);
-    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));
+        break;
-  } else if (OB_FAIL(tablet.get_snapshot<ObTabletCreateDeleteMdsUserData>(
+      case ObTabletStatus::DELETED:
-      func,
+        ret = check_read_snapshot_for_deleted(tablet, snapshot_version, user_data, is_committed);
-      snapshot,
+        break;
-      0/*read_seq*/,
+      case ObTabletStatus::TRANSFER_IN:
-      timeout_us))) {
+        ret = check_read_snapshot_for_transfer_in(tablet, snapshot_version, user_data, is_committed);
-    if (OB_EMPTY_RESULT == ret) {
+        break;
-      ret = OB_TABLET_NOT_EXIST;
+      case ObTabletStatus::TRANSFER_OUT:
-      LOG_WARN("tablet creation has not been committed, or has been roll backed", K(ret), K(ls_id), K(tablet_id));
+        ret = check_read_snapshot_for_transfer_out(tablet, snapshot_version, user_data, is_committed);
-    } else if (OB_ERR_SHARED_LOCK_CONFLICT == ret) {
+        break;
-      LOG_WARN("tablet transaction is in commit progress", K(ret), K(ls_id), K(tablet_id), K(snapshot), K(timeout_us));
+      case ObTabletStatus::TRANSFER_OUT_DELETED:
-    } else {
+        ret = check_read_snapshot_for_transfer_out_deleted(tablet, snapshot_version, user_data, is_committed);
-      LOG_WARN("failed to get snapshot", KR(ret), K(ls_id), K(tablet_id), K(snapshot), K(timeout_us));
+        break;
+      default:
+        ret = OB_ERR_UNEXPECTED;
+        LOG_WARN("unexpected tablet status", K(ret), K(ls_id), K(tablet_id), K(user_data));
     }
-  } 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));
-  }
 
-  if (OB_FAIL(ret)) {
+    if (OB_FAIL(ret)) {
-  } else if (ObTabletStatus::NORMAL == tablet_status
+    } else if (ObTabletStatus::NORMAL == user_data.tablet_status_ && is_committed) {
-      && user_data.is_valid()
+      tablet_status_cache.set_value(user_data);
-      && ObTabletStatus::NORMAL == user_data.tablet_status_) {
+      LOG_INFO("refresh tablet status cache", K(ret), K(ls_id), K(tablet_id), K(tablet_status_cache), K(snapshot_version));
-    // we only set tablet status cache when current status NORMAL and create transaction is COMIITTED
-    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));
     }
   }
 
@@ -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,

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,

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;