diff --git a/deps/oblib/src/common/object/ob_object.h b/deps/oblib/src/common/object/ob_object.h
index bd9f4b5ae0..67d27a7635 100644
--- a/deps/oblib/src/common/object/ob_object.h
+++ b/deps/oblib/src/common/object/ob_object.h
@@ -492,7 +492,7 @@ struct ObLobDataOutRowCtx
   uint64_t op_ : 8;
   uint64_t offset_ : 55;
   uint64_t check_sum_;
-  uint64_t seq_no_st_;
+  int64_t seq_no_st_;
   uint32_t seq_no_cnt_;
   uint32_t del_seq_no_cnt_; // for sql update
   uint64_t modified_len_;
@@ -803,13 +803,13 @@ struct ObMemLobTxInfo
 {
   ObMemLobTxInfo(){}
   ObMemLobTxInfo(int64_t snapshot_ver, int64_t tx_id, int64_t scn) :
-    version_(snapshot_ver), tx_id_(tx_id), scn_(scn)
+    snapshot_version_(snapshot_ver), snapshot_tx_id_(tx_id), snapshot_seq_(scn)
   {}
-  TO_STRING_KV(K_(version), K_(tx_id), K_(scn));
+  TO_STRING_KV(K_(snapshot_version), K_(snapshot_tx_id), K_(snapshot_seq));
 
-  int64_t version_;
-  int64_t tx_id_;
-  int64_t scn_;
+  int64_t snapshot_version_;
+  int64_t snapshot_tx_id_;
+  int64_t snapshot_seq_;
   char data_[0];
 };
 
diff --git a/mittest/mtlenv/storage/test_lob_manager.cpp b/mittest/mtlenv/storage/test_lob_manager.cpp
index a546bad4aa..fac57cc7a6 100644
--- a/mittest/mtlenv/storage/test_lob_manager.cpp
+++ b/mittest/mtlenv/storage/test_lob_manager.cpp
@@ -350,7 +350,7 @@ void TestLobManager::insert_lob_piece(
   // 2. create savepoint (can be rollbacked)
   ObTxParam tx_param;
   TestDmlCommon::build_tx_param(tx_param);
-  int64_t savepoint = 0;
+  ObTxSEQ savepoint;
   ASSERT_EQ(OB_SUCCESS, tx_service->create_implicit_savepoint(*tx_desc, tx_param, savepoint, true));
   // 3. acquire snapshot (write also need snapshot)
   ObTxIsolationLevel isolation = ObTxIsolationLevel::RC;
@@ -474,7 +474,7 @@ void TestLobManager::insert_lob_meta(
   // 2. create savepoint (can be rollbacked)
   ObTxParam tx_param;
   TestDmlCommon::build_tx_param(tx_param);
-  int64_t savepoint = 0;
+  ObTxSEQ savepoint;
   ASSERT_EQ(OB_SUCCESS, tx_service->create_implicit_savepoint(*tx_desc, tx_param, savepoint, true));
   // 3. acquire snapshot (write also need snapshot)
   ObTxIsolationLevel isolation = ObTxIsolationLevel::RC;
@@ -1053,7 +1053,7 @@ TEST_F(TestLobManager, DISABLED_basic3)
     // 2. create savepoint (can be rollbacked)
     ObTxParam tx_param;
     TestDmlCommon::build_tx_param(tx_param);
-    int64_t savepoint = 0;
+    ObTxSEQ savepoint;
     ASSERT_EQ(OB_SUCCESS, tx_service->create_implicit_savepoint(*tx_desc, tx_param, savepoint, true));
     // 3. acquire snapshot (write also need snapshot)
     ObTxIsolationLevel isolation = ObTxIsolationLevel::RC;
@@ -1134,7 +1134,7 @@ TEST_F(TestLobManager, DISABLED_basic3)
     // 2. create savepoint (can be rollbacked)
     ObTxParam tx_param;
     TestDmlCommon::build_tx_param(tx_param);
-    int64_t savepoint = 0;
+    ObTxSEQ savepoint;
     ASSERT_EQ(OB_SUCCESS, tx_service->create_implicit_savepoint(*tx_desc, tx_param, savepoint, true));
     // 3. acquire snapshot (write also need snapshot)
     ObTxIsolationLevel isolation = ObTxIsolationLevel::RC;
diff --git a/mittest/mtlenv/storage/test_memtable_v2.cpp b/mittest/mtlenv/storage/test_memtable_v2.cpp
index 9c1b525b89..16f815c567 100644
--- a/mittest/mtlenv/storage/test_memtable_v2.cpp
+++ b/mittest/mtlenv/storage/test_memtable_v2.cpp
@@ -250,8 +250,8 @@ public:
   }
 
   void rollback_to_txn(ObStoreCtx *store_ctx,
-                       const int64_t from,
-                       const int64_t to)
+                       const ObTxSEQ from,
+                       const ObTxSEQ to)
   {
     ObUndoAction undo(from, to);
     ObPartTransCtx *tx_ctx = store_ctx->mvcc_acc_ctx_.tx_ctx_;
@@ -387,14 +387,14 @@ public:
     store_ctx->mvcc_acc_ctx_.type_ = ObMvccAccessCtx::T::WRITE;
     store_ctx->mvcc_acc_ctx_.snapshot_.tx_id_ = store_ctx->mvcc_acc_ctx_.tx_id_;
     store_ctx->mvcc_acc_ctx_.snapshot_.version_ = snapshot_scn;
-    store_ctx->mvcc_acc_ctx_.snapshot_.scn_ = ObSequence::get_max_seq_no();
+    store_ctx->mvcc_acc_ctx_.snapshot_.scn_ = ObTxSEQ(ObSequence::get_max_seq_no(), 0);
     const int64_t abs_expire_time = expire_time + ::oceanbase::common::ObTimeUtility::current_time();
     store_ctx->mvcc_acc_ctx_.abs_lock_timeout_ = abs_expire_time;
-    store_ctx->mvcc_acc_ctx_.tx_scn_ = ObSequence::inc_and_get_max_seq_no();
+    store_ctx->mvcc_acc_ctx_.tx_scn_ = ObTxSEQ(ObSequence::inc_and_get_max_seq_no(), 0);
   }
   void start_pdml_stmt(ObStoreCtx *store_ctx,
                        const share::SCN snapshot_scn,
-                       const int64_t read_seq_no,
+                       const ObTxSEQ read_seq_no,
                        const int64_t expire_time = 10000000000)
   {
     ObSequence::inc();
@@ -404,7 +404,7 @@ public:
     store_ctx->mvcc_acc_ctx_.snapshot_.scn_ = read_seq_no;
     const int64_t abs_expire_time = expire_time + ::oceanbase::common::ObTimeUtility::current_time();
     store_ctx->mvcc_acc_ctx_.abs_lock_timeout_ = abs_expire_time;
-    store_ctx->mvcc_acc_ctx_.tx_scn_ = ObSequence::inc_and_get_max_seq_no();
+    store_ctx->mvcc_acc_ctx_.tx_scn_ = ObTxSEQ(ObSequence::inc_and_get_max_seq_no(), 0);
   }
   void print_callback(ObStoreCtx *wtx)
   {
@@ -920,7 +920,7 @@ public:
 
   void verify_cb(ObMvccRowCallback *cb,
                  const ObMemtable *mt,
-                 const int64_t seq_no,
+                 const ObTxSEQ seq_no,
                  const int64_t k,
                  const bool is_link = true,
                  const bool need_fill_redo = true,
@@ -952,7 +952,7 @@ public:
                     const ObMemtable *mt,
                     const ObTransID &tx_id,
                     const int64_t trans_version,
-                    const int64_t seq_no,
+                    const ObTxSEQ seq_no,
                     const uint32_t modify_count,
                     const uint8_t tnode_flag,
                     const ObDmlFlag dml_flag,
@@ -1011,7 +1011,7 @@ public:
                   ObMemtable *wmt,
                   ObMvccTransNode *prev,
                   ObMvccTransNode *next,
-                  int64_t seq_no,
+                  ObTxSEQ seq_no,
                   uint32_t modify_count,
                   int64_t k,
                   int64_t v)
@@ -1200,7 +1200,7 @@ TEST_F(TestMemtableV2, test_write_read_conflict)
            memtable,
            1000, /*snapshot version*/
            write_row);
-  const int64_t wtx_seq_no = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no = ObTxSEQ(ObSequence::get_max_seq_no(),0);
 
   verify_cb(get_tx_last_cb(wtx),
             memtable,
@@ -1343,7 +1343,7 @@ TEST_F(TestMemtableV2, test_tx_abort)
            memtable,
            1000, /*snapshot version*/
            write_row);
-  const int64_t wtx_seq_no = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no = ObTxSEQ(ObSequence::get_max_seq_no(),0);
 
   verify_cb(get_tx_last_cb(wtx),
             memtable,
@@ -1459,7 +1459,7 @@ TEST_F(TestMemtableV2, test_write_write_conflict)
 
   verify_cb(get_tx_last_cb(wtx),
             memtable,
-            ObSequence::get_max_seq_no(),
+            ObTxSEQ(ObSequence::get_max_seq_no(),0),
             1,   /*key*/
             true /*is_link*/);
   verify_tnode(get_tx_last_tnode(wtx),
@@ -1468,7 +1468,7 @@ TEST_F(TestMemtableV2, test_write_write_conflict)
                memtable,
                wtx->mvcc_acc_ctx_.tx_id_,
                INT64_MAX, /*trans_version*/
-               ObSequence::get_max_seq_no(),
+               ObTxSEQ(ObSequence::get_max_seq_no(),0),
                0,         /*modify_count*/
                ObMvccTransNode::F_INIT,
                ObDmlFlag::DF_INSERT,
@@ -1526,7 +1526,7 @@ TEST_F(TestMemtableV2, test_write_write_conflict)
 
   verify_cb(get_tx_last_cb(wtx),
             memtable,
-            ObSequence::get_max_seq_no(),
+            ObTxSEQ(ObSequence::get_max_seq_no(),0),
             1,   /*key*/
             true /*is_link*/);
   verify_tnode(get_tx_last_tnode(wtx),
@@ -1535,7 +1535,7 @@ TEST_F(TestMemtableV2, test_write_write_conflict)
                memtable,
                wtx->mvcc_acc_ctx_.tx_id_,
                INT64_MAX, /*trans_version*/
-               ObSequence::get_max_seq_no(),
+               ObTxSEQ(ObSequence::get_max_seq_no(),0),
                1,         /*modify_count*/
                ObMvccTransNode::F_INIT,
                ObDmlFlag::DF_INSERT,
@@ -1590,7 +1590,7 @@ TEST_F(TestMemtableV2, test_write_write_conflict)
            memtable,
            2100, /*snapshot version*/
            write_row2);
-  const int64_t wtx2_seq_no = ObSequence::get_max_seq_no();
+  const auto wtx2_seq_no = ObTxSEQ(ObSequence::get_max_seq_no(),0);
 
   verify_cb(get_tx_last_cb(wtx2),
             memtable,
@@ -1672,7 +1672,7 @@ TEST_F(TestMemtableV2, test_lock)
           memtable,
           1000, /*snapshot version*/
           rowkey);
-  const int64_t wtx_seq_no = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no = ObTxSEQ(ObSequence::get_max_seq_no(),0);
 
   verify_cb(get_tx_last_cb(ltx),
             memtable,
@@ -1780,7 +1780,7 @@ TEST_F(TestMemtableV2, test_lock)
           memtable,
           2500, /*snapshot version*/
           rowkey);
-  const int64_t wtx2_seq_no = ObSequence::get_max_seq_no();
+  const auto wtx2_seq_no = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   verify_cb(get_tx_last_cb(wtx2),
             memtable,
             wtx2_seq_no,
@@ -1845,7 +1845,7 @@ TEST_F(TestMemtableV2, test_lock)
            memtable,
            4500, /*snapshot version*/
            write_row3);
-  const int64_t wtx3_seq_no = ObSequence::get_max_seq_no();
+  const auto wtx3_seq_no = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   verify_cb(get_tx_last_cb(wtx3),
             memtable,
             wtx3_seq_no,
@@ -1972,12 +1972,12 @@ TEST_F(TestMemtableV2, test_rollback_to)
            memtable,
            1000, /*snapshot version*/
            write_row);
-  const int64_t wtx_seq_no1 = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no1 = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   write_tx(wtx,
            memtable,
            1000, /*snapshot version*/
            write_row2);
-  const int64_t wtx_seq_no2 = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no2 = ObTxSEQ(ObSequence::get_max_seq_no(),0);
 
   print_callback(wtx);
 
@@ -2071,7 +2071,7 @@ TEST_F(TestMemtableV2, test_replay)
            lmemtable,
            500, /*snapshot version*/
            write_row3);
-  const int64_t wtx3_seq_no1 = ObSequence::get_max_seq_no();
+  const auto wtx3_seq_no1 = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   commit_txn(wtx3,
              800,/*commit_version*/
              false/*need_write_back*/);
@@ -2082,12 +2082,12 @@ TEST_F(TestMemtableV2, test_replay)
            lmemtable,
            1000, /*snapshot version*/
            write_row);
-  const int64_t wtx_seq_no1 = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no1 = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   write_tx(wtx,
            lmemtable,
            1200, /*snapshot version*/
            write_row2);
-  const int64_t wtx_seq_no2 = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no2 = ObTxSEQ(ObSequence::get_max_seq_no(),0);
 
   ObMemtableMutatorIterator mmi;
   mock_replay_iterator(wtx, mmi);
@@ -2258,12 +2258,12 @@ TEST_F(TestMemtableV2, test_replay_with_clog_encryption)
            lmemtable,
            1000, /*snapshot version*/
            write_row);
-  const int64_t wtx_seq_no1 = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no1 = ObTxSEQ(ObSequence::get_max_seq_no(), 0);
   write_tx(wtx,
            lmemtable,
            1200, /*snapshot version*/
            write_row2);
-  const int64_t wtx_seq_no2 = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no2 = ObTxSEQ(ObSequence::get_max_seq_no(), 0);
 
   //use encrypt_meta_ in memtable during submitting log
   char *redo_log_buffer = new char[REDO_BUFFER_SIZE];
@@ -2393,12 +2393,12 @@ TEST_F(TestMemtableV2, test_compact)
            lmemtable,
            1000, /*snapshot version*/
            write_row);
-  const int64_t wtx_seq_no1 = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no1 = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   write_tx(wtx,
            lmemtable,
            1200, /*snapshot version*/
            write_row2);
-  const int64_t wtx_seq_no2 = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no2 = ObTxSEQ(ObSequence::get_max_seq_no(),0);
 
   ObMemtableMutatorIterator mmi;
   mock_replay_iterator(wtx, mmi);
@@ -2415,7 +2415,7 @@ TEST_F(TestMemtableV2, test_compact)
            lmemtable,
            2500, /*snapshot version*/
            write_row3);
-  const int64_t wtx3_seq_no1 = ObSequence::get_max_seq_no();
+  const auto wtx3_seq_no1 = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   commit_txn(wtx3,
              3000,/*commit_version*/
              false/*need_write_back*/);
@@ -2626,7 +2626,7 @@ TEST_F(TestMemtableV2, test_compact_v2)
           memtable,
           1000, /*snapshot version*/
           rowkey);
-  const int64_t wtx_seq_no1 = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no1 = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   ObMvccTransNode *wtx_first_tnode = get_tx_last_tnode(wtx);
   ObMvccRow *row = get_tx_last_mvcc_row(wtx);
 
@@ -2634,14 +2634,14 @@ TEST_F(TestMemtableV2, test_compact_v2)
            memtable,
            1200, /*snapshot version*/
            write_row);
-  const int64_t wtx_seq_no2 = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no2 = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   ObMvccTransNode *wtx_second_tnode = get_tx_last_tnode(wtx);
 
   write_tx(wtx,
            memtable,
            1300, /*snapshot version*/
            write_row2);
-  const int64_t wtx_seq_no3 = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no3 = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   ObMvccTransNode *wtx_third_tnode = get_tx_last_tnode(wtx);
 
   print_callback(wtx);
@@ -2656,7 +2656,7 @@ TEST_F(TestMemtableV2, test_compact_v2)
            memtable,
            2500, /*snapshot version*/
            write_row3);
-  const int64_t wtx3_seq_no1 = ObSequence::get_max_seq_no();
+  const auto wtx3_seq_no1 = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   ObMvccTransNode *wtx3_first_tnode = get_tx_last_tnode(wtx3);
   commit_txn(wtx3,
              3000,/*commit_version*/
@@ -2929,7 +2929,7 @@ TEST_F(TestMemtableV2, test_dml_flag)
            lmemtable,
            400, /*snapshot version*/
            write_row1);
-  const int64_t wtx1_seq_no1 = ObSequence::get_max_seq_no();
+  const auto wtx1_seq_no1 = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   ObMvccRow *wtx1_row = get_tx_last_mvcc_row(wtx1);
   ObMvccTransNode *wtx1_tnode1 = get_tx_last_tnode(wtx1);
 
@@ -2960,7 +2960,7 @@ TEST_F(TestMemtableV2, test_dml_flag)
           lmemtable,
           1000, /*snapshot version*/
           rowkey);
-  const int64_t wtx2_seq_no1 = ObSequence::get_max_seq_no();
+  const auto wtx2_seq_no1 = ObTxSEQ(ObSequence::get_max_seq_no(),0);
 
   ObMemtableMutatorIterator mmi2;
   mock_replay_iterator(wtx2, mmi2);
@@ -2982,7 +2982,7 @@ TEST_F(TestMemtableV2, test_dml_flag)
            lmemtable,
            1400, /*snapshot version*/
            write_row2);
-  const int64_t wtx3_seq_no1 = ObSequence::get_max_seq_no();
+  const auto wtx3_seq_no1 = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   ObMvccTransNode *wtx3_tnode1 = get_tx_last_tnode(wtx3);
 
   ObMemtableMutatorIterator mmi3;
@@ -3082,7 +3082,7 @@ TEST_F(TestMemtableV2, test_fast_commit)
            memtable,
            1000, /*snapshot version*/
            write_row);
-  const int64_t wtx_seq_no = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   ObMvccRowCallback *wtx_cb = (ObMvccRowCallback *)(get_tx_last_cb(wtx));
   ObMvccRow *wtx_row = get_tx_last_mvcc_row(wtx);
   ObMvccTransNode *wtx_tnode = get_tx_last_tnode(wtx);
@@ -3202,7 +3202,7 @@ TEST_F(TestMemtableV2, test_fast_commit_with_no_delay_cleanout)
            memtable,
            1000, /*snapshot version*/
            write_row);
-  const int64_t wtx_seq_no = ObSequence::get_max_seq_no();
+  const auto wtx_seq_no = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   ObMvccRowCallback *wtx_cb = (ObMvccRowCallback *)(get_tx_last_cb(wtx));
   ObMvccRow *wtx_row = get_tx_last_mvcc_row(wtx);
   ObMvccTransNode *wtx_tnode = get_tx_last_tnode(wtx);
@@ -3330,7 +3330,7 @@ TEST_F(TestMemtableV2, test_seq_set_violation)
   ObTransID write_tx_id = ObTransID(1);
   ObStoreCtx *wtx = start_tx(write_tx_id);
 
-  int64_t read_seq_no = ObSequence::get_max_seq_no();
+  ObTxSEQ read_seq_no = ObTxSEQ(ObSequence::get_max_seq_no(),0);
   share::SCN scn_3000;
   scn_3000.convert_for_tx(3000);
   start_pdml_stmt(wtx, scn_3000, read_seq_no, 1000000000/*expire_time*/);
@@ -3385,7 +3385,7 @@ TEST_F(TestMemtableV2, test_parallel_lock_with_same_txn)
 
   // Step1: prepare the global sequence
   ObSequence::inc();
-  int64_t read_seq_no = ObSequence::get_max_seq_no();
+  ObTxSEQ read_seq_no = ObTxSEQ(ObSequence::get_max_seq_no(),0);
 
   // Step2: init the mvcc acc ctx
   wtx->mvcc_acc_ctx_.type_ = ObMvccAccessCtx::T::WRITE;
@@ -3394,7 +3394,7 @@ TEST_F(TestMemtableV2, test_parallel_lock_with_same_txn)
   wtx->mvcc_acc_ctx_.snapshot_.scn_ = read_seq_no;
   const int64_t abs_expire_time = 10000000000 + ::oceanbase::common::ObTimeUtility::current_time();
   wtx->mvcc_acc_ctx_.abs_lock_timeout_ = abs_expire_time;
-  wtx->mvcc_acc_ctx_.tx_scn_ = ObSequence::inc_and_get_max_seq_no();
+  wtx->mvcc_acc_ctx_.tx_scn_ = ObTxSEQ(ObSequence::inc_and_get_max_seq_no(),0);
 
   ObTableAccessContext context;
   ObVersionRange trans_version_range;
@@ -3417,7 +3417,7 @@ TEST_F(TestMemtableV2, test_parallel_lock_with_same_txn)
                                               rowkey)));
 
   // Step4: lock for the second time
-  wtx->mvcc_acc_ctx_.tx_scn_ = ObSequence::inc_and_get_max_seq_no();
+  wtx->mvcc_acc_ctx_.tx_scn_ = ObTxSEQ(ObSequence::inc_and_get_max_seq_no(),0);
   EXPECT_EQ(OB_SUCCESS, (ret = memtable->lock(iter_param_,
                                               context,
                                               rowkey)));
diff --git a/mittest/mtlenv/storage/test_multi_version_sstable_merge.cpp b/mittest/mtlenv/storage/test_multi_version_sstable_merge.cpp
index 7cce7445ab..e6fdba8440 100644
--- a/mittest/mtlenv/storage/test_multi_version_sstable_merge.cpp
+++ b/mittest/mtlenv/storage/test_multi_version_sstable_merge.cpp
@@ -1060,7 +1060,7 @@ TEST_F(TestMultiVersionMerge, test_merge_with_multi_trans)
       tx_data->start_scn_.convert_for_tx(i);
       tx_data->end_scn_.convert_for_tx(30);
       tx_data->state_ = ObTxData::RUNNING;
-      transaction::ObUndoAction undo_action(2,1);
+      transaction::ObUndoAction undo_action(ObTxSEQ(2, 0),ObTxSEQ(1, 0));
       tx_data->add_undo_action(tx_table, undo_action);
     }
 
@@ -1223,7 +1223,7 @@ TEST_F(TestMultiVersionMerge, test_merge_with_multi_trans_can_compact)
       tx_data->start_scn_.convert_for_tx(i);
       tx_data->end_scn_.convert_for_tx(50);
       tx_data->state_ = ObTxData::RUNNING;
-      transaction::ObUndoAction undo_action(2,1);
+      transaction::ObUndoAction undo_action(ObTxSEQ(2, 0),ObTxSEQ(1,0));
       tx_data->add_undo_action(tx_table, undo_action);
     }
 
@@ -1386,7 +1386,7 @@ TEST_F(TestMultiVersionMerge, test_merge_with_multi_trans_can_not_compact)
       tx_data->start_scn_.convert_for_tx(i);
       tx_data->end_scn_.convert_for_tx(50);
       tx_data->state_ = ObTxData::RUNNING;
-      transaction::ObUndoAction undo_action(2,1);
+      transaction::ObUndoAction undo_action(ObTxSEQ(2, 0),ObTxSEQ(1, 0));
       tx_data->add_undo_action(tx_table, undo_action);
 ;
     }
