init push

2021-05-31 22:56:52 +08:00
commit cea7de1475
7020 changed files with 5689869 additions and 0 deletions
--- a/unittest/storage/transaction/test_ob_trans_define.cpp
+++ b/unittest/storage/transaction/test_ob_trans_define.cpp
@ -0,0 +1,527 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#include "storage/transaction/ob_trans_define.h"
+#include <gtest/gtest.h>
+#include "share/ob_errno.h"
+#include "lib/oblog/ob_log.h"
+#include "common/ob_partition_key.h"
+#include "common/ob_clock_generator.h"
+#include "sql/ob_sql_define.h"
+#include "sql/resolver/ob_stmt.h"
+
+namespace oceanbase {
+using namespace common;
+using namespace transaction;
+using namespace sql;
+namespace unittest {
+class TestObTransDefine : public ::testing::Test {
+  public:
+  virtual void SetUp()
+  {}
+  virtual void TearDown()
+  {}
+
+  public:
+  // valid partition parameters
+  static const int64_t VALID_TABLE_ID = 1;
+  static const int32_t VALID_PARTITION_ID = 1;
+  static const int32_t VALID_PARTITION_COUNT = 100;
+  // invalid partition parameters
+  static const int64_t INVALID_TABLE_ID = -1;
+  static const int32_t INVALID_PARTITION_ID = -1;
+  static const int32_t INVALID_PARTITION_COUNT = -100;
+
+  static const int32_t PORT = 8080;
+  static const ObAddr::VER IP_TYPE = ObAddr::IPV4;
+  static const char* LOCAL_IP;
+};
+const char* TestObTransDefine::LOCAL_IP = "127.0.0.1";
+
+////////////////////////////////test ObTransID//////////////////////////////////////////
+// test the init of ObTransID
+TEST_F(TestObTransDefine, trans_id_constructor)
+{
+  TRANS_LOG(INFO, "called", "func", test_info_->name());
+  ObTransID trans_id;
+  EXPECT_FALSE(trans_id.is_valid());
+
+  ObAddr observer(TestObTransDefine::IP_TYPE, TestObTransDefine::LOCAL_IP, TestObTransDefine::PORT);
+  ObTransID trans_id1(observer);
+  EXPECT_EQ(true, trans_id1.is_valid());
+
+  ObTransID trans_id2(trans_id1);
+  EXPECT_EQ(1, trans_id2.get_inc_num());
+  EXPECT_EQ(true, trans_id2.is_valid());
+
+  ObTransID trans_id3(trans_id1);
+  trans_id2 = trans_id3;
+  EXPECT_EQ(1, trans_id2.get_inc_num());
+  EXPECT_EQ(true, trans_id2.is_valid());
+
+  EXPECT_TRUE(trans_id1 == trans_id2);
+
+  EXPECT_EQ(0, trans_id1.compare(trans_id2));
+  EXPECT_EQ(0, trans_id2.compare(trans_id1));
+}
+// test the serialization and deserialization of ObTransID
+TEST_F(TestObTransDefine, trans_id_enconde_deconde)
+{
+  TRANS_LOG(INFO, "called", "func", test_info_->name());
+  ObAddr observer(TestObTransDefine::IP_TYPE, TestObTransDefine::LOCAL_IP, TestObTransDefine::PORT);
+  ObTransID trans_id(observer);
+  EXPECT_EQ(2, trans_id.get_inc_num());
+  // serialization
+  int64_t pos = 0;
+  const int64_t BUFFER_SIZE = 10240;
+  char buffer[BUFFER_SIZE];
+  ASSERT_EQ(OB_SUCCESS, trans_id.serialize(buffer, BUFFER_SIZE, pos));
+  // deserialization
+  ObTransID trans_id1;
+  int64_t start_index = 0;
+  ASSERT_EQ(OB_SUCCESS, trans_id1.deserialize(buffer, pos, start_index));
+  EXPECT_EQ(2, trans_id1.get_inc_num());
+
+  EXPECT_EQ(trans_id, trans_id1);
+}
+
+// test the reset
+TEST_F(TestObTransDefine, trans_id_reset)
+{
+  ObAddr observer(TestObTransDefine::IP_TYPE, TestObTransDefine::LOCAL_IP, TestObTransDefine::PORT);
+  ObTransID tid_1(observer);
+  ObTransID tid_2(tid_1);
+  EXPECT_TRUE(tid_2 == tid_1);
+  EXPECT_EQ(0, tid_2.compare(tid_1));
+  EXPECT_TRUE(tid_2.is_valid());
+  tid_2.reset();
+  EXPECT_FALSE(tid_2 == tid_1);
+  EXPECT_NE(0, tid_2.compare(tid_1));
+  EXPECT_FALSE(tid_2.is_valid());
+}
+
+/*
+TEST_F(TestObTransDefine, trans_id_compare)
+{
+  ObAddr addr_little(TestObTransDefine::IP_TYPE, TestObTransDefine::LOCAL_IP, 1000);
+  ObAddr addr_bigger(TestObTransDefine::IP_TYPE, TestObTransDefine::LOCAL_IP, 2000);
+
+  ASSERT_TRUE(addr_little < addr_bigger);
+
+  ObTransID tid_1(addr_little);
+  EXPECT_TRUE(0 == tid_1.compare(tid_1));
+
+  ObTransID tid_1_copy(tid_1);
+  EXPECT_TRUE(0 == tid_1.compare(tid_1_copy));
+  EXPECT_TRUE(0 == tid_1_copy.compare(tid_1));
+
+  ObTransID tid_2(addr_little);
+  EXPECT_TRUE(tid_1.compare(tid_2) < 0);
+  EXPECT_TRUE(tid_2.compare(tid_1) > 0);
+
+  ObTransID tid_3(addr_bigger);
+  EXPECT_TRUE(tid_1.compare(tid_3) < 0);
+  EXPECT_TRUE(tid_3.compare(tid_1) > 0);
+  EXPECT_TRUE(tid_2.compare(tid_3) < 0);
+  EXPECT_TRUE(tid_3.compare(tid_2) > 0);
+
+  ObTransID tid_4(addr_little);
+  EXPECT_TRUE(tid_3.compare(tid_4) > 0);
+  EXPECT_TRUE(tid_4.compare(tid_3) < 0);
+}
+*/
+
+// test the hash of ObTransID
+TEST_F(TestObTransDefine, trans_id_hash)
+{
+  TRANS_LOG(INFO, "called", "func", test_info_->name());
+  ObAddr observer = ObAddr(TestObTransDefine::IP_TYPE, TestObTransDefine::LOCAL_IP, TestObTransDefine::PORT);
+  ObTransID trans_id(observer);
+  uint64_t hashcode = trans_id.hash();
+  TRANS_LOG(INFO, "hashcode info", K(hashcode));
+}
+
+//////////////////////////////////////////test ObXATransID///////////////////////////////////
+TEST_F(TestObTransDefine, xid_encode_decode)
+{
+  const char* gtrid_cstr = "gtrid01";
+  const char* bqual_cstr = "bqual01";
+  char gtrid_buf[128];
+  char bqual_buf[128];
+  common::ObString gtrid_str;
+  common::ObString bqual_str;
+  gtrid_str.reset();
+  gtrid_str.assign_buffer(gtrid_buf, sizeof(gtrid_buf));
+  gtrid_str.write(gtrid_cstr, 7);
+  bqual_str.reset();
+  bqual_str.assign_buffer(bqual_buf, sizeof(bqual_buf));
+  bqual_str.write(bqual_cstr, 7);
+  ObXATransID xid;
+  xid.set(gtrid_str, bqual_str, 1);
+  // serialization
+  int64_t pos = 0;
+  const int64_t BUFFER_SIZE = 10240;
+  char buffer[BUFFER_SIZE];
+  ASSERT_EQ(OB_SUCCESS, xid.serialize(buffer, BUFFER_SIZE, pos));
+  // deserialization
+  ObXATransID xid2;
+  int64_t start_index = 0;
+  ASSERT_EQ(OB_SUCCESS, xid2.deserialize(buffer, pos, start_index));
+  EXPECT_EQ(xid, xid2);
+  TRANS_LOG(INFO, "xid info", K(xid), K(xid2));
+}
+
+//////////////////////////////////////////test ObTransDesc///////////////////////////////////
+// test the set_tranas_id and get_trans_id of ObTransDesc
+TEST_F(TestObTransDefine, trans_desc_set_get_trans_id)
+{
+  TRANS_LOG(INFO, "called", "func", test_info_->name());
+  // invalid trans_id
+  ObTransDesc trans_desc;
+  ObTransID trans_id;
+  EXPECT_EQ(OB_INVALID_ARGUMENT, trans_desc.set_trans_id(trans_id));
+  TRANS_LOG(INFO, "trans_desc info after setted with invalid_trans_id", K(trans_desc));
+  // valid trans_id
+  ObAddr observer(TestObTransDefine::IP_TYPE, TestObTransDefine::LOCAL_IP, TestObTransDefine::PORT);
+  ObTransID trans_id1(observer);
+  EXPECT_EQ(OB_SUCCESS, trans_desc.set_trans_id(trans_id1));
+  EXPECT_FALSE(trans_desc.is_valid());
+
+  // test the get_trans_id
+  const ObTransID& trans_id2 = trans_desc.get_trans_id();
+  EXPECT_EQ(trans_id1, trans_id2);
+  TRANS_LOG(INFO, "trans_id1 and the copied obj trans_id2 info", K(trans_id1), K(trans_id2));
+}
+
+// test the set_snapshot_version and get_snapshot_version of ObTransDesc
+TEST_F(TestObTransDefine, trans_desc_set_get_snapshot_version)
+{
+  TRANS_LOG(INFO, "called", "func", test_info_->name());
+  // invalid snapshot_version
+  int64_t snapshot_version = -1;
+  ObTransDesc trans_desc;
+  EXPECT_EQ(OB_INVALID_ARGUMENT, trans_desc.set_snapshot_version(snapshot_version));
+
+  snapshot_version = 1;
+  EXPECT_EQ(OB_SUCCESS, trans_desc.set_snapshot_version(snapshot_version));
+  TRANS_LOG(INFO, "trans_desc info after setted valid snapshot_version", K(trans_desc));
+
+  // test the get_snapshot
+  EXPECT_EQ(snapshot_version, trans_desc.get_snapshot_version());
+  TRANS_LOG(INFO, "snapshot_version", K(snapshot_version));
+}
+// test the set_trans_param and get_trans_param of ObTransDesc
+TEST_F(TestObTransDefine, trans_desc_set_get_trans_param)
+{
+  TRANS_LOG(INFO, "called", "func", test_info_->name());
+  // invalid trans_param
+  ObTransDesc trans_desc;
+  ObStartTransParam parms;
+  EXPECT_EQ(OB_INVALID_ARGUMENT, trans_desc.set_trans_param(parms));
+
+  parms.set_access_mode(ObTransAccessMode::READ_ONLY);
+  parms.set_type(ObTransType::TRANS_USER);
+  parms.set_isolation(ObTransIsolation::READ_COMMITED);
+  EXPECT_EQ(OB_SUCCESS, trans_desc.set_trans_param(parms));
+  // test the get_trans_param
+  const ObStartTransParam& parms1 = trans_desc.get_trans_param();
+  EXPECT_EQ(parms.get_access_mode(), parms1.get_access_mode());
+  EXPECT_EQ(parms.get_type(), parms1.get_type());
+  EXPECT_EQ(parms.get_isolation(), parms1.get_isolation());
+}
+// test the sql_no, trans_expired_time, cur_stmt_expired_time and rollback of scheduler
+TEST_F(TestObTransDefine, trans_desc_set_get_args)
+{
+  TRANS_LOG(INFO, "called", "func", test_info_->name());
+  ObTransDesc trans_desc;
+  ObAddr scheduler;
+  EXPECT_EQ(OB_INVALID_ARGUMENT, trans_desc.set_scheduler(scheduler));
+
+  scheduler = ObAddr(TestObTransDefine::IP_TYPE, TestObTransDefine::LOCAL_IP, TestObTransDefine::PORT);
+  EXPECT_EQ(OB_SUCCESS, trans_desc.set_scheduler(scheduler));
+  const ObAddr& scheduler1 = trans_desc.get_scheduler();
+  EXPECT_EQ(scheduler, scheduler1);
+  // sql_no
+  trans_desc.inc_sql_no();
+  EXPECT_EQ(1, trans_desc.get_sql_no() & 0xffffffffL);
+  // trans_expired_time
+  EXPECT_EQ(OB_INVALID_ARGUMENT, trans_desc.set_trans_expired_time(-1));
+  EXPECT_EQ(OB_SUCCESS, trans_desc.set_trans_expired_time(1000));
+  EXPECT_EQ(1000, trans_desc.get_trans_expired_time());
+  // cur_stmt_expired_time
+  EXPECT_EQ(OB_INVALID_ARGUMENT, trans_desc.set_cur_stmt_expired_time(-1));
+  EXPECT_EQ(OB_SUCCESS, trans_desc.set_cur_stmt_expired_time(1000));
+  EXPECT_EQ(1000, trans_desc.get_cur_stmt_expired_time());
+  // rollback
+  trans_desc.set_need_rollback();
+  trans_desc.need_rollback();
+  // other set/get mothod
+  ObPartitionKey partition_key(TestObTransDefine::VALID_TABLE_ID,
+      TestObTransDefine::VALID_PARTITION_ID,
+      TestObTransDefine::VALID_PARTITION_COUNT);
+  EXPECT_TRUE(false == trans_desc.has_create_ctx(partition_key));
+  EXPECT_EQ(true, trans_desc.is_trans_timeout());
+  EXPECT_EQ(true, trans_desc.is_stmt_timeout());
+  EXPECT_TRUE(false == trans_desc.is_readonly());
+}
+// test the set_stmt_participants and get_stmt_participants
+TEST_F(TestObTransDefine, trans_desc_set_get_participants)
+{
+  TRANS_LOG(INFO, "called", "func", test_info_->name());
+  ObTransDesc trans_desc;
+  ObPartitionArray participants;
+  ObPartitionKey partition_key(TestObTransDefine::VALID_TABLE_ID,
+      TestObTransDefine::VALID_PARTITION_ID,
+      TestObTransDefine::VALID_PARTITION_COUNT);
+  // EXPECT_EQ(OB_INVALID_ARGUMENT, trans_desc.set_stmt_participants(participants));
+  participants.push_back(partition_key);
+  ASSERT_EQ(OB_SUCCESS, trans_desc.set_stmt_participants(participants));
+
+  const ObPartitionArray& array = trans_desc.get_stmt_participants();
+  ASSERT_EQ(participants.count(), array.count());
+  const ObPartitionKey& partition = array.at(0);
+  ASSERT_EQ(partition_key, partition);
+}
+
+// test merge_participants
+TEST_F(TestObTransDefine, trans_desc_merage_participants)
+{
+  TRANS_LOG(INFO, "called", "func", test_info_->name());
+  ObTransDesc trans_desc;
+  ObPartitionArray stmt_participants;
+  ObPartitionKey partition_key(TestObTransDefine::VALID_TABLE_ID,
+      TestObTransDefine::VALID_PARTITION_ID,
+      TestObTransDefine::VALID_PARTITION_COUNT);
+  stmt_participants.push_back(partition_key);
+  EXPECT_EQ(OB_SUCCESS, trans_desc.set_stmt_participants(stmt_participants));
+  EXPECT_EQ(OB_SUCCESS, trans_desc.merge_participants());
+  trans_desc.clear_stmt_participants();
+}
+// test set/get_stmt_desc
+TEST_F(TestObTransDefine, set_get_stmt_desc)
+{
+  TRANS_LOG(INFO, "called", "func", test_info_->name());
+  ObTransDesc trans_desc;
+  ObPartitionArray stmt_participants;
+  ObPartitionKey partition_key(TestObTransDefine::VALID_TABLE_ID,
+      TestObTransDefine::VALID_PARTITION_ID,
+      TestObTransDefine::VALID_PARTITION_COUNT);
+  stmt_participants.push_back(partition_key);
+  EXPECT_EQ(OB_SUCCESS, trans_desc.set_stmt_participants(stmt_participants));
+  EXPECT_EQ(OB_SUCCESS, trans_desc.merge_participants());
+
+  // stmt_desc
+  ObStmtDesc& stmt_desc = trans_desc.get_cur_stmt_desc();
+  sql::ObPhyPlanType plan_type = OB_PHY_PLAN_LOCAL;
+  stmt::StmtType stmt_type = stmt::T_SELECT;
+  int64_t consistency_level = ObTransConsistencyLevel::STRONG;
+
+  stmt_desc.phy_plan_type_ = plan_type;
+  stmt_desc.consistency_level_ = consistency_level;
+  stmt_desc.stmt_type_ = stmt_type;
+  stmt_desc.is_sfu_ = false;
+  EXPECT_EQ(consistency_level, stmt_desc.consistency_level_);
+
+  const ObStmtDesc& stmt_desc1 = trans_desc.get_cur_stmt_desc();
+  EXPECT_EQ(OB_PHY_PLAN_LOCAL, stmt_desc1.phy_plan_type_);
+  EXPECT_EQ(stmt::T_SELECT, stmt_desc1.stmt_type_);
+  EXPECT_EQ(consistency_level, stmt_desc1.consistency_level_);
+}
+// test the serialization and deserialization of ObTransDesc
+TEST_F(TestObTransDefine, trans_desc_encode_decode)
+{
+  TRANS_LOG(INFO, "called", "func", test_info_->name());
+  ObTransDesc trans_desc;
+  ObAddr observer(TestObTransDefine::IP_TYPE, TestObTransDefine::LOCAL_IP, TestObTransDefine::PORT);
+  ObTransID trans_id(observer);
+  EXPECT_EQ(OB_SUCCESS, trans_desc.set_trans_id(trans_id));
+  // serialization
+  int64_t pos = 0;
+  const int64_t BUFFER_SIZE = 10240;
+  char buffer[BUFFER_SIZE];
+  ASSERT_EQ(OB_SUCCESS, trans_desc.serialize(buffer, BUFFER_SIZE, pos));
+  // deserialization
+  ObTransDesc trans_desc1;
+  int64_t start_index = 0;
+  ASSERT_EQ(OB_SUCCESS, trans_desc1.deserialize(buffer, pos, start_index));
+  EXPECT_EQ(trans_id, trans_desc1.get_trans_id());
+  EXPECT_EQ(trans_desc.get_xid(), trans_desc1.get_xid());
+}
+// test the parse of ObTransID
+TEST_F(TestObTransDefine, trans_id_parse)
+{
+  TRANS_LOG(INFO, "called", "func", test_info_->name());
+  ObAddr observer(TestObTransDefine::IP_TYPE, TestObTransDefine::LOCAL_IP, TestObTransDefine::PORT);
+  ObTransID trans_id(observer);
+  char trans_id_buf[128];
+  (void)trans_id.to_string(trans_id_buf, 128);
+  ObTransID trans_id1;
+  EXPECT_EQ(OB_SUCCESS, trans_id1.parse(trans_id_buf));
+  EXPECT_EQ(trans_id, trans_id1);
+  const char* trans_id_str1 = "invalid trans_id str";
+  const char* trans_id_str2 = "{hash:13654146498437109679, inc:23227686, addr:\"127.0.0.1:8080\"}";
+  ObTransID trans_id2;
+  EXPECT_EQ(OB_INVALID_ARGUMENT, trans_id2.parse(trans_id_str1));
+  EXPECT_EQ(OB_INVALID_ARGUMENT, trans_id2.parse(trans_id_str2));
+}
+///////////////////////////////////////test ObStartTransParam///////////////////////////////////////////////
+TEST_F(TestObTransDefine, ob_start_trans_param_is_valid)
+{
+  TRANS_LOG(INFO, "called", "func", test_info_->name());
+
+  // create an object of ObStartTransParm
+  ObStartTransParam parms;
+  EXPECT_FALSE(parms.is_valid());
+
+  parms.set_access_mode(ObTransAccessMode::READ_ONLY);
+  parms.set_type(ObTransType::TRANS_USER);
+  parms.set_isolation(ObTransIsolation::READ_COMMITED);
+
+  EXPECT_TRUE(parms.is_valid());
+  parms.reset();
+  // check the parameter values after reset
+  EXPECT_TRUE(ObTransAccessMode::UNKNOWN == parms.get_access_mode());
+  EXPECT_TRUE(ObTransType::UNKNOWN == parms.get_type());
+  EXPECT_TRUE(ObTransIsolation::UNKNOWN == parms.get_isolation());
+}
+
+// test the serialization and deserialization of ObTransSeqNum
+TEST_F(TestObTransDefine, start_trans_param_encode_decode)
+{
+  TRANS_LOG(INFO, "called", "func", test_info_->name());
+  ObStartTransParam parms;
+  EXPECT_FALSE(parms.is_valid());
+
+  parms.set_access_mode(ObTransAccessMode::READ_ONLY);
+  parms.set_type(ObTransType::TRANS_USER);
+  parms.set_isolation(ObTransIsolation::READ_COMMITED);
+
+  // serialization
+  int64_t pos = 0;
+  const int64_t BUFFER_SIZE = 10240;
+  char buffer[BUFFER_SIZE];
+  ASSERT_EQ(OB_SUCCESS, parms.serialize(buffer, BUFFER_SIZE, pos));
+  // deserialization
+  ObStartTransParam param1;
+  int64_t start_index = 0;
+  ASSERT_EQ(OB_SUCCESS, param1.deserialize(buffer, pos, start_index));
+
+  // check the values
+  EXPECT_TRUE(ObTransAccessMode::READ_ONLY == param1.get_access_mode());
+  EXPECT_TRUE(ObTransType::TRANS_USER == param1.get_type());
+  EXPECT_TRUE(ObTransIsolation::READ_COMMITED == param1.get_isolation());
+}
+
+// test the query operation for trans undo status
+TEST_F(TestObTransDefine, test_ob_trans_undo_status)
+{
+  TRANS_LOG(INFO, "called", "func", test_info_->name());
+  ObTransUndoStatus undo_status;
+  EXPECT_FALSE(undo_status.is_contain(2));
+  ASSERT_EQ(OB_SUCCESS, undo_status.undo(2, 3));
+  EXPECT_FALSE(undo_status.is_contain(2));
+  EXPECT_FALSE(undo_status.is_contain(4));
+  EXPECT_TRUE(undo_status.is_contain(3));
+
+  ASSERT_EQ(OB_SUCCESS, undo_status.undo(7, 9));
+  EXPECT_FALSE(undo_status.is_contain(2));
+  EXPECT_FALSE(undo_status.is_contain(4));
+  EXPECT_TRUE(undo_status.is_contain(3));
+  EXPECT_FALSE(undo_status.is_contain(7));
+  EXPECT_FALSE(undo_status.is_contain(10));
+  EXPECT_TRUE(undo_status.is_contain(9));
+
+  ASSERT_EQ(OB_SUCCESS, undo_status.undo(11, 15));
+  EXPECT_FALSE(undo_status.is_contain(2));
+  EXPECT_FALSE(undo_status.is_contain(4));
+  EXPECT_TRUE(undo_status.is_contain(3));
+  EXPECT_FALSE(undo_status.is_contain(7));
+  EXPECT_FALSE(undo_status.is_contain(10));
+  EXPECT_TRUE(undo_status.is_contain(9));
+  EXPECT_FALSE(undo_status.is_contain(11));
+  EXPECT_FALSE(undo_status.is_contain(16));
+  EXPECT_TRUE(undo_status.is_contain(12));
+  EXPECT_TRUE(undo_status.is_contain(13));
+  EXPECT_TRUE(undo_status.is_contain(14));
+  EXPECT_TRUE(undo_status.is_contain(15));
+
+  ASSERT_EQ(OB_SUCCESS, undo_status.undo(15, 20));
+  EXPECT_FALSE(undo_status.is_contain(2));
+  EXPECT_FALSE(undo_status.is_contain(4));
+  EXPECT_TRUE(undo_status.is_contain(3));
+  EXPECT_FALSE(undo_status.is_contain(7));
+  EXPECT_FALSE(undo_status.is_contain(10));
+  EXPECT_TRUE(undo_status.is_contain(9));
+  EXPECT_FALSE(undo_status.is_contain(11));
+  EXPECT_TRUE(undo_status.is_contain(16));
+  EXPECT_TRUE(undo_status.is_contain(12));
+  EXPECT_TRUE(undo_status.is_contain(13));
+  EXPECT_TRUE(undo_status.is_contain(14));
+  EXPECT_TRUE(undo_status.is_contain(15));
+  EXPECT_TRUE(undo_status.is_contain(19));
+  EXPECT_TRUE(undo_status.is_contain(20));
+
+  ASSERT_EQ(OB_SUCCESS, undo_status.undo(21, 30));
+  EXPECT_FALSE(undo_status.is_contain(2));
+  EXPECT_FALSE(undo_status.is_contain(4));
+  EXPECT_TRUE(undo_status.is_contain(3));
+  EXPECT_FALSE(undo_status.is_contain(7));
+  EXPECT_FALSE(undo_status.is_contain(10));
+  EXPECT_TRUE(undo_status.is_contain(9));
+  EXPECT_FALSE(undo_status.is_contain(11));
+  EXPECT_TRUE(undo_status.is_contain(16));
+  EXPECT_TRUE(undo_status.is_contain(12));
+  EXPECT_TRUE(undo_status.is_contain(13));
+  EXPECT_TRUE(undo_status.is_contain(14));
+  EXPECT_TRUE(undo_status.is_contain(15));
+  EXPECT_TRUE(undo_status.is_contain(19));
+  EXPECT_TRUE(undo_status.is_contain(20));
+  EXPECT_FALSE(undo_status.is_contain(21));
+  EXPECT_FALSE(undo_status.is_contain(31));
+  EXPECT_TRUE(undo_status.is_contain(22));
+  EXPECT_TRUE(undo_status.is_contain(30));
+
+  ASSERT_EQ(OB_SUCCESS, undo_status.undo(40, 50));
+  ASSERT_EQ(OB_SUCCESS, undo_status.undo(60, 70));
+  ASSERT_EQ(OB_SUCCESS, undo_status.undo(35, 75));
+  EXPECT_TRUE(undo_status.is_contain(40));
+  EXPECT_TRUE(undo_status.is_contain(50));
+  EXPECT_TRUE(undo_status.is_contain(60));
+  EXPECT_TRUE(undo_status.is_contain(70));
+  EXPECT_TRUE(undo_status.is_contain(75));
+  EXPECT_FALSE(undo_status.is_contain(35));
+
+  ASSERT_EQ(OB_SUCCESS, undo_status.undo(100, 200));
+  ASSERT_EQ(OB_SUCCESS, undo_status.undo(90, 190));
+  EXPECT_FALSE(undo_status.is_contain(91));
+  ASSERT_EQ(OB_SUCCESS, undo_status.undo(250, 300));
+  ASSERT_EQ(OB_SUCCESS, undo_status.undo(100, 300));
+  EXPECT_TRUE(undo_status.is_contain(300));
+  EXPECT_FALSE(undo_status.is_contain(100));
+}
+}  // namespace unittest
+}  // namespace oceanbase
+
+using namespace oceanbase;
+using namespace oceanbase::common;
+
+int main(int argc, char** argv)
+{
+  int ret = 1;
+  ObLogger& logger = ObLogger::get_logger();
+  system("rm -rf test_ob_trans_define.log*");
+  logger.set_file_name("test_ob_trans_define.log", true);
+  logger.set_log_level(OB_LOG_LEVEL_INFO);
+  testing::InitGoogleTest(&argc, argv);
+  ret = RUN_ALL_TESTS();
+  return ret;
+}