hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Enable test_multi_version_sstable_merge test case

Browse Source
This commit is contained in:
ZenoWang
2023-05-22 10:47:10 +00:00
committed by ob-robot
parent c298ac1e41
commit e87e18bfca
2 changed files with 71 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

225
mittest/mtlenv/storage/test_multi_version_sstable_merge.cpp
View File

@ -13,6 +13,7 @@
#include <gtest/gtest.h>
#define private public
#define protected public
#define UNITTEST
#include "lib/container/ob_iarray.h"
#include "storage/memtable/ob_memtable_interface.h"
#include "storage/ob_partition_component_factory.h"
@ -42,6 +43,7 @@
#include "storage/tx_table/ob_tx_table.h"
#include "storage/tx_storage/ob_ls_service.h"
#include "storage/tx/ob_trans_ctx_mgr_v4.h"
#include "storage/tx/ob_tx_data_define.h"
#include "share/scn.h"
namespace oceanbase
@ -60,67 +62,38 @@ using namespace palf;
namespace storage
{
int ObTxDataTable::check_tx_data_with_cache_once_(const transaction::ObTransID tx_id, ObITxDataCheckFunctor &fn)
ObSEArray<ObTxData, 8> TX_DATA_ARR;
int ObTxTable::insert(ObTxData *&tx_data)
{
int ret = OB_SUCCESS;
ret = TX_DATA_ARR.push_back(*tx_data);
return ret;
}
ObTxDataGuard tx_data_guard;
bool find = false;
if (OB_FAIL(get_tx_data_from_cache_(tx_id, tx_data_guard, find))) {
if (OB_EAGAIN != ret) {
STORAGE_LOG(WARN, "get tx data from cache failed", KR(ret));
}
} else {
if (find) {
/**************** rewrite logic *******************/
ret = fn(*tx_data_guard.tx_data());
/**************** rewrite logic *******************/
} else {
int64_t memtable_head = -1;
int64_t memtable_tail = -1;
if (OB_FAIL(get_memtable_mgr_()->get_memtable_range(memtable_head, memtable_tail))) {
STORAGE_LOG(WARN, "get memtable range failed", KR(ret));
} else if (memtable_head != memtables_cache_.memtable_head_ || memtable_tail != memtables_cache_.memtable_tail_) {
ret = OB_EAGAIN;
} else {
ret = OB_TRANS_CTX_NOT_EXIST;
int ObTxTable::check_with_tx_data(ObReadTxDataArg &read_tx_data_arg, ObITxDataCheckFunctor &fn)
{
int ret = OB_SUCCESS;
for (int i = 0; i < TX_DATA_ARR.count(); i++)
{
if (read_tx_data_arg.tx_id_ == TX_DATA_ARR.at(i).tx_id_) {
ret = fn(TX_DATA_ARR[i]);
if (OB_FAIL(ret)) {
STORAGE_LOG(ERROR, "check with tx data failed", KR(ret), K(read_tx_data_arg), K(TX_DATA_ARR.at(i)));
}
break;
}
}
return ret;
}
int clear_tx_data(ObTxDataTable *tx_data_table)
int clear_tx_data()
{
int ret = OB_SUCCESS;
ObTxDataMemtableMgr *mgr = tx_data_table->memtable_mgr_;
ObTxDataMemtableWriteGuard write_guard;
ObTxDataMemtable *tx_data_memtable = nullptr;
if (OB_FAIL(mgr->get_all_memtables_for_write(write_guard))) {
STORAGE_LOG(WARN, "get all memtables for write fail.", KR(ret), KPC(mgr));
} else {
ObTransID tx_id;
ObTableHandleV2 (&memtable_handles)[MAX_TX_DATA_MEMTABLE_CNT] = write_guard.handles_;
for (int i = write_guard.size_ - 1; OB_SUCC(ret) && i >= 0; i--) {
tx_data_memtable = nullptr;
if (OB_FAIL(memtable_handles[i].get_tx_data_memtable(tx_data_memtable))) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(ERROR, "get tx data memtable from table handles fail.", KR(ret),
K(memtable_handles[i]));
} else if (OB_ISNULL(tx_data_memtable)) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(ERROR, "tx data memtable is nullptr.", KR(ret), K(memtable_handles[i]));
} else {
tx_data_memtable->TEST_reset_tx_data_map_();
}
}
}
return ret;
TX_DATA_ARR.reset();
return OB_SUCCESS;
};
class TestMultiVersionMerge : public ObMultiVersionSSTableTest
{
public:
@ -1069,20 +1042,13 @@ TEST_F(TestMultiVersionMerge, test_merge_with_multi_trans)
ASSERT_EQ(OB_SUCCESS, ls_svr->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD));
ObTxTable *tx_table = nullptr;
ObTxDataTable *tx_data_table = nullptr;
ObTxTableGuard tx_table_guard;
ls_handle.get_ls()->get_tx_table_guard(tx_table_guard);
ASSERT_NE(nullptr, tx_table = tx_table_guard.get_tx_table());
ASSERT_NE(nullptr, tx_data_table = tx_table->get_tx_data_table());
ObTxData *tx_data = nullptr;
transaction::ObTransID tx_id;
for (int64_t i = 1; i <= 4; i++) {
tx_id = i;
ObTxDataGuard tx_data_guard;
ASSERT_EQ(OB_SUCCESS, tx_data_table->alloc_tx_data(tx_data_guard));
tx_data = tx_data_guard.tx_data();
ObTxData *tx_data = new ObTxData();
transaction::ObTransID tx_id = i;
// fill in data
tx_data->tx_id_ = tx_id;
@ -1100,7 +1066,8 @@ TEST_F(TestMultiVersionMerge, test_merge_with_multi_trans)
tx_data->add_undo_action(tx_table, undo_action);
}
ASSERT_EQ(OB_SUCCESS, tx_data_table->insert(tx_data));
ASSERT_EQ(OB_SUCCESS, tx_table->insert(tx_data));
delete tx_data;
}
ObVersionRange trans_version_range;
@ -1143,7 +1110,7 @@ TEST_F(TestMultiVersionMerge, test_merge_with_multi_trans)
ObMockDirectReadIterator sstable_iter;
ASSERT_EQ(OB_SUCCESS, sstable_iter.init(scanner, allocator_, full_read_info_));
ASSERT_TRUE(res_iter.equals(sstable_iter, true));
ASSERT_EQ(OB_SUCCESS, clear_tx_data(tx_data_table));
ASSERT_EQ(OB_SUCCESS, clear_tx_data());
scanner->~ObStoreRowIterator();
handle1.reset();
handle2.reset();
@ -1238,20 +1205,13 @@ TEST_F(TestMultiVersionMerge, test_merge_with_multi_trans_can_compact)
ASSERT_EQ(OB_SUCCESS, ls_svr->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD));
ObTxTable *tx_table = nullptr;
ObTxDataTable *tx_data_table = nullptr;
ObTxTableGuard tx_table_guard;
ls_handle.get_ls()->get_tx_table_guard(tx_table_guard);
ASSERT_NE(nullptr, tx_table = tx_table_guard.get_tx_table());
ASSERT_NE(nullptr, tx_data_table = tx_table->get_tx_data_table());
ObTxData *tx_data = nullptr;
transaction::ObTransID tx_id;
for (int64_t i = 1; i <= 5; i++) {
tx_id = i;
ObTxDataGuard tx_data_guard;
ASSERT_EQ(OB_SUCCESS, tx_data_table->alloc_tx_data(tx_data_guard));
ASSERT_NE(nullptr, tx_data = tx_data_guard.tx_data());
ObTxData *tx_data = new ObTxData();
transaction::ObTransID tx_id = i;
// fill in data
tx_data->tx_id_ = tx_id;
@ -1269,7 +1229,8 @@ TEST_F(TestMultiVersionMerge, test_merge_with_multi_trans_can_compact)
tx_data->add_undo_action(tx_table, undo_action);
}
ASSERT_EQ(OB_SUCCESS, tx_data_table->insert(tx_data));
ASSERT_EQ(OB_SUCCESS, tx_table->insert(tx_data));
delete tx_data;
}
ObVersionRange trans_version_range;
@ -1310,7 +1271,7 @@ TEST_F(TestMultiVersionMerge, test_merge_with_multi_trans_can_compact)
ObMockDirectReadIterator sstable_iter;
ASSERT_EQ(OB_SUCCESS, sstable_iter.init(scanner, allocator_, full_read_info_));
ASSERT_TRUE(res_iter.equals(sstable_iter, true));
ASSERT_EQ(OB_SUCCESS, clear_tx_data(tx_data_table));
ASSERT_EQ(OB_SUCCESS, clear_tx_data());
scanner->~ObStoreRowIterator();
handle1.reset();
handle2.reset();
@ -1407,20 +1368,13 @@ TEST_F(TestMultiVersionMerge, test_merge_with_multi_trans_can_not_compact)
ASSERT_EQ(OB_SUCCESS, ls_svr->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD));
ObTxTable *tx_table = nullptr;
ObTxDataTable *tx_data_table = nullptr;
ObTxTableGuard tx_table_guard;
ls_handle.get_ls()->get_tx_table_guard(tx_table_guard);
ASSERT_NE(nullptr, tx_table = tx_table_guard.get_tx_table());
ASSERT_NE(nullptr, tx_data_table = tx_table->get_tx_data_table());
ObTxData *tx_data = nullptr;
transaction::ObTransID tx_id;
for (int64_t i = 1; i <= 5; i++) {
tx_id = i;
ObTxDataGuard tx_data_guard;
ASSERT_EQ(OB_SUCCESS, tx_data_table->alloc_tx_data(tx_data_guard));
ASSERT_NE(nullptr, tx_data = tx_data_guard.tx_data());
ObTxData *tx_data = new ObTxData();
transaction::ObTransID tx_id = i;
// fill in data
tx_data->tx_id_ = tx_id;
@ -1439,7 +1393,8 @@ TEST_F(TestMultiVersionMerge, test_merge_with_multi_trans_can_not_compact)
;
}
ASSERT_EQ(OB_SUCCESS, tx_data_table->insert(tx_data));
ASSERT_EQ(OB_SUCCESS, tx_table->insert(tx_data));
delete tx_data;
}
ObVersionRange trans_version_range;
@ -1483,7 +1438,7 @@ TEST_F(TestMultiVersionMerge, test_merge_with_multi_trans_can_not_compact)
ObMockDirectReadIterator sstable_iter;
ASSERT_EQ(OB_SUCCESS, sstable_iter.init(scanner, allocator_, full_read_info_));
ASSERT_TRUE(res_iter.equals(sstable_iter, true));
ASSERT_EQ(OB_SUCCESS, clear_tx_data(tx_data_table));
ASSERT_EQ(OB_SUCCESS, clear_tx_data());
scanner->~ObStoreRowIterator();
handle1.reset();
handle2.reset();
@ -1550,13 +1505,6 @@ TEST_F(TestMultiVersionMerge, test_merge_with_macro_reused_with_shadow)
ObLSService *ls_svr = MTL(ObLSService*);
ASSERT_EQ(OB_SUCCESS, ls_svr->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD));
ObTxTable *tx_table = nullptr;
ObTxDataTable *tx_data_table = nullptr;
ObTxTableGuard tx_table_guard;
ls_handle.get_ls()->get_tx_table_guard(tx_table_guard);
ASSERT_NE(nullptr, tx_table = tx_table_guard.get_tx_table());
ASSERT_NE(nullptr, tx_data_table = tx_table->get_tx_data_table());
ObVersionRange trans_version_range;
trans_version_range.snapshot_version_ = 100;
trans_version_range.multi_version_start_ = 1;
@ -1596,7 +1544,7 @@ TEST_F(TestMultiVersionMerge, test_merge_with_macro_reused_with_shadow)
ObMockDirectReadIterator sstable_iter;
ASSERT_EQ(OB_SUCCESS, sstable_iter.init(scanner, allocator_, full_read_info_));
ASSERT_TRUE(res_iter.equals(sstable_iter, true));
ASSERT_EQ(OB_SUCCESS, clear_tx_data(tx_data_table));
ASSERT_EQ(OB_SUCCESS, clear_tx_data());
scanner->~ObStoreRowIterator();
handle1.reset();
handle2.reset();
@ -1663,20 +1611,13 @@ TEST_F(TestMultiVersionMerge, test_merge_with_macro_reused_without_shadow)
ASSERT_EQ(OB_SUCCESS, ls_svr->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD));
ObTxTable *tx_table = nullptr;
ObTxDataTable *tx_data_table = nullptr;
ObTxTableGuard tx_table_guard;
ls_handle.get_ls()->get_tx_table_guard(tx_table_guard);
ASSERT_NE(nullptr, tx_table = tx_table_guard.get_tx_table());
ASSERT_NE(nullptr, tx_data_table = tx_table->get_tx_data_table());
ObTxData *tx_data = nullptr;
transaction::ObTransID tx_id;
for (int64_t i = 1; i <= 4; i++) {
tx_id = i;
ObTxDataGuard tx_data_guard;
ASSERT_EQ(OB_SUCCESS, tx_data_table->alloc_tx_data(tx_data_guard));
ASSERT_NE(nullptr, tx_data = tx_data_guard.tx_data());
ObTxData *tx_data = new ObTxData();
transaction::ObTransID tx_id = i;
// fill in data
tx_data->tx_id_ = tx_id;
@ -1685,7 +1626,8 @@ TEST_F(TestMultiVersionMerge, test_merge_with_macro_reused_without_shadow)
tx_data->end_scn_ = tx_data->commit_version_;
tx_data->state_ = ObTxData::COMMIT;
ASSERT_EQ(OB_SUCCESS, tx_data_table->insert(tx_data));
ASSERT_EQ(OB_SUCCESS, tx_table->insert(tx_data));
delete tx_data;
}
ObVersionRange trans_version_range;
@ -1728,7 +1670,7 @@ TEST_F(TestMultiVersionMerge, test_merge_with_macro_reused_without_shadow)
ObMockDirectReadIterator sstable_iter;
ASSERT_EQ(OB_SUCCESS, sstable_iter.init(scanner, allocator_, full_read_info_));
ASSERT_TRUE(res_iter.equals(sstable_iter, true));
ASSERT_EQ(OB_SUCCESS, clear_tx_data(tx_data_table));
ASSERT_EQ(OB_SUCCESS, clear_tx_data());
scanner->~ObStoreRowIterator();
handle1.reset();
handle2.reset();
@ -1877,20 +1819,13 @@ TEST_F(TestMultiVersionMerge, test_merge_with_greater_multi_version_and_uncommit
ASSERT_EQ(OB_SUCCESS, ls_svr->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD));
ObTxTable *tx_table = nullptr;
ObTxDataTable *tx_data_table = nullptr;
ObTxTableGuard tx_table_guard;
ls_handle.get_ls()->get_tx_table_guard(tx_table_guard);
ASSERT_NE(nullptr, tx_table = tx_table_guard.get_tx_table());
ASSERT_NE(nullptr, tx_data_table = tx_table->get_tx_data_table());
ObTxData *tx_data = nullptr;
transaction::ObTransID tx_id;
for (int64_t i = 1; i <= 4; i++) {
tx_id = i;
ObTxDataGuard tx_data_guard;
ASSERT_EQ(OB_SUCCESS, tx_data_table->alloc_tx_data(tx_data_guard));
ASSERT_NE(nullptr, tx_data = tx_data_guard.tx_data());
ObTxData *tx_data = new ObTxData();
transaction::ObTransID tx_id = i;
// fill in data
tx_data->tx_id_ = tx_id;
@ -1899,7 +1834,8 @@ TEST_F(TestMultiVersionMerge, test_merge_with_greater_multi_version_and_uncommit
tx_data->end_scn_ = tx_data->commit_version_;
tx_data->state_ = ObTxData::COMMIT;
ASSERT_EQ(OB_SUCCESS, tx_data_table->insert(tx_data));
ASSERT_EQ(OB_SUCCESS, tx_table->insert(tx_data));
delete tx_data;
}
prepare_merge_context(MINOR_MERGE, false, trans_version_range, merge_context);
@ -1929,7 +1865,7 @@ TEST_F(TestMultiVersionMerge, test_merge_with_greater_multi_version_and_uncommit
ObMockDirectReadIterator sstable_iter;
ASSERT_EQ(OB_SUCCESS, sstable_iter.init(scanner, allocator_, full_read_info_));
ASSERT_TRUE(res_iter.equals(sstable_iter, true));
ASSERT_EQ(OB_SUCCESS, clear_tx_data(tx_data_table));
ASSERT_EQ(OB_SUCCESS, clear_tx_data());
scanner->~ObStoreRowIterator();
handle1.reset();
handle2.reset();
@ -2006,20 +1942,13 @@ TEST_F(TestMultiVersionMerge, test_merge_with_ghost_row)
ASSERT_EQ(OB_SUCCESS, ls_svr->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD));
ObTxTable *tx_table = nullptr;
ObTxDataTable *tx_data_table = nullptr;
ObTxTableGuard tx_table_guard;
ls_handle.get_ls()->get_tx_table_guard(tx_table_guard);
ASSERT_NE(nullptr, tx_table = tx_table_guard.get_tx_table());
ASSERT_NE(nullptr, tx_data_table = tx_table->get_tx_data_table());
ObTxData *tx_data = nullptr;
transaction::ObTransID tx_id;
for (int64_t i = 1; i <= 4; i++) {
tx_id = i;
ObTxDataGuard tx_data_guard;
ASSERT_EQ(OB_SUCCESS, tx_data_table->alloc_tx_data(tx_data_guard));
ASSERT_NE(nullptr, tx_data = tx_data_guard.tx_data());
ObTxData *tx_data = new ObTxData();
transaction::ObTransID tx_id = i;
// fill in data
tx_data->tx_id_ = tx_id;
@ -2035,7 +1964,8 @@ TEST_F(TestMultiVersionMerge, test_merge_with_ghost_row)
tx_data->state_ = ObTxData::COMMIT;
}
ASSERT_EQ(OB_SUCCESS, tx_data_table->insert(tx_data));
ASSERT_EQ(OB_SUCCESS, tx_table->insert(tx_data));
delete tx_data;
}
ObVersionRange trans_version_range;
@ -2070,7 +2000,7 @@ TEST_F(TestMultiVersionMerge, test_merge_with_ghost_row)
ObMockDirectReadIterator sstable_iter;
ASSERT_EQ(OB_SUCCESS, sstable_iter.init(scanner, allocator_, full_read_info_));
ASSERT_TRUE(res_iter.equals(sstable_iter, true));
ASSERT_EQ(OB_SUCCESS, clear_tx_data(tx_data_table));
ASSERT_EQ(OB_SUCCESS, clear_tx_data());
scanner->~ObStoreRowIterator();
handle1.reset();
handle2.reset();
@ -2413,20 +2343,13 @@ TEST_F(TestMultiVersionMerge, rowkey_cross_macro_with_last_shadow_version_less_t
ASSERT_EQ(OB_SUCCESS, ls_svr->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD));
ObTxTable *tx_table = nullptr;
ObTxDataTable *tx_data_table = nullptr;
ObTxTableGuard tx_table_guard;
ls_handle.get_ls()->get_tx_table_guard(tx_table_guard);
ASSERT_NE(nullptr, tx_table = tx_table_guard.get_tx_table());
ASSERT_NE(nullptr, tx_data_table = tx_table->get_tx_data_table());
ObTxData *tx_data = nullptr;
transaction::ObTransID tx_id;
for (int64_t i = 1; i < 3; i++) {
tx_id = i;
ObTxDataGuard tx_data_guard;
ASSERT_EQ(OB_SUCCESS, tx_data_table->alloc_tx_data(tx_data_guard));
ASSERT_NE(nullptr, tx_data = tx_data_guard.tx_data());
ObTxData *tx_data = new ObTxData();
transaction::ObTransID tx_id = i;
// fill in data
tx_data->tx_id_ = tx_id;
@ -2435,7 +2358,8 @@ TEST_F(TestMultiVersionMerge, rowkey_cross_macro_with_last_shadow_version_less_t
tx_data->end_scn_ = tx_data->commit_version_;
tx_data->state_ = ObTxData::COMMIT;
ASSERT_EQ(OB_SUCCESS, tx_data_table->insert(tx_data));
ASSERT_EQ(OB_SUCCESS, tx_table->insert(tx_data));
delete tx_data;
}
ObVersionRange trans_version_range;
@ -2473,7 +2397,7 @@ TEST_F(TestMultiVersionMerge, rowkey_cross_macro_with_last_shadow_version_less_t
ObMockDirectReadIterator sstable_iter;
ASSERT_EQ(OB_SUCCESS, sstable_iter.init(scanner, allocator_, full_read_info_));
ASSERT_TRUE(res_iter.equals(sstable_iter, true/*cmp multi version row flag*/));
ASSERT_EQ(OB_SUCCESS, clear_tx_data(tx_data_table));
ASSERT_EQ(OB_SUCCESS, clear_tx_data());
scanner->~ObStoreRowIterator();
handle1.reset();
handle2.reset();
@ -2643,26 +2567,22 @@ TEST_F(TestMultiVersionMerge, rowkey_cross_macro_without_open_next_macro)
ASSERT_EQ(OB_SUCCESS, ls_svr->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD));
ObTxTable *tx_table = nullptr;
ObTxDataTable *tx_data_table = nullptr;
ObTxTableGuard tx_table_guard;
ls_handle.get_ls()->get_tx_table_guard(tx_table_guard);
ASSERT_NE(nullptr, tx_table = tx_table_guard.get_tx_table());
ASSERT_NE(nullptr, tx_data_table = tx_table->get_tx_data_table());
ObTxData *tx_data = nullptr;
transaction::ObTransID tx_id;
for (int64_t i = 1; i < 3; i++) {
tx_id = i;
ObTxDataGuard tx_data_guard;
ASSERT_EQ(OB_SUCCESS, tx_data_table->alloc_tx_data(tx_data_guard));
ASSERT_NE(nullptr, tx_data = tx_data_guard.tx_data());
ObTxData *tx_data = new ObTxData();
transaction::ObTransID tx_id = i;
// fill in data
tx_data->tx_id_ = tx_id;
tx_data->commit_version_.convert_for_tx(INT64_MAX);
tx_data->start_scn_.convert_for_tx(i);
tx_data->end_scn_.convert_for_tx(100);
tx_data->state_ = ObTxData::ABORT;
ASSERT_EQ(OB_SUCCESS, tx_data_table->insert(tx_data));
ASSERT_EQ(OB_SUCCESS, tx_table->insert(tx_data));
delete tx_data;
}
ObVersionRange trans_version_range;
@ -2700,7 +2620,7 @@ TEST_F(TestMultiVersionMerge, rowkey_cross_macro_without_open_next_macro)
ObMockDirectReadIterator sstable_iter;
ASSERT_EQ(OB_SUCCESS, sstable_iter.init(scanner, allocator_, full_read_info_));
ASSERT_TRUE(res_iter.equals(sstable_iter, true/*cmp multi version row flag*/));
ASSERT_EQ(OB_SUCCESS, clear_tx_data(tx_data_table));
ASSERT_EQ(OB_SUCCESS, clear_tx_data());
scanner->~ObStoreRowIterator();
handle1.reset();
handle2.reset();
@ -2889,20 +2809,13 @@ TEST_F(TestMultiVersionMerge, test_merge_base_iter_have_ghost_row)
ASSERT_EQ(OB_SUCCESS, ls_svr->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD));
ObTxTable *tx_table = nullptr;
ObTxDataTable *tx_data_table = nullptr;
ObTxTableGuard tx_table_guard;
ls_handle.get_ls()->get_tx_table_guard(tx_table_guard);
ASSERT_NE(nullptr, tx_table = tx_table_guard.get_tx_table());
ASSERT_NE(nullptr, tx_data_table = tx_table->get_tx_data_table());
ObTxData *tx_data = nullptr;
transaction::ObTransID tx_id;
for (int64_t i = 1; i <= 4; i++) {
tx_id = i;
ObTxDataGuard tx_data_guard;
ASSERT_EQ(OB_SUCCESS, tx_data_table->alloc_tx_data(tx_data_guard));
ASSERT_NE(nullptr, tx_data = tx_data_guard.tx_data());
ObTxData *tx_data = new ObTxData();
transaction::ObTransID tx_id = i;
// fill in data
tx_data->tx_id_ = tx_id;
@ -2918,7 +2831,9 @@ TEST_F(TestMultiVersionMerge, test_merge_base_iter_have_ghost_row)
tx_data->state_ = ObTxData::COMMIT;
}
ASSERT_EQ(OB_SUCCESS, tx_data_table->insert(tx_data));
ASSERT_EQ(OB_SUCCESS, tx_table->insert(tx_data));
delete tx_data;
}
ObVersionRange trans_version_range;
@ -2954,7 +2869,7 @@ TEST_F(TestMultiVersionMerge, test_merge_base_iter_have_ghost_row)
ObMockDirectReadIterator sstable_iter;
ASSERT_EQ(OB_SUCCESS, sstable_iter.init(scanner, allocator_, full_read_info_));
ASSERT_TRUE(res_iter.equals(sstable_iter, true));
ASSERT_EQ(OB_SUCCESS, clear_tx_data(tx_data_table));
ASSERT_EQ(OB_SUCCESS, clear_tx_data());
scanner->~ObStoreRowIterator();
handle1.reset();
handle2.reset();