diff --git a/mittest/mtlenv/storage/test_table_scan_pure_data_table.cpp b/mittest/mtlenv/storage/test_table_scan_pure_data_table.cpp
index 08e31da2c5..a433c06bf3 100644
--- a/mittest/mtlenv/storage/test_table_scan_pure_data_table.cpp
+++ b/mittest/mtlenv/storage/test_table_scan_pure_data_table.cpp
@@ -114,7 +114,7 @@ void TestTableScanPureDataTable::insert_data_to_tablet(MockObAccessService *acce
   // 2. create savepoint (can be rollbacked)
   ObTxParam tx_param;
   TestDmlCommon::build_tx_param(tx_param);
-  int64_t savepoint = 0;
+  ObTxSEQ savepoint;
   ASSERT_EQ(OB_SUCCESS, tx_service->create_implicit_savepoint(*tx_desc, tx_param, savepoint, true));
   // 3. acquire snapshot (write also need snapshot)
   ObTxIsolationLevel isolation = ObTxIsolationLevel::RC;
diff --git a/mittest/mtlenv/tablelock/table_lock_common_env.h b/mittest/mtlenv/tablelock/table_lock_common_env.h
index 27590fdc91..c5dfd2fbd0 100644
--- a/mittest/mtlenv/tablelock/table_lock_common_env.h
+++ b/mittest/mtlenv/tablelock/table_lock_common_env.h
@@ -58,7 +58,7 @@ ObTableLockOp       DEFAULT_CONFLICT_OUT_TRANS_LOCK_OP;
 void init_default_lock_test_value()
 {
   int ret = OB_SUCCESS;
-  const int64_t seq_no = 0;
+  const ObTxSEQ seq_no;
   const int64_t create_timestamp = 1;
   const int64_t create_schema_version = 1;
 
diff --git a/mittest/mtlenv/tablelock/table_lock_tx_common_env.h b/mittest/mtlenv/tablelock/table_lock_tx_common_env.h
index d8bd7ceea4..26837fb804 100644
--- a/mittest/mtlenv/tablelock/table_lock_tx_common_env.h
+++ b/mittest/mtlenv/tablelock/table_lock_tx_common_env.h
@@ -142,7 +142,7 @@ void MockTxEnv::get_store_ctx(MyTxCtx &my_ctx,
   store_ctx.mvcc_acc_ctx_.init_write(my_ctx.tx_ctx_,
                                      my_ctx.tx_ctx_.mt_ctx_,
                                      my_ctx.tx_ctx_.trans_id_,
-                                     100000,
+                                     ObTxSEQ(100000, 0),
                                      my_ctx.tx_desc_,
                                      tx_table_guard,
                                      snapshot,
diff --git a/mittest/mtlenv/tablelock/test_lock_table_callback.cpp b/mittest/mtlenv/tablelock/test_lock_table_callback.cpp
index ec455eefa1..a53b0ea2b7 100644
--- a/mittest/mtlenv/tablelock/test_lock_table_callback.cpp
+++ b/mittest/mtlenv/tablelock/test_lock_table_callback.cpp
@@ -35,7 +35,7 @@ using namespace memtable;
 namespace memtable
 {
 
-void ObMemtableCtx::update_max_submitted_seq_no(const int64_t seq_no)
+void ObMemtableCtx::update_max_submitted_seq_no(const ObTxSEQ seq_no)
 {
   UNUSEDx(seq_no);
 }
diff --git a/mittest/mtlenv/tablelock/test_mem_ctx_table_lock.cpp b/mittest/mtlenv/tablelock/test_mem_ctx_table_lock.cpp
index d3232d8a1c..75fce25305 100644
--- a/mittest/mtlenv/tablelock/test_mem_ctx_table_lock.cpp
+++ b/mittest/mtlenv/tablelock/test_mem_ctx_table_lock.cpp
@@ -288,12 +288,12 @@ TEST_F(TestMemCtxTableLock, rollback_table_lock)
   // 1.1 add lock record
   LOG_INFO("TestMemCtxTableLock::rollback_table_lock 1.1");
   ObTableLockOp lock_op1 = DEFAULT_IN_TRANS_LOCK_OP;
-  lock_op1.lock_seq_no_ = 1;
+  lock_op1.lock_seq_no_ = ObTxSEQ(2, 0);
   ret = mem_ctx_.add_lock_record(lock_op1,
                                  lock_op_node);
   ASSERT_EQ(OB_SUCCESS, ret);
   ObTableLockOp lock_op2 = DEFAULT_OUT_TRANS_LOCK_OP;
-  lock_op2.lock_seq_no_ = 2;
+  lock_op2.lock_seq_no_ = ObTxSEQ(3, 0);
   ret = mem_ctx_.add_lock_record(lock_op2,
                                  lock_op_node);
   ASSERT_EQ(OB_SUCCESS, ret);
@@ -317,7 +317,7 @@ TEST_F(TestMemCtxTableLock, rollback_table_lock)
   ASSERT_EQ(lock_exist, true);
   // 1.3 rollback
   LOG_INFO("TestMemCtxTableLock::rollback_table_lock 1.3");
-  int64_t rollback_to_seq_no = 1;
+  auto rollback_to_seq_no = ObTxSEQ(2, 0);
   ret = mem_ctx_.rollback_table_lock(rollback_to_seq_no);
   ASSERT_EQ(OB_SUCCESS, ret);
   ret = mem_ctx_.check_lock_exist(DEFAULT_IN_TRANS_LOCK_OP.lock_id_,
@@ -338,7 +338,7 @@ TEST_F(TestMemCtxTableLock, rollback_table_lock)
   ASSERT_EQ(lock_exist, false);
   // 1.4 rollback again
   LOG_INFO("TestMemCtxTableLock::rollback_table_lock 1.4");
-  rollback_to_seq_no = 0;
+  rollback_to_seq_no = ObTxSEQ(1, 0);
   ret = mem_ctx_.rollback_table_lock(rollback_to_seq_no);
   ASSERT_EQ(OB_SUCCESS, ret);
   ret = mem_ctx_.check_lock_exist(DEFAULT_IN_TRANS_LOCK_OP.lock_id_,
diff --git a/mittest/mtlenv/tablelock/test_table_lock_flush.cpp b/mittest/mtlenv/tablelock/test_table_lock_flush.cpp
index 225d98c1cb..8bfb8b1dbd 100644
--- a/mittest/mtlenv/tablelock/test_table_lock_flush.cpp
+++ b/mittest/mtlenv/tablelock/test_table_lock_flush.cpp
@@ -128,7 +128,7 @@ static void mock_store_ctx(ObStoreCtx &store_ctx,
   store_ctx.mvcc_acc_ctx_.init_write(part_ctx,
                                      part_ctx.mt_ctx_,
                                      tx_desc.tx_id_,
-                                     19999,
+                                     ObTxSEQ(19999, 0),
                                      tx_desc,
                                      tx_guard,
                                      snapshot,
diff --git a/mittest/mtlenv/test_tx_data_table.cpp b/mittest/mtlenv/test_tx_data_table.cpp
index c96c790f4d..ae0f124205 100644
--- a/mittest/mtlenv/test_tx_data_table.cpp
+++ b/mittest/mtlenv/test_tx_data_table.cpp
@@ -256,9 +256,12 @@ void TestTxDataTable::insert_tx_data_()
     tx_data->state_ = is_abort_tx ? ObTxData::ABORT : ObTxData::COMMIT;
     int undo_act_num = is_abort_tx ? 0 : rand() & 15;
     for (int j = 0; j < undo_act_num; j++) {
-      auto from = random();
-      auto to = (from - 10000 > 0) ? (from - 100000) : 1;
-      transaction::ObUndoAction undo_action(from, to);
+      int64_t from = ObRandom::rand(2, 200000);
+      auto to = (from > 100000) ? (from - 100000) : 1;
+      transaction::ObUndoAction undo_action(ObTxSEQ(from, 0), ObTxSEQ(to, 0));
+      char buf[128];
+      undo_action.to_string(buf, 128);
+      ASSERT_TRUE(undo_action.is_valid()) << buf;
       ASSERT_EQ(OB_SUCCESS, tx_data->add_undo_action(&tx_table_, undo_action));
     }
 
@@ -290,7 +293,7 @@ void TestTxDataTable::insert_rollback_tx_data_()
     if (tx_data->end_scn_ > max_end_scn) {
       max_end_scn = tx_data->end_scn_;
     }
-    transaction::ObUndoAction undo_action(100, 10);
+    transaction::ObUndoAction undo_action(ObTxSEQ(100, 0), ObTxSEQ(10, 0));
     tx_data->add_undo_action(&tx_table_, undo_action);
     tx_data->state_ = ObTxData::RUNNING;
 
@@ -462,13 +465,13 @@ void TestTxDataTable::do_undo_status_test()
 
     tx_data->tx_id_ = rand();
     for (int i = 1; i <= 1001; i++) {
-      transaction::ObUndoAction undo_action(10 * (i + 1), 10 * i);
+      transaction::ObUndoAction undo_action(ObTxSEQ(10 * (i + 1), 0), ObTxSEQ(10 * i, 0));
       ASSERT_EQ(OB_SUCCESS, tx_data->add_undo_action(&tx_table_, undo_action));
     }
     ASSERT_EQ(1000 / TX_DATA_UNDO_ACT_MAX_NUM_PER_NODE + 1, tx_data->undo_status_list_.undo_node_cnt_);
 
     {
-      transaction::ObUndoAction undo_action(10000000, 10);
+      transaction::ObUndoAction undo_action(ObTxSEQ(10000000, 0), ObTxSEQ(10,0));
       ASSERT_EQ(OB_SUCCESS, tx_data->add_undo_action(&tx_table_, undo_action));
     }
 
@@ -488,13 +491,13 @@ void TestTxDataTable::do_undo_status_test()
     tx_data->tx_id_ = rand();
 
     for (int i = 1; i <= 14; i++) {
-      transaction::ObUndoAction undo_action(i + 1, i);
+      transaction::ObUndoAction undo_action(ObTxSEQ(i + 1,0), ObTxSEQ(i,0));
       ASSERT_EQ(OB_SUCCESS, tx_data->add_undo_action(&tx_table_, undo_action));
     }
     ASSERT_EQ(2, tx_data->undo_status_list_.undo_node_cnt_);
 
     {
-      transaction::ObUndoAction undo_action(15, 7);
+      transaction::ObUndoAction undo_action(ObTxSEQ(15, 0), ObTxSEQ(7,0));
       ASSERT_EQ(OB_SUCCESS, tx_data->add_undo_action(&tx_table_, undo_action));
     }
 
@@ -518,7 +521,7 @@ void TestTxDataTable::test_serialize_with_action_cnt_(int cnt)
     tx_data->state_ = ObTxData::COMMIT;
 
     for (int i = 1; i <= cnt; i++) {
-      transaction::ObUndoAction undo_action(10 * (i + 1), 10 * i);
+      transaction::ObUndoAction undo_action(ObTxSEQ(10 * (i + 1), 0), ObTxSEQ(10 * i,0));
       ASSERT_EQ(OB_SUCCESS, tx_data->add_undo_action(&tx_table_, undo_action));
     }
     int64_t node_cnt = 0;
@@ -655,9 +658,9 @@ void TestTxDataTable::do_repeat_insert_test() {
     tx_data->state_ = ObTxData::RUNNING;
     int undo_act_num = (rand() & 31) + 1;
     for (int j = 0; j < undo_act_num; j++) {
-      auto from = random();
-      auto to = (from - 10000 > 0) ? (from - 100000) : 1;
-      transaction::ObUndoAction undo_action(from, to);
+      int64_t from = ObRandom::rand(1, 200000);
+      auto to = (from > 100000) ? (from - 100000) : 1;
+      transaction::ObUndoAction undo_action(ObTxSEQ(from, 0), ObTxSEQ(to, 0));
       ASSERT_EQ(OB_SUCCESS, tx_data->add_undo_action(&tx_table_, undo_action));
     }
 
diff --git a/src/logservice/libobcdc/src/ob_cdc_lob_aux_meta_storager.cpp b/src/logservice/libobcdc/src/ob_cdc_lob_aux_meta_storager.cpp
index f7710016b5..c3c93e1e08 100644
--- a/src/logservice/libobcdc/src/ob_cdc_lob_aux_meta_storager.cpp
+++ b/src/logservice/libobcdc/src/ob_cdc_lob_aux_meta_storager.cpp
@@ -203,7 +203,7 @@ int ObCDCLobAuxMetaStorager::del_lob_col_value_(
   } else {
     const uint64_t seq_no_start = lob_data_out_row_ctx->seq_no_st_;
     const uint32_t seq_no_cnt = lob_data_out_row_ctx->seq_no_cnt_;
-    uint64_t seq_no = seq_no_start;
+    auto seq_no = transaction::ObTxSEQ::cast_from_int(seq_no_start);
     const ObLobId &lob_id = lob_data_get_ctx.get_new_lob_data()->id_;
 
     for (int64_t idx = 0; OB_SUCC(ret) && idx < seq_no_cnt; ++idx, ++seq_no) {
diff --git a/src/logservice/libobcdc/src/ob_cdc_lob_aux_meta_storager.h b/src/logservice/libobcdc/src/ob_cdc_lob_aux_meta_storager.h
index ca1bb8c5fa..6f62a26fbb 100644
--- a/src/logservice/libobcdc/src/ob_cdc_lob_aux_meta_storager.h
+++ b/src/logservice/libobcdc/src/ob_cdc_lob_aux_meta_storager.h
@@ -31,7 +31,7 @@ struct LobAuxMetaKey
       const transaction::ObTransID &trans_id,
       const uint64_t aux_lob_meta_tid,
       const common::ObLobId &lob_id,
-      const int64_t seq_no) :
+      const transaction::ObTxSEQ &seq_no) :
     tenant_id_(tenant_id),
     trans_id_(trans_id),
     aux_lob_meta_tid_(aux_lob_meta_tid),
@@ -44,7 +44,7 @@ struct LobAuxMetaKey
   {
     return common::OB_INVALID_TENANT_ID != tenant_id_
       && common::OB_INVALID_ID != aux_lob_meta_tid_
-      && seq_no_ > 0;
+      && seq_no_.is_valid();
   }
 
   uint64_t hash() const
@@ -87,7 +87,7 @@ struct LobAuxMetaKey
   transaction::ObTransID trans_id_;
   uint64_t aux_lob_meta_tid_;
   common::ObLobId lob_id_;
-  int64_t seq_no_;
+  transaction::ObTxSEQ seq_no_;
 };
 
 struct LobAuxMetaValue
diff --git a/src/logservice/libobcdc/src/ob_cdc_lob_ctx.h b/src/logservice/libobcdc/src/ob_cdc_lob_ctx.h
index 21e5e32811..e8da1d19d1 100644
--- a/src/logservice/libobcdc/src/ob_cdc_lob_ctx.h
+++ b/src/logservice/libobcdc/src/ob_cdc_lob_ctx.h
@@ -144,7 +144,7 @@ struct LobColumnFragmentCtx
   LobColumnFragmentCtx(ObLobDataGetCtx &host) :
     host_(host),
     is_new_col_(0),
-    seq_no_(0),
+    seq_no_(),
     idx_(-1),
     ref_cnt_(-1),
     next_(nullptr)
@@ -152,7 +152,7 @@ struct LobColumnFragmentCtx
 
   void reset(
     const bool is_new_col,
-    const int64_t seq_no,
+    const transaction::ObTxSEQ &seq_no,
     const uint32_t idx,
     const uint32_t ref_cnt)
   {
@@ -164,7 +164,7 @@ struct LobColumnFragmentCtx
 
   bool is_valid() const
   {
-    return (0 != seq_no_) && (idx_ < ref_cnt_);
+    return seq_no_.is_valid() && (idx_ < ref_cnt_);
   }
 
   LobColumnFragmentCtx *get_next() { return next_; }
@@ -179,7 +179,7 @@ struct LobColumnFragmentCtx
 
   ObLobDataGetCtx &host_;
   int8_t is_new_col_ : 1;
-  int64_t seq_no_;
+  transaction::ObTxSEQ seq_no_;
   uint64_t idx_ : 32;
   uint64_t ref_cnt_ : 32;
   LobColumnFragmentCtx *next_;
diff --git a/src/logservice/libobcdc/src/ob_cdc_lob_data_merger.cpp b/src/logservice/libobcdc/src/ob_cdc_lob_data_merger.cpp
index 23d733f51d..730a6e957a 100644
--- a/src/logservice/libobcdc/src/ob_cdc_lob_data_merger.cpp
+++ b/src/logservice/libobcdc/src/ob_cdc_lob_data_merger.cpp
@@ -211,7 +211,7 @@ int ObCDCLobDataMerger::push_lob_column_(
   } else {
     LOG_DEBUG("push_lob_column_", K(lob_data_get_ctx), K(lob_data_out_row_ctx_list));
     const bool is_empty_sql = (ObLobDataOutRowCtx::OpType::EMPTY_SQL == lob_data_out_row_ctx->op_);
-    uint64_t seq_no_st = lob_data_out_row_ctx->seq_no_st_;
+    const auto seq_no_st = transaction::ObTxSEQ::cast_from_int(lob_data_out_row_ctx->seq_no_st_);
     const uint32_t seq_no_cnt = lob_data_out_row_ctx->seq_no_cnt_;
     const uint32_t del_seq_no_cnt = lob_data_out_row_ctx->del_seq_no_cnt_;
     LobColumnFragmentCtxList new_lob_col_fra_ctx_list;
@@ -293,14 +293,14 @@ int ObCDCLobDataMerger::push_lob_column_(
 
 int ObCDCLobDataMerger::get_lob_col_fra_ctx_list_(
     const bool is_new_col,
-    const uint64_t seq_no_start,
+    const transaction::ObTxSEQ &seq_no_start,
     const uint32_t seq_no_cnt,
     ObIAllocator &allocator,
     ObLobDataGetCtx &lob_data_get_ctx,
     LobColumnFragmentCtxList &lob_col_fra_ctx_list)
 {
   int ret = OB_SUCCESS;
-  uint64_t seq_no = seq_no_start;
+  transaction::ObTxSEQ seq_no = seq_no_start;
 
   for (int64_t idx = 0; OB_SUCC(ret) && idx < seq_no_cnt; ++idx, ++seq_no) {
     LobColumnFragmentCtx *lob_col_fragment_ctx
diff --git a/src/logservice/libobcdc/src/ob_cdc_lob_data_merger.h b/src/logservice/libobcdc/src/ob_cdc_lob_data_merger.h
index 886a9dd78f..490393b3ea 100644
--- a/src/logservice/libobcdc/src/ob_cdc_lob_data_merger.h
+++ b/src/logservice/libobcdc/src/ob_cdc_lob_data_merger.h
@@ -83,7 +83,7 @@ private:
       volatile bool &stop_flag);
   int get_lob_col_fra_ctx_list_(
       const bool is_new_col,
-      const uint64_t seq_no_start,
+      const transaction::ObTxSEQ &seq_no_start,
       const uint32_t seq_no_cnt,
       ObIAllocator &allocator,
       ObLobDataGetCtx &lob_data_get_ctx,
diff --git a/src/logservice/libobcdc/src/ob_log_formatter.cpp b/src/logservice/libobcdc/src/ob_log_formatter.cpp
index f284728d18..41691e5ddf 100644
--- a/src/logservice/libobcdc/src/ob_log_formatter.cpp
+++ b/src/logservice/libobcdc/src/ob_log_formatter.cpp
@@ -2109,7 +2109,7 @@ int ObLogFormatter::parse_aux_lob_meta_table_insert_(
     const transaction::ObTransID &trans_id = log_entry_task.get_trans_id();
     const uint64_t aux_lob_meta_table_id = stmt_task.get_table_id();
     ObLobId lob_id;
-    int64_t row_seq_no = stmt_task.get_row_seq_no();
+    const ObTxSEQ &row_seq_no = stmt_task.get_row_seq_no();
     const char *lob_data = nullptr;
     int64_t lob_data_len = 0;
     ObCDCLobAuxMetaStorager &lob_aux_meta_storager = TCTX.lob_aux_meta_storager_;
@@ -2143,7 +2143,7 @@ int ObLogFormatter::parse_aux_lob_meta_table_delete_(
     const transaction::ObTransID &trans_id = log_entry_task.get_trans_id();
     const uint64_t aux_lob_meta_table_id = stmt_task.get_table_id();
     ObLobId lob_id;
-    int64_t row_seq_no = stmt_task.get_row_seq_no();
+    const transaction::ObTxSEQ &row_seq_no = stmt_task.get_row_seq_no();
     const char *lob_data = nullptr;
     int64_t lob_data_len = 0;
     ObCDCLobAuxMetaStorager &lob_aux_meta_storager = TCTX.lob_aux_meta_storager_;
diff --git a/src/logservice/libobcdc/src/ob_log_part_trans_parser.cpp b/src/logservice/libobcdc/src/ob_log_part_trans_parser.cpp
index c37a4ad937..98b418e8de 100644
--- a/src/logservice/libobcdc/src/ob_log_part_trans_parser.cpp
+++ b/src/logservice/libobcdc/src/ob_log_part_trans_parser.cpp
@@ -527,7 +527,7 @@ int ObLogPartTransParser::check_row_need_rollback_(
   int ret = OB_SUCCESS;
   need_rollback = false;
   const RollbackList &rollback_list = part_trans_task.get_rollback_list();
-  const int64_t row_seq_no = row.seq_no_;
+  const auto &row_seq_no = row.seq_no_;
   const RollbackNode *rollback_node = rollback_list.head_;
 
   while (OB_SUCC(ret) && OB_NOT_NULL(rollback_node) && ! need_rollback) {
@@ -790,7 +790,7 @@ int ObLogPartTransParser::parse_ddl_lob_aux_stmts_(
       const uint64_t tenant_id = part_trans_task.get_tenant_id();
       const transaction::ObTransID &trans_id = part_trans_task.get_trans_id();
       ObLobId lob_id;
-      int64_t row_seq_no = stmt_task->get_row_seq_no();
+      const transaction::ObTxSEQ &row_seq_no = stmt_task->get_row_seq_no();
       const char *lob_data = nullptr;
       int64_t lob_data_len = 0;
       ObCDCLobAuxMetaStorager &lob_aux_meta_storager = TCTX.lob_aux_meta_storager_;
@@ -862,7 +862,7 @@ int ObLogPartTransParser::parse_dml_stmts_(
   return ret;
 }
 
-int64_t ObLogPartTransParser::get_row_seq_(PartTransTask &task, MutatorRow &row) const
+const transaction::ObTxSEQ &ObLogPartTransParser::get_row_seq_(PartTransTask &task, MutatorRow &row) const
 {
   //return task.is_cluster_version_before_320() ? row.sql_no_ : row.seq_no_;
   return row.seq_no_;
diff --git a/src/logservice/libobcdc/src/ob_log_part_trans_parser.h b/src/logservice/libobcdc/src/ob_log_part_trans_parser.h
index 51fa05f044..2f8ab17d54 100644
--- a/src/logservice/libobcdc/src/ob_log_part_trans_parser.h
+++ b/src/logservice/libobcdc/src/ob_log_part_trans_parser.h
@@ -131,7 +131,7 @@ private:
       MutatorRow &row,
       ObLogEntryTask &redo_log_entry_task,
       PartTransTask &part_trans_task);
-  int64_t get_row_seq_(PartTransTask &task, MutatorRow &row) const;
+  const transaction::ObTxSEQ &get_row_seq_(PartTransTask &task, MutatorRow &row) const;
   int alloc_mutator_row_(
       PartTransTask &part_trans_task,
       ObLogEntryTask &redo_log_entry_task,
@@ -151,7 +151,6 @@ private:
       MutatorRow *&row,
       ObCDCTableInfo &table_info,
       bool &is_ignored);
-
 private:
   bool              inited_;
   IObLogBRPool      *br_pool_;
diff --git a/src/logservice/libobcdc/src/ob_log_part_trans_task.cpp b/src/logservice/libobcdc/src/ob_log_part_trans_task.cpp
index f56fd080d8..501dcf878c 100644
--- a/src/logservice/libobcdc/src/ob_log_part_trans_task.cpp
+++ b/src/logservice/libobcdc/src/ob_log_part_trans_task.cpp
@@ -2403,7 +2403,7 @@ int PartTransTask::push_redo_log(
   return ret;
 }
 
-int PartTransTask::push_rollback_to_info(const palf::LSN &lsn, const int64_t rollback_from, const int64_t rollback_to)
+int PartTransTask::push_rollback_to_info(const palf::LSN &lsn, const ObTxSEQ &rollback_from, const ObTxSEQ &rollback_to)
 {
   int ret = OB_SUCCESS;
   RollbackNode *rollback_node = static_cast<RollbackNode*>(allocator_.alloc(sizeof(RollbackNode)));
diff --git a/src/logservice/libobcdc/src/ob_log_part_trans_task.h b/src/logservice/libobcdc/src/ob_log_part_trans_task.h
index 75f5846e67..bd7ea539c0 100644
--- a/src/logservice/libobcdc/src/ob_log_part_trans_task.h
+++ b/src/logservice/libobcdc/src/ob_log_part_trans_task.h
@@ -466,7 +466,7 @@ public:
 
   ObLogEntryTask &get_redo_log_entry_task() { return log_entry_task_; }
 
-  int64_t get_row_seq_no() const { return row_.seq_no_; }
+  const transaction::ObTxSEQ get_row_seq_no() const { return row_.seq_no_; }
 
   bool is_callback() const { return 1 == is_callback_; }
   void mark_callback() { is_callback_ = 1; }
@@ -550,7 +550,7 @@ public:
   uint64_t get_op_tablegroup_id() const { return ddl_op_tablegroup_id_; }
   int64_t get_op_schema_version() const { return ddl_op_schema_version_; }
   uint64_t get_exec_tenant_id() const { return ddl_exec_tenant_id_; }
-  int64_t get_row_seq_no() const { return row_.seq_no_; }
+  const transaction::ObTxSEQ &get_row_seq_no() const { return row_.seq_no_; }
 
 public:
   // tennat_id(UINT64_MAX: 20) + schema_version(INT64_MAX:19)
@@ -797,13 +797,13 @@ public:
    * 1. lsn of rollback_to should push into all_recorded_lsns(ObTxRollbackToLog should has independent LogEntry)
    * 2. construct RollbackNode and push into rollback_list_
    * @param {LSN} &lsn lsn of ObTxRollbackToLog
-   * @param {int64_t} rollback_from
-   * @param {int64_t} rollback_to
+   * @param {ObTxSEQ} rollback_from
+   * @param {ObTxSEQ} rollback_to
    * @retval OB_ENTRY_EXIST: the tollback_to node already recorded
    * @retval OB_SUCCESS: op succ
    * @retval other error code: op fail by other reason
    */
-  int push_rollback_to_info(const palf::LSN &lsn, const int64_t rollback_from, const int64_t rollback_to);
+  int push_rollback_to_info(const palf::LSN &lsn, const transaction::ObTxSEQ &rollback_from, const transaction::ObTxSEQ &rollback_to);
 
   /// set PartTrans Commit Info
   /// @param [in] trace_id              app trace id
diff --git a/src/logservice/libobcdc/src/ob_log_rollback_section.cpp b/src/logservice/libobcdc/src/ob_log_rollback_section.cpp
index 8887c4b98c..b20ebde119 100644
--- a/src/logservice/libobcdc/src/ob_log_rollback_section.cpp
+++ b/src/logservice/libobcdc/src/ob_log_rollback_section.cpp
@@ -20,7 +20,7 @@ namespace libobcdc
 {
 using namespace oceanbase::common;
 
-RollbackNode::RollbackNode(const int64_t rollback_from_seq, const int64_t rollback_to_seq)
+RollbackNode::RollbackNode(const transaction::ObTxSEQ &rollback_from_seq, const transaction::ObTxSEQ &rollback_to_seq)
   : from_seq_(rollback_from_seq),
     to_seq_(rollback_to_seq)
 {
@@ -28,16 +28,16 @@ RollbackNode::RollbackNode(const int64_t rollback_from_seq, const int64_t rollba
 
 RollbackNode::~RollbackNode()
 {
-  from_seq_ = -1;
-  to_seq_ = -1;
+  from_seq_.reset();
+  to_seq_.reset();
 }
 
 bool RollbackNode::is_valid() const
 {
-  return from_seq_ >= 0 && to_seq_ >= 0 && from_seq_ >= to_seq_;
+  return from_seq_.is_valid() && to_seq_.is_valid() && from_seq_ > to_seq_;
 }
 
-bool RollbackNode::should_rollback_stmt(const int64_t stmt_seq_no) const
+bool RollbackNode::should_rollback_stmt(const transaction::ObTxSEQ &stmt_seq_no) const
 {
   // note: from_seq is large than to_seq
   return from_seq_ >= stmt_seq_no && to_seq_ < stmt_seq_no;
diff --git a/src/logservice/libobcdc/src/ob_log_rollback_section.h b/src/logservice/libobcdc/src/ob_log_rollback_section.h
index 9c458be243..3ac6e58a69 100644
--- a/src/logservice/libobcdc/src/ob_log_rollback_section.h
+++ b/src/logservice/libobcdc/src/ob_log_rollback_section.h
@@ -16,6 +16,7 @@
 #include "ob_log_lighty_list.h"                     // LightyList
 #include "lib/queue/ob_link.h"                      // ObLink
 #include "lib/container/ob_array_iterator.h"        // ObArray
+#include "storage/tx/ob_trans_define.h"             // ObTxSEQ
 
 namespace oceanbase
 {
@@ -25,22 +26,22 @@ namespace libobcdc
 class RollbackNode : public common::ObLink
 {
 public:
-  RollbackNode(const int64_t rollback_from_seq, const int64_t rollback_to_seq);
+  RollbackNode(const transaction::ObTxSEQ &rollback_from_seq, const transaction::ObTxSEQ &rollback_to_seq);
   ~RollbackNode();
 
 public:
   bool is_valid() const;
   void set_next(RollbackNode* next) { next_ = next; }
   const RollbackNode *get_next() const { return static_cast<RollbackNode*>(next_); }
-  int64_t get_rollback_from_seq() const { return from_seq_; }
-  int64_t get_rollback_to_seq() const { return to_seq_; }
-  bool should_rollback_stmt(const int64_t stmt_seq_no) const;
+  const transaction::ObTxSEQ &get_rollback_from_seq() const { return from_seq_; }
+  const transaction::ObTxSEQ &get_rollback_to_seq() const { return to_seq_; }
+  bool should_rollback_stmt(const transaction::ObTxSEQ &stmt_seq_no) const;
 
   TO_STRING_KV(K_(from_seq), K_(to_seq));
 private:
-  // from_seq_ >= to_seq_
-  int64_t from_seq_;
-  int64_t to_seq_;
+  // from_seq_ > to_seq_
+  transaction::ObTxSEQ from_seq_;
+  transaction::ObTxSEQ to_seq_;
 };
 
 // Rollback algorithm:
diff --git a/src/logservice/libobcdc/src/ob_log_trans_log.cpp b/src/logservice/libobcdc/src/ob_log_trans_log.cpp
index 04949e1ca0..3889653439 100644
--- a/src/logservice/libobcdc/src/ob_log_trans_log.cpp
+++ b/src/logservice/libobcdc/src/ob_log_trans_log.cpp
@@ -253,13 +253,13 @@ int DmlRedoLogNode::set_data_info(char *data, int64_t data_len)
   return ret;
 }
 
-void RedoSortedProgress::set_sorted_row_seq_no(const int64_t row_seq_no)
+void RedoSortedProgress::set_sorted_row_seq_no(const transaction::ObTxSEQ &row_seq_no)
 {
-  if (row_seq_no < ATOMIC_LOAD(&sorted_row_seq_no_)) {
+  if (row_seq_no < sorted_row_seq_no_.atomic_load()) {
     // TODO PDML may cause row_seq_no rollback
     LOG_WARN_RET(OB_STATE_NOT_MATCH, "row_seq_no rollbacked! check if PDML sence", K(row_seq_no), K_(sorted_row_seq_no));
   }
-  ATOMIC_STORE(&sorted_row_seq_no_, row_seq_no);
+  sorted_row_seq_no_.atomic_store(row_seq_no);
 }
 
 int SortedRedoLogList::push(const bool is_data_in_memory,
diff --git a/src/logservice/libobcdc/src/ob_log_trans_log.h b/src/logservice/libobcdc/src/ob_log_trans_log.h
index b59398657c..3de84f5f60 100644
--- a/src/logservice/libobcdc/src/ob_log_trans_log.h
+++ b/src/logservice/libobcdc/src/ob_log_trans_log.h
@@ -295,20 +295,20 @@ public:
   {
     ATOMIC_SET(&dispatched_redo_count_, 0);
     ATOMIC_SET(&sorted_redo_count_, 0);
-    ATOMIC_SET(&sorted_row_seq_no_, 0);
+    sorted_row_seq_no_.atomic_reset();
   }
   void reset_for_sys_ls_dml_trans(const int64_t redo_node_count)
   {
     ATOMIC_SET(&dispatched_redo_count_, redo_node_count);
     ATOMIC_SET(&sorted_redo_count_, redo_node_count);
-    ATOMIC_SET(&sorted_row_seq_no_, 0);
+    sorted_row_seq_no_.atomic_reset();
   }
   OB_INLINE int64_t get_dispatched_redo_count() const { return ATOMIC_LOAD(&dispatched_redo_count_); }
   OB_INLINE void inc_dispatched_redo_count() { ATOMIC_INC(&dispatched_redo_count_); }
   OB_INLINE int64_t get_sorted_redo_count() const { return ATOMIC_LOAD(&sorted_redo_count_); }
   OB_INLINE void inc_sorted_redo_count() { ATOMIC_INC(&sorted_redo_count_); }
-  OB_INLINE int64_t get_sorted_row_seq_no() const { return ATOMIC_LOAD(&sorted_row_seq_no_); }
-  void set_sorted_row_seq_no(const int64_t row_seq_no);
+  OB_INLINE transaction::ObTxSEQ get_sorted_row_seq_no() const { return sorted_row_seq_no_.atomic_load(); }
+  void set_sorted_row_seq_no(const transaction::ObTxSEQ &row_seq_no);
   OB_INLINE int64_t get_dispatched_not_sort_redo_count() const
   { return ATOMIC_LOAD(&dispatched_redo_count_) - ATOMIC_LOAD(&sorted_redo_count_); }
 public:
@@ -319,7 +319,7 @@ public:
 private:
   int64_t dispatched_redo_count_;
   int64_t sorted_redo_count_;
-  int64_t sorted_row_seq_no_;
+  transaction::ObTxSEQ sorted_row_seq_no_;
 };
 
 class IStmtTask;
@@ -392,7 +392,7 @@ struct SortedRedoLogList
   OB_INLINE bool has_dispatched_but_unsorted_redo() const
   { return sorted_progress_.get_dispatched_not_sort_redo_count() > 0; }
 
-  OB_INLINE void set_sorted_row_seq_no(const int64_t row_seq_no) { sorted_progress_.set_sorted_row_seq_no(row_seq_no); }
+  OB_INLINE void set_sorted_row_seq_no(const transaction::ObTxSEQ &row_seq_no) { sorted_progress_.set_sorted_row_seq_no(row_seq_no); }
 
   bool is_dml_stmt_iter_end() const { return is_dml_stmt_iter_end_; }
 
diff --git a/src/observer/table/ob_table_insert_up_executor.cpp b/src/observer/table/ob_table_insert_up_executor.cpp
index 83ae00f1ee..8bbeb3690b 100644
--- a/src/observer/table/ob_table_insert_up_executor.cpp
+++ b/src/observer/table/ob_table_insert_up_executor.cpp
@@ -586,7 +586,7 @@ int ObTableApiInsertUpExecutor::get_next_row()
 
   while (OB_SUCC(ret) && !is_iter_end) {
     int64_t insert_rows = 0;
-    int64_t savepoint_no = 0;
+    transaction::ObTxSEQ savepoint_no;
     // must set conflict_row fetch flag
     set_need_fetch_conflict();
     if (OB_FAIL(ObSqlTransControl::create_anonymous_savepoint(exec_ctx_, savepoint_no))) {
diff --git a/src/observer/table/ob_table_replace_executor.cpp b/src/observer/table/ob_table_replace_executor.cpp
index 830ee6a6bd..d1f00ba8cf 100644
--- a/src/observer/table/ob_table_replace_executor.cpp
+++ b/src/observer/table/ob_table_replace_executor.cpp
@@ -301,7 +301,7 @@ int ObTableApiReplaceExecutor::get_next_row()
   bool is_iter_end = false;
 
   while (OB_SUCC(ret) && !is_iter_end) {
-    int64_t savepoint_no = 0;
+    transaction::ObTxSEQ savepoint_no;
     set_need_fetch_conflict();
     if (OB_FAIL(ObSqlTransControl::create_anonymous_savepoint(exec_ctx_, savepoint_no))) {
       LOG_WARN("fail to create save_point", K(ret));
diff --git a/src/observer/virtual_table/ob_all_virtual_obj_lock.cpp b/src/observer/virtual_table/ob_all_virtual_obj_lock.cpp
index ad59c39f86..cdb0eebb0b 100644
--- a/src/observer/virtual_table/ob_all_virtual_obj_lock.cpp
+++ b/src/observer/virtual_table/ob_all_virtual_obj_lock.cpp
@@ -284,7 +284,7 @@ int ObAllVirtualObjLock::process_curr_tenant(ObNewRow *&row)
         case EXTRA_INFO:
           snprintf(lock_op_extra_info_, sizeof(lock_op_extra_info_),
                    "count:%ld, position:%s",
-                   ((lock_op.op_type_ == IN_TRANS_DML_LOCK && !is_iter_tx_) ? lock_op.lock_seq_no_ : 0),
+                   ((lock_op.op_type_ == IN_TRANS_DML_LOCK && !is_iter_tx_) ? lock_op.lock_seq_no_.cast_to_int() : 0),
                    is_iter_tx_ ? "tx_ctx" : "lock_table");
           lock_op_extra_info_[MAX_LOCK_OP_EXTRA_INFO_LENGTH - 1] = '\0';
           cur_row_.cells_[i].set_varchar(lock_op_extra_info_);
diff --git a/src/share/ob_lob_access_utils.cpp b/src/share/ob_lob_access_utils.cpp
index e734b9b1ff..64491744d2 100644
--- a/src/share/ob_lob_access_utils.cpp
+++ b/src/share/ob_lob_access_utils.cpp
@@ -146,9 +146,9 @@ static int init_lob_access_param(storage::ObLobAccessParam &param,
   } else if (OB_FAIL(lob_iter_ctx->locator_.get_location_info(location_info))) {
   } else {
     param.tx_desc_ = NULL;
-    param.snapshot_.core_.tx_id_ = tx_info->tx_id_;
-    param.snapshot_.core_.version_.convert_for_tx(tx_info->version_);
-    param.snapshot_.core_.scn_ = tx_info->scn_;
+    param.snapshot_.core_.tx_id_ = tx_info->snapshot_tx_id_;
+    param.snapshot_.core_.version_.convert_for_tx(tx_info->snapshot_version_);
+    param.snapshot_.core_.scn_ = transaction::ObTxSEQ::cast_from_int(tx_info->snapshot_seq_);
     param.snapshot_.valid_= true;
     param.snapshot_.source_ = transaction::ObTxReadSnapshot::SRC::LS;
     param.snapshot_.snapshot_lsid_ = share::ObLSID(location_info->ls_id_);
diff --git a/src/sql/das/ob_das_context.h b/src/sql/das/ob_das_context.h
index 620c7240e4..0408f8e96d 100644
--- a/src/sql/das/ob_das_context.h
+++ b/src/sql/das/ob_das_context.h
@@ -49,7 +49,7 @@ public:
       related_tablet_map_(allocator),
       allocator_(allocator),
       snapshot_(),
-      savepoint_(0),
+      savepoint_(),
       del_ctx_list_(allocator),
       jump_read_group_id_(-1),
       flags_(0)
@@ -85,8 +85,8 @@ public:
   int64_t get_related_tablet_cnt() const;
   void set_snapshot(const transaction::ObTxReadSnapshot &snapshot) { snapshot_ = snapshot; }
   transaction::ObTxReadSnapshot &get_snapshot() { return snapshot_; }
-  int64_t get_savepoint() const { return savepoint_; }
-  void set_savepoint(const int64_t savepoint) { savepoint_ = savepoint; }
+  transaction::ObTxSEQ get_savepoint() const { return savepoint_; }
+  void set_savepoint(const transaction::ObTxSEQ savepoint) { savepoint_ = savepoint; }
   ObDASLocationRouter &get_location_router() { return location_router_; }
   int build_related_tablet_loc(ObDASTabletLoc &tablet_loc);
   int build_related_table_loc(ObDASTableLoc &table_loc);
@@ -127,7 +127,7 @@ private:
   DASRelatedTabletMap related_tablet_map_;
   common::ObIAllocator &allocator_;
   transaction::ObTxReadSnapshot snapshot_;           // Mvcc snapshot
-  int64_t savepoint_;                                // DML savepoint
+  transaction::ObTxSEQ savepoint_;                   // DML savepoint
   //@todo: save snapshot version
   DASDelCtxList del_ctx_list_;
 public:
diff --git a/src/sql/engine/dml/ob_dml_service.cpp b/src/sql/engine/dml/ob_dml_service.cpp
index 0a4d7a0fd1..a168735712 100644
--- a/src/sql/engine/dml/ob_dml_service.cpp
+++ b/src/sql/engine/dml/ob_dml_service.cpp
@@ -1657,7 +1657,7 @@ int ObDMLService::convert_exprs_to_stored_row(ObIAllocator &allocator,
 }
 
 int ObDMLService::catch_violate_error(int err_ret,
-                                      int64_t savepoint_no,
+                                      transaction::ObTxSEQ savepoint_no,
                                       ObDMLRtCtx &dml_rtctx,
                                       ObErrLogRtDef &err_log_rt_def,
                                       ObErrLogCtDef &error_logging_ctdef,
@@ -1848,7 +1848,7 @@ int ObDMLService::check_nested_sql_legality(ObExecContext &ctx, common::ObTableI
   return ret;
 }
 
-int ObDMLService::create_anonymous_savepoint(ObTxDesc &tx_desc, int64_t &savepoint)
+int ObDMLService::create_anonymous_savepoint(ObTxDesc &tx_desc, transaction::ObTxSEQ &savepoint)
 {
   int ret = OB_SUCCESS;
   if (OB_FAIL(ObSqlTransControl::create_anonymous_savepoint(tx_desc, savepoint))) {
@@ -1857,7 +1857,7 @@ int ObDMLService::create_anonymous_savepoint(ObTxDesc &tx_desc, int64_t &savepoi
   return ret;
 }
 
-int ObDMLService::rollback_local_savepoint(ObTxDesc &tx_desc, int64_t savepoint, int64_t expire_ts)
+int ObDMLService::rollback_local_savepoint(ObTxDesc &tx_desc, const transaction::ObTxSEQ savepoint, int64_t expire_ts)
 {
   int ret = OB_SUCCESS;
   ObTransService *tx = MTL(transaction::ObTransService*);
diff --git a/src/sql/engine/dml/ob_dml_service.h b/src/sql/engine/dml/ob_dml_service.h
index 7afb5f5870..c5b23f9d2d 100644
--- a/src/sql/engine/dml/ob_dml_service.h
+++ b/src/sql/engine/dml/ob_dml_service.h
@@ -186,7 +186,7 @@ public:
                                          const ObExprPtrIArray &exprs,
                                          ObChunkDatumStore::StoredRow *&new_row);
   static int catch_violate_error(int err_ret,
-                                 int64_t savepoint_no,
+                                 transaction::ObTxSEQ savepoint_no,
                                  ObDMLRtCtx &dml_rtctx,
                                  ObErrLogRtDef &err_log_rt_def,
                                  ObErrLogCtDef &error_logging_ctdef,
@@ -209,9 +209,9 @@ public:
   static int set_heap_table_hidden_pk(const ObInsCtDef &ins_ctdef,
                                       const common::ObTabletID &tablet_id,
                                       ObEvalCtx &eval_ctx);
-  static int create_anonymous_savepoint(transaction::ObTxDesc &tx_desc, int64_t &savepoint);
+  static int create_anonymous_savepoint(transaction::ObTxDesc &tx_desc, transaction::ObTxSEQ &savepoint);
   static int rollback_local_savepoint(transaction::ObTxDesc &tx_desc,
-                                      int64_t savepoint,
+                                      const transaction::ObTxSEQ savepoint,
                                       int64_t expire_ts);
   static int check_local_index_affected_rows(int64_t table_affected_rows,
                                              int64_t index_affected_rows,
@@ -364,7 +364,7 @@ int ObDASIndexDMLAdaptor<N, DMLIterator>::write_tablet_with_ignore(DMLIterator &
     LOG_WARN("begin write iterator failed", K(ret));
   }
   while (OB_SUCC(ret) && OB_SUCC(write_iter.get_next_row(dml_row))) {
-    int64_t savepoint_no = 0;
+    transaction::ObTxSEQ savepoint_no;
     int64_t table_affected_rows = 0;
     ObDASWriteBuffer single_row_buffer;
     ObDASWriteBuffer::DmlShadowRow dsr;
diff --git a/src/sql/engine/dml/ob_table_insert_op.cpp b/src/sql/engine/dml/ob_table_insert_op.cpp
index f2139e6cf1..3dd3392a14 100644
--- a/src/sql/engine/dml/ob_table_insert_op.cpp
+++ b/src/sql/engine/dml/ob_table_insert_op.cpp
@@ -229,7 +229,7 @@ void ObTableInsertOp::record_err_for_load_data(int err_ret, int row_num)
 OB_INLINE int ObTableInsertOp::insert_row_to_das()
 {
   int ret = OB_SUCCESS;
-  int64_t savepoint_no = 0;
+  transaction::ObTxSEQ savepoint_no;
   NG_TRACE(insert_start);
   // first get next row from child operator
   ObPhysicalPlanCtx *plan_ctx = GET_PHY_PLAN_CTX(ctx_);
diff --git a/src/sql/engine/dml/ob_table_insert_up_op.cpp b/src/sql/engine/dml/ob_table_insert_up_op.cpp
index caf64cfeeb..ad2e9d5b54 100644
--- a/src/sql/engine/dml/ob_table_insert_up_op.cpp
+++ b/src/sql/engine/dml/ob_table_insert_up_op.cpp
@@ -838,7 +838,7 @@ int ObTableInsertUpOp::do_insert_up()
   bool is_iter_end = false;
   while (OB_SUCC(ret) && !is_iter_end) {
     int64_t insert_rows = 0;
-    int64_t savepoint_no = 0;
+    transaction::ObTxSEQ savepoint_no;
     // must set conflict_row fetch flag
     add_need_conflict_result_flag();
     NG_TRACE_TIMES(2, insert_up_load_all_row);
diff --git a/src/sql/engine/dml/ob_table_lock_op.cpp b/src/sql/engine/dml/ob_table_lock_op.cpp
index 986448bad8..ade08630c5 100644
--- a/src/sql/engine/dml/ob_table_lock_op.cpp
+++ b/src/sql/engine/dml/ob_table_lock_op.cpp
@@ -119,7 +119,7 @@ ObTableLockOp::ObTableLockOp(ObExecContext &exec_ctx,
                              const ObOpSpec &spec,
                              ObOpInput *input)
   : ObTableModifyOp(exec_ctx, spec, input),
-    savepoint_no_(0),
+    savepoint_no_(),
     need_return_row_(false)
 {
 }
diff --git a/src/sql/engine/dml/ob_table_lock_op.h b/src/sql/engine/dml/ob_table_lock_op.h
index 2f9741fad1..8e9a2dd19a 100644
--- a/src/sql/engine/dml/ob_table_lock_op.h
+++ b/src/sql/engine/dml/ob_table_lock_op.h
@@ -125,7 +125,7 @@ protected:
   int submit_row_by_strategy();
 
 protected:
-  int64_t savepoint_no_;
+  transaction::ObTxSEQ savepoint_no_;
   LockRtDef2DArray lock_rtdefs_;
   bool need_return_row_;
 };
diff --git a/src/sql/engine/dml/ob_table_replace_op.cpp b/src/sql/engine/dml/ob_table_replace_op.cpp
index 9c1cb2e724..7aa9225ab5 100644
--- a/src/sql/engine/dml/ob_table_replace_op.cpp
+++ b/src/sql/engine/dml/ob_table_replace_op.cpp
@@ -462,7 +462,7 @@ int ObTableReplaceOp::do_replace_into()
   int ret = OB_SUCCESS;
   bool is_iter_end = false;
   while (OB_SUCC(ret) && !is_iter_end) {
-    int64_t savepoint_no = 0;
+    transaction::ObTxSEQ savepoint_no;
     // must set conflict_row fetch flag
     add_need_conflict_result_flag();
     NG_TRACE_TIMES(2, replace_load_all_row);
diff --git a/src/sql/ob_sql_trans_control.cpp b/src/sql/ob_sql_trans_control.cpp
index 9fec6b6127..3c6f63a159 100644
--- a/src/sql/ob_sql_trans_control.cpp
+++ b/src/sql/ob_sql_trans_control.cpp
@@ -550,7 +550,7 @@ int ObSqlTransControl::start_stmt(ObExecContext &exec_ctx)
     auto &ar_snapshot = audit_record.snapshot_;
     ar_snapshot.version_ = snapshot.core_.version_;
     ar_snapshot.tx_id_ = snapshot.core_.tx_id_.get_id();
-    ar_snapshot.scn_ = snapshot.core_.scn_;
+    ar_snapshot.scn_ = snapshot.core_.scn_.cast_to_int();
     ar_snapshot.source_ = snapshot.get_source_name().ptr();
   }
   if (OB_SUCC(ret) && !session->has_start_stmt()) {
@@ -679,7 +679,7 @@ int ObSqlTransControl::stmt_setup_snapshot_(ObSQLSessionInfo *session,
     auto &tx_desc = *session->get_tx_desc();
     snapshot.init_none_read();
     snapshot.core_.tx_id_ = tx_desc.get_tx_id();
-    snapshot.core_.scn_ = common::ObSequence::get_max_seq_no();
+    snapshot.core_.scn_ = tx_desc.get_tx_seq();
   } else {
     auto &tx_desc = *session->get_tx_desc();
     int64_t stmt_expire_ts = get_stmt_expire_ts(plan_ctx, *session);
@@ -740,7 +740,7 @@ int ObSqlTransControl::stmt_setup_savepoint_(ObSQLSessionInfo *session,
   ObTxParam &tx_param = plan_ctx->get_trans_param();
   OZ (build_tx_param_(session, tx_param));
   auto &tx = *session->get_tx_desc();
-  int64_t savepoint = 0;
+  transaction::ObTxSEQ savepoint;
   OZ (txs->create_implicit_savepoint(tx, tx_param, savepoint, nested_level == 0), tx, tx_param);
   OX (das_ctx.set_savepoint(savepoint));
   return ret;
@@ -950,7 +950,7 @@ int ObSqlTransControl::end_stmt(ObExecContext &exec_ctx, const bool rollback)
   transaction::ObTxDesc *tx_desc = NULL;
   sql::stmt::StmtType stmt_type = sql::stmt::StmtType::T_NONE;
   bool is_plain_select = false;
-  int64_t savepoint = das_ctx.get_savepoint();
+  transaction::ObTxSEQ savepoint = das_ctx.get_savepoint();
 
   CK (OB_NOT_NULL(session), OB_NOT_NULL(plan_ctx));
   CK (OB_NOT_NULL(plan = plan_ctx->get_phy_plan()));
@@ -1047,7 +1047,7 @@ bool ObSqlTransControl::is_isolation_RR_or_SE(ObTxIsolationLevel isolation)
           || isolation == ObTxIsolationLevel::SERIAL);
 }
 
-int ObSqlTransControl::create_anonymous_savepoint(ObExecContext &exec_ctx, int64_t &savepoint)
+int ObSqlTransControl::create_anonymous_savepoint(ObExecContext &exec_ctx, transaction::ObTxSEQ &savepoint)
 {
   int ret = OB_SUCCESS;
   transaction::ObTransService *txs = NULL;
@@ -1060,7 +1060,7 @@ int ObSqlTransControl::create_anonymous_savepoint(ObExecContext &exec_ctx, int64
   return ret;
 }
 
-int ObSqlTransControl::create_anonymous_savepoint(transaction::ObTxDesc &tx_desc, int64_t &savepoint)
+int ObSqlTransControl::create_anonymous_savepoint(transaction::ObTxDesc &tx_desc, transaction::ObTxSEQ &savepoint)
 {
   int ret = OB_SUCCESS;
   transaction::ObTransService *txs = NULL;
@@ -1072,7 +1072,7 @@ int ObSqlTransControl::create_anonymous_savepoint(transaction::ObTxDesc &tx_desc
   return ret;
 }
 
-int ObSqlTransControl::rollback_savepoint(ObExecContext &exec_ctx, const int64_t savepoint)
+int ObSqlTransControl::rollback_savepoint(ObExecContext &exec_ctx, const transaction::ObTxSEQ savepoint)
 {
   int ret = OB_SUCCESS;
   ObSQLSessionInfo *session = GET_MY_SESSION(exec_ctx);
diff --git a/src/sql/ob_sql_trans_control.h b/src/sql/ob_sql_trans_control.h
index 2b588e073d..bd3bbb6e3e 100644
--- a/src/sql/ob_sql_trans_control.h
+++ b/src/sql/ob_sql_trans_control.h
@@ -266,8 +266,8 @@ public:
    * capability:
    *   only support inner stmt savepoint, and can not been used to cross stmt rollback
    */
-  static int create_anonymous_savepoint(ObExecContext &exec_ctx, int64_t &savepoint);
-  static int create_anonymous_savepoint(transaction::ObTxDesc &tx_desc, int64_t &savepoint);
+  static int create_anonymous_savepoint(ObExecContext &exec_ctx, transaction::ObTxSEQ &savepoint);
+  static int create_anonymous_savepoint(transaction::ObTxDesc &tx_desc, transaction::ObTxSEQ &savepoint);
   /*
    * rollback to savepoint
    *
@@ -281,7 +281,7 @@ public:
    * for example: the sql-task executed timeout and its result was unknown, and then do rollback_savepoint;
    *   in this case, the trans_result was incomplete, the flag must been set.
    */
-  static int rollback_savepoint(ObExecContext &exec_ctx, const int64_t savepoint);
+  static int rollback_savepoint(ObExecContext &exec_ctx, const transaction::ObTxSEQ savepoint);
 
   //
   // Transaction free route relative
diff --git a/src/storage/access/ob_dml_param.h b/src/storage/access/ob_dml_param.h
index 67659e967b..7021297f60 100755
--- a/src/storage/access/ob_dml_param.h
+++ b/src/storage/access/ob_dml_param.h
@@ -183,7 +183,7 @@ struct ObDMLBaseParam
         dml_allocator_(nullptr),
         encrypt_meta_(NULL),
         encrypt_meta_legacy_(),
-        spec_seq_no_(-1),
+        spec_seq_no_(),
         snapshot_(),
         direct_insert_task_id_(0),
         write_flag_(),
@@ -212,7 +212,7 @@ struct ObDMLBaseParam
   common::ObSEArray<transaction::ObEncryptMetaCache, 1> encrypt_meta_legacy_;
 
   // specified seq_no
-  int64_t spec_seq_no_;
+  transaction::ObTxSEQ spec_seq_no_;
   // transaction snapshot
   transaction::ObTxReadSnapshot snapshot_;
   int64_t direct_insert_task_id_; // 0 means no direct insert
diff --git a/src/storage/blocksstable/ob_micro_block_row_lock_checker.cpp b/src/storage/blocksstable/ob_micro_block_row_lock_checker.cpp
index 8057cda93b..c6bb5a9ee2 100755
--- a/src/storage/blocksstable/ob_micro_block_row_lock_checker.cpp
+++ b/src/storage/blocksstable/ob_micro_block_row_lock_checker.cpp
@@ -67,17 +67,21 @@ int ObMicroBlockRowLockChecker::get_next_row(const ObDatumRow *&row)
         ObTxTableGuards tx_table_guards = ctx.get_tx_table_guards();
         ObTxTable *tx_table = nullptr;
         int64 read_epoch = ObTxTable::INVALID_READ_EPOCH;
+        transaction::ObTxSEQ tx_sequence = transaction::ObTxSEQ::cast_from_int(sql_sequence);
         if (!tx_table_guards.is_valid()) {
           ret = OB_ERR_UNEXPECTED;
           LOG_ERROR("tx table guard is invalid", KR(ret), K(ctx));
-        } else if (OB_FAIL(tx_table_guards.check_row_locked(read_trans_id, row_header->get_trans_id(), sql_sequence,
-            sstable_->get_end_scn(), *lock_state_))) {
+        } else if (OB_FAIL(tx_table_guards.check_row_locked(read_trans_id,
+                                                            row_header->get_trans_id(),
+                                                            tx_sequence,
+                                                            sstable_->get_end_scn(),
+                                                            *lock_state_))) {
         } else if (lock_state_->is_locked_) {
           lock_state_->lock_dml_flag_ = row_header->get_row_flag().get_dml_flag();
         }
 
         STORAGE_LOG(DEBUG, "check row lock", K(ret), KPC_(range), K(read_trans_id), KPC(row_header),
-                    K(sql_sequence), KPC_(lock_state));
+                    K(tx_sequence), KPC_(lock_state));
         if (SCN::min_scn() != lock_state_->trans_version_ || // trans is commit
             lock_state_->is_locked_) {
           break;
diff --git a/src/storage/blocksstable/ob_micro_block_row_scanner.cpp b/src/storage/blocksstable/ob_micro_block_row_scanner.cpp
index eb275d632b..2cbcb6683b 100644
--- a/src/storage/blocksstable/ob_micro_block_row_scanner.cpp
+++ b/src/storage/blocksstable/ob_micro_block_row_scanner.cpp
@@ -1075,16 +1075,17 @@ int ObMultiVersionMicroBlockRowScanner::inner_inner_get_next_row(
     } else if (flag.is_uncommitted_row()) {
       have_uncommited_row = true;  // TODO @lvling check transaction status instead
       compaction::ObMergeCachedTransState trans_state;
+      transaction::ObTxSEQ tx_sequence = transaction::ObTxSEQ::cast_from_int(sql_sequence);
       if (OB_NOT_NULL(context_->trans_state_mgr_) &&
         OB_SUCCESS == context_->trans_state_mgr_->get_trans_state(
-          transaction::ObTransID(row_header->get_trans_id()), sql_sequence, trans_state)) {
+          transaction::ObTransID(row_header->get_trans_id()), tx_sequence, trans_state)) {
         can_read = trans_state.can_read_;
         trans_version = trans_state.trans_version_;
         is_determined_state = trans_state.is_determined_state_;
       } else {
         transaction::ObLockForReadArg lock_for_read_arg(acc_ctx,
                                                         transaction::ObTransID(row_header->get_trans_id()),
-                                                        sql_sequence,
+                                                        tx_sequence,
                                                         context_->query_flag_.read_latest_,
                                                         sstable_->get_end_scn());
 
@@ -1104,7 +1105,7 @@ int ObMultiVersionMicroBlockRowScanner::inner_inner_get_next_row(
                   acc_ctx.get_tx_table_guards(),
                   acc_ctx.get_tx_id(),
                   transaction::ObTransID(row_header->get_trans_id()),
-                  sql_sequence,
+                  transaction::ObTxSEQ::cast_from_int(sql_sequence),
                   trans_version,
                   snapshot_version,
                   sstable_->get_end_scn(),
@@ -1811,12 +1812,13 @@ int ObMultiVersionMicroBlockMinorMergeRowScanner::read_uncommitted_row(
   } else if (FALSE_IT(read_trans_id_ = row_header->get_trans_id())) {
   } else if (flag.is_uncommitted_row()) { // uncommitted row
     bool read_row_flag = false;
+    transaction::ObTxSEQ tx_sequence = transaction::ObTxSEQ::cast_from_int(sql_sequence);
     if (OB_UNLIKELY(read_trans_id_ != last_trans_id_)) { // another uncommitted trans
       ret = OB_ERR_UNEXPECTED;
       LOG_WARN("Unexpected meet multi uncommitted trans in sstable", K(ret),
                K_(read_trans_id), K_(last_trans_id), KPC(this));
     } else if (FILTER_ABORT_TRANS_ROW != scan_state_
-               && OB_FAIL(check_curr_row_can_read(read_trans_id_, sql_sequence, can_read))) { // same uncommitted trans
+               && OB_FAIL(check_curr_row_can_read(read_trans_id_, tx_sequence, can_read))) { // same uncommitted trans
       LOG_WARN("micro block reader fail to get row.", K(ret), K_(macro_id));
     } else if (!can_read && !flag.is_last_multi_version_row()) { // can't read && not last row
       ++current_; // move forward
@@ -2101,8 +2103,9 @@ int ObMultiVersionMicroBlockMinorMergeRowScanner::find_uncommitted_row()
         int64_t state;
         int64_t commit_trans_version = INT64_MAX;
         compaction::ObMergeCachedTransState trans_state;
+        transaction::ObTxSEQ tx_sequence = transaction::ObTxSEQ::cast_from_int(sql_sequence);
         if (OB_NOT_NULL(context_->trans_state_mgr_) &&
-          OB_SUCCESS == context_->trans_state_mgr_->get_trans_state(last_trans_id_, sql_sequence, trans_state)) {
+          OB_SUCCESS == context_->trans_state_mgr_->get_trans_state(last_trans_id_, tx_sequence, trans_state)) {
           state = trans_state.trans_state_;
           last_trans_state_ = trans_state.trans_state_;
           commit_trans_version = trans_state.trans_version_;
@@ -2258,9 +2261,10 @@ int ObMultiVersionMicroBlockMinorMergeRowScanner::set_trans_version_for_uncommit
   return ret;
 }
 
-int ObMultiVersionMicroBlockMinorMergeRowScanner::check_curr_row_can_read(const transaction::ObTransID &trans_id,
-                                                                          const int64_t sql_seq,
-                                                                          bool &can_read)
+int ObMultiVersionMicroBlockMinorMergeRowScanner::check_curr_row_can_read(
+    const transaction::ObTransID &trans_id,
+    const transaction::ObTxSEQ &sql_seq,
+    bool &can_read)
 {
   int ret = OB_SUCCESS;
   int tmp_ret = OB_SUCCESS;
diff --git a/src/storage/blocksstable/ob_micro_block_row_scanner.h b/src/storage/blocksstable/ob_micro_block_row_scanner.h
index 2cc0d2e5e7..871d60902b 100644
--- a/src/storage/blocksstable/ob_micro_block_row_scanner.h
+++ b/src/storage/blocksstable/ob_micro_block_row_scanner.h
@@ -339,7 +339,7 @@ private:
   void clear_scan_status();
   int prepare_committed_row_queue(const ObDatumRow *&row);
   int get_row_from_row_queue(const ObDatumRow *&row);
-  int check_curr_row_can_read(const transaction::ObTransID &trans_id, const int64_t sql_seq, bool &can_read);
+  int check_curr_row_can_read(const transaction::ObTransID &trans_id, const transaction::ObTxSEQ &sql_seq, bool &can_read);
   int compact_trans_row_into_row_queue();
   int set_trans_version_for_uncommitted_row(ObDatumRow &row);
   int get_trans_state(const transaction::ObTransID &trans_id,
diff --git a/src/storage/compaction/ob_compaction_trans_cache.cpp b/src/storage/compaction/ob_compaction_trans_cache.cpp
index 96120599fd..4614be2cb8 100644
--- a/src/storage/compaction/ob_compaction_trans_cache.cpp
+++ b/src/storage/compaction/ob_compaction_trans_cache.cpp
@@ -57,7 +57,7 @@ void ObCachedTransStateMgr::destroy()
 
 int ObCachedTransStateMgr::get_trans_state(
   const transaction::ObTransID &trans_id,
-  const int64_t sql_seq,
+  const transaction::ObTxSEQ &sql_seq,
   ObMergeCachedTransState &trans_state)
 {
   int ret = OB_SUCCESS;
@@ -81,7 +81,7 @@ int ObCachedTransStateMgr::get_trans_state(
 
 int ObCachedTransStateMgr::add_trans_state(
   const transaction::ObTransID &trans_id,
-  const int64_t sql_seq,
+  const transaction::ObTxSEQ &sql_seq,
   const int64_t commited_trans_version,
   const int32_t trans_state,
   const int16_t can_read,
@@ -103,4 +103,4 @@ int ObCachedTransStateMgr::add_trans_state(
 }
 
 } // namespace compaction
-} // namespace oceanbase
\ No newline at end of file
+} // namespace oceanbase
diff --git a/src/storage/compaction/ob_compaction_trans_cache.h b/src/storage/compaction/ob_compaction_trans_cache.h
index d12cbfd4de..052ebc3041 100644
--- a/src/storage/compaction/ob_compaction_trans_cache.h
+++ b/src/storage/compaction/ob_compaction_trans_cache.h
@@ -32,11 +32,11 @@ namespace compaction
 struct ObMergeCachedTransKey {
   ObMergeCachedTransKey()
     : trans_id_(),
-      sql_sequence_(0)
+      sql_sequence_()
   {}
   ObMergeCachedTransKey(
     transaction::ObTransID trans_id,
-    int64_t sql_sequence)
+    transaction::ObTxSEQ sql_sequence)
     : trans_id_(trans_id),
       sql_sequence_(sql_sequence)
   {}
@@ -48,17 +48,18 @@ struct ObMergeCachedTransKey {
   inline uint64_t hash() const
   {
     uint64_t hash_value = trans_id_.hash();
-    hash_value = murmurhash(&sql_sequence_, sizeof(sql_sequence_), hash_value);
+    uint64_t seq_hash = sql_sequence_.hash();
+    hash_value = murmurhash(&seq_hash, sizeof(seq_hash), hash_value);
     return hash_value;
   }
   inline bool is_valid() const
   {
-    return trans_id_.is_valid() && 0 != sql_sequence_;
+    return trans_id_.is_valid() && sql_sequence_.is_valid();
   }
   TO_STRING_KV(K_(trans_id), K_(sql_sequence));
 
   transaction::ObTransID trans_id_;
-  int64_t sql_sequence_;
+  transaction::ObTxSEQ sql_sequence_;
 };
 
 struct ObMergeCachedTransState {
@@ -71,7 +72,7 @@ struct ObMergeCachedTransState {
   {}
   ObMergeCachedTransState(
     transaction::ObTransID trans_id,
-    int64_t sql_sequence,
+    transaction::ObTxSEQ sql_sequence,
     int64_t trans_version,
     int32_t trans_state,
     int16_t can_read,
@@ -111,10 +112,10 @@ public:
   int init(int64_t max_cnt);
   void destroy();
   inline uint64_t cal_idx(const ObMergeCachedTransKey &key) { return key.hash() % max_cnt_; }
-  int get_trans_state(const transaction::ObTransID &trans_id, const int64_t sql_seq, ObMergeCachedTransState &trans_state);
+  int get_trans_state(const transaction::ObTransID &trans_id, const transaction::ObTxSEQ &sql_seq, ObMergeCachedTransState &trans_state);
   int add_trans_state(
     const transaction::ObTransID &trans_id,
-    const int64_t sql_seq,
+    const transaction::ObTxSEQ &sql_seq,
     const int64_t trans_version,
     const int32_t trans_state,
     const int16_t can_read,
@@ -129,4 +130,4 @@ private:
 } // namespace compaction
 } // namespace oceanbase
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/storage/concurrency_control/ob_trans_stat_row.cpp b/src/storage/concurrency_control/ob_trans_stat_row.cpp
index 7f45b48f69..9fde4eebc5 100644
--- a/src/storage/concurrency_control/ob_trans_stat_row.cpp
+++ b/src/storage/concurrency_control/ob_trans_stat_row.cpp
@@ -54,7 +54,7 @@ void build_trans_stat_(const ObTransStatRow trans_stat_row,
                               trans_stat_row.trans_version_.get_val_for_tx(),
                               trans_stat_row.scn_.get_val_for_tx(),
                               trans_stat_row.trans_id_.get_id(),
-                              trans_stat_row.seq_no_))) {
+                              trans_stat_row.seq_no_.cast_to_int()))) {
     TRANS_LOG(WARN, "failed to printf", K(ret), K(pos), K(trans_stat_len), K(trans_stat_row));
     trans_stat_ptr[0] = '\0';
   } else {
diff --git a/src/storage/concurrency_control/ob_trans_stat_row.h b/src/storage/concurrency_control/ob_trans_stat_row.h
index fcbce3eea8..ec1bd3c08e 100644
--- a/src/storage/concurrency_control/ob_trans_stat_row.h
+++ b/src/storage/concurrency_control/ob_trans_stat_row.h
@@ -29,12 +29,12 @@ public:
     : trans_version_(share::SCN::max_scn()),
     scn_(share::SCN::max_scn()),
     trans_id_(),
-    seq_no_(0) {}
+    seq_no_() {}
 
   void set(const share::SCN trans_version,
            const share::SCN scn,
            const transaction::ObTransID trans_id,
-           const int64_t seq_no)
+           const transaction::ObTxSEQ &seq_no)
   {
     trans_version_ = trans_version;
     scn_ = scn;
@@ -47,14 +47,14 @@ public:
     trans_version_ = share::SCN::max_scn();
     scn_ = share::SCN::max_scn();
     trans_id_.reset();
-    seq_no_ = 0;
+    seq_no_.reset();
   }
 
   TO_STRING_KV(K_(trans_version), K_(scn), K_(trans_id), K_(seq_no));
   share::SCN trans_version_;
   share::SCN scn_;
   transaction::ObTransID trans_id_;
-  int64_t seq_no_;
+  transaction::ObTxSEQ seq_no_;
 public:
   static const int64_t MAX_TRANS_STRING_SIZE = 120;
 };
diff --git a/src/storage/lob/ob_lob_locator.cpp b/src/storage/lob/ob_lob_locator.cpp
index 0402a24f4c..0776ed104b 100644
--- a/src/storage/lob/ob_lob_locator.cpp
+++ b/src/storage/lob/ob_lob_locator.cpp
@@ -31,9 +31,7 @@ ObLobLocatorHelper::ObLobLocatorHelper()
   : table_id_(OB_INVALID_ID),
     tablet_id_(OB_INVALID_ID),
     ls_id_(OB_INVALID_ID),
-    tx_id_(OB_INVALID_ID),
-    snapshot_version_(0),
-    scn_(0),
+    read_snapshot_(),
     rowid_version_(ObURowIDData::INVALID_ROWID_VERSION),
     rowid_project_(nullptr),
     rowid_objs_(),
@@ -53,9 +51,7 @@ void ObLobLocatorHelper::reset()
   table_id_ = OB_INVALID_ID;
   tablet_id_ = OB_INVALID_ID;
   ls_id_ = OB_INVALID_ID;
-  tx_id_ = OB_INVALID_ID;
-  scn_ = 0;
-  snapshot_version_ = 0;
+  read_snapshot_.reset();
   rowid_version_ = ObURowIDData::INVALID_ROWID_VERSION;
   rowid_project_ = nullptr;
   rowid_objs_.reset();
@@ -96,16 +92,14 @@ int ObLobLocatorHelper::init(const ObTableScanParam &scan_param,
       rowid_version_ = table_param.get_rowid_version();
       rowid_project_ = &table_param.get_rowid_projector();
       table_id_ = table_param.get_table_id();
-      snapshot_version_ = snapshot_version;
       tablet_id_ = scan_param.tablet_id_.id();
       ls_id_ = ls_id.id();
-      tx_id_ = scan_param.tx_id_;
-      scn_ = ctx.mvcc_acc_ctx_.snapshot_.scn_;
+      read_snapshot_ = ctx.mvcc_acc_ctx_.snapshot_;
       enable_locator_v2_ = table_param.enable_lob_locator_v2();
-      if (snapshot_version != ctx.mvcc_acc_ctx_.snapshot_.version_.get_val_for_tx()) {
+      if (snapshot_version != read_snapshot_.version_.get_val_for_tx()) {
         ret = OB_ERR_UNEXPECTED;
         STORAGE_LOG(WARN, "snapshot version mismatch",
-          K(snapshot_version), K(ctx.mvcc_acc_ctx_.snapshot_.version_.get_val_for_tx()));
+          K(snapshot_version), K(read_snapshot_));
       } else {
         is_inited_ = true;
       }
@@ -134,8 +128,7 @@ int ObLobLocatorHelper::init(const ObTableStoreStat &table_store_stat,
     table_id_ = table_store_stat.table_id_;
     tablet_id_ = table_store_stat.tablet_id_.id();
     ls_id_ = ls_id.id();
-    tx_id_ = ctx.mvcc_acc_ctx_.snapshot_.tx_id_; // scn?
-    snapshot_version_ = snapshot_version;
+    read_snapshot_ = ctx.mvcc_acc_ctx_.snapshot_;
     enable_locator_v2_ = true; // must be called en locator v2 enabled
     OB_ASSERT(ob_enable_lob_locator_v2() == true);
     is_inited_ = true;
@@ -308,7 +301,9 @@ int ObLobLocatorHelper::fuse_mem_lob_header(ObObj &def_obj, uint64_t col_id, boo
           STORAGE_LOG(WARN, "Lob: init locator in build_lob_locatorv2", K(ret), K(col_id));
         } else if (OB_FAIL(locator.set_payload_data(&lob_common, def_obj.get_string()))) {
         } else if (has_extern) {
-          ObMemLobTxInfo tx_info(snapshot_version_, tx_id_, scn_);
+          ObMemLobTxInfo tx_info(read_snapshot_.version_.get_val_for_tx(),
+                                 read_snapshot_.tx_id_.get_id(),
+                                 read_snapshot_.scn_.cast_to_int());
           ObMemLobLocationInfo location_info(tablet_id_, ls_id_, def_obj.get_collation_type());
           if (OB_FAIL(locator.set_table_info(table_id_, col_id))) { // ToDo: @gehao should be column idx
             STORAGE_LOG(WARN, "Lob: set table info failed", K(ret), K(table_id_), K(col_id));
@@ -422,7 +417,7 @@ int ObLobLocatorHelper::build_lob_locator(common::ObString payload,
       STORAGE_LOG(WARN, "Failed to alloc memory for lob locator", K(ret), K(locator_size));
     } else if (FALSE_IT(MEMSET(buf, 0, locator_size))) {
     } else if (FALSE_IT(locator = reinterpret_cast<ObLobLocator *>(buf))) {
-    } else if (OB_FAIL(locator->init(table_id_, column_id, snapshot_version_,
+    } else if (OB_FAIL(locator->init(table_id_, column_id, read_snapshot_.version_.get_val_for_tx(),
                                      LOB_DEFAULT_FLAGS, rowid_str, payload))) {
       STORAGE_LOG(WARN, "Failed to init lob locator", K(ret), K(*this), K(rowid_str));
     } else {
@@ -515,7 +510,9 @@ int ObLobLocatorHelper::build_lob_locatorv2(ObLobLocatorV2 &locator,
           STORAGE_LOG(WARN, "Lob: fill payload failed", K(ret), K(column_id));
         }
       } else if (has_extern) {
-        ObMemLobTxInfo tx_info(snapshot_version_, tx_id_, scn_);
+        ObMemLobTxInfo tx_info(read_snapshot_.version_.get_val_for_tx(),
+                               read_snapshot_.tx_id_.get_id(),
+                               read_snapshot_.scn_.cast_to_int());
         ObMemLobLocationInfo location_info(tablet_id_, ls_id_, cs_type);
         if (has_extern && OB_FAIL(locator.set_table_info(table_id_, column_id))) { // should be column idx
           STORAGE_LOG(WARN, "Lob: set table info failed", K(ret), K(table_id_), K(column_id));
@@ -567,9 +564,7 @@ int ObLobLocatorHelper::build_lob_locatorv2(ObLobLocatorV2 &locator,
             ObArenaAllocator tmp_lob_allocator(ObModIds::OB_LOB_READER, OB_MALLOC_NORMAL_BLOCK_SIZE, MTL_ID());
             ObLobAccessParam param;
             param.tx_desc_ = NULL;
-            param.snapshot_.core_.tx_id_ = tx_id_;
-            param.snapshot_.core_.version_.convert_for_tx(snapshot_version_);
-            param.snapshot_.core_.scn_ = scn_;
+            param.snapshot_.core_ = read_snapshot_;
             param.snapshot_.valid_= true;
             param.snapshot_.source_ = transaction::ObTxReadSnapshot::SRC::LS;
             param.snapshot_.snapshot_lsid_ = share::ObLSID(ls_id_);
diff --git a/src/storage/lob/ob_lob_locator.h b/src/storage/lob/ob_lob_locator.h
index 063c22c54e..7d37573e72 100644
--- a/src/storage/lob/ob_lob_locator.h
+++ b/src/storage/lob/ob_lob_locator.h
@@ -81,7 +81,7 @@ private:
   int64_t ls_id_;
   int64_t tx_id_;
   int64_t snapshot_version_;
-  int64_t scn_;
+  transaction::ObTxSnapshot read_snapshot_;
   int64_t rowid_version_;
   const common::ObIArray<int32_t> *rowid_project_; //map to projected row
   common::ObSEArray<common::ObObj, DEFAULT_LOCATOR_OBJ_ARRAY_SIZE> rowid_objs_;
diff --git a/src/storage/lob/ob_lob_manager.cpp b/src/storage/lob/ob_lob_manager.cpp
index 576a1df3cb..037f36ace1 100644
--- a/src/storage/lob/ob_lob_manager.cpp
+++ b/src/storage/lob/ob_lob_manager.cpp
@@ -1054,19 +1054,19 @@ int ObLobManager::init_out_row_ctx(
 {
   int ret = OB_SUCCESS;
   ObLobDataOutRowCtx *out_row_ctx = reinterpret_cast<ObLobDataOutRowCtx*>(param.lob_data_->buffer_);
-  if (param.seq_no_st_ == -1) {
+  if (!param.seq_no_st_.is_valid()) {
     // pre-calc seq_no_cnt and init seq_no_st
     // for insert, most oper len/128K + 2
     // for erase, most oper len/128K + 2
     // for append, most oper len/256K + 1
     // for sql update, calc erase+insert
     int64_t N = ((len + param.update_len_) / (ObLobMetaUtil::LOB_OPER_PIECE_DATA_SIZE / 2) + 2) * 2;
-    param.seq_no_st_ = ObSequence::get_and_inc_max_seq_no(N);
+    param.seq_no_st_ = param.tx_desc_->get_and_inc_tx_seq(param.parent_seq_no_.get_branch(), N);
     param.used_seq_cnt_ = 0;
     param.total_seq_cnt_ = N;
   }
   if (OB_SUCC(ret)) {
-    out_row_ctx->seq_no_st_ = param.seq_no_st_;
+    out_row_ctx->seq_no_st_ = param.seq_no_st_.cast_to_int();
     out_row_ctx->is_full_ = 1;
     out_row_ctx->offset_ = param.offset_;
     out_row_ctx->check_sum_ = param.checksum_;
@@ -3263,12 +3263,13 @@ int ObLobManager::build_lob_param(ObLobAccessParam& param,
         } else if (OB_FAIL(lob.get_location_info(location_info))) {
           LOG_WARN("failed to get location info", K(ret), K(lob));
         } else {
+          auto snapshot_tx_seq = transaction::ObTxSEQ::cast_from_int(tx_info->snapshot_seq_);
           if (OB_ISNULL(param.tx_desc_) ||
-              param.tx_desc_->get_tx_id().get_id() == tx_info->tx_id_ || // read in same tx
-              (tx_info->tx_id_ == 0 && tx_info->scn_ == -1 && tx_info->version_ > 0)) { // read not in tx
-            param.snapshot_.core_.version_.convert_for_tx(tx_info->version_);
-            param.snapshot_.core_.tx_id_ = tx_info->tx_id_;
-            param.snapshot_.core_.scn_ = tx_info->scn_;
+              param.tx_desc_->get_tx_id().get_id() == tx_info->snapshot_tx_id_ || // read in same tx
+              (tx_info->snapshot_tx_id_ == 0 && !snapshot_tx_seq.is_valid() && tx_info->snapshot_version_ > 0)) { // read not in tx
+            param.snapshot_.core_.version_.convert_for_tx(tx_info->snapshot_version_);
+            param.snapshot_.core_.tx_id_ = tx_info->snapshot_tx_id_;
+            param.snapshot_.core_.scn_ = snapshot_tx_seq;
             param.snapshot_.valid_ = true;
             param.snapshot_.source_ = transaction::ObTxReadSnapshot::SRC::LS;
             param.snapshot_.snapshot_lsid_ = share::ObLSID(location_info->ls_id_);
diff --git a/src/storage/lob/ob_lob_persistent_adaptor.cpp b/src/storage/lob/ob_lob_persistent_adaptor.cpp
index b8dcc4c277..7032f75c59 100644
--- a/src/storage/lob/ob_lob_persistent_adaptor.cpp
+++ b/src/storage/lob/ob_lob_persistent_adaptor.cpp
@@ -279,7 +279,7 @@ int ObPersistentLobApator::prepare_lob_meta_dml(
       LOG_WARN("failed to build meta schema", K(ret), K(data_tablet), K(lob_meta_tablet));
     }
   } else {
-    if (param.seq_no_st_ != -1) {
+    if (param.seq_no_st_.is_valid()) {
       if (param.used_seq_cnt_ < param.total_seq_cnt_) {
         param.dml_base_param_->spec_seq_no_ = param.seq_no_st_ + param.used_seq_cnt_;
         param.used_seq_cnt_++;
@@ -314,7 +314,7 @@ int ObPersistentLobApator::build_lob_meta_table_dml(
   dml_base_param.encrypt_meta_ = &dml_base_param.encrypt_meta_legacy_;
   dml_base_param.snapshot_ = param.snapshot_;
   dml_base_param.check_schema_version_ = false; // lob tablet should not check schema version
-  if (param.seq_no_st_ != -1) {
+  if (param.seq_no_st_.is_valid()) {
     if (param.used_seq_cnt_ < param.total_seq_cnt_) {
       dml_base_param.spec_seq_no_ = param.seq_no_st_ + param.used_seq_cnt_;
       param.used_seq_cnt_++;
diff --git a/src/storage/lob/ob_lob_util.h b/src/storage/lob/ob_lob_util.h
index 1389a6cf56..fcc4598644 100644
--- a/src/storage/lob/ob_lob_util.h
+++ b/src/storage/lob/ob_lob_util.h
@@ -40,7 +40,7 @@ struct ObLobAccessParam {
       lob_data_(nullptr), byte_size_(0), handle_size_(0), timeout_(0),
       fb_snapshot_(),
       scan_backward_(false), asscess_ptable_(false), offset_(0), len_(0),
-      seq_no_st_(-1), used_seq_cnt_(0), total_seq_cnt_(0), checksum_(0), update_len_(0),
+      parent_seq_no_(), seq_no_st_(), used_seq_cnt_(0), total_seq_cnt_(0), checksum_(0), update_len_(0),
       op_type_(ObLobDataOutRowCtx::OpType::SQL), is_fill_zero_(false), from_rpc_(false),
       inrow_read_nocopy_(false)
   {}
@@ -52,8 +52,8 @@ struct ObLobAccessParam {
 public:
   int set_lob_locator(common::ObLobLocatorV2 *lob_locator);
   TO_STRING_KV(K_(ls_id), K_(tablet_id), KPC_(lob_locator), KPC_(lob_common), KPC_(lob_data), K_(byte_size), K_(handle_size),
-    K_(coll_type), K_(scan_backward), K_(offset), K_(len), K_(seq_no_st), K_(used_seq_cnt), K_(total_seq_cnt), K_(checksum),
-    K_(update_len), K_(op_type), K_(is_fill_zero), K_(from_rpc), K_(snapshot), K_(tx_id), K_(inrow_read_nocopy));
+    K_(coll_type), K_(scan_backward), K_(offset), K_(len), K_(parent_seq_no), K_(seq_no_st), K_(used_seq_cnt), K_(total_seq_cnt),
+    K_(checksum), K_(update_len), K_(op_type), K_(is_fill_zero), K_(from_rpc), K_(snapshot), K_(tx_id), K_(inrow_read_nocopy));
 public:
   transaction::ObTxDesc *tx_desc_; // for write/update/delete
   transaction::ObTxReadSnapshot snapshot_; // for read
@@ -83,7 +83,8 @@ public:
   uint64_t offset_; // is_char == true, offset means char offset
   uint64_t len_; // is_char == true, len means char len
   // runtime
-  int64_t seq_no_st_;
+  transaction::ObTxSEQ parent_seq_no_; // the parent tablet write seq_no
+  transaction::ObTxSEQ seq_no_st_; // start seq_no of lob tablet write
   uint32_t used_seq_cnt_;
   uint32_t total_seq_cnt_;
   int64_t checksum_;
diff --git a/src/storage/ls/ob_ls_tablet_service.cpp b/src/storage/ls/ob_ls_tablet_service.cpp
index 62afafcc64..9260e3a7df 100755
--- a/src/storage/ls/ob_ls_tablet_service.cpp
+++ b/src/storage/ls/ob_ls_tablet_service.cpp
@@ -3920,6 +3920,7 @@ int ObLSTabletService::insert_lob_col(
     // init lob access param
     ObLobAccessParam lob_param;
     lob_param.tx_desc_ = run_ctx.store_ctx_.mvcc_acc_ctx_.tx_desc_;
+    lob_param.parent_seq_no_ = run_ctx.store_ctx_.mvcc_acc_ctx_.tx_scn_;
     lob_param.snapshot_ = run_ctx.dml_param_.snapshot_;
     lob_param.is_total_quantity_log_ = run_ctx.dml_param_.is_total_quantity_log_;
     if (lob_param.snapshot_.is_none_read()) {
@@ -4258,6 +4259,7 @@ int ObLSTabletService::process_delta_lob(
     ObLobAccessParam lob_param;
     // init lob param
     lob_param.tx_desc_ = run_ctx.store_ctx_.mvcc_acc_ctx_.tx_desc_;
+    lob_param.parent_seq_no_ = run_ctx.store_ctx_.mvcc_acc_ctx_.tx_scn_;
     lob_param.snapshot_ = run_ctx.dml_param_.snapshot_;
     if (lob_param.snapshot_.is_none_read()) {
       // NOTE:
@@ -5311,6 +5313,7 @@ int ObLSTabletService::delete_lob_col(
         MEMCPY(buf, data.ptr(), data.length());
         lob_common = reinterpret_cast<ObLobCommon*>(buf);
         lob_param.tx_desc_ = run_ctx.store_ctx_.mvcc_acc_ctx_.tx_desc_;
+        lob_param.parent_seq_no_ = run_ctx.store_ctx_.mvcc_acc_ctx_.tx_scn_;
         lob_param.snapshot_ = run_ctx.dml_param_.snapshot_;
         lob_param.tx_id_ = lob_param.tx_desc_->get_tx_id();
         lob_param.sql_mode_ = run_ctx.dml_param_.sql_mode_;
diff --git a/src/storage/ls/ob_ls_tx_service.cpp b/src/storage/ls/ob_ls_tx_service.cpp
index df24a90510..518c98cee8 100644
--- a/src/storage/ls/ob_ls_tx_service.cpp
+++ b/src/storage/ls/ob_ls_tx_service.cpp
@@ -167,14 +167,15 @@ int ObLSTxService::get_read_store_ctx(const SCN &snapshot,
 int ObLSTxService::get_write_store_ctx(ObTxDesc &tx,
                                        const ObTxReadSnapshot &snapshot,
                                        const concurrent_control::ObWriteFlag write_flag,
-                                       storage::ObStoreCtx &store_ctx) const
+                                       storage::ObStoreCtx &store_ctx,
+                                       const ObTxSEQ &spec_seq_no) const
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(trans_service_)) {
     ret = OB_NOT_INIT;
     TRANS_LOG(WARN, "not init", K(ret));
   } else {
-    ret = trans_service_->get_write_store_ctx(tx, snapshot, write_flag, store_ctx, false);
+    ret = trans_service_->get_write_store_ctx(tx, snapshot, write_flag, store_ctx, spec_seq_no, false);
   }
   return ret;
 }
diff --git a/src/storage/ls/ob_ls_tx_service.h b/src/storage/ls/ob_ls_tx_service.h
index 6bfe90e224..63e7135051 100644
--- a/src/storage/ls/ob_ls_tx_service.h
+++ b/src/storage/ls/ob_ls_tx_service.h
@@ -100,7 +100,8 @@ public:
   int get_write_store_ctx(transaction::ObTxDesc &tx,
                           const transaction::ObTxReadSnapshot &snapshot,
                           const concurrent_control::ObWriteFlag write_flag,
-                          storage::ObStoreCtx &store_ctx) const;
+                          storage::ObStoreCtx &store_ctx,
+                          const transaction::ObTxSEQ &spec_seq_no = transaction::ObTxSEQ::INVL()) const;
   int revert_store_ctx(storage::ObStoreCtx &store_ctx) const;
   // Freeze process needs to traverse trans ctx to submit redo log
   int traverse_trans_to_submit_redo_log(transaction::ObTransID &fail_tx_id);
diff --git a/src/storage/memtable/mvcc/ob_multi_version_iterator.cpp b/src/storage/memtable/mvcc/ob_multi_version_iterator.cpp
index 844b8c44fe..f0714ddb3f 100644
--- a/src/storage/memtable/mvcc/ob_multi_version_iterator.cpp
+++ b/src/storage/memtable/mvcc/ob_multi_version_iterator.cpp
@@ -134,7 +134,7 @@ int ObMultiVersionValueIterator::get_next_uncommitted_node(
     const void *&tnode,
     transaction::ObTransID &trans_id,
     SCN &trans_version,
-    int64_t &sql_sequence)
+    transaction::ObTxSEQ &sql_sequence)
 {
   int ret = OB_SUCCESS;
   int64_t state = -1;
@@ -199,7 +199,7 @@ int ObMultiVersionValueIterator::get_next_uncommitted_node(
 
 int ObMultiVersionValueIterator::check_next_sql_sequence(
     const ObTransID &input_trans_id,
-    const int64_t input_sql_sequence,
+    const ObTxSEQ input_sql_sequence,
     bool &same_sql_sequence_flag)
 {
   int ret = OB_SUCCESS;
@@ -244,7 +244,7 @@ int ObMultiVersionValueIterator::get_state_of_curr_trans_node(
     ret = OB_ERR_UNEXPECTED;
     TRANS_LOG(WARN, "trans node is null", K(ret), K(version_iter_));
   } else {
-    int64_t sql_sequence = INT64_MAX;
+    transaction::ObTxSEQ sql_sequence;
     version_iter_->get_trans_id_and_seq_no(trans_id, sql_sequence);
 
     if (version_iter_->is_aborted()) {
diff --git a/src/storage/memtable/mvcc/ob_multi_version_iterator.h b/src/storage/memtable/mvcc/ob_multi_version_iterator.h
index a2647cde65..82b5b5fa42 100644
--- a/src/storage/memtable/mvcc/ob_multi_version_iterator.h
+++ b/src/storage/memtable/mvcc/ob_multi_version_iterator.h
@@ -50,10 +50,10 @@ public:
       const void *&tnode,
       transaction::ObTransID &trans_id,
       share::SCN &trans_version,
-      int64_t &sql_sequence);
+      transaction::ObTxSEQ &sql_sequence);
   int check_next_sql_sequence(
       const transaction::ObTransID &input_trans_id,
-      const int64_t input_sql_sequence,
+      const transaction::ObTxSEQ input_sql_sequence,
       bool &same_sql_sequence_flag);
   void reset();
   bool is_exist() const { return nullptr != version_iter_; }
diff --git a/src/storage/memtable/mvcc/ob_mvcc.h b/src/storage/memtable/mvcc/ob_mvcc.h
index ee33570e0c..3aaf35af9d 100644
--- a/src/storage/memtable/mvcc/ob_mvcc.h
+++ b/src/storage/memtable/mvcc/ob_mvcc.h
@@ -49,7 +49,7 @@ public:
   virtual bool on_memtable(const ObIMemtable * const memtable)
   { UNUSED(memtable); return false; }
   virtual ObIMemtable* get_memtable() const { return nullptr; }
-  virtual int64_t get_seq_no() const { return 0; }
+  virtual transaction::ObTxSEQ get_seq_no() const { return transaction::ObTxSEQ::INVL(); }
   virtual int del() { return remove(); }
   virtual bool is_need_free() const { return true; }
   virtual bool log_synced() const { return false; }
diff --git a/src/storage/memtable/mvcc/ob_mvcc_acc_ctx.h b/src/storage/memtable/mvcc/ob_mvcc_acc_ctx.h
index 2ef19ddcd3..e251521202 100755
--- a/src/storage/memtable/mvcc/ob_mvcc_acc_ctx.h
+++ b/src/storage/memtable/mvcc/ob_mvcc_acc_ctx.h
@@ -51,7 +51,7 @@ public:
       tx_desc_(NULL),
       tx_ctx_(NULL),
       mem_ctx_(NULL),
-      tx_scn_(-1),
+      tx_scn_(),
       write_flag_(),
       handle_start_time_(OB_INVALID_TIMESTAMP),
       is_standby_read_(false),
@@ -65,7 +65,7 @@ public:
     tx_desc_ = NULL;
     tx_ctx_ = NULL;
     mem_ctx_ = NULL;
-    tx_scn_ = -1;
+    tx_scn_.reset();
     write_flag_.reset();
     handle_start_time_ = OB_INVALID_TIMESTAMP;
     is_standby_read_ = false;
@@ -83,7 +83,7 @@ public:
     tx_desc_ = NULL;
     tx_ctx_ = NULL;
     mem_ctx_ = NULL;
-    tx_scn_ = -1;
+    tx_scn_.reset();
     write_flag_.reset();
     handle_start_time_ = OB_INVALID_TIMESTAMP;
     is_standby_read_ = false;
@@ -102,7 +102,7 @@ public:
       && snapshot_.is_valid()
       && tx_ctx_
       && mem_ctx_
-      && tx_scn_ > 0
+      && tx_scn_.is_valid()
       && tx_id_.is_valid()
       && tx_table_guards_.is_valid();
   }
@@ -147,7 +147,7 @@ public:
   void init_write(transaction::ObPartTransCtx &tx_ctx,
                   ObMemtableCtx &mem_ctx,
                   const transaction::ObTransID &tx_id,
-                  const int64_t tx_scn,
+                  const transaction::ObTxSEQ tx_scn,
                   transaction::ObTxDesc &tx_desc,
                   const storage::ObTxTableGuard &tx_table_guard,
                   const transaction::ObTxSnapshot &snapshot,
@@ -267,7 +267,7 @@ public: // NOTE: those field should only be accessed by txn relative routine
   transaction::ObTxDesc *tx_desc_;             // the txn descriptor
   transaction::ObPartTransCtx *tx_ctx_;        // the txn context
   ObMemtableCtx *mem_ctx_;                     // memtable-ctx
-  int64_t tx_scn_;                             // the change's number of this modify
+  transaction::ObTxSEQ tx_scn_;                             // the change's number of this modify
   concurrent_control::ObWriteFlag write_flag_; // the write flag of the write process
 
   // this was used for runtime mertic
diff --git a/src/storage/memtable/mvcc/ob_mvcc_ctx.cpp b/src/storage/memtable/mvcc/ob_mvcc_ctx.cpp
index 887bb2a5b3..39ab5538d7 100644
--- a/src/storage/memtable/mvcc/ob_mvcc_ctx.cpp
+++ b/src/storage/memtable/mvcc/ob_mvcc_ctx.cpp
@@ -56,7 +56,7 @@ int ObIMvccCtx::register_row_commit_cb(
     const int64_t data_size,
     const ObRowData *old_row,
     ObMemtable *memtable,
-    const int64_t seq_no,
+    const transaction::ObTxSEQ seq_no,
     const int64_t column_cnt)
 {
   int ret = OB_SUCCESS;
@@ -104,7 +104,7 @@ int ObIMvccCtx::register_row_replay_cb(
     ObMvccTransNode *node,
     const int64_t data_size,
     ObMemtable *memtable,
-    const int64_t seq_no,
+    const transaction::ObTxSEQ seq_no,
     const SCN scn,
     const int64_t column_cnt)
 {
diff --git a/src/storage/memtable/mvcc/ob_mvcc_ctx.h b/src/storage/memtable/mvcc/ob_mvcc_ctx.h
index dbe523517f..b8106b41d1 100644
--- a/src/storage/memtable/mvcc/ob_mvcc_ctx.h
+++ b/src/storage/memtable/mvcc/ob_mvcc_ctx.h
@@ -98,7 +98,7 @@ public: // for mvcc engine invoke
   virtual void on_wlock_retry(const ObMemtableKey& key, const transaction::ObTransID &conflict_tx_id) = 0;
   virtual void inc_truncate_cnt() = 0;
   virtual void add_trans_mem_total_size(const int64_t size) = 0;
-  virtual void update_max_submitted_seq_no(const int64_t seq_no) = 0;
+  virtual void update_max_submitted_seq_no(const transaction::ObTxSEQ seq_no) = 0;
   virtual transaction::ObTransID get_tx_id() const = 0;
   virtual transaction::ObPartTransCtx *get_trans_ctx() const = 0;
   // statics maintainness for txn logging
@@ -163,7 +163,7 @@ public:
       const int64_t data_size,
       const ObRowData *old_row,
       ObMemtable *memtable,
-      const int64_t seq_no,
+      const transaction::ObTxSEQ seq_no,
       const int64_t column_cnt);
   int register_row_replay_cb(
       const ObMemtableKey *key,
@@ -171,7 +171,7 @@ public:
       ObMvccTransNode *node,
       const int64_t data_size,
       ObMemtable *memtable,
-      const int64_t seq_no,
+      const transaction::ObTxSEQ seq_no,
       const share::SCN scn,
       const int64_t column_cnt);
   int register_table_lock_cb(
diff --git a/src/storage/memtable/mvcc/ob_mvcc_define.h b/src/storage/memtable/mvcc/ob_mvcc_define.h
index a90e7101ee..e05e559055 100644
--- a/src/storage/memtable/mvcc/ob_mvcc_define.h
+++ b/src/storage/memtable/mvcc/ob_mvcc_define.h
@@ -41,7 +41,7 @@ struct ObTxNodeArg
   // of the memtable. It is used for debug.
   int64_t memstore_version_;
   // seq_no_ is the sequence no of the executing sql
-  int64_t seq_no_;
+  transaction::ObTxSEQ seq_no_;
   // scn_ is thee log ts of the redo log
   share::SCN scn_;
   int64_t column_cnt_;
@@ -59,7 +59,7 @@ struct ObTxNodeArg
   ObTxNodeArg(const ObMemtableData *data,
               const ObRowData *old_row,
               const int64_t memstore_version,
-              const int64_t seq_no,
+              const transaction::ObTxSEQ seq_no,
               const int64_t column_cnt)
     : data_(data),
     old_row_(old_row),
@@ -74,7 +74,7 @@ struct ObTxNodeArg
   ObTxNodeArg(const ObMemtableData *data,
               const ObRowData *old_row,
               const int64_t memstore_version,
-              const int64_t seq_no,
+              const transaction::ObTxSEQ seq_no,
               const uint32_t modify_count,
               const uint32_t acc_checksum,
               const share::SCN scn,
@@ -94,7 +94,7 @@ struct ObTxNodeArg
     modify_count_ = 0;
     acc_checksum_ = 0;
     memstore_version_ = 0;
-    seq_no_ = 0;
+    seq_no_.reset();
     scn_ = share::SCN::min_scn();
     column_cnt_ = 0;
   }
diff --git a/src/storage/memtable/mvcc/ob_mvcc_iterator.cpp b/src/storage/memtable/mvcc/ob_mvcc_iterator.cpp
index 52737b7e3d..4b45d9701f 100755
--- a/src/storage/memtable/mvcc/ob_mvcc_iterator.cpp
+++ b/src/storage/memtable/mvcc/ob_mvcc_iterator.cpp
@@ -139,7 +139,7 @@ int ObMvccValueIterator::lock_for_read_inner_(const ObQueryFlag &flag,
   //        reader_tx_id.
   const ObTransID &snapshot_tx_id = ctx_->snapshot_.tx_id_;
   const ObTransID &reader_tx_id = ctx_->tx_id_;
-  const int64_t snapshot_seq_no = ctx_->snapshot_.scn_;
+  const ObTxSEQ snapshot_seq_no = ctx_->snapshot_.scn_;
 
   const SCN snapshot_version = ctx_->get_snapshot_version();
   const bool read_latest = flag.is_read_latest();
diff --git a/src/storage/memtable/mvcc/ob_mvcc_row.cpp b/src/storage/memtable/mvcc/ob_mvcc_row.cpp
index e2337abfaf..c9edcb84f7 100644
--- a/src/storage/memtable/mvcc/ob_mvcc_row.cpp
+++ b/src/storage/memtable/mvcc/ob_mvcc_row.cpp
@@ -146,7 +146,7 @@ void ObMvccTransNode::get_snapshot_version_barrier(int64_t &version,
 }
 
 void ObMvccTransNode::get_trans_id_and_seq_no(ObTransID &tx_id,
-                                              int64_t &seq_no)
+                                              ObTxSEQ &seq_no)
 {
   tx_id = tx_id_;
   seq_no = seq_no_;
@@ -233,7 +233,7 @@ int64_t ObMvccTransNode::to_string(char *buf, const int64_t buf_len) const
                           & (~SNAPSHOT_VERSION_BARRIER_BIT),
                           snapshot_version_barrier_ >> 62,
                           to_cstring(*mtd),
-                          seq_no_);
+                          seq_no_.cast_to_int());
   return pos;
 }
 
@@ -820,7 +820,7 @@ int ObMvccRow::mvcc_write_(ObIMemtableCtx &ctx,
   ObMvccTransNode *iter = ATOMIC_LOAD(&list_head_);
   ObTransID writer_tx_id = ctx.get_tx_id();
   const SCN snapshot_version = snapshot.version_;
-  const int64_t reader_seq_no = snapshot.scn_;
+  const ObTxSEQ reader_seq_no = snapshot.scn_;
   bool &can_insert = res.can_insert_;
   bool &need_insert = res.need_insert_;
   bool &is_new_locked = res.is_new_locked_;
diff --git a/src/storage/memtable/mvcc/ob_mvcc_row.h b/src/storage/memtable/mvcc/ob_mvcc_row.h
index 6220fd6a8b..4b81851280 100644
--- a/src/storage/memtable/mvcc/ob_mvcc_row.h
+++ b/src/storage/memtable/mvcc/ob_mvcc_row.h
@@ -65,7 +65,7 @@ public:
   : tx_id_(),
     trans_version_(share::SCN::min_scn()),
     scn_(share::SCN::max_scn()),
-    seq_no_(0),
+    seq_no_(),
     tx_end_scn_(share::SCN::max_scn()),
     prev_(NULL),
     next_(NULL),
@@ -81,7 +81,7 @@ public:
   transaction::ObTransID tx_id_;
   share::SCN trans_version_;
   share::SCN scn_;
-  int64_t seq_no_;
+  transaction::ObTxSEQ seq_no_;
   share::SCN tx_end_scn_;
   ObMvccTransNode *prev_;
   ObMvccTransNode *next_;
@@ -170,10 +170,10 @@ public:
   blocksstable::ObDmlFlag get_dml_flag() const;
   int fill_trans_version(const share::SCN version);
   int fill_scn(const share::SCN scn);
-  void get_trans_id_and_seq_no(transaction::ObTransID &trans_id, int64_t &seq_no);
-  int64_t get_seq_no() const { return seq_no_; }
+  void get_trans_id_and_seq_no(transaction::ObTransID &trans_id, transaction::ObTxSEQ &seq_no);
+  transaction::ObTxSEQ get_seq_no() const { return seq_no_; }
   transaction::ObTransID get_tx_id() const { return tx_id_; }
-  void set_seq_no(const int64_t seq_no) { seq_no_ = seq_no; }
+  void set_seq_no(const transaction::ObTxSEQ seq_no) { seq_no_ = seq_no; }
   int is_lock_node(bool &is_lock) const;
   int64_t to_string(char *buf, const int64_t buf_len) const;
   void set_tx_end_scn(const share::SCN tx_end_scn)
diff --git a/src/storage/memtable/mvcc/ob_mvcc_trans_ctx.cpp b/src/storage/memtable/mvcc/ob_mvcc_trans_ctx.cpp
index 27b0131fd4..4a415611ef 100644
--- a/src/storage/memtable/mvcc/ob_mvcc_trans_ctx.cpp
+++ b/src/storage/memtable/mvcc/ob_mvcc_trans_ctx.cpp
@@ -41,7 +41,7 @@ void RedoDataNode::set(const ObMemtableKey *key,
                        const uint32_t acc_checksum,
                        const int64_t version,
                        const int32_t flag,
-                       const int64_t seq_no,
+                       const transaction::ObTxSEQ seq_no,
                        const common::ObTabletID &tablet_id,
                        const int64_t column_cnt)
 {
@@ -385,14 +385,11 @@ void ObTransCallbackMgr::after_append(ObITransCallback *node, const int ret_code
   }
 }
 
-int ObTransCallbackMgr::rollback_to(const int64_t to_seq_no,
-                                    const int64_t from_seq_no)
+int ObTransCallbackMgr::rollback_to(const ObTxSEQ to_seq_no,
+                                    const ObTxSEQ from_seq_no)
 {
   int ret = OB_SUCCESS;
-  if (0 > to_seq_no || 0 > from_seq_no) {
-    ret = OB_INVALID_ARGUMENT;
-    TRANS_LOG(WARN, "invalid argument", K(ret), K(from_seq_no), K(to_seq_no));
-  } else if (OB_FAIL(callback_list_.remove_callbacks_for_rollback_to(to_seq_no))) {
+  if (OB_FAIL(callback_list_.remove_callbacks_for_rollback_to(to_seq_no))) {
     TRANS_LOG(WARN, "invalid argument", K(ret), K(from_seq_no), K(to_seq_no));
   }
   return ret;
@@ -1268,7 +1265,7 @@ int64_t ObMvccRowCallback::to_string(char *buf, const int64_t buf_len) const
       "seq_no=%ld, memtable=%p, scn=%s",
       this, to_cstring(ctx_), is_link_, need_fill_redo_,
       to_cstring(value_), NULL == tnode_ ? "null" : to_cstring(*tnode_),
-      seq_no_, memtable_, to_cstring(scn_));
+      seq_no_.cast_to_int(), memtable_, to_cstring(scn_));
   return pos;
 }
 
diff --git a/src/storage/memtable/mvcc/ob_mvcc_trans_ctx.h b/src/storage/memtable/mvcc/ob_mvcc_trans_ctx.h
index 1e76eda86b..56591633f8 100644
--- a/src/storage/memtable/mvcc/ob_mvcc_trans_ctx.h
+++ b/src/storage/memtable/mvcc/ob_mvcc_trans_ctx.h
@@ -49,7 +49,7 @@ struct RedoDataNode
            const uint32_t acc_checksum,
            const int64_t version,
            const int32_t flag,
-           const int64_t seq_no,
+           const transaction::ObTxSEQ seq_no,
            const common::ObTabletID &tablet_id,
            const int64_t column_cnt);
   void set_callback(ObITransCallback *callback) { callback_ = callback; }
@@ -61,7 +61,7 @@ struct RedoDataNode
   uint32_t acc_checksum_;
   int64_t version_;
   int32_t flag_; // currently, unused
-  int64_t seq_no_;
+  transaction::ObTxSEQ seq_no_;
   ObITransCallback *callback_;
   common::ObTabletID tablet_id_;
   int64_t column_cnt_;
@@ -74,7 +74,7 @@ struct TableLockRedoDataNode
           const common::ObTabletID &tablet_id,
           ObITransCallback *callback);
   ObMemtableKey key_;
-  int64_t seq_no_;
+  transaction::ObTxSEQ seq_no_;
   ObITransCallback *callback_;
   common::ObTabletID tablet_id_;
 
@@ -215,8 +215,8 @@ public:
   int trans_end(const bool commit);
   int replay_fail(const share::SCN scn);
   int replay_succ(const share::SCN scn);
-  int rollback_to(const int64_t seq_no,
-                  const int64_t from_seq_no);
+  int rollback_to(const transaction::ObTxSEQ seq_no,
+                  const transaction::ObTxSEQ from_seq_no);
   void set_for_replay(const bool for_replay);
   bool is_for_replay() const { return ATOMIC_LOAD(&for_replay_); }
   int remove_callbacks_for_fast_commit(const ObITransCallback *generate_cursor,
@@ -349,7 +349,7 @@ public:
       memtable_(memtable),
       is_link_(false),
       not_calc_checksum_(false),
-      seq_no_(0),
+      seq_no_(),
       column_cnt_(0)
   {}
   ObMvccRowCallback(ObMvccRowCallback &cb, ObMemtable *memtable) :
@@ -372,12 +372,12 @@ public:
   void set_is_link() { is_link_ = true; }
   void unset_is_link() { is_link_ = false; }
   void set(const ObMemtableKey *key,
-            ObMvccTransNode *node,
-            const int64_t data_size,
-            const ObRowData *old_row,
-            const bool is_replay,
-            const int64_t seq_no,
-            const int64_t column_cnt)
+           ObMvccTransNode *node,
+           const int64_t data_size,
+           const ObRowData *old_row,
+           const bool is_replay,
+           const transaction::ObTxSEQ seq_no,
+           const int64_t column_cnt)
   {
     UNUSED(is_replay);
 
@@ -413,7 +413,7 @@ public:
   const ObMemtableKey *get_key() { return &key_; }
   int get_memtable_key(uint64_t &table_id, common::ObStoreRowkey &rowkey) const;
   bool is_logging_blocked() const override;
-  int64_t get_seq_no() const { return seq_no_; }
+  transaction::ObTxSEQ get_seq_no() const { return seq_no_; }
   int get_trans_id(transaction::ObTransID &trans_id) const;
   int get_cluster_version(uint64_t &cluster_version) const override;
   transaction::ObTransCtx *get_trans_ctx() const;
@@ -470,7 +470,7 @@ private:
     bool is_link_ : 1;
     bool not_calc_checksum_ : 1;
   };
-  int64_t seq_no_;
+  transaction::ObTxSEQ seq_no_;
   int64_t column_cnt_;
 };
 
diff --git a/src/storage/memtable/mvcc/ob_tx_callback_list.cpp b/src/storage/memtable/mvcc/ob_tx_callback_list.cpp
index 0a281742ff..efcc535d55 100644
--- a/src/storage/memtable/mvcc/ob_tx_callback_list.cpp
+++ b/src/storage/memtable/mvcc/ob_tx_callback_list.cpp
@@ -246,7 +246,7 @@ int ObTxCallbackList::remove_callbacks_for_remove_memtable(
   return ret;
 }
 
-int ObTxCallbackList::remove_callbacks_for_rollback_to(const int64_t to_seq_no)
+int ObTxCallbackList::remove_callbacks_for_rollback_to(const transaction::ObTxSEQ to_seq_no)
 {
   int ret = OB_SUCCESS;
   SpinLockGuard guard(latch_);
@@ -266,14 +266,14 @@ int ObTxCallbackList::remove_callbacks_for_rollback_to(const int64_t to_seq_no)
   } else {
     callback_mgr_.add_rollback_to_callback_remove_cnt(functor.get_remove_cnt());
     ensure_checksum_(functor.get_checksum_last_scn());
-    TRANS_LOG(DEBUG, "remove callbacks for rollback to", KP(to_seq_no), K(functor), K(*this));
+    TRANS_LOG(DEBUG, "remove callbacks for rollback to", K(to_seq_no), K(functor), K(*this));
   }
 
 
   return ret;
 }
 
-int ObTxCallbackList::reverse_search_callback_by_seq_no(const int64_t seq_no,
+int ObTxCallbackList::reverse_search_callback_by_seq_no(const transaction::ObTxSEQ seq_no,
                                                         ObITransCallback *search_res)
 {
   int ret = OB_SUCCESS;
diff --git a/src/storage/memtable/mvcc/ob_tx_callback_list.h b/src/storage/memtable/mvcc/ob_tx_callback_list.h
index 66ab66d593..da7ee70570 100644
--- a/src/storage/memtable/mvcc/ob_tx_callback_list.h
+++ b/src/storage/memtable/mvcc/ob_tx_callback_list.h
@@ -72,11 +72,11 @@ public:
   // until callbacks smaller or equal than the seq_no. It will remove both
   // callbacks and data by calling rollback_callback. For synced callback we need
   // calculate checksum and for unsynced one we need remove them.
-  int remove_callbacks_for_rollback_to(const int64_t to_seq_no);
+  int remove_callbacks_for_rollback_to(const transaction::ObTxSEQ to_seq_no);
 
   // reverse_search_callback_by_seq_no will search callback from back to front
   // until callbacks smaller or equal than the seq_no
-  int reverse_search_callback_by_seq_no(const int64_t seq_no, ObITransCallback *search_res);
+  int reverse_search_callback_by_seq_no(const transaction::ObTxSEQ seq_no, ObITransCallback *search_res);
 
   // get_memtable_key_arr_w_timeout get all memtable key until timeout
   int get_memtable_key_arr_w_timeout(transaction::ObMemtableKeyArray &memtable_key_arr);
diff --git a/src/storage/memtable/ob_concurrent_control.cpp b/src/storage/memtable/ob_concurrent_control.cpp
index 01958779e4..56f5434052 100644
--- a/src/storage/memtable/ob_concurrent_control.cpp
+++ b/src/storage/memtable/ob_concurrent_control.cpp
@@ -40,13 +40,13 @@ OB_SERIALIZE_MEMBER(ObWriteFlag, flag_);
 // effort to sort out these posibilities(listed in the following cases), new
 // possibility should be added carefully and remind the owner of the code.
 int check_sequence_set_violation(const concurrent_control::ObWriteFlag write_flag,
-                                 const int64_t reader_seq_no,
+                                 const transaction::ObTxSEQ reader_seq_no,
                                  const transaction::ObTransID writer_tx_id,
                                  const blocksstable::ObDmlFlag writer_dml_flag,
-                                 const int64_t writer_seq_no,
+                                 const transaction::ObTxSEQ writer_seq_no,
                                  const transaction::ObTransID locker_tx_id,
                                  const blocksstable::ObDmlFlag locker_dml_flag,
-                                 const int64_t locker_seq_no)
+                                 const transaction::ObTxSEQ locker_seq_no)
 {
   int ret = OB_SUCCESS;
   // TODO(handora.qc): add flag to carefully screen out the different cases. For
diff --git a/src/storage/memtable/ob_concurrent_control.h b/src/storage/memtable/ob_concurrent_control.h
index 1a96790c2b..710b62804f 100644
--- a/src/storage/memtable/ob_concurrent_control.h
+++ b/src/storage/memtable/ob_concurrent_control.h
@@ -119,13 +119,13 @@ struct ObWriteFlag
 // rolled back. This solves the common problem between B and C mentioned above
 // It is guaranteed that only There is a concurrent modification of a task.
 int check_sequence_set_violation(const concurrent_control::ObWriteFlag write_flag,
-                                 const int64_t reader_seq_no,
+                                 const transaction::ObTxSEQ reader_seq_no,
                                  const transaction::ObTransID checker_tx_id,
                                  const blocksstable::ObDmlFlag checker_dml_flag,
-                                 const int64_t checker_seq_no,
+                                 const transaction::ObTxSEQ checker_seq_no,
                                  const transaction::ObTransID locker_tx_id,
                                  const blocksstable::ObDmlFlag locker_dml_flag,
-                                 const int64_t locker_seq_no);
+                                 const transaction::ObTxSEQ locker_seq_no);
 
 } // namespace concurrent_control
 } // namespace oceanbase
diff --git a/src/storage/memtable/ob_memtable.cpp b/src/storage/memtable/ob_memtable.cpp
index 83ab0583b5..701faf089b 100755
--- a/src/storage/memtable/ob_memtable.cpp
+++ b/src/storage/memtable/ob_memtable.cpp
@@ -1002,7 +1002,7 @@ int ObMemtable::replay_row(ObStoreCtx &ctx,
   uint32_t acc_checksum = 0;
   int64_t version = 0;
   int32_t flag = 0;
-  int64_t seq_no = 0;
+  transaction::ObTxSEQ seq_no;
   int64_t column_cnt = 0;
   ObStoreRowkey rowkey;
   ObRowData row;
@@ -1079,7 +1079,7 @@ int ObMemtable::lock_row_on_frozen_stores_(
   int ret = OB_SUCCESS;
   ObStoreRowLockState &lock_state = res.lock_state_;
   ObStoreCtx &ctx = *(context.store_ctx_);
-  const int64_t reader_seq_no = ctx.mvcc_acc_ctx_.snapshot_.scn_;
+  const auto reader_seq_no = ctx.mvcc_acc_ctx_.snapshot_.scn_;
   if (OB_ISNULL(value) || !ctx.mvcc_acc_ctx_.is_write() || NULL == key) {
     TRANS_LOG(WARN, "invalid param", KP(value), K(ctx), KP(key));
     ret = OB_INVALID_ARGUMENT;
diff --git a/src/storage/memtable/ob_memtable_context.cpp b/src/storage/memtable/ob_memtable_context.cpp
index f8d8f384ca..5303b96ae9 100644
--- a/src/storage/memtable/ob_memtable_context.cpp
+++ b/src/storage/memtable/ob_memtable_context.cpp
@@ -818,19 +818,19 @@ uint64_t ObMemtableCtx::get_tenant_id() const
   return tenant_id;
 }
 
-void ObMemtableCtx::update_max_submitted_seq_no(const int64_t seq_no)
+void ObMemtableCtx::update_max_submitted_seq_no(const transaction::ObTxSEQ seq_no)
 {
   if (NULL != ATOMIC_LOAD(&ctx_)) {
     static_cast<ObPartTransCtx *>(ctx_)->update_max_submitted_seq_no(seq_no);
   }
 }
 
-int ObMemtableCtx::rollback(const int64_t to_seq_no, const int64_t from_seq_no)
+int ObMemtableCtx::rollback(const transaction::ObTxSEQ to_seq_no, const transaction::ObTxSEQ from_seq_no)
 {
   int ret = OB_SUCCESS;
   ObByteLockGuard guard(lock_);
 
-  if (0 > to_seq_no || 0 > from_seq_no) {
+  if (!to_seq_no.is_valid() || !from_seq_no.is_valid()) {
     ret = OB_INVALID_ARGUMENT;
     TRANS_LOG(WARN, "invalid argument", K(ret), K(from_seq_no), K(to_seq_no));
   } else if (OB_ISNULL(ATOMIC_LOAD(&ctx_))) {
@@ -1189,7 +1189,7 @@ int ObMemtableCtx::clear_table_lock_(const bool is_commit,
   return ret;
 }
 
-int ObMemtableCtx::rollback_table_lock_(int64_t seq_no)
+int ObMemtableCtx::rollback_table_lock_(transaction::ObTxSEQ seq_no)
 {
   int ret = OB_SUCCESS;
   if (is_read_only_) {
diff --git a/src/storage/memtable/ob_memtable_context.h b/src/storage/memtable/ob_memtable_context.h
index 0ebfd6826a..1cb3039ecc 100644
--- a/src/storage/memtable/ob_memtable_context.h
+++ b/src/storage/memtable/ob_memtable_context.h
@@ -337,7 +337,7 @@ public:
   }
   virtual int write_lock_yield();
 
-  virtual void update_max_submitted_seq_no(const int64_t seq_no) override;
+  virtual void update_max_submitted_seq_no(const transaction::ObTxSEQ seq_no) override;
 public:
   virtual void set_read_only();
   virtual void inc_ref();
@@ -401,7 +401,7 @@ public:
   int remove_callback_for_uncommited_txn(
     const memtable::ObMemtableSet *memtable_set,
     const share::SCN max_applied_scn);
-  int rollback(const int64_t seq_no, const int64_t from_seq_no);
+  int rollback(const transaction::ObTxSEQ seq_no, const transaction::ObTxSEQ from_seq_no);
   bool is_all_redo_submitted();
   bool is_for_replay() const { return trans_mgr_.is_for_replay(); }
   int64_t get_trans_mem_total_size() const { return trans_mem_total_size_; }
@@ -494,7 +494,7 @@ private:
   int clear_table_lock_(const bool is_commit,
                         const share::SCN &commit_version,
                         const share::SCN &commit_scn);
-  int rollback_table_lock_(int64_t seq_no);
+  int rollback_table_lock_(transaction::ObTxSEQ seq_no);
   int register_multi_source_data_if_need_(
       const transaction::tablelock::ObTableLockOp &lock_op,
       const bool is_replay);
diff --git a/src/storage/memtable/ob_memtable_iterator.cpp b/src/storage/memtable/ob_memtable_iterator.cpp
index 071eb58f73..1bcf18afa9 100755
--- a/src/storage/memtable/ob_memtable_iterator.cpp
+++ b/src/storage/memtable/ob_memtable_iterator.cpp
@@ -1208,8 +1208,8 @@ int ObMemtableMultiVersionScanIterator::iterate_uncommitted_row_value_(ObDatumRo
   ObRowReader row_reader;
   const void *tnode = NULL;
   const ObMemtableDataHeader *mtd = NULL;
-  int64_t sql_seq = -1;
-  int64_t first_sql_sequence = -1;
+  transaction::ObTxSEQ sql_seq;
+  transaction::ObTxSEQ first_sql_sequence;
   int64_t trans_version = INT64_MAX;
   SCN trans_scn;
   bool same_sql_sequence_flag = true;
@@ -1219,7 +1219,7 @@ int ObMemtableMultiVersionScanIterator::iterate_uncommitted_row_value_(ObDatumRo
   } else {
     bitmap_.reuse();
     while (OB_SUCC(ret)) {
-      if (first_sql_sequence > -1
+      if (first_sql_sequence.is_valid()
           && OB_FAIL(value_iter_->check_next_sql_sequence(row.trans_id_, first_sql_sequence, same_sql_sequence_flag))) {
         TRANS_LOG(WARN, "failed to check next sql sequence", K(ret), K(tnode));
       } else if (!same_sql_sequence_flag) { // different sql sequence need break
@@ -1246,12 +1246,12 @@ int ObMemtableMultiVersionScanIterator::iterate_uncommitted_row_value_(ObDatumRo
           bool read_finished = false;
           if (OB_FAIL(row_reader.read_memtable_row(mtd->buf_, mtd->buf_len_, *read_info_, row, bitmap_, read_finished))) {
             TRANS_LOG(WARN, "Failed to read memtable row", K(ret));
-          } else if (-1 == first_sql_sequence) { // record sql sequence
+          } else if (!first_sql_sequence.is_valid()) { // record sql sequence
             first_sql_sequence = sql_seq;
             row.storage_datums_[trans_version_col_idx_].reuse();
             row.storage_datums_[sql_sequence_col_idx_].reuse();
             row.storage_datums_[trans_version_col_idx_].set_int(-trans_version);
-            row.storage_datums_[sql_sequence_col_idx_].set_int(-sql_seq);
+            row.storage_datums_[sql_sequence_col_idx_].set_int(-sql_seq.cast_to_int());
             row.row_flag_.set_flag(mtd->dml_flag_);
           } else {
             row.row_flag_.fuse_flag(mtd->dml_flag_);
diff --git a/src/storage/memtable/ob_memtable_mutator.cpp b/src/storage/memtable/ob_memtable_mutator.cpp
index c7bd2a11a3..0481a468af 100644
--- a/src/storage/memtable/ob_memtable_mutator.cpp
+++ b/src/storage/memtable/ob_memtable_mutator.cpp
@@ -230,7 +230,7 @@ ObMutator::ObMutator():
     row_size_(0),
     table_id_(OB_INVALID_ID),
     table_version_(0),
-    seq_no_(0)
+    seq_no_()
 {
   rowkey_.assign((ObObj*)obj_array_, OB_MAX_ROWKEY_COLUMN_NUMBER);
 }
@@ -239,7 +239,7 @@ ObMutator::ObMutator(
     const uint64_t table_id,
     const common::ObStoreRowkey &rowkey,
     const int64_t table_version,
-    const int64_t seq_no):
+    const transaction::ObTxSEQ seq_no):
     rowkey_(rowkey),
     row_size_(0),
     table_id_(table_id),
@@ -254,7 +254,7 @@ void ObMutator::reset()
   rowkey_.reset();
   rowkey_.get_rowkey().assign((ObObj*)obj_array_, OB_MAX_ROWKEY_COLUMN_NUMBER);
   table_version_ = 0;
-  seq_no_ = 0;
+  seq_no_.reset();
 }
 
 const char *get_mutator_type_str(MutatorType mutator_type)
@@ -341,7 +341,7 @@ ObMemtableMutatorRow::ObMemtableMutatorRow(const uint64_t table_id,
                                            const uint32_t acc_checksum,
                                            const int64_t version,
                                            const int32_t flag,
-                                           const int64_t seq_no,
+                                           const transaction::ObTxSEQ seq_no,
                                            const int64_t column_cnt):
     ObMutator(table_id, rowkey, table_version, seq_no),
     dml_flag_(dml_flag),
@@ -379,7 +379,7 @@ int ObMemtableMutatorRow::copy(uint64_t &table_id,
                                uint32_t &acc_checksum,
                                int64_t &version,
                                int32_t &flag,
-                               int64_t &seq_no,
+                               transaction::ObTxSEQ &seq_no,
                                int64_t &column_cnt) const
 {
   int ret = OB_SUCCESS;
@@ -429,7 +429,7 @@ int ObMemtableMutatorRow::serialize(char *buf, int64_t &buf_len, int64_t &pos,
         || OB_FAIL(encode_vi32(buf, buf_len, new_pos, acc_checksum_))
         || OB_FAIL(encode_vi64(buf, buf_len, new_pos, version_))
         || OB_FAIL(encode_vi32(buf, buf_len, new_pos, flag_))
-        || OB_FAIL(encode_vi64(buf, buf_len, new_pos, seq_no_))) {
+        || OB_FAIL(seq_no_.serialize(buf, buf_len, new_pos))) {
         if (OB_BUF_NOT_ENOUGH != ret || buf_len > common::OB_MAX_LOG_ALLOWED_SIZE) {
           TRANS_LOG(INFO, "serialize row fail", K(ret), KP(buf), K(buf_len), K(pos));
         }
@@ -505,7 +505,7 @@ int ObMemtableMutatorRow::deserialize(const char *buf, const int64_t buf_len, in
           }
         }
         if (OB_SUCC(ret) && (new_pos < decrypted_len)) {
-          if (OB_FAIL(decode_vi64(decrypted_buf, decrypted_len, new_pos, (int64_t *)&seq_no_))) {
+          if (OB_FAIL(seq_no_.deserialize(decrypted_buf, decrypted_len, new_pos))) {
             TRANS_LOG(WARN, "deserialize seq no fail", K(ret), K(table_id_), K(decrypted_len), K(new_pos));
           }
         }
@@ -541,7 +541,7 @@ ObMutatorTableLock::ObMutatorTableLock(
     const ObTableLockOwnerID owner_id,
     const ObTableLockMode lock_mode,
     const ObTableLockOpType lock_op_type,
-    const int64_t seq_no,
+    const transaction::ObTxSEQ seq_no,
     const int64_t create_timestamp,
     const int64_t create_schema_version) :
     ObMutator(table_id, rowkey, table_version, seq_no),
@@ -580,7 +580,7 @@ int ObMutatorTableLock::copy(ObLockID &lock_id,
                              ObTableLockOwnerID &owner_id,
                              ObTableLockMode &lock_mode,
                              ObTableLockOpType &lock_op_type,
-                             int64_t &seq_no,
+                             transaction::ObTxSEQ &seq_no,
                              int64_t &create_timestamp,
                              int64_t &create_schema_version) const
 {
@@ -607,7 +607,7 @@ int ObMutatorTableLock::serialize(
              OB_FAIL(owner_id_.serialize(buf, buf_len, new_pos)) ||
              OB_FAIL(encode_i8(buf, buf_len, new_pos, mode_)) ||
              OB_FAIL(encode_i8(buf, buf_len, new_pos, lock_type_)) ||
-             OB_FAIL(encode_vi64(buf, buf_len, new_pos, seq_no_)) ||
+             OB_FAIL(seq_no_.serialize(buf, buf_len, new_pos)) ||
              OB_FAIL(encode_vi64(buf, buf_len, new_pos, create_timestamp_)) ||
              OB_FAIL(encode_vi64(buf, buf_len, new_pos, create_schema_version_))) {
     if (OB_BUF_NOT_ENOUGH != ret
@@ -651,7 +651,7 @@ int ObMutatorTableLock::deserialize(
     TRANS_LOG(WARN, "deserialize lock mode fail", K(ret), K(pos), K(new_pos), K(row_size_), K(buf_len));
   } else if (OB_FAIL(decode_i8(buf, buf_len, new_pos, reinterpret_cast<int8_t*>(&lock_type_)))) {
     TRANS_LOG(WARN, "deserialize lock op type fail", K(ret), K(pos), K(new_pos), K(row_size_), K(buf_len));
-  } else if (OB_FAIL(decode_vi64(buf, buf_len, new_pos, &seq_no_))) {
+  } else if (OB_FAIL(seq_no_.deserialize(buf, buf_len, new_pos))) {
     TRANS_LOG(WARN, "deserialize seq no fail", K(ret));
   } else {
     // do nothing
diff --git a/src/storage/memtable/ob_memtable_mutator.h b/src/storage/memtable/ob_memtable_mutator.h
index 5957ab31bf..03220a4f9c 100644
--- a/src/storage/memtable/ob_memtable_mutator.h
+++ b/src/storage/memtable/ob_memtable_mutator.h
@@ -136,7 +136,7 @@ public:
   ObMutator(const uint64_t table_id,
             const ObStoreRowkey &rowkey,
             const int64_t table_version,
-            const int64_t seq_no);
+            const transaction::ObTxSEQ seq_no);
   void reset();
 public:
   char obj_array_[sizeof(common::ObObj) * common::OB_MAX_ROWKEY_COLUMN_NUMBER];
@@ -144,7 +144,7 @@ public:
   uint32_t row_size_;
   uint64_t table_id_;
   int64_t table_version_;
-  int64_t seq_no_;
+  transaction::ObTxSEQ seq_no_;
 };
 
 class ObMemtableMutatorRow : public ObMutator
@@ -161,7 +161,7 @@ public:
                        const uint32_t acc_checksum,
                        const int64_t version,
                        const int32_t flag,
-                       const int64_t seq_no,
+                       const transaction::ObTxSEQ seq_no,
                        const int64_t column_cnt);
   virtual ~ObMemtableMutatorRow();
   void reset();
@@ -175,9 +175,8 @@ public:
            uint32_t &acc_checksum,
            int64_t &version,
            int32_t &flag,
-           int64_t &seq_no,
+           transaction::ObTxSEQ &seq_no,
            int64_t &column_cnt) const;
-
   int serialize(char *buf, int64_t &buf_len, int64_t &pos,
                 const transaction::ObTxEncryptMeta *encrypt_meta,
                 transaction::ObCLogEncryptInfo &new_encrypt_info,
@@ -231,7 +230,7 @@ public:
                      const transaction::tablelock::ObTableLockOwnerID owner_id,
                      const transaction::tablelock::ObTableLockMode lock_mode,
                      const transaction::tablelock::ObTableLockOpType lock_op_type,
-                     const int64_t seq_no,
+                     const transaction::ObTxSEQ seq_no,
                      const int64_t create_timestamp,
                      const int64_t create_schema_version);
   virtual ~ObMutatorTableLock();
@@ -241,7 +240,7 @@ public:
            transaction::tablelock::ObTableLockOwnerID &owner_id,
            transaction::tablelock::ObTableLockMode &lock_mode,
            transaction::tablelock::ObTableLockOpType &lock_op_type,
-           int64_t &seq_no,
+           transaction::ObTxSEQ &seq_no,
            int64_t &create_timestamp,
            int64_t &create_schema_version) const;
   int serialize(char *buf, const int64_t buf_len, int64_t &pos);
diff --git a/src/storage/memtable/ob_redo_log_generator.cpp b/src/storage/memtable/ob_redo_log_generator.cpp
index b5d336d40e..984ce4278b 100644
--- a/src/storage/memtable/ob_redo_log_generator.cpp
+++ b/src/storage/memtable/ob_redo_log_generator.cpp
@@ -84,7 +84,7 @@ int ObRedoLogGenerator::fill_redo_log(char *buf,
     TableLockRedoDataNode table_lock_redo;
     // record the number of serialized trans node in the filling process
     int64_t data_node_count = 0;
-    int64_t max_seq_no = 0;
+    transaction::ObTxSEQ max_seq_no;
     // TODO by fengshuo.fs : fix this usage
     ObTransCallbackMgr::RDLockGuard guard(callback_mgr_->get_rwlock());
     ObCallbackScope callbacks;
@@ -133,7 +133,7 @@ int ObRedoLogGenerator::fill_redo_log(char *buf,
         if (OB_UNLIKELY(OB_ERR_TOO_BIG_ROWSIZE == ret)) {
           callbacks.start_ = callbacks.end_ = cursor;
           data_size += iter->get_data_size();
-          max_seq_no = max(max_seq_no, iter->get_seq_no());
+          max_seq_no = MAX(max_seq_no, iter->get_seq_no());
         } else if (OB_SUCC(ret)) {
           if (nullptr == *callbacks.start_) {
             callbacks.start_ = cursor;
@@ -144,7 +144,7 @@ int ObRedoLogGenerator::fill_redo_log(char *buf,
             data_node_count++;
           }
           data_size += iter->get_data_size();
-          max_seq_no = max(max_seq_no, iter->get_seq_no());
+          max_seq_no = MAX(max_seq_no, iter->get_seq_no());
         }
       }
     }
diff --git a/src/storage/memtable/ob_redo_log_generator.h b/src/storage/memtable/ob_redo_log_generator.h
index 624fb3bada..b8a6e46e7a 100644
--- a/src/storage/memtable/ob_redo_log_generator.h
+++ b/src/storage/memtable/ob_redo_log_generator.h
@@ -38,16 +38,16 @@ struct ObCallbackScope
 
 struct ObRedoLogSubmitHelper
 {
-  ObRedoLogSubmitHelper() : callbacks_(), max_seq_no_(0), data_size_(0) {}
+  ObRedoLogSubmitHelper() : callbacks_(), max_seq_no_(), data_size_(0) {}
   ~ObRedoLogSubmitHelper() {}
   void reset()
   {
     callbacks_.reset();
-    max_seq_no_ = 0;
+    max_seq_no_.reset();
     data_size_ = 0;
   }
   ObCallbackScope callbacks_; // callbacks in the redo log
-  int64_t max_seq_no_;
+  transaction::ObTxSEQ max_seq_no_;
   int64_t data_size_;  // records the data amount of all serialized trans node of this fill process
 };
 
diff --git a/src/storage/memtable/ob_row_conflict_handler.cpp b/src/storage/memtable/ob_row_conflict_handler.cpp
index b36c9aff1c..d3210fdbf7 100644
--- a/src/storage/memtable/ob_row_conflict_handler.cpp
+++ b/src/storage/memtable/ob_row_conflict_handler.cpp
@@ -51,7 +51,7 @@ int ObRowConflictHandler::check_foreign_key_constraint_for_memtable(ObMvccValueI
 int ObRowConflictHandler::check_foreign_key_constraint_for_sstable(ObTxTableGuards &tx_table_guards,
                                                                    const ObTransID &read_trans_id,
                                                                    const ObTransID &data_trans_id,
-                                                                   const int64_t sql_sequence,
+                                                                   const ObTxSEQ &sql_sequence,
                                                                    const int64_t trans_version,
                                                                    const int64_t snapshot_version,
                                                                    const share::SCN &end_scn,
diff --git a/src/storage/memtable/ob_row_conflict_handler.h b/src/storage/memtable/ob_row_conflict_handler.h
index 50a2ea9191..9b58af6371 100644
--- a/src/storage/memtable/ob_row_conflict_handler.h
+++ b/src/storage/memtable/ob_row_conflict_handler.h
@@ -21,6 +21,7 @@ class ObMvccValueIterator;
 }
 namespace transaction {
 class ObTransID;
+class ObTxSEQ;
 }
 namespace common {
 class ObTabletID;
@@ -50,7 +51,7 @@ public:
   static int check_foreign_key_constraint_for_sstable(storage::ObTxTableGuards &tx_table_guards,
                                                       const transaction::ObTransID &read_trans_id,
                                                       const transaction::ObTransID &data_trans_id,
-                                                      const int64_t sql_sequence,
+                                                      const transaction::ObTxSEQ &sql_sequence,
                                                       const int64_t trans_version,
                                                       const int64_t snapshot_version,
                                                       const share::SCN &end_scn,
diff --git a/src/storage/ob_i_store.cpp b/src/storage/ob_i_store.cpp
index 3b9c2b1063..9597d766df 100644
--- a/src/storage/ob_i_store.cpp
+++ b/src/storage/ob_i_store.cpp
@@ -134,7 +134,7 @@ void ObStoreRowLockState::reset()
   is_locked_ = false;
   trans_version_ = SCN::min_scn();
   lock_trans_id_.reset();
-  lock_data_sequence_ = 0;
+  lock_data_sequence_.reset();
   lock_dml_flag_ = blocksstable::ObDmlFlag::DF_NOT_EXIST;
   is_delayed_cleanout_ = false;
   mvcc_row_ = NULL;
diff --git a/src/storage/ob_i_store.h b/src/storage/ob_i_store.h
index 73cf5d2809..03f71d7279 100644
--- a/src/storage/ob_i_store.h
+++ b/src/storage/ob_i_store.h
@@ -225,7 +225,7 @@ public:
     : is_locked_(false),
     trans_version_(share::SCN::min_scn()),
     lock_trans_id_(),
-    lock_data_sequence_(0),
+    lock_data_sequence_(),
     lock_dml_flag_(blocksstable::ObDmlFlag::DF_NOT_EXIST),
     is_delayed_cleanout_(false),
     mvcc_row_(NULL),
@@ -243,7 +243,7 @@ public:
   bool is_locked_;
   share::SCN trans_version_;
   transaction::ObTransID lock_trans_id_;
-  int64_t lock_data_sequence_;
+  transaction::ObTxSEQ lock_data_sequence_;
   blocksstable::ObDmlFlag lock_dml_flag_;
   bool is_delayed_cleanout_;
   memtable::ObMvccRow *mvcc_row_;
diff --git a/src/storage/tablelock/ob_lock_memtable.cpp b/src/storage/tablelock/ob_lock_memtable.cpp
index b3ae899d11..187614a85f 100644
--- a/src/storage/tablelock/ob_lock_memtable.cpp
+++ b/src/storage/tablelock/ob_lock_memtable.cpp
@@ -883,7 +883,7 @@ int ObLockMemtable::replay_row(
   ObTableLockOwnerID owner_id(0);
   ObTableLockMode lock_mode = NO_LOCK;
   ObTableLockOpType lock_op_type = ObTableLockOpType::UNKNOWN_TYPE;
-  int64_t seq_no = 0;
+  transaction::ObTxSEQ seq_no;
   int64_t create_timestamp = 0;
   int64_t create_schema_vesion = -1;
   ObMemtableCtx *mem_ctx = nullptr;
diff --git a/src/storage/tablelock/ob_mem_ctx_table_lock.cpp b/src/storage/tablelock/ob_mem_ctx_table_lock.cpp
index 444da3800b..47aea60083 100755
--- a/src/storage/tablelock/ob_mem_ctx_table_lock.cpp
+++ b/src/storage/tablelock/ob_mem_ctx_table_lock.cpp
@@ -78,7 +78,7 @@ void ObLockMemCtx::reset()
   callback_pool_.reset();
 }
 
-void ObLockMemCtx::rollback_table_lock_(const int64_t seq_no)
+void ObLockMemCtx::rollback_table_lock_(const ObTxSEQ seq_no)
 {
   int ret = OB_SUCCESS;
   ObLockMemtable *memtable = nullptr;
@@ -153,7 +153,7 @@ int ObLockMemCtx::commit_table_lock_(const SCN &commit_version, const SCN &commi
   return ret;
 }
 
-int ObLockMemCtx::rollback_table_lock(const int64_t seq_no)
+int ObLockMemCtx::rollback_table_lock(const ObTxSEQ seq_no)
 {
   int ret = OB_SUCCESS;
   if (lock_list_.is_empty()) {
diff --git a/src/storage/tablelock/ob_mem_ctx_table_lock.h b/src/storage/tablelock/ob_mem_ctx_table_lock.h
index 3064b61df8..94ad75a3b9 100644
--- a/src/storage/tablelock/ob_mem_ctx_table_lock.h
+++ b/src/storage/tablelock/ob_mem_ctx_table_lock.h
@@ -102,7 +102,7 @@ public:
       const bool is_committed,
       const share::SCN &commit_version,
       const share::SCN &commit_scn);
-  int rollback_table_lock(const int64_t seq_no);
+  int rollback_table_lock(const ObTxSEQ seq_no);
   void *alloc_lock_op_callback();
   void free_lock_op_callback(void *cb);
   int get_table_lock_store_info(ObTableLockInfo &table_lock_info);
@@ -117,7 +117,7 @@ private:
   void free_lock_op(void *op);
   void free_lock_op_(void *op);
   void print() const;
-  void rollback_table_lock_(const int64_t seq_no);
+  void rollback_table_lock_(const ObTxSEQ seq_no);
   int commit_table_lock_(const share::SCN &commit_version, const share::SCN &commit_scn);
   void abort_table_lock_();
 private:
diff --git a/src/storage/tablelock/ob_obj_lock.cpp b/src/storage/tablelock/ob_obj_lock.cpp
index 1f17a909db..abe22272d7 100644
--- a/src/storage/tablelock/ob_obj_lock.cpp
+++ b/src/storage/tablelock/ob_obj_lock.cpp
@@ -1162,7 +1162,7 @@ int ObOBJLock::get_lock_op_iter(const ObLockID &lock_id,
     tmp_op.op_type_ = IN_TRANS_DML_LOCK;
     tmp_op.lock_op_status_ = LOCK_OP_DOING;
     // we use this one for the count.
-    tmp_op.lock_seq_no_ = row_share_;
+    tmp_op.lock_seq_no_ = ObTxSEQ(row_share_, 0);
     if (OB_FAIL(iter.push(tmp_op))) {
       TABLELOCK_LOG(WARN, "push tmp lock op into iterator failed", K(ret), K(tmp_op));
     }
@@ -1175,7 +1175,7 @@ int ObOBJLock::get_lock_op_iter(const ObLockID &lock_id,
     tmp_op.op_type_ = IN_TRANS_DML_LOCK;
     tmp_op.lock_op_status_ = LOCK_OP_DOING;
     // we use this one for the count.
-    tmp_op.lock_seq_no_ = row_exclusive_;
+    tmp_op.lock_seq_no_ = ObTxSEQ(row_exclusive_, 0);
     if (OB_FAIL(iter.push(tmp_op))) {
       TABLELOCK_LOG(WARN, "push tmp lock op into iterator failed", K(ret), K(tmp_op));
     }
diff --git a/src/storage/tablelock/ob_table_lock_callback.cpp b/src/storage/tablelock/ob_table_lock_callback.cpp
index b79df7e5c3..72ec85a550 100644
--- a/src/storage/tablelock/ob_table_lock_callback.cpp
+++ b/src/storage/tablelock/ob_table_lock_callback.cpp
@@ -185,7 +185,7 @@ int ObOBJLockCallback::get_trans_id(ObTransID &trans_id) const
   return ret;
 }
 
-int64_t ObOBJLockCallback::get_seq_no() const
+transaction::ObTxSEQ ObOBJLockCallback::get_seq_no() const
 {
   return lock_op_->lock_op_.lock_seq_no_;
 }
diff --git a/src/storage/tablelock/ob_table_lock_callback.h b/src/storage/tablelock/ob_table_lock_callback.h
index 426e6b6825..f62525e428 100644
--- a/src/storage/tablelock/ob_table_lock_callback.h
+++ b/src/storage/tablelock/ob_table_lock_callback.h
@@ -61,7 +61,7 @@ public:
   bool on_memtable(const memtable::ObIMemtable * const memtable) override;
   memtable::ObIMemtable* get_memtable() const override;
   virtual int del() override;
-  int64_t get_seq_no() const override;
+  transaction::ObTxSEQ get_seq_no() const override;
   bool is_table_lock_callback() const override { return true; }
   bool log_synced() const override { return share::SCN::max_scn() != scn_; }
   bool must_log() const;
diff --git a/src/storage/tablelock/ob_table_lock_common.cpp b/src/storage/tablelock/ob_table_lock_common.cpp
index 32b09ed006..9f09880287 100644
--- a/src/storage/tablelock/ob_table_lock_common.cpp
+++ b/src/storage/tablelock/ob_table_lock_common.cpp
@@ -161,7 +161,7 @@ void ObTableLockOp::set(
     const ObTransID &trans_id,
     const ObTableLockOpType type,
     const ObTableLockOpStatus lock_op_status,
-    const int64_t seq_no,
+    const ObTxSEQ seq_no,
     const int64_t create_timestamp,
     const int64_t create_schema_version)
 {
diff --git a/src/storage/tablelock/ob_table_lock_common.h b/src/storage/tablelock/ob_table_lock_common.h
index 20e3ad0933..16d83f8375 100755
--- a/src/storage/tablelock/ob_table_lock_common.h
+++ b/src/storage/tablelock/ob_table_lock_common.h
@@ -355,7 +355,7 @@ public:
       create_trans_id_(),
       op_type_(UNKNOWN_TYPE),
       lock_op_status_(UNKNOWN_STATUS),
-      lock_seq_no_(0),
+      lock_seq_no_(),
       commit_version_(),
       commit_scn_(),
       create_timestamp_(0),
@@ -368,7 +368,7 @@ public:
       const ObTransID &trans_id,
       const ObTableLockOpType op_type,
       const ObTableLockOpStatus lock_op_status,
-      const int64_t seq_no,
+      const ObTxSEQ seq_no,
       const int64_t create_timestamp,
       const int64_t create_schema_version) :
       lock_id_(),
@@ -377,7 +377,7 @@ public:
       create_trans_id_(),
       op_type_(UNKNOWN_TYPE),
       lock_op_status_(UNKNOWN_STATUS),
-      lock_seq_no_(0),
+      lock_seq_no_(),
       commit_version_(),
       commit_scn_(),
       create_timestamp_(0),
@@ -400,7 +400,7 @@ public:
       const ObTransID &trans_id,
       const ObTableLockOpType op_type,
       const ObTableLockOpStatus lock_op_status,
-      const int64_t seq_no,
+      const ObTxSEQ seq_no,
       const int64_t create_timestamp,
       const int64_t create_schema_version);
   bool is_valid() const;
@@ -445,7 +445,7 @@ public:
   ObTransID create_trans_id_;
   ObTableLockOpType op_type_;
   ObTableLockOpStatus lock_op_status_;
-  int64_t lock_seq_no_;
+  ObTxSEQ lock_seq_no_;
   share::SCN commit_version_;
   share::SCN commit_scn_;
   // used to check whether a trans modify before a schema_version or timestamp.
diff --git a/src/storage/tablelock/ob_table_lock_service.cpp b/src/storage/tablelock/ob_table_lock_service.cpp
index 6b2360be63..fc0df95978 100755
--- a/src/storage/tablelock/ob_table_lock_service.cpp
+++ b/src/storage/tablelock/ob_table_lock_service.cpp
@@ -50,12 +50,12 @@ ObTableLockService::ObTableLockCtx::ObTableLockCtx(const ObTableLockTaskType tas
     abs_timeout_ts_(),
     trans_state_(),
     tx_desc_(nullptr),
-    current_savepoint_(-1),
+    current_savepoint_(),
     tablet_list_(),
     schema_version_(-1),
     tx_is_killed_(false),
     is_from_sql_(false),
-    stmt_savepoint_(-1)
+    stmt_savepoint_()
 {
   abs_timeout_ts_ = (0 == timeout_us)
     ? ObTimeUtility::current_time() + DEFAULT_TIMEOUT_US
@@ -2869,7 +2869,7 @@ int ObTableLockService::start_sub_tx_(ObTableLockCtx &ctx)
     const ObTxParam &tx_param = ctx.tx_param_;
     const ObTxIsolationLevel &isolation_level = tx_param.isolation_;
     const int64_t expire_ts = ctx.abs_timeout_ts_;
-    int64_t &savepoint = ctx.current_savepoint_;
+    auto &savepoint = ctx.current_savepoint_;
     if (OB_FAIL(txs->create_implicit_savepoint(*ctx.tx_desc_,
                                                tx_param,
                                                savepoint))) {
@@ -2889,7 +2889,7 @@ int ObTableLockService::end_sub_tx_(ObTableLockCtx &ctx, const bool is_rollback)
   if (!ctx.is_savepoint_valid()) {
     LOG_INFO("end_sub_tx_ skip", K(ret), K(ctx));
   } else {
-    const int64_t &savepoint = ctx.current_savepoint_;
+    const auto &savepoint = ctx.current_savepoint_;
     const int64_t expire_ts = OB_MAX(ctx.abs_timeout_ts_, DEFAULT_TIMEOUT_US + ObTimeUtility::current_time());
     ObTransService *txs = MTL(ObTransService*);
     if (is_rollback &&
@@ -2921,7 +2921,7 @@ int ObTableLockService::start_stmt_(ObTableLockCtx &ctx)
     const ObTxParam &tx_param = ctx.tx_param_;
     const ObTxIsolationLevel &isolation_level = tx_param.isolation_;
     const int64_t expire_ts = ctx.abs_timeout_ts_;
-    int64_t &savepoint = ctx.stmt_savepoint_;
+    auto &savepoint = ctx.stmt_savepoint_;
     if (OB_FAIL(txs->create_implicit_savepoint(*ctx.tx_desc_,
                                                tx_param,
                                                savepoint))) {
@@ -2941,7 +2941,7 @@ int ObTableLockService::end_stmt_(ObTableLockCtx &ctx, const bool is_rollback)
   if (!ctx.is_stmt_savepoint_valid()) {
     LOG_INFO("end_stmt_ skip", K(ret), K(ctx));
   } else {
-    const int64_t &savepoint = ctx.stmt_savepoint_;
+    const auto &savepoint = ctx.stmt_savepoint_;
     const int64_t expire_ts = OB_MAX(ctx.abs_timeout_ts_, DEFAULT_TIMEOUT_US + ObTimeUtility::current_time());
     ObTransService *txs = MTL(ObTransService*);
     // just rollback the whole stmt, if it is needed.
diff --git a/src/storage/tablelock/ob_table_lock_service.h b/src/storage/tablelock/ob_table_lock_service.h
index 7ca2bbb5a6..36de52e4f4 100755
--- a/src/storage/tablelock/ob_table_lock_service.h
+++ b/src/storage/tablelock/ob_table_lock_service.h
@@ -93,11 +93,11 @@ private:
     const common::ObTabletID &get_tablet_id(const int64_t index) const;
     int add_touched_ls(const share::ObLSID &lsid);
     void clean_touched_ls();
-    bool is_savepoint_valid() { return -1 != current_savepoint_; }
-    void reset_savepoint() { current_savepoint_ = -1; }
+    bool is_savepoint_valid() { return current_savepoint_.is_valid(); }
+    void reset_savepoint() { current_savepoint_.reset(); }
 
-    bool is_stmt_savepoint_valid() { return -1 != stmt_savepoint_; }
-    void reset_stmt_savepoint() { stmt_savepoint_ = -1; }
+    bool is_stmt_savepoint_valid() { return stmt_savepoint_.is_valid(); }
+    void reset_stmt_savepoint() { stmt_savepoint_.reset(); }
     ObTableLockOpType get_lock_op_type() const { return lock_op_type_; }
     bool is_unlock_task() const
     {
@@ -135,7 +135,7 @@ private:
     sql::TransState trans_state_;
     transaction::ObTxDesc *tx_desc_;
     ObTxParam tx_param_;           // the tx param for current tx
-    int64_t current_savepoint_;    // used to rollback current sub tx.
+    transaction::ObTxSEQ current_savepoint_;    // used to rollback current sub tx.
     share::ObLSArray need_rollback_ls_; // which ls has been modified after
                                         // the current_savepoint_ created.
     common::ObTabletIDArray tablet_list_; // all the tablets need to be locked/unlocked
@@ -147,7 +147,7 @@ private:
     bool is_from_sql_;
 
     // use to kill the whole lock table stmt.
-    int64_t stmt_savepoint_;
+    transaction::ObTxSEQ stmt_savepoint_;
 
     TO_STRING_KV(K(is_in_trans_), K(table_id_), K(partition_id_),
                  K(tablet_list_), K(obj_list_), K(lock_op_type_),
diff --git a/src/storage/tx/ob_trans_define.cpp b/src/storage/tx/ob_trans_define.cpp
index af6ebdb880..ddc0d545f8 100755
--- a/src/storage/tx/ob_trans_define.cpp
+++ b/src/storage/tx/ob_trans_define.cpp
@@ -1100,7 +1100,7 @@ void ObTxExecInfo::reset()
   max_applied_log_ts_.reset();
   max_applying_log_ts_.reset();
   max_applying_part_log_no_ = INT64_MAX;
-  max_submitted_seq_no_ = 0;
+  max_submitted_seq_no_.reset();
   checksum_ = 0;
   checksum_scn_.set_min();
   max_durable_lsn_.reset();
diff --git a/src/storage/tx/ob_trans_define.h b/src/storage/tx/ob_trans_define.h
index 864a74c451..cf170ad6d8 100644
--- a/src/storage/tx/ob_trans_define.h
+++ b/src/storage/tx/ob_trans_define.h
@@ -283,11 +283,109 @@ private:
   int64_t tx_id_;
 };
 
+// Transaction used Sequence number,
+// since 4.3 the Sequence number split into two parts:
+//   part 1: sequence number offset against transaction start
+//   part 2: id of parallel write branch
+class ObTxSEQ
+{
+public:
+  ObTxSEQ() : raw_val_(0) {}
+  explicit ObTxSEQ(int64_t seq, int16_t branch):
+    branch_(branch), seq_(seq), n_format_(true), _sign_(0)
+  {
+    OB_ASSERT(seq > 0 && seq >> 62 == 0);
+    OB_ASSERT(branch >= 0);
+  }
+private:
+  explicit ObTxSEQ(int64_t raw_v): raw_val_(raw_v) {}
+public:
+  // old version builder
+  static ObTxSEQ mk_v0(int64_t seq_v)
+  {
+    OB_ASSERT(seq_v > 0);
+    return ObTxSEQ(seq_v);
+  }
+  static const ObTxSEQ &INVL() { static ObTxSEQ v; return v; }
+  static const ObTxSEQ &MAX_VAL() { static ObTxSEQ v(INT64_MAX); return v; }
+  void reset() { raw_val_ = 0; }
+  bool is_valid() const { return raw_val_ > 0; }
+  bool is_max() const { return *this == MAX_VAL(); }
+  ObTxSEQ clone_with_seq(int64_t seq_n) const
+  {
+    ObTxSEQ n = *this;
+    if (n_format_) { n.seq_ = seq_n; } else { n.seq_v0_ = seq_n; }
+    return n;
+  }
+  bool operator>(const ObTxSEQ &b) const
+  {
+    return n_format_ ? seq_ > b.seq_ : seq_v0_ > b.seq_v0_;
+  }
+  bool operator>=(const ObTxSEQ &b) const
+  {
+    return *this > b || *this == b;
+  }
+  bool operator<(const ObTxSEQ &b) const
+  {
+    return b > *this;
+  }
+  bool operator<=(const ObTxSEQ &b) const
+  {
+    return b >= *this;
+  }
+  bool operator==(const ObTxSEQ &b) const
+  {
+    return raw_val_ == b.raw_val_;
+  }
+  bool operator!=(const ObTxSEQ &b) const
+  {
+    return !(*this == b);
+  }
+  ObTxSEQ &operator++() {
+    if (n_format_) { ++seq_; } else { ++seq_v0_; }
+    return *this;
+  }
+  ObTxSEQ operator+(int n) const {
+    int64_t s = n_format_ ? seq_ + n : seq_v0_ + n;
+    return n_format_ ? ObTxSEQ(s, branch_) : ObTxSEQ::mk_v0(s);
+  }
+  uint64_t hash() const { return murmurhash(&raw_val_, sizeof(raw_val_), 0); }
+  // atomic incremental update
+  int64_t inc_update(const ObTxSEQ &b) { return common::inc_update(&raw_val_, b.raw_val_); }
+  uint64_t cast_to_int() const { return raw_val_; }
+  static ObTxSEQ cast_from_int(int64_t seq) { return ObTxSEQ(seq); }
+  // return sequence number
+  int64_t get_seq() const { return n_format_ ? seq_ : seq_v0_; }
+  int16_t get_branch() const { return n_format_ ? branch_ : 0; }
+  // atomic Load/Store
+  void atomic_reset() { ATOMIC_SET(&raw_val_, 0); }
+  ObTxSEQ atomic_load() const { auto v = ATOMIC_LOAD(&raw_val_); ObTxSEQ s; s.raw_val_ = v; return s; }
+  void atomic_store(ObTxSEQ seq) { ATOMIC_STORE(&raw_val_, seq.raw_val_); }
+  NEED_SERIALIZE_AND_DESERIALIZE;
+  DECLARE_TO_STRING;
+private:
+  union {
+    int64_t raw_val_;
+    union {
+      struct { // v0, old_version
+        uint64_t seq_v0_     :62;
+      };
+      struct { // new_version
+        uint16_t branch_     :15;
+        uint64_t seq_        :47;
+        bool     n_format_   :1;
+        int     _sign_       :1;
+      };
+    };
+  };
+};
+static_assert(sizeof(ObTxSEQ) == sizeof(int64_t), "ObTxSEQ should sizeof(int64_t)");
+
 struct ObLockForReadArg
 {
   ObLockForReadArg(memtable::ObMvccAccessCtx &acc_ctx,
                    ObTransID data_trans_id,
-                   int64_t data_sql_sequence,
+                   ObTxSEQ data_sql_sequence,
                    bool read_latest,
                    share::SCN scn)
     : mvcc_acc_ctx_(acc_ctx),
@@ -300,7 +398,7 @@ struct ObLockForReadArg
 
   memtable::ObMvccAccessCtx &mvcc_acc_ctx_;
   ObTransID data_trans_id_;
-  int64_t data_sql_sequence_;
+  ObTxSEQ data_sql_sequence_;
   bool read_latest_;
   share::SCN scn_; // Compare with transfer_start_scn, sstable is end_scn, and memtable is ObMvccTransNode scn
 };
@@ -1394,36 +1492,35 @@ class ObUndoAction
   OB_UNIS_VERSION(1);
 public:
   ObUndoAction() { reset(); }
-  ObUndoAction(const int64_t undo_from, const int64_t undo_to)
+  ObUndoAction(const ObTxSEQ undo_from, const ObTxSEQ undo_to)
       : undo_from_(undo_from), undo_to_(undo_to) {}
   ~ObUndoAction() { destroy(); }
   void reset()
   {
-    undo_from_ = 0;
-    undo_to_ = 0;
+    undo_from_.reset();
+    undo_to_.reset();
   }
   void destroy() { reset(); }
   bool is_valid() const
-  { return undo_from_ > 0 && undo_to_ > 0 && undo_from_ > undo_to_; }
+  { return undo_from_.is_valid() && undo_to_.is_valid() && undo_from_ > undo_to_; }
 
-  bool is_contain(const int64_t seq_no) const
+  bool is_contain(const ObTxSEQ seq_no) const
   { return seq_no > undo_to_ && seq_no <= undo_from_; }
 
   bool is_contain(const ObUndoAction &other) const
   { return undo_from_ >= other.undo_from_ && undo_to_ <= other.undo_to_; }
 
-  bool is_less_than(const int64_t seq_no) const
+  bool is_less_than(const ObTxSEQ seq_no) const
   { return seq_no > undo_from_;}
 
   int merge(const ObUndoAction &other);
-  int64_t get_undo_from() { return undo_from_; }
 
   TO_STRING_KV(K_(undo_from), K_(undo_to));
 
 public:
   // from > to
-  int64_t undo_from_; // inclusive
-  int64_t undo_to_;   // exclusive
+  ObTxSEQ undo_from_; // inclusive
+  ObTxSEQ undo_to_;   // exclusive
 };
 
 class ObLSLogInfo final
@@ -1687,7 +1784,7 @@ public:
   share::SCN max_applied_log_ts_;
   share::SCN max_applying_log_ts_;
   int64_t max_applying_part_log_no_; // start from 0 on follower and always be INT64_MAX on leader
-  int64_t max_submitted_seq_no_; // maintains on Leader and transfer to Follower via ActiveInfoLog
+  ObTxSEQ max_submitted_seq_no_; // maintains on Leader and transfer to Follower via ActiveInfoLog
   uint64_t checksum_;
   share::SCN checksum_scn_;
   palf::LSN max_durable_lsn_;
diff --git a/src/storage/tx/ob_trans_define_v4.cpp b/src/storage/tx/ob_trans_define_v4.cpp
index 8d8896c1e0..ac27a7c0ed 100644
--- a/src/storage/tx/ob_trans_define_v4.cpp
+++ b/src/storage/tx/ob_trans_define_v4.cpp
@@ -75,7 +75,7 @@ const ObString &get_tx_isolation_str(const ObTxIsolationLevel isolation)
 }
 
 ObTxSavePoint::ObTxSavePoint()
-  : type_(T::INVL), scn_(0), session_id_(0), user_create_(false), name_() {}
+  : type_(T::INVL), scn_(), session_id_(0), user_create_(false), name_() {}
 
 ObTxSavePoint::ObTxSavePoint(const ObTxSavePoint &a)
 {
@@ -126,7 +126,7 @@ void ObTxSavePoint::release()
 {
   type_ = T::INVL;
   snapshot_ = NULL;
-  scn_ = 0;
+  scn_.reset();
   session_id_ = 0;
   user_create_ = false;
 }
@@ -146,7 +146,7 @@ void ObTxSavePoint::init(ObTxReadSnapshot *snapshot)
   scn_ = snapshot->core_.scn_;
 }
 
-int ObTxSavePoint::init(int64_t scn, const ObString &name, const uint32_t session_id, const bool user_create, const bool stash)
+int ObTxSavePoint::init(const ObTxSEQ &scn, const ObString &name, const uint32_t session_id, const bool user_create, const bool stash)
 {
   int ret = OB_SUCCESS;
   if (OB_FAIL(name_.assign(name))) {
@@ -265,7 +265,7 @@ ObTxDesc::ObTxDesc()
     access_mode_(ObTxAccessMode::RW),   // default is RW
     snapshot_version_(),
     snapshot_uncertain_bound_(0),
-    snapshot_scn_(0),
+    snapshot_scn_(),
     sess_id_(0),
     assoc_sess_id_(0),
     global_tx_type_(ObGlobalTxType::PLAIN),
@@ -280,8 +280,8 @@ ObTxDesc::ObTxDesc()
     expire_ts_(INT64_MAX),              // never expire by default
     commit_ts_(-1),
     finish_ts_(-1),
-    active_scn_(-1),
-    min_implicit_savepoint_(INT64_MAX),
+    active_scn_(),
+    min_implicit_savepoint_(),
     parts_(),
     savepoints_(),
     cflict_txs_(),
@@ -330,7 +330,7 @@ int ObTxDesc::switch_to_idle()
   expire_ts_ = INT64_MAX;
   commit_ts_ = 0;
   finish_ts_ = 0;
-  active_scn_ = 0;
+  active_scn_.reset();
   parts_.reset();
   cflict_txs_.reset();
   coord_id_.reset();
@@ -400,7 +400,7 @@ void ObTxDesc::reset()
   access_mode_ = ObTxAccessMode::INVL;
   snapshot_version_.reset();
   snapshot_uncertain_bound_ = 0;
-  snapshot_scn_ = 0;
+  snapshot_scn_.reset();
   global_tx_type_ = ObGlobalTxType::PLAIN;
 
   op_sn_ = -1;
@@ -419,8 +419,8 @@ void ObTxDesc::reset()
   commit_ts_ = -1;
   finish_ts_ = -1;
 
-  active_scn_ = -1;
-  min_implicit_savepoint_ = INT64_MAX; // easy for compare
+  active_scn_.reset();
+  min_implicit_savepoint_.reset();
   parts_.reset();
   savepoints_.reset();
   cflict_txs_.reset();
@@ -575,8 +575,8 @@ int ObTxDesc::update_part_(ObTxPart &a, const bool append)
       }
       if (OB_SUCC(ret)) {
         if (a.addr_.is_valid()) { p.addr_ = a.addr_; }
-        p.first_scn_ = std::min(a.first_scn_, p.first_scn_);
-        p.last_scn_ = (INT64_MAX == p.last_scn_) ? a.last_scn_ : std::max(a.last_scn_, p.last_scn_);
+        p.first_scn_ = MIN(a.first_scn_, p.first_scn_);
+        p.last_scn_ = p.last_scn_.is_max() ? a.last_scn_ : MAX(a.last_scn_, p.last_scn_);
         p.last_touch_ts_ = exec_info_reap_ts_ + 1;
       }
       break;
@@ -607,8 +607,8 @@ int ObTxDesc::update_clean_part(const share::ObLSID &id,
   p.id_ = id;
   p.epoch_ = epoch;
   p.addr_ = addr;
-  p.first_scn_ = INT64_MAX;
-  p.last_scn_ = ObSequence::get_max_seq_no();
+  p.first_scn_ = ObTxSEQ::MAX_VAL();
+  p.last_scn_ = get_tx_seq();
   return update_part_(p, false);
 }
 
@@ -636,8 +636,8 @@ int ObTxDesc::update_parts(const share::ObLSArray &list)
     ObTxPart n;
     n.id_ = it;
     n.epoch_ = ObTxPart::EPOCH_UNKNOWN;
-    n.first_scn_ = INT64_MAX;
-    n.last_scn_ = INT64_MAX;
+    n.first_scn_ = ObTxSEQ::MAX_VAL();
+    n.last_scn_ = ObTxSEQ::MAX_VAL();
     if (OB_TMP_FAIL(update_part_(n))) {
       ret = tmp_ret;
     }
@@ -651,7 +651,7 @@ void ObTxDesc::implicit_start_tx_()
     state_ = ObTxDesc::State::IMPLICIT_ACTIVE;
     active_ts_ = ObClockGenerator::getClock();
     expire_ts_ = active_ts_ + timeout_us_;
-    active_scn_ = ObSequence::get_max_seq_no();
+    active_scn_ = get_tx_seq();
     state_change_flags_.mark_all();
   }
 }
@@ -856,20 +856,22 @@ bool ObTxDesc::is_xa_terminate_state_() const
 
 bool ObTxDesc::has_implicit_savepoint() const
 {
-  return min_implicit_savepoint_ != INT64_MAX;
+  return min_implicit_savepoint_.is_valid();
 }
-void ObTxDesc::add_implicit_savepoint(const int64_t savepoint)
+void ObTxDesc::add_implicit_savepoint(const ObTxSEQ savepoint)
 {
-  min_implicit_savepoint_ = std::min(savepoint, min_implicit_savepoint_);
+  if (!min_implicit_savepoint_.is_valid() || min_implicit_savepoint_ > savepoint ) {
+    min_implicit_savepoint_ = savepoint;
+  }
 }
 void ObTxDesc::release_all_implicit_savepoint()
 {
-  min_implicit_savepoint_ = INT64_MAX;
+  min_implicit_savepoint_.reset();
 }
-void ObTxDesc::release_implicit_savepoint(const int64_t savepoint)
+void ObTxDesc::release_implicit_savepoint(const ObTxSEQ savepoint)
 {
   if (min_implicit_savepoint_ == savepoint) {
-    min_implicit_savepoint_ = INT64_MAX;
+    min_implicit_savepoint_.reset();
   }
   // invalid txn snapshot if it was created after the savepoint
   if (snapshot_version_.is_valid() && savepoint < snapshot_scn_) {
@@ -1003,11 +1005,11 @@ ObTxParam::~ObTxParam()
 }
 
 ObTxSnapshot::ObTxSnapshot()
-  : version_(), tx_id_(), scn_(-1), elr_(false) {}
+  : version_(), tx_id_(), scn_(), elr_(false) {}
 
 ObTxSnapshot::~ObTxSnapshot()
 {
-  scn_ = -1;
+  scn_.reset();
   elr_ = false;
 }
 
@@ -1015,7 +1017,7 @@ void ObTxSnapshot::reset()
 {
   version_.reset();
   tx_id_.reset();
-  scn_ = -1;
+  scn_.reset();
   elr_ = false;
 }
 
@@ -1072,7 +1074,7 @@ void ObTxReadSnapshot::init_weak_read(const SCN snapshot)
 {
   core_.version_ = snapshot;
   core_.tx_id_.reset();
-  core_.scn_ = 0;
+  core_.scn_.reset();
   core_.elr_ = false;
   source_ = SRC::WEAK_READ_SERVICE;
   parts_.reset();
@@ -1083,7 +1085,7 @@ void ObTxReadSnapshot::init_special_read(const SCN snapshot)
 {
   core_.version_ = snapshot;
   core_.tx_id_.reset();
-  core_.scn_ = 0;
+  core_.scn_.reset();
   core_.elr_ = false;
   source_ = SRC::SPECIAL;
   parts_.reset();
@@ -1229,17 +1231,15 @@ ObTxPart::ObTxPart()
   : id_(),
     addr_(),
     epoch_(-1),
-    first_scn_(INT64_MAX),
-    last_scn_(INT64_MIN),
+    first_scn_(),
+    last_scn_(),
     last_touch_ts_(0)
 {}
 ObTxPart::~ObTxPart()
 {
   epoch_ = -1;
-  // make first_scn > last_scn
-  // so that default is clean
-  first_scn_ = INT64_MAX;
-  last_scn_ = INT64_MIN;
+  first_scn_.reset();
+  last_scn_.reset();
   last_touch_ts_ = 0;
 }
 
@@ -1530,6 +1530,38 @@ void TxCtxStateHelper::restore_state()
   }
 }
 
+OB_SERIALIZE_MEMBER_SIMPLE(ObTxSEQ, raw_val_);
+DEF_TO_STRING(ObTxSEQ)
+{
+  int64_t pos = 0;
+  if (raw_val_ == INT64_MAX) {
+    BUF_PRINTF("MAX");
+  } else if (_sign_ == 0 && n_format_) {
+    J_OBJ_START();
+    J_KV(K_(branch), "seq", seq_);
+    J_OBJ_END();
+  } else {
+    BUF_PRINTF("%lu", raw_val_);
+  }
+  return pos;
+}
+
+ObTxSEQ ObTxDesc::get_tx_seq(int64_t seq_abs) const
+{
+  return ObTxSEQ::mk_v0(seq_abs > 0 ? seq_abs : ObSequence::get_max_seq_no());
+}
+ObTxSEQ ObTxDesc::get_and_inc_tx_seq(int16_t branch, int N) const
+{
+  UNUSED(branch);
+  auto seq = ObSequence::get_and_inc_max_seq_no(N);
+  return ObTxSEQ::mk_v0(seq);
+}
+ObTxSEQ ObTxDesc::inc_and_get_tx_seq(int16_t branch) const
+{
+  UNUSED(branch);
+  auto seq = ObSequence::inc_and_get_max_seq_no();
+  return ObTxSEQ::mk_v0(seq);
+}
 } // transaction
 } // oceanbase
 #undef USING_LOG_PREFIX
diff --git a/src/storage/tx/ob_trans_define_v4.h b/src/storage/tx/ob_trans_define_v4.h
index b7ddd918ab..e338c2853a 100644
--- a/src/storage/tx/ob_trans_define_v4.h
+++ b/src/storage/tx/ob_trans_define_v4.h
@@ -207,12 +207,12 @@ struct ObTxPart
   share::ObLSID id_;             // identifier, the logstream
   ObAddr addr_;           // its latest address
   int64_t epoch_;         // used to judge a ctx not revived
-  int64_t first_scn_;      // used to judge a ctx is clean in scheduler view
-  int64_t last_scn_;       // used to get rollback savepoint set
+  ObTxSEQ first_scn_;      // used to judge a ctx is clean in scheduler view
+  ObTxSEQ last_scn_;       // used to get rollback savepoint set
   int64_t last_touch_ts_; // used to judge a ctx retouched after a time point
   bool operator==(const ObTxPart &rhs) const { return id_ == rhs.id_ && addr_ == rhs.addr_; }
   bool operator!=(const ObTxPart &rhs) const { return !operator==(rhs); }
-  bool is_clean() const { return first_scn_ > last_scn_; }
+  bool is_clean() const { return !first_scn_.is_valid() || (first_scn_ > last_scn_); }
   bool is_without_ctx() const { return is_without_ctx(epoch_); }
   static bool is_without_ctx(int64_t epoch) { return EPOCH_DEAD == epoch; }
   TO_STRING_KV(K_(id), K_(addr), K_(epoch), K_(first_scn), K_(last_scn), K_(last_touch_ts));
@@ -228,7 +228,7 @@ struct ObTxSnapshot
 {
   share::SCN version_;
   ObTransID tx_id_;
-  int64_t scn_;
+  ObTxSEQ scn_;
   bool elr_;
   TO_STRING_KV(K_(version), K_(tx_id), K_(scn));
   ObTxSnapshot();
@@ -287,11 +287,15 @@ class ObTxSavePoint
   friend class ObTxDesc;
 private:
   enum class T { INVL= 0, SAVEPOINT= 1, SNAPSHOT= 2, STASH= 3 } type_;
-  int64_t scn_;
+  ObTxSEQ scn_;
   /* The savepoint should be unique to the session,
     and the session id is required to distinguish the
     savepoint for the multi-branch scenario of xa */
   uint32_t session_id_;
+  /*
+    used by XA, synchronize savepoint should exclude internal savepoint
+    (eg. 'PL IMPLICIT_SAVEPOINT')
+  */
   bool user_create_;
   union {
     ObTxReadSnapshot *snapshot_;
@@ -305,7 +309,7 @@ public:
   bool operator==(const ObTxSavePoint &a) const;
   void release();
   void rollback();
-  int init(const int64_t scn,
+  int init(const ObTxSEQ &scn,
            const ObString &name,
            const uint32_t session_id,
            const bool user_create,
@@ -382,7 +386,7 @@ protected:
   ObTxAccessMode access_mode_;         // READ_ONLY | READ_WRITE
   share::SCN snapshot_version_;           // snapshot for RR | SERIAL Isolation
   int64_t snapshot_uncertain_bound_;   // uncertain bound of @snapshot_version_
-  int64_t snapshot_scn_;               // the time of acquire @snapshot_version_
+  ObTxSEQ snapshot_scn_;               // the time of acquire @snapshot_version_
   uint32_t sess_id_;                   // sesssion id of txn start, for XA it is XA_START session id
   uint32_t assoc_sess_id_;             // the session which associated with
   ObGlobalTxType global_tx_type_;      // global trans type, i.e., xa or dblink
@@ -451,8 +455,8 @@ protected:
   int64_t commit_ts_;                // COMMIT start time
   int64_t finish_ts_;                // COMMIT/ABORT finish time
 
-  int64_t active_scn_;               // logical time of ACTIVE | IMPLICIT_ACTIVE
-  int64_t min_implicit_savepoint_;   // mininum of implicit savepoints
+  ObTxSEQ active_scn_;               // logical time of ACTIVE | IMPLICIT_ACTIVE
+  ObTxSEQ min_implicit_savepoint_;   // mininum of implicit savepoints
   ObTxPartList parts_;               // participant list
   ObTxSavePointList savepoints_;     // savepoints established
   // cflict_txs_ is used to store conflict trans id when try acquire row lock failed(meet lock conflict)
@@ -665,9 +669,9 @@ public:
   int get_inc_exec_info(ObTxExecResult &exec_info);
   int add_exec_info(const ObTxExecResult &exec_info);
   bool has_implicit_savepoint() const;
-  void add_implicit_savepoint(const int64_t savepoint);
+  void add_implicit_savepoint(const ObTxSEQ savepoint);
   void release_all_implicit_savepoint();
-  void release_implicit_savepoint(const int64_t savepoint);
+  void release_implicit_savepoint(const ObTxSEQ savepoint);
   ObTransTraceLog &get_tlog() { return tlog_; }
   bool is_xa_terminate_state_() const;
   void set_can_elr(const bool can_elr) { can_elr_ = can_elr; }
@@ -700,6 +704,9 @@ LST_DO(DEF_FREE_ROUTE_DECODE, (;), static, dynamic, parts, extra);
   bool is_extra_changed() { return state_change_flags_.EXTRA_CHANGED_; };
   void set_explicit() { flags_.EXPLICIT_ = true; }
   void clear_interrupt() { flags_.INTERRUPTED_ = false; }
+  ObTxSEQ get_and_inc_tx_seq(int16_t branch, int N) const;
+  ObTxSEQ inc_and_get_tx_seq(int16_t branch) const;
+  ObTxSEQ get_tx_seq(int64_t seq_abs = 0) const;
 };
 
 // Is used to store and travserse all TxScheduler's Stat information;
@@ -812,7 +819,7 @@ protected:
   int64_t timeout_us_;
   int64_t expire_ts_;
   int64_t finish_ts_;
-  int64_t active_scn_;
+  ObTxSEQ active_scn_;
   ObTxPartList parts_;
   uint32_t session_id_ = 0;
   ObTxSavePointList savepoints_;
diff --git a/src/storage/tx/ob_trans_part_ctx.cpp b/src/storage/tx/ob_trans_part_ctx.cpp
index 7271f6bc4d..eeaa53236d 100755
--- a/src/storage/tx/ob_trans_part_ctx.cpp
+++ b/src/storage/tx/ob_trans_part_ctx.cpp
@@ -304,8 +304,8 @@ void ObPartTransCtx::default_init_()
   sub_state_.reset();
   reset_log_cbs_();
   last_op_sn_ = 0;
-  last_scn_ = 0;
-  first_scn_ = 0;
+  last_scn_.reset();
+  first_scn_.reset();
   dup_table_follower_max_read_version_.reset();
   rec_log_ts_.reset();
   prev_rec_log_ts_.reset();
@@ -2906,7 +2906,7 @@ int ObPartTransCtx::submit_redo_active_info_log_()
   } else if (OB_FAIL(submit_redo_log_(log_block, has_redo, helper))) {
     TRANS_LOG(WARN, "submit redo log failed", KR(ret), K(*this));
   } else {
-    int64_t cur_submitted_seq_no = max(exec_info_.max_submitted_seq_no_, helper.max_seq_no_);
+    ObTxSEQ cur_submitted_seq_no = MAX(exec_info_.max_submitted_seq_no_, helper.max_seq_no_);
     ObTxActiveInfoLog active_info_log(exec_info_.scheduler_, exec_info_.trans_type_, session_id_,
                                       trace_info_.get_app_trace_id(),
                                       mt_ctx_.get_min_table_version(), can_elr_,
@@ -4682,8 +4682,8 @@ int ObPartTransCtx::replay_active_info(const ObTxActiveInfoLog &log,
     exec_info_.xid_ = log.get_xid();
     epoch_ = log.get_epoch();
     last_op_sn_ = log.get_last_op_sn();
-    first_scn_ = log.get_first_scn();
-    last_scn_ = log.get_last_scn();
+    first_scn_ = log.get_first_seq_no();
+    last_scn_ = log.get_last_seq_no();
     cluster_version_ = log.get_cluster_version();
     update_max_submitted_seq_no(log.get_max_submitted_seq_no());
     exec_info_.data_complete_ = true;
@@ -7054,7 +7054,7 @@ int ObPartTransCtx::check_status_()
  * 3) remember data_scn
  */
 int ObPartTransCtx::start_access(const ObTxDesc &tx_desc,
-                                 const int64_t data_scn)
+                                 const ObTxSEQ data_scn)
 {
   int ret = OB_SUCCESS;
   CtxLockGuard guard(lock_);
@@ -7064,8 +7064,8 @@ int ObPartTransCtx::start_access(const ObTxDesc &tx_desc,
     TRANS_LOG(WARN, "stale access operation", K(ret),
               K_(tx_desc.op_sn), K_(last_op_sn), KPC(this), K(tx_desc));
   } else if (FALSE_IT(++pending_write_)) {
-  } else if (FALSE_IT(last_scn_ = std::max(data_scn, last_scn_))) {
-  } else if (first_scn_ == 0 && FALSE_IT(first_scn_ = last_scn_)) {
+  } else if (FALSE_IT(last_scn_ = MAX(data_scn, last_scn_))) {
+  } else if (!first_scn_.is_valid() && FALSE_IT(first_scn_ = last_scn_)) {
   } else if (tx_desc.op_sn_ != last_op_sn_) {
     last_op_sn_ = tx_desc.op_sn_;
   }
@@ -7080,7 +7080,7 @@ int ObPartTransCtx::start_access(const ObTxDesc &tx_desc,
                       OB_ID(ret), ret,
                       OB_ID(trace_id), ObCurTraceId::get_trace_id_str(),
                       OB_ID(opid), tx_desc.op_sn_,
-                      OB_ID(data_seq), data_scn,
+                      OB_ID(data_seq), data_scn.cast_to_int(),
                       OB_ID(pending), pending_write_,
                       OB_ID(ctx_ref), get_ref(),
                       OB_ID(thread_id), get_itid() + 1);
@@ -7136,8 +7136,8 @@ int ObPartTransCtx::end_access()
  *   when start_access was called
  */
 int ObPartTransCtx::rollback_to_savepoint(const int64_t op_sn,
-                                          const int64_t from_scn,
-                                          const int64_t to_scn)
+                                          const ObTxSEQ from_scn,
+                                          const ObTxSEQ to_scn)
 {
   int ret = OB_SUCCESS;
   bool need_write_log = false;
@@ -7172,8 +7172,8 @@ int ObPartTransCtx::rollback_to_savepoint(const int64_t op_sn,
   }
   REC_TRANS_TRACE_EXT(tlog_, rollback_savepoint,
                       OB_ID(ret), ret,
-                      OB_ID(from), from_scn,
-                      OB_ID(to), to_scn,
+                      OB_ID(from), from_scn.cast_to_int(),
+                      OB_ID(to), to_scn.cast_to_int(),
                       OB_ID(pending), pending_write_,
                       OB_ID(opid), op_sn,
                       OB_ID(thread_id), GETTID());
@@ -7184,8 +7184,8 @@ int ObPartTransCtx::rollback_to_savepoint(const int64_t op_sn,
   return ret;
 }
 
-int ObPartTransCtx::rollback_to_savepoint_(const int64_t from_scn,
-                                           const int64_t to_scn)
+int ObPartTransCtx::rollback_to_savepoint_(const ObTxSEQ from_scn,
+                                           const ObTxSEQ to_scn)
 {
   int ret = OB_SUCCESS;
 
@@ -7240,8 +7240,8 @@ int ObPartTransCtx::rollback_to_savepoint_(const int64_t from_scn,
   return ret;
 }
 
-int ObPartTransCtx::submit_rollback_to_log_(const int64_t from_scn,
-                                            const int64_t to_scn,
+int ObPartTransCtx::submit_rollback_to_log_(const ObTxSEQ from_scn,
+                                            const ObTxSEQ to_scn,
                                             ObTxData *tx_data)
 {
   int ret = OB_SUCCESS;
@@ -7278,8 +7278,10 @@ int ObPartTransCtx::submit_rollback_to_log_(const int64_t from_scn,
   } else {
     log_cb->set_tx_data(tx_data);
   }
-  REC_TRANS_TRACE_EXT(tlog_, submit_rollback_log, OB_ID(ret), ret, OB_ID(from), from_scn, OB_ID(to),
-                      to_scn);
+  REC_TRANS_TRACE_EXT(tlog_, submit_rollback_log,
+                      OB_ID(ret), ret,
+                      OB_ID(from), from_scn.cast_to_int(),
+                      OB_ID(to), to_scn.cast_to_int());
   TRANS_LOG(INFO, "RollbackToLog submit", K(ret), K(from_scn), K(to_scn), KP(log_cb), KPC(this));
   return ret;
 }
diff --git a/src/storage/tx/ob_trans_part_ctx.h b/src/storage/tx/ob_trans_part_ctx.h
index fa7890889b..4c36057a3a 100644
--- a/src/storage/tx/ob_trans_part_ctx.h
+++ b/src/storage/tx/ob_trans_part_ctx.h
@@ -182,9 +182,9 @@ public:
     const memtable::ObMemtableSet *memtable_set);
   int64_t get_trans_mem_total_size() const { return mt_ctx_.get_trans_mem_total_size(); }
 
-  void update_max_submitted_seq_no(const int64_t seq_no)
+  void update_max_submitted_seq_no(const ObTxSEQ seq_no)
   {
-    inc_update(&(exec_info_.max_submitted_seq_no_), seq_no);
+    exec_info_.max_submitted_seq_no_.inc_update(seq_no);
   }
   int check_with_tx_data(ObITxDataCheckFunctor &fn);
   const share::SCN get_rec_log_ts() const;
@@ -730,12 +730,12 @@ public:
    *            new created data will marked with this seq no
    */
   int start_access(const ObTxDesc &tx_desc,
-                   const int64_t data_seq);
+                   const ObTxSEQ data_seq);
   /*
    * end_access - end of txn protected resources access
    */
   int end_access();
-  int rollback_to_savepoint(const int64_t op_sn, const int64_t from_scn, const int64_t to_scn);
+  int rollback_to_savepoint(const int64_t op_sn, const ObTxSEQ from_scn, const ObTxSEQ to_scn);
   int set_block_frozen_memtable(memtable::ObMemtable *memtable);
   void clear_block_frozen_memtable();
   bool is_logging_blocked();
@@ -743,8 +743,8 @@ public:
 private:
   int check_status_();
   int tx_keepalive_response_(const int64_t status);
-  int rollback_to_savepoint_(const int64_t from_scn, const int64_t to_scn);
-  int submit_rollback_to_log_(const int64_t from_scn, const int64_t to_scn, ObTxData *tx_data);
+  int rollback_to_savepoint_(const ObTxSEQ from_scn, const ObTxSEQ to_scn);
+  int submit_rollback_to_log_(const ObTxSEQ from_scn, const ObTxSEQ to_scn, ObTxData *tx_data);
   int set_state_info_array_();
   void build_and_post_collect_state_msg_(const share::SCN &snapshot);
   int build_and_post_ask_state_msg_(const share::SCN &snapshot);
@@ -791,9 +791,9 @@ private:
   // latest operation sequence no, used to detect duplicate operation
   int64_t last_op_sn_;
   // data sequence no of latest access
-  int64_t last_scn_;
+  ObTxSEQ last_scn_;
   // data sequence no of first access
-  int64_t first_scn_;
+  ObTxSEQ first_scn_;
 private:
   TransModulePageAllocator reserve_allocator_;
   // ========================================================
diff --git a/src/storage/tx/ob_trans_service.cpp b/src/storage/tx/ob_trans_service.cpp
index ebb141452e..c05d5868e9 100755
--- a/src/storage/tx/ob_trans_service.cpp
+++ b/src/storage/tx/ob_trans_service.cpp
@@ -729,7 +729,7 @@ int ObTransService::register_mds_into_tx(ObTxDesc &tx_desc,
   tx_param.access_mode_ = tx_desc.access_mode_;
   tx_param.isolation_ = tx_desc.isolation_;
   tx_param.timeout_us_ = tx_desc.timeout_us_;
-  int64_t savepoint = 0;
+  ObTxSEQ savepoint;
   if (OB_UNLIKELY(!tx_desc.is_valid() || !ls_id.is_valid() || type <= ObTxDataSourceType::UNKNOWN
                   || type >= ObTxDataSourceType::MAX_TYPE || OB_ISNULL(buf) || buf_len < 0)) {
     ret = OB_INVALID_ARGUMENT;
@@ -873,7 +873,7 @@ int ObTransService::register_mds_into_ctx_(ObTxDesc &tx_desc,
     ret = OB_INVALID_ARGUMENT;
     TRANS_LOG(WARN, "invalid argument", KR(ret), K(tx_desc), K(ls_id), KP(buf), K(buf_len));
   } else if (FALSE_IT(store_ctx.ls_id_ = ls_id)) {
-  } else if (OB_FAIL(get_write_store_ctx(tx_desc, snapshot, write_flag, store_ctx, true))) {
+  } else if (OB_FAIL(get_write_store_ctx(tx_desc, snapshot, write_flag, store_ctx, ObTxSEQ::INVL(), true))) {
     TRANS_LOG(WARN, "get store ctx failed", KR(ret), K(tx_desc), K(ls_id));
   } else {
     ObPartTransCtx *ctx = store_ctx.mvcc_acc_ctx_.tx_ctx_;
diff --git a/src/storage/tx/ob_trans_service_v4.cpp b/src/storage/tx/ob_trans_service_v4.cpp
index 3e66f2d88c..bc1470ba7b 100755
--- a/src/storage/tx/ob_trans_service_v4.cpp
+++ b/src/storage/tx/ob_trans_service_v4.cpp
@@ -936,7 +936,7 @@ int ObTransService::handle_trans_keepalive_response(const ObTxKeepaliveRespMsg &
 
 int ObTransService::find_parts_after_sp_(ObTxDesc &tx,
                                          ObTxPartRefList &parts,
-                                         const int64_t scn)
+                                         const ObTxSEQ scn)
 {
   int ret = OB_SUCCESS;
   ARRAY_FOREACH(tx.parts_, i) {
@@ -1073,12 +1073,13 @@ int ObTransService::get_write_store_ctx(ObTxDesc &tx,
                                         const ObTxReadSnapshot &snapshot,
                                         const concurrent_control::ObWriteFlag write_flag,
                                         storage::ObStoreCtx &store_ctx,
+                                        const ObTxSEQ &spec_seq_no,
                                         const bool special)
 {
   int ret = OB_SUCCESS;
   const share::ObLSID &ls_id = store_ctx.ls_id_;
   ObPartTransCtx *tx_ctx = NULL;
-  const int64_t data_scn = ObSequence::inc_and_get_max_seq_no();
+  const ObTxSEQ data_scn = spec_seq_no.is_valid() ? spec_seq_no : tx.inc_and_get_tx_seq(0);
   ObTxSnapshot snap = snapshot.core_;
   ObTxTableGuard tx_table_guard;
   bool access_started = false;
@@ -3251,7 +3252,7 @@ int ObTransService::check_scheduler_status(const share::ObLSID &ls_id)
 /*
  * create_in_txn_implicit_savepoint - create an implicit savepoint when txn is active
  */
-int ObTransService::create_in_txn_implicit_savepoint(ObTxDesc &tx, int64_t &savepoint)
+int ObTransService::create_in_txn_implicit_savepoint(ObTxDesc &tx, ObTxSEQ &savepoint)
 {
   int ret = OB_SUCCESS;
 
diff --git a/src/storage/tx/ob_trans_service_v4.h b/src/storage/tx/ob_trans_service_v4.h
index b3a26bc238..da7d19a74f 100644
--- a/src/storage/tx/ob_trans_service_v4.h
+++ b/src/storage/tx/ob_trans_service_v4.h
@@ -29,7 +29,7 @@ int interrupt(ObTxDesc &tx, int cause);
 /*
  * create an implicit savepoint when txn is active
  */
-int create_in_txn_implicit_savepoint(ObTxDesc &tx, int64_t &savepoint);
+int create_in_txn_implicit_savepoint(ObTxDesc &tx, ObTxSEQ &savepoint);
 
 /*
  * prepare a transaction
@@ -80,7 +80,8 @@ int get_write_store_ctx(ObTxDesc &tx,
                         const ObTxReadSnapshot &snapshot,
                         const concurrent_control::ObWriteFlag write_flag,
                         storage::ObStoreCtx &store_ctx,
-                        const bool special);
+                        const ObTxSEQ &spec_seq_no = ObTxSEQ::INVL(),
+                        const bool special = false);
 int revert_store_ctx(storage::ObStoreCtx &store_ctx);
 
 int acquire_tx_ctx(const share::ObLSID &ls_id,
@@ -198,14 +199,14 @@ void abort_tx__(ObTxDesc &tx, bool cleanup);
 int finalize_tx_(ObTxDesc &tx);
 int find_parts_after_sp_(ObTxDesc &tx,
                          ObTxPartRefList &parts,
-                         const int64_t scn);
+                         const ObTxSEQ scn);
 int rollback_savepoint_(ObTxDesc &tx,
                         ObTxPartRefList &parts,
-                        const int64_t savepoint,
+                        const ObTxSEQ savepoint,
                         int64_t expire_ts);
 int rollback_savepoint_slowpath_(ObTxDesc &tx,
                                  const ObTxPartRefList &parts,
-                                 const int64_t scn,
+                                 const ObTxSEQ scn,
                                  const int64_t expire_ts);
 void on_sp_rollback_succ_(const ObTxLSEpochPair &part,
                           ObTxDesc &tx,
@@ -341,7 +342,7 @@ int ls_rollback_to_savepoint_(const ObTransID &tx_id,
                               const share::ObLSID &ls,
                               const int64_t verify_epoch,
                               const int64_t op_sn,
-                              const int64_t savepoint,
+                              const ObTxSEQ savepoint,
                               int64_t &ctx_born_epoch,
                               const ObTxDesc *tx,
                               int64_t expire_ts = -1);
@@ -352,20 +353,20 @@ int sync_rollback_savepoint__(ObTxDesc &tx,
                               const int64_t max_retry_interval,
                               int &retries);
 int create_local_implicit_savepoint_(ObTxDesc &tx,
-                                     int64_t &savepoint);
+                                     ObTxSEQ &savepoint);
 int create_global_implicit_savepoint_(ObTxDesc &tx,
                                       const ObTxParam &tx_param,
-                                      int64_t &savepoint,
+                                      ObTxSEQ &savepoint,
                                       const bool release);
 int rollback_to_local_implicit_savepoint_(ObTxDesc &tx,
-                                          const int64_t savepoint,
+                                          const ObTxSEQ savepoint,
                                           const int64_t expire_ts);
 int rollback_to_global_implicit_savepoint_(ObTxDesc &tx,
-                                           const int64_t savepoint,
+                                           const ObTxSEQ savepoint,
                                            const int64_t expire_ts,
                                            const share::ObLSArray *extra_touched_ls);
 int ls_sync_rollback_savepoint__(ObPartTransCtx *part_ctx,
-                                 const int64_t savepoint,
+                                 const ObTxSEQ savepoint,
                                  const int64_t op_sn,
                                  const int64_t expire_ts);
 void tx_post_terminate_(ObTxDesc &tx);
diff --git a/src/storage/tx/ob_tx_api.cpp b/src/storage/tx/ob_tx_api.cpp
index 9c097a46de..ae68b5430a 100644
--- a/src/storage/tx/ob_tx_api.cpp
+++ b/src/storage/tx/ob_tx_api.cpp
@@ -265,7 +265,7 @@ int ObTransService::start_tx(ObTxDesc &tx, const ObTxParam &tx_param, const ObTr
       // start tx need reacquire snapshot
       tx.snapshot_version_.reset();
       // setup correct active_scn, whatever its used or not
-      tx.active_scn_      = ObSequence::get_max_seq_no();
+      tx.active_scn_      = tx.get_tx_seq();
       tx.state_           = ObTxDesc::State::ACTIVE;
       tx.flags_.EXPLICIT_ = true;
     }
@@ -595,7 +595,7 @@ int ObTransService::get_read_snapshot(ObTxDesc &tx,
       } else {
         tx.snapshot_version_ = version;
         tx.snapshot_uncertain_bound_ = uncertain_bound;
-        tx.snapshot_scn_ = ObSequence::get_max_seq_no() + 1;
+        tx.snapshot_scn_ = tx.get_tx_seq(ObSequence::get_max_seq_no() + 1);
         tx.state_change_flags_.EXTRA_CHANGED_ = true;
       }
     }
@@ -618,7 +618,7 @@ int ObTransService::get_read_snapshot(ObTxDesc &tx,
     // If tx id is valid , record tx_id and scn
     if (tx.tx_id_.is_valid()) {
       snapshot.core_.tx_id_ = tx.tx_id_;
-      snapshot.core_.scn_ = ObSequence::get_max_seq_no();
+      snapshot.core_.scn_ = tx.get_tx_seq();
     }
     if (tx.state_ != ObTxDesc::State::IDLE) {
       ARRAY_FOREACH(tx.parts_, i) {
@@ -637,7 +637,7 @@ int ObTransService::get_read_snapshot(ObTxDesc &tx,
                       OB_ID(snapshot_source), (int)snapshot.source_,
                       OB_ID(snapshot_version), snapshot.core_.version_,
                       OB_ID(snapshot_txid), snapshot.core_.tx_id_.get_id(),
-                      OB_ID(snapshot_scn), snapshot.core_.scn_,
+                      OB_ID(snapshot_scn), snapshot.core_.scn_.cast_to_int(),
                       OB_ID(trace_id), ObCurTraceId::get_trace_id_str(),
                       OB_ID(ref), tx.get_ref(),
                       OB_ID(thread_id), GETTID());
@@ -671,7 +671,7 @@ int ObTransService::get_ls_read_snapshot(ObTxDesc &tx,
       // If tx id is valid , record tx_id and scn
       if (tx.tx_id_.is_valid()) {
         snapshot.core_.tx_id_ = tx.tx_id_;
-        snapshot.core_.scn_ = ObSequence::get_max_seq_no();
+        snapshot.core_.scn_ = tx.get_tx_seq();
       }
       if (tx.state_ != ObTxDesc::State::IDLE) {
         ARRAY_FOREACH(tx.parts_, i) {
@@ -700,7 +700,7 @@ int ObTransService::get_ls_read_snapshot(ObTxDesc &tx,
                       OB_ID(snapshot_source), (int)snapshot.source_,
                       OB_ID(snapshot_version), snapshot.core_.version_,
                       OB_ID(snapshot_txid), snapshot.core_.tx_id_.get_id(),
-                      OB_ID(snapshot_scn), snapshot.core_.scn_,
+                      OB_ID(snapshot_scn), snapshot.core_.scn_.cast_to_int(),
                       OB_ID(trace_id), ObCurTraceId::get_trace_id_str(),
                       OB_ID(ref), tx.get_ref(),
                       OB_ID(thread_id), GETTID());
@@ -823,7 +823,7 @@ int ObTransService::register_tx_snapshot_verify(ObTxReadSnapshot &snapshot)
       REC_TRANS_TRACE_EXT(&tlog, register_snapshot, OB_Y(ret),
                           OB_ID(arg), (void*)&snapshot,
                           OB_ID(snapshot_version), snapshot.core_.version_,
-                          OB_ID(snapshot_scn), snapshot.core_.scn_,
+                          OB_ID(snapshot_scn), snapshot.core_.scn_.cast_to_int(),
                           OB_ID(ref), tx->get_ref(),
                           OB_ID(thread_id), GETTID());
     } else if (ret != OB_ENTRY_NOT_EXIST) {
@@ -858,7 +858,7 @@ void ObTransService::unregister_tx_snapshot_verify(ObTxReadSnapshot &snapshot)
       REC_TRANS_TRACE_EXT(&tlog, unregister_snapshot, OB_Y(ret),
                           OB_ID(arg), (void*)&snapshot,
                           OB_ID(snapshot_version), snapshot.core_.version_,
-                          OB_ID(snapshot_scn), snapshot.core_.scn_,
+                          OB_ID(snapshot_scn), snapshot.core_.scn_.cast_to_int(),
                           OB_ID(ref), tx->get_ref(),
                           OB_ID(thread_id), GETTID());
     }
@@ -871,7 +871,7 @@ void ObTransService::unregister_tx_snapshot_verify(ObTxReadSnapshot &snapshot)
 
 int ObTransService::create_implicit_savepoint(ObTxDesc &tx,
                                               const ObTxParam &tx_param,
-                                              int64_t &savepoint,
+                                              ObTxSEQ &savepoint,
                                               const bool release)
 {
   int ret = OB_SUCCESS;
@@ -894,14 +894,14 @@ int ObTransService::create_implicit_savepoint(ObTxDesc &tx,
 }
 
 int ObTransService::create_local_implicit_savepoint_(ObTxDesc &tx,
-                                                     int64_t &savepoint)
+                                                     ObTxSEQ &savepoint)
 {
   int ret = OB_SUCCESS;
-  savepoint = ObSequence::inc_and_get_max_seq_no();
+  savepoint = tx.inc_and_get_tx_seq(0);
   TRANS_LOG(TRACE, "create local implicit savepoint", K(ret), K(savepoint), K(tx));
   ObTransTraceLog &tlog = tx.get_tlog();
   REC_TRANS_TRACE_EXT(&tlog, create_local_implicit_savepoint,
-                      OB_Y(ret), OB_Y(savepoint), OB_ID(opid), tx.op_sn_,
+                      OB_Y(ret), OB_ID(savepoint), savepoint.cast_to_int(), OB_ID(opid), tx.op_sn_,
                       OB_ID(ref), tx.get_ref(),
                       OB_ID(thread_id), GETTID());
   return ret;
@@ -909,7 +909,7 @@ int ObTransService::create_local_implicit_savepoint_(ObTxDesc &tx,
 
 int ObTransService::create_global_implicit_savepoint_(ObTxDesc &tx,
                                                       const ObTxParam &tx_param,
-                                                      int64_t &savepoint,
+                                                      ObTxSEQ &savepoint,
                                                       const bool release)
 {
   int ret = OB_SUCCESS;
@@ -927,7 +927,7 @@ int ObTransService::create_global_implicit_savepoint_(ObTxDesc &tx,
   tx.lock_timeout_us_ = tx_param.lock_timeout_us_;
 
   tx.inc_op_sn();
-  savepoint = ObSequence::inc_and_get_max_seq_no();
+  savepoint = tx.inc_and_get_tx_seq(0);
   if (tx.state_ == ObTxDesc::State::IDLE && !tx.tx_id_.is_valid()) {
     if (tx.has_implicit_savepoint()) {
       ret = OB_TRANS_INVALID_STATE;
@@ -945,7 +945,7 @@ int ObTransService::create_global_implicit_savepoint_(ObTxDesc &tx,
   ObTransTraceLog &tlog = tx.get_tlog();
   REC_TRANS_TRACE_EXT(&tlog, create_global_implicit_savepoint, OB_Y(ret),
                       OB_ID(txid), tx.tx_id_,
-                      OB_Y(savepoint), OB_Y(release),
+                      OB_ID(savepoint), savepoint.cast_to_int(), OB_Y(release),
                       OB_ID(opid), tx.op_sn_,
                       OB_ID(ref), tx.get_ref(),
                       OB_ID(thread_id), GETTID());
@@ -972,7 +972,7 @@ int ObTransService::create_global_implicit_savepoint_(ObTxDesc &tx,
 // [2] normal rollback:
 //     if rollback failed: abort tx
 int ObTransService::rollback_to_implicit_savepoint(ObTxDesc &tx,
-                                                   const int64_t savepoint,
+                                                   const ObTxSEQ savepoint,
                                                    const int64_t expire_ts,
                                                    const share::ObLSArray *extra_touched_ls)
 {
@@ -997,7 +997,7 @@ int ObTransService::rollback_to_implicit_savepoint(ObTxDesc &tx,
 }
 
 int ObTransService::rollback_to_local_implicit_savepoint_(ObTxDesc &tx,
-                                                          const int64_t savepoint,
+                                                          const ObTxSEQ savepoint,
                                                           const int64_t expire_ts)
 {
   int ret = OB_SUCCESS;
@@ -1033,7 +1033,7 @@ int ObTransService::rollback_to_local_implicit_savepoint_(ObTxDesc &tx,
 #endif
   ObTransTraceLog &tlog = tx.get_tlog();
   REC_TRANS_TRACE_EXT(&tlog, rollback_local_implicit_savepoint,
-                      OB_Y(ret), OB_Y(savepoint), OB_Y(expire_ts),
+                      OB_Y(ret), OB_ID(savepoint), savepoint.cast_to_int(), OB_Y(expire_ts),
                       OB_ID(time_used) , elapsed_us,
                       OB_ID(opid), tx.op_sn_,
                       OB_ID(ref), tx.get_ref(),
@@ -1042,7 +1042,7 @@ int ObTransService::rollback_to_local_implicit_savepoint_(ObTxDesc &tx,
 }
 
 int ObTransService::rollback_to_global_implicit_savepoint_(ObTxDesc &tx,
-                                                           const int64_t savepoint,
+                                                           const ObTxSEQ savepoint,
                                                            const int64_t expire_ts,
                                                            const share::ObLSArray *extra_touched_ls)
 {
@@ -1139,7 +1139,7 @@ int ObTransService::rollback_to_global_implicit_savepoint_(ObTxDesc &tx,
 #endif
   ObTransTraceLog &tlog = tx.get_tlog();
   REC_TRANS_TRACE_EXT(&tlog, rollback_global_implicit_savepoint,
-                      OB_Y(ret), OB_Y(savepoint), OB_Y(expire_ts),
+                      OB_Y(ret), OB_ID(savepoint), savepoint.cast_to_int(), OB_Y(expire_ts),
                       OB_ID(time_used), elapsed_us,
                       OB_ID(arg), (void*)extra_touched_ls,
                       OB_ID(tag1), reset_tx,
@@ -1150,14 +1150,14 @@ int ObTransService::rollback_to_global_implicit_savepoint_(ObTxDesc &tx,
 }
 
 int ObTransService::ls_sync_rollback_savepoint__(ObPartTransCtx *part_ctx,
-                                                 const int64_t savepoint,
+                                                 const ObTxSEQ savepoint,
                                                  const int64_t op_sn,
                                                  const int64_t expire_ts)
 {
   int ret = OB_SUCCESS;
   int64_t retry_cnt = 0;
   bool blockable = expire_ts > 0;
-  const int64_t from_scn = ObSequence::inc_and_get_max_seq_no();
+  const auto from_scn = savepoint.clone_with_seq(ObSequence::inc_and_get_max_seq_no());
   do {
     ret = part_ctx->rollback_to_savepoint(op_sn, from_scn, savepoint);
     if (OB_NEED_RETRY == ret && blockable) {
@@ -1193,10 +1193,9 @@ int ObTransService::create_explicit_savepoint(ObTxDesc &tx,
                                               const bool user_create)
 {
   int ret = OB_SUCCESS;
-  int64_t scn = 0;
   ObSpinLockGuard guard(tx.lock_);
   tx.inc_op_sn();
-  scn = ObSequence::inc_and_get_max_seq_no();
+  const auto scn = tx.inc_and_get_tx_seq(0);
   ObTxSavePoint sp;
   if (OB_SUCC(sp.init(scn, savepoint, session_id, user_create))) {
     if (OB_FAIL(tx.savepoints_.push_back(sp))) {
@@ -1222,7 +1221,7 @@ int ObTransService::create_explicit_savepoint(ObTxDesc &tx,
   ObTransTraceLog &tlog = tx.get_tlog();
   REC_TRANS_TRACE_EXT(&tlog, create_explicit_savepoint, OB_Y(ret),
                       OB_ID(savepoint), savepoint,
-                      OB_ID(seq_no), scn,
+                      OB_ID(seq_no), scn.cast_to_int(),
                       OB_ID(opid), tx.op_sn_,
                       OB_ID(ref), tx.get_ref(),
                       OB_ID(thread_id), GETTID());
@@ -1240,7 +1239,7 @@ int ObTransService::rollback_to_explicit_savepoint(ObTxDesc &tx,
 {
   int ret = OB_SUCCESS;
   auto start_ts = ObTimeUtility::current_time();
-  int64_t sp_scn = -1;
+  ObTxSEQ sp_scn;
   ObSpinLockGuard guard(tx.lock_);
   if (OB_SUCC(tx_sanity_check_(tx))) {
     tx.inc_op_sn();
@@ -1253,7 +1252,7 @@ int ObTransService::rollback_to_explicit_savepoint(ObTxDesc &tx,
         break;
       }
     }
-    if (sp_scn == -1) {
+    if (!sp_scn.is_valid()) {
       ret = OB_SAVEPOINT_NOT_EXIST;
       TRANS_LOG(WARN, "savepoint not exist", K(ret), K(savepoint), K_(tx.savepoints));
     }
@@ -1288,7 +1287,7 @@ int ObTransService::rollback_to_explicit_savepoint(ObTxDesc &tx,
   ObTransTraceLog &tlog = tx.get_tlog();
   REC_TRANS_TRACE_EXT(&tlog, rollback_explicit_savepoint, OB_Y(ret),
                       OB_ID(id), savepoint,
-                      OB_ID(savepoint), sp_scn,
+                      OB_ID(savepoint), sp_scn.cast_to_int(),
                       OB_ID(time_used), elapsed_us,
                       OB_ID(opid), tx.op_sn_,
                       OB_ID(ref), tx.get_ref(),
@@ -1302,7 +1301,7 @@ int ObTransService::release_explicit_savepoint(ObTxDesc &tx, const ObString &sav
 {
   int ret = OB_SUCCESS;
   bool hit = false;
-  int64_t sp_id = 0;
+  ObTxSEQ sp_id;
   ObSpinLockGuard guard(tx.lock_);
   if (OB_SUCC(tx_sanity_check_(tx))) {
     tx.inc_op_sn();
@@ -1332,7 +1331,7 @@ int ObTransService::release_explicit_savepoint(ObTxDesc &tx, const ObString &sav
   ObTransTraceLog &tlog = tx.get_tlog();
   REC_TRANS_TRACE_EXT(&tlog, release_explicit_savepoint, OB_Y(ret),
                       OB_ID(savepoint), savepoint,
-                      OB_ID(seq_no), sp_id,
+                      OB_ID(seq_no), sp_id.cast_to_int(),
                       OB_ID(opid), tx.op_sn_);
   return ret;
 }
@@ -1342,7 +1341,7 @@ int ObTransService::create_stash_savepoint(ObTxDesc &tx, const ObString &name)
   int ret = OB_SUCCESS;
   ObSpinLockGuard guard(tx.lock_);
   tx.inc_op_sn();
-  auto seq_no = ObSequence::inc_and_get_max_seq_no();
+  const auto seq_no = tx.inc_and_get_tx_seq(0);
   ObTxSavePoint sp;
   if (OB_SUCC(sp.init(seq_no, name, 0, false, true))) {
     if (OB_FAIL(tx.savepoints_.push_back(sp))) {
@@ -1352,7 +1351,7 @@ int ObTransService::create_stash_savepoint(ObTxDesc &tx, const ObString &name)
   TRANS_LOG(TRACE, "create stash savepoint", K(ret), K(seq_no), K(name), K(tx));
   REC_TRANS_TRACE_EXT(&tx.tlog_, create_stash_savepoint, OB_Y(ret),
                       OB_ID(savepoint), name,
-                      OB_ID(seq_no), seq_no,
+                      OB_ID(seq_no), seq_no.cast_to_int(),
                       OB_ID(opid), tx.op_sn_);
   return ret;
 }
@@ -1365,7 +1364,7 @@ int ObTransService::create_stash_savepoint(ObTxDesc &tx, const ObString &name)
 //  abort tx if rollback failed
 int ObTransService::rollback_savepoint_(ObTxDesc &tx,
                                         ObTxPartRefList &parts,
-                                        const int64_t savepoint,
+                                        const ObTxSEQ savepoint,
                                         int64_t expire_ts)
 {
   int ret = OB_SUCCESS;
@@ -1436,7 +1435,7 @@ int ObTransService::ls_rollback_to_savepoint_(const ObTransID &tx_id,
                                               const share::ObLSID &ls,
                                               const int64_t verify_epoch,
                                               const int64_t op_sn,
-                                              const int64_t savepoint,
+                                              const ObTxSEQ savepoint,
                                               int64_t &ctx_born_epoch,
                                               const ObTxDesc *tx,
                                               int64_t expire_ts)
@@ -1502,7 +1501,7 @@ int ObTransService::ls_rollback_to_savepoint_(const ObTransID &tx_id,
 
 inline int ObTransService::rollback_savepoint_slowpath_(ObTxDesc &tx,
                                                         const ObTxPartRefList &parts,
-                                                        const int64_t savepoint,
+                                                        const ObTxSEQ savepoint,
                                                         const int64_t expire_ts)
 {
   int ret = OB_SUCCESS;
@@ -1592,7 +1591,7 @@ inline int ObTransService::rollback_savepoint_slowpath_(ObTxDesc &tx,
             K(savepoint), K(expire_ts), K(tx), K(parts.count()));
   ObTransTraceLog &tlog = tx.get_tlog();
   REC_TRANS_TRACE_EXT(&tlog, rollback_savepoint_slowpath, OB_Y(ret),
-                      OB_Y(savepoint), OB_Y(expire_ts),
+                      OB_ID(savepoint), savepoint.cast_to_int(), OB_Y(expire_ts),
                       OB_ID(retry_cnt), retries,
                       OB_ID(time_used), elapsed_us);
   return ret;
@@ -1774,11 +1773,11 @@ void ObTransService::tx_post_terminate_(ObTxDesc &tx)
     }
   }
   // release all savepoints
-  tx.min_implicit_savepoint_ = INT64_MAX;
+  tx.min_implicit_savepoint_.reset();
   tx.savepoints_.reset();
   // reset snapshot
   tx.snapshot_version_.reset();
-  tx.snapshot_scn_ = 0;
+  tx.snapshot_scn_.reset();
 }
 
 int ObTransService::start_epoch_(ObTxDesc &tx)
diff --git a/src/storage/tx/ob_tx_api.h b/src/storage/tx/ob_tx_api.h
index 7ce8d33bb2..0be089c043 100644
--- a/src/storage/tx/ob_tx_api.h
+++ b/src/storage/tx/ob_tx_api.h
@@ -314,7 +314,7 @@ void unregister_tx_snapshot_verify(ObTxReadSnapshot &snapshot);
  */
 int create_implicit_savepoint(ObTxDesc &tx,
                               const ObTxParam &tx_param,
-                              int64_t &savepoint,
+                              ObTxSEQ &savepoint,
                               const bool release = false);
 
 /**
@@ -370,7 +370,7 @@ int create_explicit_savepoint(ObTxDesc &tx,
  *                          rollback
  */
 int rollback_to_implicit_savepoint(ObTxDesc &tx,
-                                   const int64_t savepoint,
+                                   const ObTxSEQ savepoint,
                                    const int64_t expire_ts,
                                    const share::ObLSArray *extra_touched_ls);
 
diff --git a/src/storage/tx/ob_tx_data_define.cpp b/src/storage/tx/ob_tx_data_define.cpp
index a61b19edb4..cb3cde0051 100644
--- a/src/storage/tx/ob_tx_data_define.cpp
+++ b/src/storage/tx/ob_tx_data_define.cpp
@@ -170,7 +170,7 @@ int64_t ObUndoStatusList::get_serialize_size_() const
   return len;
 }
 
-bool ObUndoStatusList::is_contain(const int64_t seq_no, const int32_t tx_data_state) const
+bool ObUndoStatusList::is_contain(const transaction::ObTxSEQ seq_no, const int32_t tx_data_state) const
 {
   if (OB_LIKELY(ObTxData::COMMIT == tx_data_state || ObTxData::ABORT == tx_data_state)) {
     return is_contain_(seq_no);
@@ -180,7 +180,7 @@ bool ObUndoStatusList::is_contain(const int64_t seq_no, const int32_t tx_data_st
   }
 }
 
-bool ObUndoStatusList::is_contain_(const int64_t seq_no) const
+bool ObUndoStatusList::is_contain_(const transaction::ObTxSEQ seq_no) const
 {
   bool bool_ret = false;
   ObUndoStatusNode *node_ptr = head_;
@@ -234,7 +234,7 @@ void ObUndoStatusList::dump_2_text(FILE *fd) const
   }
   while (OB_NOT_NULL(node)) {
     for (int64_t i = node->size_ - 1; i >= 0; i--) {
-      fprintf(fd, "{from:%ld, to:%ld}", node->undo_actions_[i].undo_from_, node->undo_actions_[i].undo_to_);
+      fprintf(fd, "{from:%ld, to:%ld}", node->undo_actions_[i].undo_from_.cast_to_int(), node->undo_actions_[i].undo_to_.cast_to_int());
     }
     node = node->next_;
   }
diff --git a/src/storage/tx/ob_tx_data_define.h b/src/storage/tx/ob_tx_data_define.h
index e2ec4aa6a0..6dde61f6a7 100644
--- a/src/storage/tx/ob_tx_data_define.h
+++ b/src/storage/tx/ob_tx_data_define.h
@@ -156,17 +156,15 @@ public:
   int serialize(char *buf, const int64_t buf_len, int64_t &pos) const;
   int deserialize(const char *buf, const int64_t data_len, int64_t &pos, ObSliceAlloc &slice_allocator);
   int64_t get_serialize_size() const;
-
-  bool is_contain(const int64_t seq_no, int32_t tx_data_state) const;
-  bool is_contain_(const int64_t seq_no) const;
-
-  void reset() 
-  { 
+  bool is_contain(const  transaction::ObTxSEQ seq_no, int32_t tx_data_state) const;
+  void reset()
+  {
     head_ = nullptr;
     undo_node_cnt_ = 0;
   }
 
 private:
+  bool is_contain_(const transaction::ObTxSEQ seq_no) const;
   int serialize_(char *buf, const int64_t buf_len, int64_t &pos) const;
   int deserialize_(const char *buf, const int64_t data_len, int64_t &pos, ObSliceAlloc &slice_allocator);
   int64_t get_serialize_size_() const;
diff --git a/src/storage/tx/ob_tx_data_functor.cpp b/src/storage/tx/ob_tx_data_functor.cpp
index b73cc4fa91..8368aeb175 100644
--- a/src/storage/tx/ob_tx_data_functor.cpp
+++ b/src/storage/tx/ob_tx_data_functor.cpp
@@ -187,10 +187,10 @@ int LockForReadFunctor::inner_lock_for_read(const ObTxData &tx_data, ObTxCCCtx *
   const transaction::ObTxSnapshot &snapshot = lock_for_read_arg_.mvcc_acc_ctx_.snapshot_;
   const SCN &snapshot_version = snapshot.version_;
   const transaction::ObTransID snapshot_tx_id = snapshot.tx_id_;
-  const int64_t snapshot_sql_sequence = snapshot.scn_;
+  const transaction::ObTxSEQ snapshot_sql_sequence = snapshot.scn_;
 
   const transaction::ObTransID data_tx_id = lock_for_read_arg_.data_trans_id_;
-  const int64_t data_sql_sequence = lock_for_read_arg_.data_sql_sequence_;
+  const transaction::ObTxSEQ data_sql_sequence = lock_for_read_arg_.data_sql_sequence_;
   const bool read_latest = lock_for_read_arg_.read_latest_;
   const transaction::ObTransID reader_tx_id = lock_for_read_arg_.mvcc_acc_ctx_.tx_id_;
 
diff --git a/src/storage/tx/ob_tx_data_functor.h b/src/storage/tx/ob_tx_data_functor.h
index 08d7af4021..1252d231e5 100644
--- a/src/storage/tx/ob_tx_data_functor.h
+++ b/src/storage/tx/ob_tx_data_functor.h
@@ -112,12 +112,12 @@ public:
 class CheckSqlSequenceCanReadFunctor : public ObITxDataCheckFunctor
 {
 public:
-  CheckSqlSequenceCanReadFunctor(const int64_t &sql_sequence, bool &can_read)
+  CheckSqlSequenceCanReadFunctor(const transaction::ObTxSEQ &sql_sequence, bool &can_read)
     : sql_sequence_(sql_sequence), can_read_(can_read) {}
   virtual int operator()(const ObTxData &tx_data, ObTxCCCtx *tx_cc_ctx = nullptr) override;
   TO_STRING_KV(K(sql_sequence_), K(can_read_));
 public:
-  const int64_t &sql_sequence_;
+  const transaction::ObTxSEQ &sql_sequence_;
   bool &can_read_;
 };
 
@@ -133,7 +133,7 @@ class CheckRowLockedFunctor : public ObITxDataCheckFunctor
 public:
   CheckRowLockedFunctor(const transaction::ObTransID &read_tx_id,
                         const transaction::ObTransID &data_tx_id,
-                        const int64_t &sql_sequence,
+                        const transaction::ObTxSEQ &sql_sequence,
                         ObStoreRowLockState &lock_state)
     : read_tx_id_(read_tx_id),
       data_tx_id_(data_tx_id),
@@ -145,7 +145,7 @@ public:
 public:
   const transaction::ObTransID &read_tx_id_;
   const transaction::ObTransID &data_tx_id_;
-  const int64_t &sql_sequence_;
+  const transaction::ObTxSEQ &sql_sequence_;
   ObStoreRowLockState &lock_state_;
 };
 
diff --git a/src/storage/tx/ob_tx_free_route.cpp b/src/storage/tx/ob_tx_free_route.cpp
index b0f7b79989..ef7307b858 100644
--- a/src/storage/tx/ob_tx_free_route.cpp
+++ b/src/storage/tx/ob_tx_free_route.cpp
@@ -636,7 +636,7 @@ int ObTransService::txn_free_route__update_extra_state(const uint32_t session_id
       audit_record.upd_reset_snapshot_ = true;
       ObSpinLockGuard guard(tx->lock_);
       tx->snapshot_version_.reset();
-      tx->snapshot_scn_ = 0;
+      tx->snapshot_scn_.reset();
     }
   } else if (header.flag_.is_fallback()) {
     audit_record.upd_fallback_ = true;
diff --git a/src/storage/tx/ob_tx_log.cpp b/src/storage/tx/ob_tx_log.cpp
index de1460414e..577cddb6f5 100644
--- a/src/storage/tx/ob_tx_log.cpp
+++ b/src/storage/tx/ob_tx_log.cpp
@@ -195,8 +195,8 @@ OB_TX_SERIALIZE_MEMBER(ObTxActiveInfoLog,
                        /* 11 */ tx_expired_time_,
                        /* 12 */ epoch_,
                        /* 13 */ last_op_sn_,
-                       /* 14 */ first_sn,
-                       /* 15 */ last_sn,
+                       /* 14 */ first_seq_no_,
+                       /* 15 */ last_seq_no_,
                        /* 16 */ cluster_version_,
                        /* 17 */ max_submitted_seq_no_,
                        /* 18 */ xid_);
@@ -276,10 +276,10 @@ int ObTxActiveInfoLog::before_serialize()
     TX_NO_NEED_SER(tx_expired_time_ == 0, 11, compat_bytes_);
     TX_NO_NEED_SER(epoch_ == 0, 12, compat_bytes_);
     TX_NO_NEED_SER(last_op_sn_ == 0, 13, compat_bytes_);
-    TX_NO_NEED_SER(first_sn == 0, 14, compat_bytes_);
-    TX_NO_NEED_SER(last_sn == 0, 15, compat_bytes_);
+    TX_NO_NEED_SER(!first_seq_no_.is_valid(), 14, compat_bytes_);
+    TX_NO_NEED_SER(!last_seq_no_.is_valid(), 15, compat_bytes_);
     TX_NO_NEED_SER(cluster_version_ == 0, 16, compat_bytes_);
-    TX_NO_NEED_SER(max_submitted_seq_no_ == 0, 17, compat_bytes_);
+    TX_NO_NEED_SER(!max_submitted_seq_no_.is_valid(), 17, compat_bytes_);
     TX_NO_NEED_SER(xid_.empty(), 18, compat_bytes_);
   }
 
@@ -673,7 +673,7 @@ int ObTxRedoLog::format_mutator_row_(const memtable::ObMemtableMutatorRow &row,
   uint32_t acc_checksum = 0;
   int64_t version = 0;
   int32_t flag = 0;
-  int64_t seq_no = 0;
+  transaction::ObTxSEQ seq_no;
   int64_t column_cnt = 0;
   ObStoreRowkey rowkey;
   memtable::ObRowData new_row;
@@ -719,7 +719,7 @@ int ObTxRedoLog::format_mutator_row_(const memtable::ObMemtableMutatorRow &row,
     arg.writer_ptr_->dump_key("Flag");
     arg.writer_ptr_->dump_int64(flag);
     arg.writer_ptr_->dump_key("SeqNo");
-    arg.writer_ptr_->dump_int64(seq_no);
+    arg.writer_ptr_->dump_int64(seq_no.cast_to_int());
     arg.writer_ptr_->dump_key("NewRowSize");
     arg.writer_ptr_->dump_int64(new_row.size_);
     arg.writer_ptr_->dump_key("OldRowSize");
diff --git a/src/storage/tx/ob_tx_log.h b/src/storage/tx/ob_tx_log.h
index ae5fe987a3..3ee11f74bd 100755
--- a/src/storage/tx/ob_tx_log.h
+++ b/src/storage/tx/ob_tx_log.h
@@ -342,8 +342,8 @@ public:
       : scheduler_(temp_ref.scheduler_), trans_type_(TransType::SP_TRANS), session_id_(0),
         app_trace_id_str_(temp_ref.app_trace_id_str_), schema_version_(0), can_elr_(false),
         proposal_leader_(temp_ref.proposal_leader_), cur_query_start_time_(0), is_sub2pc_(false),
-        is_dup_tx_(false), tx_expired_time_(0), epoch_(0), last_op_sn_(0), first_sn(0),
-        last_sn(0), max_submitted_seq_no_(0), cluster_version_(0), xid_(temp_ref.xid_)
+        is_dup_tx_(false), tx_expired_time_(0), epoch_(0), last_op_sn_(0), first_seq_no_(),
+        last_seq_no_(), max_submitted_seq_no_(), cluster_version_(0), xid_(temp_ref.xid_)
   {
     before_serialize();
   }
@@ -360,16 +360,16 @@ public:
                     int64_t tx_expired_time,
                     int64_t epoch,
                     int64_t last_op_sn,
-                    int64_t first_scn,
-                    int64_t last_scn,
-                    int64_t max_submitted_seq_no,
+                    ObTxSEQ first_seq_no,
+                    ObTxSEQ last_seq_no,
+                    ObTxSEQ max_submitted_seq_no,
                     uint64_t cluster_version,
                     const ObXATransID &xid)
       : scheduler_(scheduler), trans_type_(trans_type), session_id_(session_id),
         app_trace_id_str_(app_trace_id_str), schema_version_(schema_version), can_elr_(elr),
         proposal_leader_(proposal_leader), cur_query_start_time_(cur_query_start_time),
         is_sub2pc_(is_sub2pc), is_dup_tx_(is_dup_tx), tx_expired_time_(tx_expired_time),
-        epoch_(epoch), last_op_sn_(last_op_sn), first_sn(first_scn), last_sn(last_scn),
+        epoch_(epoch), last_op_sn_(last_op_sn), first_seq_no_(first_seq_no), last_seq_no_(last_seq_no),
         max_submitted_seq_no_(max_submitted_seq_no), cluster_version_(cluster_version),
         xid_(xid)
   {
@@ -389,9 +389,9 @@ public:
   int64_t get_tx_expired_time() const { return tx_expired_time_; }
   int64_t get_last_op_sn() const { return last_op_sn_; }
   int64_t get_epoch() const { return epoch_; }
-  int64_t get_first_scn() const { return first_sn; }
-  int64_t get_last_scn() const { return last_sn; }
-  int64_t get_max_submitted_seq_no() const { return max_submitted_seq_no_; }
+  ObTxSEQ get_first_seq_no() const { return first_seq_no_; }
+  ObTxSEQ get_last_seq_no() const { return last_seq_no_; }
+  ObTxSEQ get_max_submitted_seq_no() const { return max_submitted_seq_no_; }
   uint64_t get_cluster_version() const { return cluster_version_; }
   const ObXATransID &get_xid() const { return xid_; }
   // for ob_admin
@@ -412,8 +412,8 @@ public:
                K(tx_expired_time_),
                K(epoch_),
                K(last_op_sn_),
-               K(first_sn),
-               K(last_sn),
+               K(first_seq_no_),
+               K(last_seq_no_),
                K(max_submitted_seq_no_),
                K(cluster_version_),
                K(xid_));
@@ -438,11 +438,11 @@ private:
   // sql execution relative
   int64_t epoch_;
   int64_t last_op_sn_;
-  int64_t first_sn;
-  int64_t last_sn;
+  ObTxSEQ first_seq_no_;
+  ObTxSEQ last_seq_no_;
 
   // ctrl savepoint written log
-  int64_t max_submitted_seq_no_;
+  ObTxSEQ max_submitted_seq_no_;
 
   uint64_t cluster_version_;
   ObXATransID xid_;
@@ -873,12 +873,12 @@ public:
   OB_UNIS_VERSION(1);
 public:
   ObTxRollbackToLog() = default;
-  ObTxRollbackToLog(const int64_t from, const int64_t to)
+  ObTxRollbackToLog(const ObTxSEQ from, const ObTxSEQ to)
     : from_(from), to_(to) {before_serialize();}
 
 
-  int64_t get_from() const { return from_; }
-  int64_t get_to() const { return to_; }
+  ObTxSEQ get_from() const { return from_; }
+  ObTxSEQ get_to() const { return to_; }
 
   int ob_admin_dump(share::ObAdminMutatorStringArg &arg);
 
@@ -889,8 +889,8 @@ public:
   int before_serialize();
 private:
   ObTxSerCompatByte compat_bytes_;
-  int64_t from_;
-  int64_t to_;
+  ObTxSEQ from_;
+  ObTxSEQ to_;
 };
 
 // ============================== Tx Log Blcok ==============================
diff --git a/src/storage/tx/ob_tx_msg.cpp b/src/storage/tx/ob_tx_msg.cpp
index e26cd13bd1..68f5cfdd96 100644
--- a/src/storage/tx/ob_tx_msg.cpp
+++ b/src/storage/tx/ob_tx_msg.cpp
@@ -281,7 +281,7 @@ bool ObTxRollbackSPMsg::is_valid() const
 {
   bool ret = false;
   if (ObTxMsg::is_valid() && type_ == ROLLBACK_SAVEPOINT
-      && savepoint_ > -1 && op_sn_ > -1) {
+      && savepoint_.is_valid() && op_sn_ > -1) {
     ret = true;
   }
   return ret;
diff --git a/src/storage/tx/ob_tx_msg.h b/src/storage/tx/ob_tx_msg.h
index 0d71298e74..7cc56f57ee 100644
--- a/src/storage/tx/ob_tx_msg.h
+++ b/src/storage/tx/ob_tx_msg.h
@@ -236,7 +236,7 @@ namespace transaction
     struct ObTxRollbackSPMsg : public ObTxMsg {
       ObTxRollbackSPMsg() :
           ObTxMsg(ROLLBACK_SAVEPOINT),
-          savepoint_(-1),
+          savepoint_(),
           op_sn_(-1),
           //todo:后续branch_id使用方式确定后，需要相应修改
           branch_id_(-1),
@@ -249,7 +249,7 @@ namespace transaction
           tx_ptr_ = NULL;
         }
       }
-      int64_t savepoint_;
+      ObTxSEQ savepoint_;
       int64_t op_sn_;
       //todo:后期设计中操作编号是否等于branch_id
       int64_t branch_id_;
diff --git a/src/storage/tx/ob_xa_service.cpp b/src/storage/tx/ob_xa_service.cpp
index 10c300c91c..44441c9fba 100644
--- a/src/storage/tx/ob_xa_service.cpp
+++ b/src/storage/tx/ob_xa_service.cpp
@@ -2065,8 +2065,6 @@ int ObXAService::xa_rollback_all_changes(const ObXATransID &xid, ObTxDesc *&tx_d
 {
   int ret = OB_SUCCESS;
   int tmp_ret = OB_SUCCESS;
-  const int64_t savepoint = 1;
-
   if (NULL == tx_desc || !tx_desc->is_valid() || !xid.is_valid() || stmt_expired_time < 0) {
     ret = OB_INVALID_ARGUMENT;
     TRANS_LOG(WARN, "invalid argument", K(ret), KP(tx_desc), K(xid), K(stmt_expired_time));
@@ -2075,6 +2073,7 @@ int ObXAService::xa_rollback_all_changes(const ObXATransID &xid, ObTxDesc *&tx_d
     if (OB_FAIL(start_stmt(xid, 0/*unused session id*/, *tx_desc))) {
       TRANS_LOG(WARN, "xa start stmt fail", K(ret), K(xid), K(tx_id));
     } else {
+      const transaction::ObTxSEQ savepoint = tx_desc->get_tx_seq(1);
       if (OB_FAIL(MTL(transaction::ObTransService *)->rollback_to_implicit_savepoint(*tx_desc,
               savepoint, stmt_expired_time, NULL))) {
         TRANS_LOG(WARN, "do savepoint rollback error", K(ret), K(xid), K(tx_id));
diff --git a/src/storage/tx_storage/ob_access_service.cpp b/src/storage/tx_storage/ob_access_service.cpp
index 9034a7219e..56fa684343 100755
--- a/src/storage/tx_storage/ob_access_service.cpp
+++ b/src/storage/tx_storage/ob_access_service.cpp
@@ -338,7 +338,8 @@ int ObAccessService::get_write_store_ctx_guard_(
     transaction::ObTxDesc &tx_desc,
     const transaction::ObTxReadSnapshot &snapshot,
     const concurrent_control::ObWriteFlag write_flag,
-    ObStoreCtxGuard &ctx_guard)
+    ObStoreCtxGuard &ctx_guard,
+    const transaction::ObTxSEQ &spec_seq_no)
 {
   int ret = OB_SUCCESS;
   ObLS *ls = nullptr;
@@ -354,7 +355,7 @@ int ObAccessService::get_write_store_ctx_guard_(
     auto &ctx = ctx_guard.get_store_ctx();
     ctx.ls_ = ls;
     ctx.timeout_ = timeout;
-    if (OB_FAIL(ls->get_write_store_ctx(tx_desc, snapshot, write_flag, ctx))) {
+    if (OB_FAIL(ls->get_write_store_ctx(tx_desc, snapshot, write_flag, ctx, spec_seq_no))) {
       LOG_WARN("can not get write store ctx", K(ret), K(ls_id), K(snapshot), K(tx_desc));
     }
   }
@@ -565,7 +566,8 @@ int ObAccessService::check_write_allowed_(
                                                 tx_desc,
                                                 dml_param.snapshot_,
                                                 dml_param.write_flag_,
-                                                ctx_guard))) {
+                                                ctx_guard,
+                                                dml_param.spec_seq_no_))) {
     LOG_WARN("get write store ctx failed", K(ret), K(ls_id), K(dml_param), K(tx_desc));
   } else if (FALSE_IT(ctx_guard.get_store_ctx().tablet_id_ = tablet_id)) {
   } else if (OB_ISNULL(ls = ctx_guard.get_ls_handle().get_ls())) {
@@ -591,8 +593,6 @@ int ObAccessService::check_write_allowed_(
     } else if (!dml_param.is_direct_insert()
         && OB_FAIL(ls->lock(ctx_guard.get_store_ctx(), lock_param))) {
       LOG_WARN("lock tablet failed", K(ret), K(lock_param));
-    } else if (dml_param.spec_seq_no_ != -1) {
-      ctx_guard.get_store_ctx().mvcc_acc_ctx_.tx_scn_ = dml_param.spec_seq_no_;
     } else {
       // do nothing
     }
diff --git a/src/storage/tx_storage/ob_access_service.h b/src/storage/tx_storage/ob_access_service.h
index 6b43bea712..b90d418800 100644
--- a/src/storage/tx_storage/ob_access_service.h
+++ b/src/storage/tx_storage/ob_access_service.h
@@ -203,7 +203,8 @@ protected:
       transaction::ObTxDesc &tx_desc,
       const transaction::ObTxReadSnapshot &snapshot,
       const concurrent_control::ObWriteFlag write_flag,
-      ObStoreCtxGuard &ctx_guard);
+      ObStoreCtxGuard &ctx_guard,
+      const transaction::ObTxSEQ &spec_seq_no = transaction::ObTxSEQ::INVL());
   int check_read_allowed_(
       const share::ObLSID &ls_id,
       const common::ObTabletID &tablet_id,
diff --git a/src/storage/tx_table/ob_tx_data_memtable.h b/src/storage/tx_table/ob_tx_data_memtable.h
index 987908c4f0..84de83f1d6 100644
--- a/src/storage/tx_table/ob_tx_data_memtable.h
+++ b/src/storage/tx_table/ob_tx_data_memtable.h
@@ -496,14 +496,14 @@ public:
             to_cstring(tx_data->commit_version_));
 
     // printf undo status list
-    fprintf(fd_, "Undo Actions : {");
+    fprintf(fd_, "Undo Actions [from, to): {");
     ObUndoStatusNode *cur_node = tx_data->undo_status_list_.head_;
     while (OB_NOT_NULL(cur_node))
     {
       for (int i = 0; i < cur_node->size_; i++) {
-        fprintf(fd_, "(from:%s,to:%s)",
-                to_cstring(cur_node->undo_actions_[i].undo_from_),
-                to_cstring(cur_node->undo_actions_[i].undo_to_));
+        fprintf(fd_, "[%ld, %ld)",
+                cur_node->undo_actions_[i].undo_from_.cast_to_int(),
+                cur_node->undo_actions_[i].undo_to_.cast_to_int());
       }
       cur_node = cur_node->next_;
     }
diff --git a/src/storage/tx_table/ob_tx_table.cpp b/src/storage/tx_table/ob_tx_table.cpp
index 274516ed4d..20d6df4f60 100755
--- a/src/storage/tx_table/ob_tx_table.cpp
+++ b/src/storage/tx_table/ob_tx_table.cpp
@@ -864,7 +864,7 @@ int64_t ObTxTable::get_filter_col_idx()
 
 int ObTxTable::check_row_locked(ObReadTxDataArg &read_tx_data_arg,
                                 const transaction::ObTransID &read_tx_id,
-                                const int64_t sql_sequence,
+                                const transaction::ObTxSEQ sql_sequence,
                                 storage::ObStoreRowLockState &lock_state)
 {
   CheckRowLockedFunctor fn(read_tx_id, read_tx_data_arg.tx_id_, sql_sequence, lock_state);
@@ -875,7 +875,7 @@ int ObTxTable::check_row_locked(ObReadTxDataArg &read_tx_data_arg,
 }
 
 int ObTxTable::check_sql_sequence_can_read(ObReadTxDataArg &read_tx_data_arg,
-                                           const int64_t sql_sequence,
+                                           const transaction::ObTxSEQ &sql_sequence,
                                            bool &can_read)
 {
   CheckSqlSequenceCanReadFunctor fn(sql_sequence, can_read);
diff --git a/src/storage/tx_table/ob_tx_table.h b/src/storage/tx_table/ob_tx_table.h
index 93955626f3..09637e4a7f 100644
--- a/src/storage/tx_table/ob_tx_table.h
+++ b/src/storage/tx_table/ob_tx_table.h
@@ -121,12 +121,11 @@ public:
    * @param[in] read_trans_id 
    * @param[in] data_trans_id 
    * @param[in] sql_sequence 
-   * @param[in] read_epoch 
    * @param[out] lock_state 
    */
   int check_row_locked(ObReadTxDataArg &read_tx_data_arg,
                        const transaction::ObTransID &read_tx_id,
-                       const int64_t sql_sequence,
+                       const transaction::ObTxSEQ sql_sequence,
                        storage::ObStoreRowLockState &lock_state);
 
   /**
@@ -134,10 +133,11 @@ public:
    * 
    * @param[in] data_tx_id 
    * @param[in] sql_sequence 
-   * @param[in] read_epoch 
    * @param[out] can_read 
    */
-  int check_sql_sequence_can_read(ObReadTxDataArg &read_tx_data_arg, const int64_t sql_sequence, bool &can_read);
+  int check_sql_sequence_can_read(ObReadTxDataArg &read_tx_data_arg,
+                                  const transaction::ObTxSEQ &sql_sequence,
+                                  bool &can_read);
 
   /**
    * @brief fetch the state of txn DATA_TRANS_ID when replaying to LOG_TS the requirement can be seen from
diff --git a/src/storage/tx_table/ob_tx_table_guards.cpp b/src/storage/tx_table/ob_tx_table_guards.cpp
index cb41198abf..31538a7532 100644
--- a/src/storage/tx_table/ob_tx_table_guards.cpp
+++ b/src/storage/tx_table/ob_tx_table_guards.cpp
@@ -54,7 +54,7 @@ namespace storage
 int ObTxTableGuards::check_row_locked(
     const transaction::ObTransID &read_tx_id,
     const transaction::ObTransID &data_tx_id,
-    const int64_t sql_sequence,
+    const transaction::ObTxSEQ &sql_sequence,
     const share::SCN &scn,
     storage::ObStoreRowLockState &lock_state)
 {
@@ -101,7 +101,7 @@ int ObTxTableGuards::check_row_locked(
 // The interface lock_for_read also applies this logic.
 int ObTxTableGuards::check_sql_sequence_can_read(
     const transaction::ObTransID &data_tx_id,
-    const int64_t sql_sequence,
+    const transaction::ObTxSEQ &sql_sequence,
     const share::SCN &scn,
     bool &can_read)
 {
diff --git a/src/storage/tx_table/ob_tx_table_guards.h b/src/storage/tx_table/ob_tx_table_guards.h
index b8a92efb6a..f34a2fbb0c 100644
--- a/src/storage/tx_table/ob_tx_table_guards.h
+++ b/src/storage/tx_table/ob_tx_table_guards.h
@@ -71,7 +71,7 @@ public:
   int check_row_locked(
       const transaction::ObTransID &read_tx_id,
       const transaction::ObTransID &data_tx_id,
-      const int64_t sql_sequence,
+      const transaction::ObTxSEQ &sql_sequence,
       const share::SCN &scn,
       storage::ObStoreRowLockState &lock_state);
   /**
@@ -84,7 +84,7 @@ public:
    */
   int check_sql_sequence_can_read(
       const transaction::ObTransID &data_tx_id,
-      const int64_t sql_sequence,
+      const transaction::ObTxSEQ &sql_sequence,
       const share::SCN &scn,
       bool &can_read);
   /**
diff --git a/src/storage/tx_table/ob_tx_table_interface.cpp b/src/storage/tx_table/ob_tx_table_interface.cpp
index 0de3b08420..d70ff54ea8 100644
--- a/src/storage/tx_table/ob_tx_table_interface.cpp
+++ b/src/storage/tx_table/ob_tx_table_interface.cpp
@@ -36,7 +36,7 @@ int ObTxTableGuard::init(ObTxTable *tx_table)
 
 int ObTxTableGuard::check_row_locked(const transaction::ObTransID &read_tx_id,
                                      const transaction::ObTransID data_tx_id,
-                                     const int64_t sql_sequence,
+                                     const transaction::ObTxSEQ &sql_sequence,
                                      storage::ObStoreRowLockState &lock_state)
 {
   if (OB_NOT_NULL(tx_table_)) {
@@ -48,7 +48,7 @@ int ObTxTableGuard::check_row_locked(const transaction::ObTransID &read_tx_id,
 }
 
 int ObTxTableGuard::check_sql_sequence_can_read(const transaction::ObTransID tx_id,
-                                                const int64_t sql_sequence,
+                                                const transaction::ObTxSEQ &sql_sequence,
                                                 bool &can_read)
 {
   if (OB_NOT_NULL(tx_table_)) {
diff --git a/src/storage/tx_table/ob_tx_table_interface.h b/src/storage/tx_table/ob_tx_table_interface.h
index 0364baed2a..374ab23f83 100644
--- a/src/storage/tx_table/ob_tx_table_interface.h
+++ b/src/storage/tx_table/ob_tx_table_interface.h
@@ -59,10 +59,10 @@ public:
 public: // dalegate functions
   int check_row_locked(const transaction::ObTransID &read_tx_id,
                        const transaction::ObTransID data_tx_id,
-                       const int64_t sql_sequence,
+                       const transaction::ObTxSEQ &sql_sequence,
                        storage::ObStoreRowLockState &lock_state);
 
-  int check_sql_sequence_can_read(const transaction::ObTransID tx_id, const int64_t sql_sequence, bool &can_read);
+  int check_sql_sequence_can_read(const transaction::ObTransID tx_id, const transaction::ObTxSEQ &sql_sequence, bool &can_read);
 
   int get_tx_state_with_scn(const transaction::ObTransID tx_id,
                             const share::SCN scn,
diff --git a/tools/ob_admin/server_tool/ob_admin_routine.cpp b/tools/ob_admin/server_tool/ob_admin_routine.cpp
index 226d32ee84..40474375d5 100644
--- a/tools/ob_admin/server_tool/ob_admin_routine.cpp
+++ b/tools/ob_admin/server_tool/ob_admin_routine.cpp
@@ -643,7 +643,7 @@ DEF_COMMAND(TRANS, remove_lock, 1, "tenant_id ls_id obj_type obj_id lock_mode ow
   int64_t create_tx_id = 0;
   int64_t op_type = 0;
   int64_t lock_op_status = 1; // does not used.
-  int64_t seq_no = 0;
+  ObTxSEQ seq_no;
   int64_t create_timestamp = 0;
   int64_t create_schema_version = 0;
 
@@ -725,7 +725,7 @@ DEF_COMMAND(TRANS, update_lock, 1, "tenant_id ls_id obj_type obj_id lock_mode ow
   int64_t lock_op_status = 1;
   int64_t commit_version = 0;
   int64_t commit_scn = 0;
-  int64_t seq_no = 0;
+  ObTxSEQ seq_no;
   int64_t create_timestamp = 0;
   int64_t create_schema_version = 0;
 
diff --git a/unittest/libobcdc/log_generator.h b/unittest/libobcdc/log_generator.h
index bec26f54b2..8432a0a029 100644
--- a/unittest/libobcdc/log_generator.h
+++ b/unittest/libobcdc/log_generator.h
@@ -248,9 +248,7 @@ void ObTxLogGenerator::gen_redo_log()
 
 void ObTxLogGenerator::gen_rollback_to_log()
 {
-  ObTxRollbackToLog rollback_to_log(2, 1);
-//  rollback_to_log.from_ = 2;
-//  rollback_to_log.to_ = 1;
+  ObTxRollbackToLog rollback_to_log(ObTxSEQ(2, 0), ObTxSEQ(1, 0));
   EXPECT_EQ(OB_SUCCESS, block_builder_.fill_tx_log_except_redo(rollback_to_log));
 }
 
diff --git a/unittest/storage/memtable/mvcc/test_mvcc_callback.cpp b/unittest/storage/memtable/mvcc/test_mvcc_callback.cpp
index 6826b0bb97..2767b511dd 100644
--- a/unittest/storage/memtable/mvcc/test_mvcc_callback.cpp
+++ b/unittest/storage/memtable/mvcc/test_mvcc_callback.cpp
@@ -35,19 +35,19 @@ public:
                    bool need_submit_log = true,
                    bool need_fill_redo = true,
                    share::SCN scn = share::SCN::max_scn(),
-                   int64_t seq_no = INT64_MAX)
+                   transaction::ObTxSEQ seq_no = transaction::ObTxSEQ::MAX_VAL())
     : ObITransCallback(need_fill_redo, need_submit_log),
       mt_(mt), seq_no_(seq_no) { scn_ = scn; }
 
   virtual ObIMemtable* get_memtable() const override { return mt_; }
-  virtual int64_t get_seq_no() const override { return seq_no_; }
+  virtual transaction::ObTxSEQ get_seq_no() const override { return seq_no_; }
   virtual int checkpoint_callback() override;
   virtual int rollback_callback() override;
   virtual int calc_checksum(const share::SCN checksum_scn,
                             ObBatchChecksum *checksumer) override;
 
   ObMemtable *mt_;
-  int64_t seq_no_;
+  transaction::ObTxSEQ seq_no_;
 };
 
 class ObMockBitSet {
@@ -99,7 +99,7 @@ class TestTxCallbackList : public ::testing::Test
 {
 public:
   TestTxCallbackList()
-    : seq_counter_(0),
+    : seq_counter_(),
       mt_counter_(0),
       mt_ctx_(),
       cb_allocator_(),
@@ -140,7 +140,7 @@ public:
                                     bool need_fill_redo = true,
                                     share::SCN scn = share::SCN::max_scn())
   {
-    int64_t seq_no = ++seq_counter_;
+    auto seq_no = ++seq_counter_;
     ObMockTxCallback *cb = new ObMockTxCallback(mt,
                                                 need_submit_log,
                                                 need_fill_redo,
@@ -171,7 +171,7 @@ public:
     return (ObMemtable *)(mt_counter_);
   }
 
-  int64_t get_seq_no() const
+  transaction::ObTxSEQ get_seq_no() const
   {
     return seq_counter_;
   }
@@ -193,7 +193,7 @@ public:
   static int64_t rollback_cnt_;
   static ObMockBitSet checksum_;
 
-  int64_t seq_counter_;
+  transaction::ObTxSEQ seq_counter_;
   int64_t mt_counter_;
   ObMemtableCtx mt_ctx_;
   ObMemtableCtxCbAllocator cb_allocator_;
@@ -222,7 +222,7 @@ int ObMockTxCallback::calc_checksum(const share::SCN checksum_scn,
                                     ObBatchChecksum *)
 {
   if (checksum_scn <= scn_) {
-    TestTxCallbackList::checksum_.add_bit(seq_no_);
+    TestTxCallbackList::checksum_.add_bit(seq_no_.get_seq());
     TRANS_LOG(INFO, "need to calc checksum", K(checksum_scn), K(scn_), K(seq_no_));
   } else {
     TRANS_LOG(INFO, "no need to calc checksum", K(checksum_scn), K(scn_), K(seq_no_));
@@ -466,7 +466,7 @@ TEST_F(TestTxCallbackList, remove_callback_by_rollback_to)
   scn_2.convert_for_logservice(2);
   scn_3.convert_for_logservice(3);
 
-  int64_t savepoint0 = get_seq_no();
+  auto savepoint0 = get_seq_no();
   create_and_append_callback(memtable1,
                              false, /*need_submit_log*/
                              false, /*need_fill_redo*/
@@ -479,7 +479,7 @@ TEST_F(TestTxCallbackList, remove_callback_by_rollback_to)
                              false, /*need_submit_log*/
                              false, /*need_fill_redo*/
                              scn_2/*scn*/);
-  int64_t savepoint1 = get_seq_no();
+  auto savepoint1 = get_seq_no();
   create_and_append_callback(memtable3,
                              false, /*need_submit_log*/
                              false, /*need_fill_redo*/
@@ -494,11 +494,11 @@ TEST_F(TestTxCallbackList, remove_callback_by_rollback_to)
   create_and_append_callback(memtable1,
                              true, /*need_submit_log*/
                              true  /*need_fill_redo*/);
-  int64_t savepoint2 = get_seq_no();
+  auto savepoint2 = get_seq_no();
   create_and_append_callback(memtable3,
                              true, /*need_submit_log*/
                              true  /*need_fill_redo*/);
-  int64_t savepoint3 = get_seq_no();
+  auto savepoint3 = get_seq_no();
   create_and_append_callback(memtable1,
                              true, /*need_submit_log*/
                              true  /*need_fill_redo*/);
@@ -923,7 +923,7 @@ TEST_F(TestTxCallbackList, checksum_rollback_to_and_tx_end)
   scn_3.convert_for_logservice(3);
   scn_4.convert_for_logservice(4);
 
-  int64_t savepoint0 = get_seq_no();
+  auto savepoint0 = get_seq_no();
   create_and_append_callback(memtable1,
                              false, /*need_submit_log*/
                              false, /*need_fill_redo*/
@@ -936,7 +936,7 @@ TEST_F(TestTxCallbackList, checksum_rollback_to_and_tx_end)
                              false, /*need_submit_log*/
                              false, /*need_fill_redo*/
                              scn_2/*scn*/);
-  int64_t savepoint1 = get_seq_no();
+  auto savepoint1 = get_seq_no();
   create_and_append_callback(memtable3,
                              false, /*need_submit_log*/
                              false, /*need_fill_redo*/
@@ -951,11 +951,11 @@ TEST_F(TestTxCallbackList, checksum_rollback_to_and_tx_end)
   create_and_append_callback(memtable1,
                              true, /*need_submit_log*/
                              true  /*need_fill_redo*/);
-  int64_t savepoint2 = get_seq_no();
+  auto savepoint2 = get_seq_no();
   create_and_append_callback(memtable3,
                              true, /*need_submit_log*/
                              true  /*need_fill_redo*/);
-  int64_t savepoint3 = get_seq_no();
+  auto savepoint3 = get_seq_no();
   create_and_append_callback(memtable1,
                              true, /*need_submit_log*/
                              true  /*need_fill_redo*/);
@@ -1023,7 +1023,7 @@ TEST_F(TestTxCallbackList, checksum_all_and_tx_end_test) {
         it->scn_.convert_for_logservice(cur_log);
         enable = true;
         need_submit_head = it;
-        my_calculate.add_bit(it->get_seq_no());
+        my_calculate.add_bit(it->get_seq_no().get_seq());
       }
 
       if (!enable) {
@@ -1085,9 +1085,10 @@ TEST_F(TestTxCallbackList, checksum_all_and_tx_end_test) {
     [&]() -> bool{
       bool enable = false;
       if (!callback_list_.empty() &&
-          callback_list_.head_.next_->get_seq_no() + 1 < seq_counter_ - 1) {
-        int64_t seq = ObRandom::rand(callback_list_.head_.next_->get_seq_no() + 1,
-                                       seq_counter_ - 1);
+          callback_list_.head_.next_->get_seq_no().get_seq() + 1 < seq_counter_.get_seq() - 1) {
+        auto from = callback_list_.head_.next_->get_seq_no();
+        auto range_cnt = seq_counter_.get_seq() - from.get_seq();
+        auto seq = from + ObRandom::rand(1, range_cnt - 1);
         enable = true;
         if (enable) {
           if (need_submit_head->get_seq_no() > seq) {
@@ -1131,7 +1132,7 @@ TEST_F(TestTxCallbackList, checksum_all_and_tx_end_test) {
        it = it->next_) {
     EXPECT_EQ(it->need_submit_log_, true);
     EXPECT_EQ(it->need_fill_redo_, true);
-    my_calculate.add_bit(it->get_seq_no());
+    my_calculate.add_bit(it->get_seq_no().get_seq());
   }
 
   EXPECT_EQ(OB_SUCCESS, callback_list_.tx_commit());
diff --git a/unittest/storage/memtable/test_memtable_basic.cpp b/unittest/storage/memtable/test_memtable_basic.cpp
index 7ca9d43e3b..111558b8d9 100644
--- a/unittest/storage/memtable/test_memtable_basic.cpp
+++ b/unittest/storage/memtable/test_memtable_basic.cpp
@@ -292,7 +292,7 @@ public:
     store_ctx.mvcc_acc_ctx_.init_write(trans_ctx_,
                                        mem_ctx_,
                                        tx_desc_.tx_id_,
-                                       1000,
+                                       ObTxSEQ(1000, 0),
                                        tx_desc_,
                                        tx_table_guard,
                                        snapshot,
diff --git a/unittest/storage/ob_uncommitted_trans_test.h b/unittest/storage/ob_uncommitted_trans_test.h
index fa6f247c2d..0582e0dbcd 100644
--- a/unittest/storage/ob_uncommitted_trans_test.h
+++ b/unittest/storage/ob_uncommitted_trans_test.h
@@ -139,7 +139,7 @@ public:
 
   int check_sql_sequence_can_read(
       const transaction::ObTransID &data_trans_id,
-      const int64_t sql_sequence,
+      const transaction::ObTxSEQ &sql_sequence,
       const share::SCN scn,
       bool &can_read)
   {
diff --git a/unittest/storage/tx/it/test_tx.cpp b/unittest/storage/tx/it/test_tx.cpp
index 61229363c6..8816447257 100644
--- a/unittest/storage/tx/it/test_tx.cpp
+++ b/unittest/storage/tx/it/test_tx.cpp
@@ -150,10 +150,10 @@ TEST_F(ObTestTx, rollback_savepoint_with_msg_lost)
   tx_param.cluster_id_ = 100;
   ObTxReadSnapshot snapshot;
   ASSERT_EQ(OB_SUCCESS, n1->get_read_snapshot(tx, tx_param.isolation_, n1->ts_after_ms(5), snapshot));
-  int64_t sp1 = 0;
+  ObTxSEQ sp1;
   ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp1));
   ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 100, 112));
-  int64_t sp2 = 0;
+  ObTxSEQ sp2;
   ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp2));
   ASSERT_EQ(OB_SUCCESS, n2->write(tx, snapshot, 101, 113));
   // inject link failure between scheduler to participant 2
@@ -215,7 +215,7 @@ TEST_F(ObTestTx, rollback_savepoint_with_uncertain_participants)
   PREPARE_TX(n1, tx);
   PREPARE_TX_PARAM(tx_param);
   CREATE_IMPLICIT_SAVEPOINT(n1, tx, tx_param, sp);
-  ASSERT_NE(sp, 0);
+  ASSERT_TRUE(sp.is_valid());
   share::ObLSArray uncertain_parts;
   ASSERT_EQ(OB_SUCCESS, uncertain_parts.push_back(share::ObLSID(1001)));
   ASSERT_EQ(OB_SUCCESS, n1->rollback_to_implicit_savepoint(tx, sp, n1->ts_after_us(100000), &uncertain_parts));
@@ -244,7 +244,7 @@ TEST_F(ObTestTx, switch_to_follower_gracefully)
   ASSERT_EQ(OB_SUCCESS, n1->acquire_tx(tx_ptr));
   ObTxDesc &tx = *tx_ptr;
 
-  int64_t sp1 = 0, sp2 = 0;
+  ObTxSEQ sp1, sp2;
 
   { // prepare snapshot for write
     ObTxReadSnapshot snapshot;
@@ -328,7 +328,7 @@ TEST_F(ObTestTx, switch_to_follower_gracefully_fail)
                              tx_param.isolation_,
                              n1->ts_after_ms(100),
                              snapshot));
-    int64_t sp = 0;
+    ObTxSEQ sp;
     ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp));
     ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 1000 + i, 2000 + i));
   }
@@ -389,7 +389,7 @@ TEST_F(ObTestTx, switch_to_follower_gracefully_fail)
                              snapshot));
     ASSERT_EQ(OB_SUCCESS, n1->read(snapshot, 1000 + i, val1));
     ASSERT_EQ(2000 + i, val1);
-    int64_t sp = 0;
+    ObTxSEQ sp;
     ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp));
     ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 1000 + i, 3000 + i));
   }
@@ -435,7 +435,7 @@ TEST_F(ObTestTx, switch_to_follower_gracefully_then_forcedly)
   ASSERT_EQ(OB_SUCCESS, n1->acquire_tx(tx_ptr));
   ObTxDesc &tx = *tx_ptr;
 
-  int64_t sp1 = 0;
+  ObTxSEQ sp1;
   { // prepare snapshot for write
     ObTxReadSnapshot snapshot;
     ASSERT_EQ(OB_SUCCESS, n1->get_read_snapshot(tx,
@@ -509,7 +509,7 @@ TEST_F(ObTestTx, switch_to_follower_forcedly)
   tx_param.isolation_ = ObTxIsolationLevel::RC;
   tx_param.cluster_id_ = 100;
 
-  int64_t sp1 = 0;
+  ObTxSEQ sp1;
   { // prepare snapshot for write
     ObTxReadSnapshot snapshot;
     ASSERT_EQ(OB_SUCCESS, n1->get_read_snapshot(tx,
@@ -567,7 +567,7 @@ TEST_F(ObTestTx, resume_leader)
   tx_param.access_mode_ = ObTxAccessMode::RW;
   tx_param.isolation_ = ObTxIsolationLevel::RC;
   tx_param.cluster_id_ = 100;
-  int64_t sp1 = 0;
+  ObTxSEQ sp1;
   { // prepare snapshot for write
     ObTxReadSnapshot snapshot;
     ASSERT_EQ(OB_SUCCESS, n1->get_read_snapshot(tx,
@@ -636,7 +636,7 @@ TEST_F(ObTestTx, switch_to_follower_gracefully_in_stmt_then_resume_leader)
   tx_param.isolation_ = ObTxIsolationLevel::RC;
   tx_param.cluster_id_ = 100;
 
-  int64_t sp1 = 0;
+  ObTxSEQ sp1;
 
   ObStoreCtx write_store_ctx;
   { // prepare snapshot for write
@@ -736,7 +736,7 @@ TEST_F(ObTestTx, replay_basic)
                                tx_param.isolation_,
                                n1->ts_after_ms(100),
                                snapshot));
-      int64_t sp1 = 0;
+      ObTxSEQ sp1;
       ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp1));
       ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 100, 112));
     }
@@ -832,7 +832,7 @@ TEST_F(ObTestTx, replay_then_commit)
                              tx_param.isolation_,
                              n1->ts_after_ms(100),
                              snapshot));
-    int64_t sp1 = 0;
+    ObTxSEQ sp1;
     ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp1));
     ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 100, 112));
   }
@@ -864,7 +864,7 @@ TEST_F(ObTestTx, replay_then_commit)
     ASSERT_EQ(OB_SUCCESS, n2->read(snapshot, 100, val1));
     ASSERT_EQ(112, val1);
 
-    int64_t sp1 = 0;
+    ObTxSEQ sp1;
     ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp1));
     ASSERT_EQ(OB_SUCCESS, n2->write(tx, snapshot, 100, 113));
   }
@@ -929,7 +929,7 @@ TEST_F(ObTestTx, wait_commit_version_elapse_block)
                              tx_param.isolation_,
                              n1->ts_after_ms(100),
                              snapshot));
-    int64_t sp1 = 0;
+    ObTxSEQ sp1;
     ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp1));
     ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 100, 113));
   }
@@ -1031,7 +1031,7 @@ TEST_F(ObTestTx, wait_commit_version_elapse_block_and_switch_to_follower_forcedl
                              tx_param.isolation_,
                              n1->ts_after_ms(100),
                              snapshot));
-    int64_t sp1 = 0;
+    ObTxSEQ sp1;
     ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp1));
     ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 100, 113));
   }
@@ -1132,7 +1132,7 @@ TEST_F(ObTestTx, get_gts_block_and_switch_to_follower_gracefully)
                              tx_param.isolation_,
                              n1->ts_after_ms(100),
                              snapshot));
-    int64_t sp1 = 0;
+    ObTxSEQ sp1;
     ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp1));
     ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 100, 112));
   }
@@ -1201,7 +1201,7 @@ TEST_F(ObTestTx, get_gts_block_and_switch_to_follower_forcedly)
                              tx_param.isolation_,
                              n1->ts_after_ms(100),
                              snapshot));
-    int64_t sp1 = 0;
+    ObTxSEQ sp1;
     ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp1));
     ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 100, 112));
   }
@@ -1257,7 +1257,7 @@ TEST_F(ObTestTx, switch_to_follower_gracefully_in_stmt_rollback_to_last_savepoin
   tx_param.isolation_ = ObTxIsolationLevel::RC;
   tx_param.cluster_id_ = 100;
 
-  int64_t sp1 = 0;
+  ObTxSEQ sp1;
   ObStoreCtx write_store_ctx;
   {
     ObTxReadSnapshot snapshot;
@@ -1354,7 +1354,7 @@ TEST_F(ObTestTx, switch_to_follower_gracefully_in_stmt_then_commit)
   tx_param.isolation_ = ObTxIsolationLevel::RC;
   tx_param.cluster_id_ = 100;
 
-  int64_t sp1 = 0;
+  ObTxSEQ sp1;
   ObStoreCtx write_store_ctx;
   {
     ObTxReadSnapshot snapshot;
@@ -1366,7 +1366,7 @@ TEST_F(ObTestTx, switch_to_follower_gracefully_in_stmt_then_commit)
     ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 1000, 1111));
   }
 
-  int64_t sp2 = 0;
+  ObTxSEQ sp2;
   {
     ObTxReadSnapshot snapshot;
     ASSERT_EQ(OB_SUCCESS, n1->get_read_snapshot(tx,
@@ -1400,7 +1400,7 @@ TEST_F(ObTestTx, switch_to_follower_gracefully_in_stmt_then_commit)
     ASSERT_EQ(OB_SUCCESS, n1->rollback_to_implicit_savepoint(tx, sp2, n1->ts_after_ms(100), nullptr));
   }
 
-  int64_t sp3 = -1;
+  ObTxSEQ sp3;
   { // prepare snapshot for read
     ObTxReadSnapshot snapshot;
     ASSERT_EQ(OB_SUCCESS, n2->get_read_snapshot(tx,
@@ -1471,7 +1471,7 @@ TEST_F(ObTestTx, distributed_tx_participant_switch_to_follower_gracefully_in_stm
   tx_param.isolation_ = ObTxIsolationLevel::RC;
   tx_param.cluster_id_ = 100;
 
-  int64_t sp1 = 0;
+  ObTxSEQ sp1;
   {
     ObTxReadSnapshot snapshot;
     ASSERT_EQ(OB_SUCCESS, n1->get_read_snapshot(tx,
@@ -1482,7 +1482,7 @@ TEST_F(ObTestTx, distributed_tx_participant_switch_to_follower_gracefully_in_stm
     ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 1000, 1111));
   }
 
-  int64_t sp2 = 0;
+  ObTxSEQ sp2;
   {
     ObTxReadSnapshot snapshot;
     ASSERT_EQ(OB_SUCCESS, n1->get_read_snapshot(tx,
@@ -1494,7 +1494,7 @@ TEST_F(ObTestTx, distributed_tx_participant_switch_to_follower_gracefully_in_stm
   }
 
   ObStoreCtx write_store_ctx;
-  int64_t sp3 = 0;
+  ObTxSEQ sp3;
   {
     ObTxReadSnapshot snapshot;
     ASSERT_EQ(OB_SUCCESS, n1->get_read_snapshot(tx,
@@ -1528,7 +1528,7 @@ TEST_F(ObTestTx, distributed_tx_participant_switch_to_follower_gracefully_in_stm
     ASSERT_EQ(OB_SUCCESS, n1->rollback_to_implicit_savepoint(tx, sp3, n1->ts_after_ms(100), nullptr));
   }
 
-  int64_t sp4 = -1;
+  ObTxSEQ sp4;
   { // prepare snapshot for read
     ObTxReadSnapshot snapshot;
     ASSERT_EQ(OB_SUCCESS, n1->get_read_snapshot(tx,
@@ -1604,7 +1604,7 @@ TEST_F(ObTestTx, distributed_tx_coordinator_switch_to_follower_gracefully_in_stm
   tx_param.isolation_ = ObTxIsolationLevel::RC;
   tx_param.cluster_id_ = 100;
 
-  int64_t sp1 = 0;
+  ObTxSEQ sp1;
   {
     ObTxReadSnapshot snapshot;
     ASSERT_EQ(OB_SUCCESS, n1->get_read_snapshot(tx,
@@ -1617,7 +1617,7 @@ TEST_F(ObTestTx, distributed_tx_coordinator_switch_to_follower_gracefully_in_stm
   }
 
   ObStoreCtx write_store_ctx;
-  int64_t sp3 = 0;
+  ObTxSEQ sp3;
   {
     ObTxReadSnapshot snapshot;
     ASSERT_EQ(OB_SUCCESS, n1->get_read_snapshot(tx,
@@ -1651,7 +1651,7 @@ TEST_F(ObTestTx, distributed_tx_coordinator_switch_to_follower_gracefully_in_stm
     ASSERT_EQ(OB_SUCCESS, n1->rollback_to_implicit_savepoint(tx, sp3, n1->ts_after_ms(100), nullptr));
   }
 
-  int64_t sp4 = -1;
+  ObTxSEQ sp4;
   { // prepare snapshot for read
     ObTxReadSnapshot snapshot;
     ASSERT_EQ(OB_SUCCESS, n1->get_read_snapshot(tx,
@@ -1729,7 +1729,7 @@ TEST_F(ObTestTx, distributed_tx_switch_to_follower_forcedly_in_prepare_state)
                              n1->ts_after_ms(100),
                              snapshot));
   }
-  int64_t sp1 = 0;
+  ObTxSEQ sp1;
   ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp1));
   ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 100, 112));
   ASSERT_EQ(OB_SUCCESS, n2->write(tx, snapshot, 101, 113));
@@ -1827,7 +1827,7 @@ TEST_F(ObTestTx, distributed_tx_coordinator_switch_to_follower_forcedly_in_prepa
                              n1->ts_after_ms(100),
                              snapshot));
   }
-  int64_t sp1 = 0;
+  ObTxSEQ sp1;
   ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp1));
   ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 100, 112));
   ASSERT_EQ(OB_SUCCESS, n2->write(tx, snapshot, 101, 113));
@@ -1918,7 +1918,7 @@ TEST_F(ObTestTx, distributed_tx_participant_switch_to_follower_forcedly_in_pre_c
                                tx_param.isolation_,
                                n2->ts_after_ms(100),
                                snapshot));
-      int64_t sp1 = 0;
+      ObTxSEQ sp1;
       ASSERT_EQ(OB_SUCCESS, n2->create_implicit_savepoint(tx, tx_param, sp1));
       ASSERT_EQ(OB_SUCCESS, n2->write(tx, snapshot, 200, 112));
     }
@@ -1940,7 +1940,7 @@ TEST_F(ObTestTx, distributed_tx_participant_switch_to_follower_forcedly_in_pre_c
                              n1->ts_after_ms(100),
                              snapshot));
   }
-  int64_t sp1 = 0;
+  ObTxSEQ sp1;
   ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp1));
   ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 100, 112));
   ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 101, 112));
@@ -2049,7 +2049,7 @@ TEST_F(ObTestTx, distributed_tx_coordinator_switch_to_follower_forcedly_in_pre_c
                                tx_param.isolation_,
                                n1->ts_after_ms(100),
                                snapshot));
-      int64_t sp1 = 0;
+      ObTxSEQ sp1;
       ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp1));
       ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 100, 112));
     }
@@ -2071,7 +2071,7 @@ TEST_F(ObTestTx, distributed_tx_coordinator_switch_to_follower_forcedly_in_pre_c
                              n1->ts_after_ms(100),
                              snapshot));
   }
-  int64_t sp1 = 0;
+  ObTxSEQ sp1;
   ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp1));
   ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 100, 113));
   ASSERT_EQ(OB_SUCCESS, n2->write(tx, snapshot, 200, 113));
@@ -2178,7 +2178,7 @@ TEST_F(ObTestTx, distributed_tx_coordinator_switch_to_follower_forcedly_in_parti
                                tx_param.isolation_,
                                n1->ts_after_ms(100),
                                snapshot));
-      int64_t sp1 = 0;
+      ObTxSEQ sp1;
       ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp1));
       ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 100, 112));
     }
@@ -2200,7 +2200,7 @@ TEST_F(ObTestTx, distributed_tx_coordinator_switch_to_follower_forcedly_in_parti
                              n1->ts_after_ms(100),
                              snapshot));
   }
-  int64_t sp1 = 0;
+  ObTxSEQ sp1;
   ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp1));
   ASSERT_EQ(OB_SUCCESS, n1->write(tx, snapshot, 100, 113));
   ASSERT_EQ(OB_SUCCESS, n2->write(tx, snapshot, 200, 113));
diff --git a/unittest/storage/tx/it/test_tx_dsl.h b/unittest/storage/tx/it/test_tx_dsl.h
index f6c9fd6f93..750dbc4b73 100644
--- a/unittest/storage/tx/it/test_tx_dsl.h
+++ b/unittest/storage/tx/it/test_tx_dsl.h
@@ -50,7 +50,7 @@
     ASSERT_EQ(OB_SUCCESS, n1->get_read_snapshot(tx, tx_param.isolation_, n1->ts_after_ms(100), snapshot));
 
 #define CREATE_IMPLICIT_SAVEPOINT(n1, tx, tx_param, sp)                 \
-    int64_t sp = 0;                                                     \
+    ObTxSEQ sp;                                                         \
     ASSERT_EQ(OB_SUCCESS, n1->create_implicit_savepoint(tx, tx_param, sp));
 
 #define ROLLBACK_TO_IMPLICIT_SAVEPOINT(n1, tx, sp, timeout_us)          \
diff --git a/unittest/storage/tx/it/test_tx_free_route.cpp b/unittest/storage/tx/it/test_tx_free_route.cpp
index 4a211055da..747f8fbdd3 100644
--- a/unittest/storage/tx/it/test_tx_free_route.cpp
+++ b/unittest/storage/tx/it/test_tx_free_route.cpp
@@ -517,7 +517,7 @@ int MockObServer::do_handle_(ObReq &req, ObResp &resp)
     break;
   case ObReq::T::DUMMY_WRITE: {
     PREPARE_TX_PARAM(tx_param);
-    int64_t sp;
+    ObTxSEQ sp;
     ret = tx_node_.create_implicit_savepoint(*tx_desc, tx_param, sp, true);
   }
     break;
diff --git a/unittest/storage/tx/it/tx_node.cpp b/unittest/storage/tx/it/tx_node.cpp
index 7f10899148..dff4170709 100644
--- a/unittest/storage/tx/it/tx_node.cpp
+++ b/unittest/storage/tx/it/tx_node.cpp
@@ -555,10 +555,10 @@ int ObTxNode::atomic_write(ObTxDesc &tx, const int64_t key, const int64_t value,
                            const int64_t expire_ts, const ObTxParam &tx_param)
 {
   int ret = OB_SUCCESS;
-  int64_t sp = -1;
+  ObTxSEQ sp;
   OZ(create_implicit_savepoint(tx, tx_param, sp, true));
   OZ(write(tx, key, value));
-  if (sp != -1 && OB_FAIL(ret)) {
+  if (sp.is_valid() && OB_FAIL(ret)) {
     OZ(rollback_to_implicit_savepoint(tx, sp, expire_ts, nullptr));
   }
   return ret;
@@ -595,8 +595,7 @@ int ObTxNode::write(ObTxDesc &tx,
   OZ(txs_.get_write_store_ctx(tx,
                               snapshot,
                               write_flag,
-                              write_store_ctx,
-                              false));
+                              write_store_ctx));
   write_store_ctx.mvcc_acc_ctx_.tx_table_guards_.tx_table_guard_.init(&fake_tx_table_);
   ObArenaAllocator allocator;
   ObStoreRow row;
@@ -650,8 +649,7 @@ int ObTxNode::write_begin(ObTxDesc &tx,
   OZ(txs_.get_write_store_ctx(tx,
                               snapshot,
                               write_flag,
-                              write_store_ctx,
-                              false));
+                              write_store_ctx));
   return ret;
 }
 
diff --git a/unittest/storage/tx/test_ob_tx_log.cpp b/unittest/storage/tx/test_ob_tx_log.cpp
index a2e877fdec..68fd47a94a 100644
--- a/unittest/storage/tx/test_ob_tx_log.cpp
+++ b/unittest/storage/tx/test_ob_tx_log.cpp
@@ -47,8 +47,8 @@ bool TEST_IS_DUP = true;
 bool TEST_IS_SUB2PC = false;
 int64_t TEST_EPOCH = 1315;
 int64_t TEST_LAST_OP_SN = 1315;
-int64_t TEST_FIRST_SCN = 1315;
-int64_t TEST_LAST_SCN = 1315;
+auto TEST_FIRST_SCN = ObTxSEQ(1315, 0);
+auto TEST_LAST_SCN = ObTxSEQ(1315, 0);
 uint64_t TEST_ORG_CLUSTER_ID = 1208;
 common::ObString TEST_TRCE_INFO("trace_info_test");
 LogOffSet TEST_LOG_OFFSET(10);
@@ -57,7 +57,7 @@ int64_t TEST_CHECKSUM = 29890209;
 int64_t TEST_SCHEMA_VERSION = 372837;
 int64_t TEST_TX_EXPIRED_TIME = 12099087;
 int64_t TEST_LOG_ENTRY_NO = 1233;
-int64_t TEST_MAX_SUBMITTED_SEQ_NO = 12345;
+auto TEST_MAX_SUBMITTED_SEQ_NO = ObTxSEQ(12345, 0);
 LSKey TEST_LS_KEY;
 ObXATransID TEST_XID;
 
@@ -241,8 +241,8 @@ TEST_F(TestObTxLog, tx_log_body_except_redo)
   EXPECT_EQ(TEST_TX_EXPIRED_TIME, replay_active_state.get_tx_expired_time());
   EXPECT_EQ(TEST_EPOCH, replay_active_state.get_epoch());
   EXPECT_EQ(TEST_LAST_OP_SN, replay_active_state.get_last_op_sn());
-  EXPECT_EQ(TEST_FIRST_SCN, replay_active_state.get_first_scn());
-  EXPECT_EQ(TEST_LAST_SCN, replay_active_state.get_last_scn());
+  EXPECT_EQ(TEST_FIRST_SCN, replay_active_state.get_first_seq_no());
+  EXPECT_EQ(TEST_LAST_SCN, replay_active_state.get_last_seq_no());
   EXPECT_EQ(TEST_CLUSTER_VERSION, replay_active_state.get_cluster_version());
 
   ObTxCommitInfoLogTempRef commit_state_temp_ref;
@@ -542,9 +542,9 @@ TEST_F(TestObTxLog, test_default_log_deserialize)
   replay_member_cnt++;
   EXPECT_EQ(fill_active_state.get_last_op_sn(), replay_active_state.get_last_op_sn());
   replay_member_cnt++;
-  EXPECT_EQ(fill_active_state.get_first_scn(), replay_active_state.get_first_scn());
+  EXPECT_EQ(fill_active_state.get_first_seq_no(), replay_active_state.get_first_seq_no());
   replay_member_cnt++;
-  EXPECT_EQ(fill_active_state.get_last_scn(), replay_active_state.get_last_scn());
+  EXPECT_EQ(fill_active_state.get_last_seq_no(), replay_active_state.get_last_seq_no());
   replay_member_cnt++;
   EXPECT_EQ(fill_active_state.get_cluster_version(), replay_active_state.get_cluster_version());
   replay_member_cnt++;
diff --git a/unittest/storage/tx/test_ob_tx_msg.cpp b/unittest/storage/tx/test_ob_tx_msg.cpp
index f6398bd02e..79879386af 100644
--- a/unittest/storage/tx/test_ob_tx_msg.cpp
+++ b/unittest/storage/tx/test_ob_tx_msg.cpp
@@ -119,7 +119,7 @@ public:
     msg.timestamp_ = op_sn_;
     msg.epoch_ = -1;
     msg.request_id_ = op_sn_;
-    msg.savepoint_ = 1;
+    msg.savepoint_ = ObTxSEQ(1, 0);
     msg.op_sn_ = op_sn_;
     msg.branch_id_ = 1;
     msg.tx_ptr_ = tx;