From b6083d27be2854307f8668d642d1b06adf8098d3 Mon Sep 17 00:00:00 2001 From: hiddenbomb Date: Mon, 17 Jul 2023 09:18:10 +0000 Subject: [PATCH] allow read snapshot less than transfer in commit version if start transfer in tx committed --- .../storage/test_tablet_status_cache.cpp | 150 ++++++----- .../compaction/ob_tenant_tablet_scheduler.cpp | 2 +- src/storage/tablet/ob_tablet.cpp | 5 +- .../tablet/ob_tablet_create_delete_helper.cpp | 250 +++++++++++++----- .../tablet/ob_tablet_create_delete_helper.h | 33 ++- unittest/storage/test_tablet_helper.h | 33 ++- 6 files changed, 340 insertions(+), 133 deletions(-) diff --git a/mittest/mtlenv/storage/test_tablet_status_cache.cpp b/mittest/mtlenv/storage/test_tablet_status_cache.cpp index c65f49e5f6..d8129c76ef 100644 --- 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 diff --git a/src/storage/compaction/ob_tenant_tablet_scheduler.cpp b/src/storage/compaction/ob_tenant_tablet_scheduler.cpp index 6fcdbc5994..33e042891b 100755 --- 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 diff --git a/src/storage/tablet/ob_tablet.cpp b/src/storage/tablet/ob_tablet.cpp index cc2ae427c6..a461ed96f6 100755 --- 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)); } } } diff --git a/src/storage/tablet/ob_tablet_create_delete_helper.cpp b/src/storage/tablet/ob_tablet_create_delete_helper.cpp index 79f87e9083..6eaa8b1cfd 100755 --- 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(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(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( - 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 { + 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)); } - } 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)) { - } 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 - 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)); + if (OB_FAIL(ret)) { + } else if (ObTabletStatus::NORMAL == user_data.tablet_status_ && is_committed) { + tablet_status_cache.set_value(user_data); + 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( + 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, diff --git a/src/storage/tablet/ob_tablet_create_delete_helper.h b/src/storage/tablet/ob_tablet_create_delete_helper.h index 86339340b7..0182c311f2 100644 --- 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, diff --git a/unittest/storage/test_tablet_helper.h b/unittest/storage/test_tablet_helper.h index a4fb94109a..0e6e87dbab 100644 --- 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;