diff --git a/src/storage/access/ob_table_scan_iterator.cpp b/src/storage/access/ob_table_scan_iterator.cpp
index 2c9b16fbba..5fcec54d3b 100755
--- a/src/storage/access/ob_table_scan_iterator.cpp
+++ b/src/storage/access/ob_table_scan_iterator.cpp
@@ -542,7 +542,7 @@ int ObTableScanIterator::check_ls_offline_after_read()
 {
   int ret = OB_SUCCESS;
 
-  auto &acc_ctx = ctx_guard_.get_store_ctx().mvcc_acc_ctx_;
+  memtable::ObMvccAccessCtx &acc_ctx = ctx_guard_.get_store_ctx().mvcc_acc_ctx_;
 
   if (acc_ctx.tx_table_guards_.check_ls_offline()) {
     ret = OB_LS_OFFLINE;
@@ -555,7 +555,7 @@ int ObTableScanIterator::check_ls_offline_after_read()
 int ObTableScanIterator::check_txn_status_if_read_uncommitted_()
 {
   int ret = OB_SUCCESS;
-  auto &acc_ctx = ctx_guard_.get_store_ctx().mvcc_acc_ctx_;
+  memtable::ObMvccAccessCtx &acc_ctx = ctx_guard_.get_store_ctx().mvcc_acc_ctx_;
   if (acc_ctx.snapshot_.tx_id_.is_valid() && acc_ctx.mem_ctx_) {
     if (acc_ctx.mem_ctx_->is_tx_rollbacked()) {
       if (acc_ctx.mem_ctx_->is_for_replay()) {
diff --git a/src/storage/memtable/ob_lock_wait_mgr.cpp b/src/storage/memtable/ob_lock_wait_mgr.cpp
index bd57418a13..f141bca4a7 100644
--- a/src/storage/memtable/ob_lock_wait_mgr.cpp
+++ b/src/storage/memtable/ob_lock_wait_mgr.cpp
@@ -36,7 +36,7 @@ namespace obmysql
 void request_finish_callback()
 {
   bool unused = false;
-  auto lock_wait_mgr = MTL(memtable::ObLockWaitMgr*);
+  memtable::ObLockWaitMgr *lock_wait_mgr = MTL(memtable::ObLockWaitMgr*);
   if (OB_ISNULL(lock_wait_mgr)) {
     TRANS_LOG(TRACE, "MTL(lock wait mgr) is null", K(MTL_ID()));
   } else {
@@ -513,18 +513,18 @@ ObLink* ObLockWaitMgr::check_timeout()
           iter->on_retry_lock(hash);
           TRANS_LOG_RET(WARN, OB_ERR_TOO_MUCH_TIME, "LOCK_MGR: req wait lock cost too much time", K(curr_lock_seq), K(last_lock_seq), K(*iter));
         } else {
-          auto tx_desc = session_info->get_tx_desc();
+          transaction::ObTxDesc *&tx_desc = session_info->get_tx_desc();
           bool ac = false, has_explicit_start_tx = session_info->has_explicit_start_trans();
           session_info->get_autocommit(ac);
           if (OB_ISNULL(tx_desc) && (!ac || has_explicit_start_tx)) {
-            auto session_id = session_info->get_sessid();
-            auto &trace_id = session_info->get_current_trace_id();
+            uint32_t session_id = session_info->get_sessid();
+            const common::ObCurTraceId::TraceId &trace_id = session_info->get_current_trace_id();
             TRANS_LOG(WARN, "LOG_MGR: found session ac = 0 or has_explicit_start_trans but txDesc was released!",
                       K(session_id), K(trace_id), K(ac), K(has_explicit_start_tx));
           }
         }
         if (OB_NOT_NULL(session_info)) {
-          auto tx_desc = session_info->get_tx_desc();
+          transaction::ObTxDesc *&tx_desc = session_info->get_tx_desc();
           TRANS_LOG(INFO, "check transaction state", KP(tx_desc));
         }
       }
@@ -583,15 +583,15 @@ int ObLockWaitMgr::post_lock(const int tmp_ret,
     Key key(&row_key);
     uint64_t &hold_key = get_thread_hold_key();
     if (OB_TRY_LOCK_ROW_CONFLICT == tmp_ret) {
-      auto row_hash = hash_rowkey(tablet_id, key);
-      auto tx_hash = hash_trans(holder_tx_id);
-      auto row_lock_seq = get_seq(row_hash);
-      auto tx_lock_seq = get_seq(tx_hash);
+      uint64_t row_hash = hash_rowkey(tablet_id, key);
+      uint64_t tx_hash = hash_trans(holder_tx_id);
+      int64_t row_lock_seq = get_seq(row_hash);
+      int64_t tx_lock_seq = get_seq(tx_hash);
       bool locked = false, wait_on_row = true;
       if (OB_FAIL(rechecker(locked, wait_on_row))) {
         TRANS_LOG(WARN, "recheck lock fail", K(key), K(holder_tx_id));
       } else if (locked) {
-        auto hash = wait_on_row ? row_hash : tx_hash;
+        uint64_t hash = wait_on_row ? row_hash : tx_hash;
         if (hold_key == hash) {
           hold_key = 0;
         }
@@ -636,7 +636,7 @@ int ObLockWaitMgr::post_lock(const int tmp_ret,
     TRANS_LOG(WARN, "lock wait mgr not inited", K(ret));
   } else if (NULL == (node = get_thread_node())) {
   } else if (OB_TRY_LOCK_ROW_CONFLICT == tmp_ret) {
-    auto hash = LockHashHelper::hash_lock_id(lock_id);
+    uint64_t hash = LockHashHelper::hash_lock_id(lock_id);
     const bool need_delay = is_remote_sql;
     char lock_id_buf[common::MAX_LOCK_ID_BUF_LENGTH];
     lock_id.to_string(lock_id_buf, sizeof(lock_id_buf));
@@ -648,7 +648,7 @@ int ObLockWaitMgr::post_lock(const int tmp_ret,
     if (need_delay) {
       delay_header_node_run_ts(hash);
     }
-    auto lock_seq = get_seq(hash);
+    int64_t lock_seq = get_seq(hash);
     bool need_wait = false;
     if (OB_FAIL(check_need_wait(need_wait))) {
       TRANS_LOG(WARN, "check need wait failed", K(ret));
diff --git a/src/storage/memtable/ob_memtable.cpp b/src/storage/memtable/ob_memtable.cpp
index e88562e3bb..1ac856c798 100755
--- a/src/storage/memtable/ob_memtable.cpp
+++ b/src/storage/memtable/ob_memtable.cpp
@@ -1121,7 +1121,7 @@ int ObMemtable::lock_row_on_frozen_stores_(
   int ret = OB_SUCCESS;
   ObStoreRowLockState &lock_state = res.lock_state_;
   ObStoreCtx &ctx = *(context.store_ctx_);
-  const auto reader_seq_no = ctx.mvcc_acc_ctx_.snapshot_.scn_;
+  const ObTxSEQ 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;
@@ -2636,7 +2636,7 @@ int ObMemtable::set_(
   ObStoreRowkey tmp_key;
   ObMemtableKey mtk;
   ObStoreCtx &ctx = *(context.store_ctx_);
-  auto *mem_ctx = ctx.mvcc_acc_ctx_.get_mem_ctx();
+  ObMemtableCtx *mem_ctx = ctx.mvcc_acc_ctx_.get_mem_ctx();
 
   //set_begin(ctx.mvcc_acc_ctx_);
 
@@ -2938,7 +2938,7 @@ int ObMemtable::mvcc_write_(
 
   // cannot be serializable when transaction set violation
   if (OB_TRANSACTION_SET_VIOLATION == ret) {
-    auto iso = ctx.mvcc_acc_ctx_.tx_desc_->get_isolation_level();
+    ObTxIsolationLevel iso = ctx.mvcc_acc_ctx_.tx_desc_->get_isolation_level();
     if (ObTxIsolationLevel::SERIAL == iso || ObTxIsolationLevel::RR == iso) {
       ret = OB_TRANS_CANNOT_SERIALIZE;
     }
@@ -2957,8 +2957,8 @@ int ObMemtable::post_row_write_conflict_(ObMvccAccessCtx &acc_ctx,
 {
   int ret = OB_TRY_LOCK_ROW_CONFLICT;
   ObLockWaitMgr *lock_wait_mgr = NULL;
-  auto conflict_tx_id = lock_state.lock_trans_id_;
-  auto mem_ctx = acc_ctx.get_mem_ctx();
+  ObTransID conflict_tx_id = lock_state.lock_trans_id_;
+  ObMemtableCtx *mem_ctx = acc_ctx.get_mem_ctx();
   int64_t current_ts = common::ObClockGenerator::getClock();
   int64_t lock_wait_start_ts = mem_ctx->get_lock_wait_start_ts() > 0
     ? mem_ctx->get_lock_wait_start_ts()
@@ -2975,15 +2975,15 @@ int ObMemtable::post_row_write_conflict_(ObMvccAccessCtx &acc_ctx,
     mem_ctx->add_conflict_trans_id(conflict_tx_id);
     mem_ctx->on_wlock_retry(row_key, conflict_tx_id);
     int tmp_ret = OB_SUCCESS;
-    auto tx_ctx = acc_ctx.tx_ctx_;
-    auto tx_id = acc_ctx.get_tx_id();
+    transaction::ObPartTransCtx *tx_ctx = acc_ctx.tx_ctx_;
+    transaction::ObTransID tx_id = acc_ctx.get_tx_id();
     bool remote_tx = tx_ctx->get_scheduler() != tx_ctx->get_addr();
     ObFunction<int(bool&, bool&)> recheck_func([&](bool &locked, bool &wait_on_row) -> int {
       int ret = OB_SUCCESS;
       lock_state.is_locked_ = false;
       if (lock_state.is_delayed_cleanout_) {
-        auto lock_data_sequence = lock_state.lock_data_sequence_;
-        auto &tx_table_guards = acc_ctx.get_tx_table_guards();
+        transaction::ObTxSEQ lock_data_sequence = lock_state.lock_data_sequence_;
+        storage::ObTxTableGuards &tx_table_guards = acc_ctx.get_tx_table_guards();
         if (OB_FAIL(tx_table_guards.check_row_locked(
                 tx_id, conflict_tx_id, lock_data_sequence, lock_state.trans_scn_, lock_state))) {
           TRANS_LOG(WARN, "re-check row locked via tx_table fail", K(ret), K(tx_id), K(lock_state));
diff --git a/src/storage/memtable/ob_row_conflict_handler.cpp b/src/storage/memtable/ob_row_conflict_handler.cpp
index 488ffc4fee..08f08ba3d7 100644
--- a/src/storage/memtable/ob_row_conflict_handler.cpp
+++ b/src/storage/memtable/ob_row_conflict_handler.cpp
@@ -100,7 +100,6 @@ int ObRowConflictHandler::post_row_read_conflict(ObMvccAccessCtx &acc_ctx,
   int ret = OB_TRY_LOCK_ROW_CONFLICT;
   ObLockWaitMgr *lock_wait_mgr = NULL;
   ObTransID conflict_tx_id = lock_state.lock_trans_id_;
-  // auto mem_ctx = acc_ctx.get_mem_ctx();
   ObTxDesc *tx_desc = acc_ctx.get_tx_desc();
   int64_t current_ts = common::ObClockGenerator::getClock();
   int64_t lock_wait_start_ts = acc_ctx.get_lock_wait_start_ts() > 0
@@ -134,8 +133,8 @@ int ObRowConflictHandler::post_row_read_conflict(ObMvccAccessCtx &acc_ctx,
       int ret = OB_SUCCESS;
       lock_state.is_locked_ = false;
       if (lock_state.is_delayed_cleanout_) {
-        auto lock_data_sequence = lock_state.lock_data_sequence_;
-        auto &tx_table_guards = acc_ctx.get_tx_table_guards();
+        ObTxSEQ lock_data_sequence = lock_state.lock_data_sequence_;
+        ObTxTableGuards &tx_table_guards = acc_ctx.get_tx_table_guards();
         if (OB_FAIL(tx_table_guards.check_row_locked(
                 tx_id, conflict_tx_id, lock_data_sequence, trans_scn, lock_state))) {
           TRANS_LOG(WARN, "re-check row locked via tx_table fail", K(ret), K(tx_id), K(lock_state));
diff --git a/src/storage/ob_value_row_iterator.cpp b/src/storage/ob_value_row_iterator.cpp
index 11cbfd225f..17778457a5 100644
--- a/src/storage/ob_value_row_iterator.cpp
+++ b/src/storage/ob_value_row_iterator.cpp
@@ -292,7 +292,7 @@ int ObSingleRowGetter::get_next_row(ObNewRow *&row)
   }
   if (OB_SUCC(ret) || OB_ITER_END == ret) {
     // check txn status not aborted, which cause readout incorrect result
-    auto &acc_ctx = store_ctx_->mvcc_acc_ctx_;
+    memtable::ObMvccAccessCtx &acc_ctx = store_ctx_->mvcc_acc_ctx_;
     if (acc_ctx.snapshot_.tx_id_.is_valid() &&
         acc_ctx.mem_ctx_ &&
         acc_ctx.mem_ctx_->is_tx_rollbacked()) {
diff --git a/src/storage/tx/ob_trans_define_v4.cpp b/src/storage/tx/ob_trans_define_v4.cpp
index 41b80fbbcd..38b489852f 100644
--- a/src/storage/tx/ob_trans_define_v4.cpp
+++ b/src/storage/tx/ob_trans_define_v4.cpp
@@ -364,7 +364,7 @@ inline void ObTxDesc::FLAG::switch_to_idle_()
 
 ObTxDesc::FLAG ObTxDesc::FLAG::update_with(const ObTxDesc::FLAG &flag)
 {
-  auto n = flag;
+  ObTxDesc::FLAG n = flag;
 #define KEEP_(x) n.x = x
 LST_DO(KEEP_, (;), SHADOW_, REPLICA_, TRACING_, INTERRUPTED_, RELEASED_, BLOCK_);
 #undef KEEP_
@@ -550,7 +550,7 @@ bool ObTxDesc::contain_savepoint(const ObString &sp)
 {
   bool hit = false;
   ARRAY_FOREACH_X(savepoints_, i, cnt, !hit) {
-    auto &it = savepoints_[cnt - 1 - i];
+    ObTxSavePoint &it = savepoints_[cnt - 1 - i];
     if (it.is_savepoint() && it.name_ == sp) {
       hit = true;
     }
@@ -564,7 +564,7 @@ int ObTxDesc::update_part_(ObTxPart &a, const bool append)
   int ret = OB_SUCCESS;
   bool hit = false;
   ARRAY_FOREACH_NORET(parts_, i) {
-    auto &p = parts_[i];
+    ObTxPart &p = parts_[i];
     if (p.id_ == a.id_) {
       hit = true;
       if (p.epoch_ == ObTxPart::EPOCH_DEAD) {
@@ -639,7 +639,7 @@ int ObTxDesc::update_parts(const share::ObLSArray &list)
 {
   int ret = OB_SUCCESS, tmp_ret = ret;
   ARRAY_FOREACH_NORET(list, i) {
-    auto &it = list[i];
+    const ObLSID &it = list[i];
     ObTxPart n;
     n.id_ = it;
     n.epoch_ = ObTxPart::EPOCH_UNKNOWN;
@@ -679,7 +679,7 @@ int ObTxDesc::update_parts_(const ObTxPartList &list)
   int ret = OB_SUCCESS;
   ARRAY_FOREACH(list, i) {
     bool hit = false;
-    auto &a = list[i];
+    const ObTxPart &a = list[i];
     ret = update_part_(const_cast<ObTxPart&>(a));
   }
   return ret;
@@ -705,7 +705,7 @@ int ObTxDesc::get_inc_exec_info(ObTxExecResult &exec_info)
   ObSpinLockGuard guard(lock_);
   if (exec_info_reap_ts_ >= 0) {
     ARRAY_FOREACH(parts_, i) {
-      auto &p = parts_[i];
+      ObTxPart &p = parts_[i];
       if (p.last_touch_ts_ > exec_info_reap_ts_ &&
           OB_FAIL(exec_info.parts_.push_back(p))) {
         TRANS_LOG(WARN, "push fail", K(ret), K(p), KPC(this), K(exec_info));
@@ -809,8 +809,8 @@ bool ObTxDesc::execute_commit_cb()
    */
   ATOMIC_LOAD_ACQ((int*)&state_);
   if (is_tx_end() || is_xa_terminate_state_()) {
-    auto tx_id = tx_id_;
-    auto cb = commit_cb_;
+    ObTransID tx_id = tx_id_;
+    ObITxCallback *cb = commit_cb_;
     int ret = OB_SUCCESS;
      if (OB_NOT_NULL(commit_cb_) && acq_commit_cb_lock_if_need_()) {
       if (OB_NOT_NULL(commit_cb_)) {
@@ -1406,7 +1406,7 @@ int ObTxDescMgr::add(ObTxDesc &tx_desc)
 int ObTxDescMgr::add_with_txid(const ObTransID &tx_id, ObTxDesc &tx_desc)
 {
   int ret = OB_SUCCESS;
-  auto desc_tx_id = tx_desc.get_tx_id();
+  ObTransID desc_tx_id = tx_desc.get_tx_id();
   if (!inited_) {
     ret = OB_NOT_INIT;
     TRANS_LOG(WARN, "ObTxDescMgr not inited", K(ret));
@@ -1449,7 +1449,7 @@ int ObTxDescMgr::get(const ObTransID &tx_id, ObTxDesc *&tx_desc)
 void ObTxDescMgr::revert(ObTxDesc &tx)
 {
   int ret = OB_SUCCESS;
-  auto tx_id = tx.get_tx_id();
+  ObTransID tx_id = tx.get_tx_id();
   OV(inited_, OB_NOT_INIT);
   if (OB_SUCC(ret)) {
     map_.revert(&tx);
@@ -1564,13 +1564,13 @@ ObTxSEQ ObTxDesc::get_tx_seq(int64_t seq_abs) const
 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);
+  int64_t 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();
+  int64_t seq = ObSequence::inc_and_get_max_seq_no();
   return ObTxSEQ::mk_v0(seq);
 }
 } // transaction
diff --git a/src/storage/tx/ob_trans_service_v4.cpp b/src/storage/tx/ob_trans_service_v4.cpp
index f02834f329..448eea6b7d 100755
--- a/src/storage/tx/ob_trans_service_v4.cpp
+++ b/src/storage/tx/ob_trans_service_v4.cpp
@@ -356,7 +356,7 @@ int ObTransService::handle_tx_commit_timeout(ObTxDesc &tx, const int64_t delay)
   // remember tx_id because tx maybe cleanout and reused
   // in this function's following steps.
   tx.lock_.lock();
-  auto tx_id = tx.tx_id_;
+  ObTransID tx_id = tx.tx_id_;
   int64_t now = ObClockGenerator::getClock();
   bool cb_executed = false;
   if (!tx.commit_task_.is_registered()){
@@ -613,7 +613,7 @@ void ObTransService::invalid_registered_snapshot_(ObTxDesc &tx)
 {
   int ret = OB_SUCCESS;
   ARRAY_FOREACH(tx.savepoints_, i) {
-    auto &it = tx.savepoints_[i];
+    ObTxSavePoint &it = tx.savepoints_[i];
     if (it.is_snapshot()) {
       it.rollback();
     }
@@ -624,7 +624,7 @@ void ObTransService::registered_snapshot_clear_part_(ObTxDesc &tx)
 {
   int ret = OB_SUCCESS;
   ARRAY_FOREACH(tx.savepoints_, i) {
-    auto &p = tx.savepoints_[i];
+    ObTxSavePoint &p = tx.savepoints_[i];
     if (p.is_snapshot() && p.snapshot_->valid_) {
       p.snapshot_->parts_.reset();
     }
@@ -956,7 +956,7 @@ int ObTransService::get_read_store_ctx(const ObTxReadSnapshot &snapshot,
                                        ObStoreCtx &store_ctx)
 {
   int ret = OB_SUCCESS;
-  auto ls_id = store_ctx.ls_id_;
+  ObLSID ls_id = store_ctx.ls_id_;
   if (!ls_id.is_valid() || !snapshot.valid_) {
     ret = OB_INVALID_ARGUMENT;
     TRANS_LOG(WARN, "invalid ls_id or invalid snapshot store_ctx", K(ret), K(snapshot), K(store_ctx), K(lbt()));
@@ -974,7 +974,7 @@ int ObTransService::get_read_store_ctx(const ObTxReadSnapshot &snapshot,
   }
 
   bool check_readable_ok = false;
-  auto snap_tx_id = snapshot.core_.tx_id_;
+  ObTransID snap_tx_id = snapshot.core_.tx_id_;
   ObPartTransCtx *tx_ctx = NULL;
   if (OB_SUCC(ret) && snap_tx_id.is_valid()) {
     // inner tx read, we verify txCtx's status
@@ -1281,8 +1281,8 @@ void ObTransService::fetch_cflict_tx_ids_from_mem_ctx_to_desc_(ObMvccAccessCtx &
 int ObTransService::revert_store_ctx(storage::ObStoreCtx &store_ctx)
 {
   int ret = OB_SUCCESS;
-  auto &acc_ctx = store_ctx.mvcc_acc_ctx_;
-  auto *tx_ctx = acc_ctx.tx_ctx_;
+  ObMvccAccessCtx &acc_ctx = store_ctx.mvcc_acc_ctx_;
+  ObPartTransCtx *tx_ctx = acc_ctx.tx_ctx_;
   if (acc_ctx.is_read()) {
     if (OB_NOT_NULL(tx_ctx)) {
       acc_ctx.tx_ctx_ = NULL;
@@ -1675,7 +1675,7 @@ int ObTransService::sync_acquire_global_snapshot_(ObTxDesc &tx,
                                                   int64_t &uncertain_bound)
 {
   int ret = OB_SUCCESS;
-  auto op_sn = tx.op_sn_;
+  uint64_t op_sn = tx.op_sn_;
   tx.flags_.BLOCK_ = true;
   tx.lock_.unlock();
   ret = acquire_global_snapshot__(expire_ts,
@@ -1766,7 +1766,7 @@ int ObTransService::batch_post_rollback_savepoint_msg_(ObTxDesc &tx,
   post_succ_num = 0;
   const ObTxDesc *msg_tx_ptr = msg.tx_ptr_;
   ARRAY_FOREACH_NORET(list, idx) {
-    auto &p = list.at(idx);
+    const ObTxLSEpochPair &p = list.at(idx);
     msg.receiver_ = p.left_;
     msg.epoch_ = p.right_;
     if (msg.epoch_ > 0) {
@@ -2241,7 +2241,7 @@ int ObTransService::handle_trans_msg_callback(const share::ObLSID &sender_ls_id,
                                               const int64_t request_id,
                                               const SCN &private_data)
 {
-  auto start_ts = ObClockGenerator::getClock();
+  int64_t start_ts = ObClockGenerator::getClock();
   int ret = OB_SUCCESS;
   if (OB_UNLIKELY(!is_running_)) {
     ret = OB_NOT_RUNNING;
@@ -2260,7 +2260,7 @@ int ObTransService::handle_trans_msg_callback(const share::ObLSID &sender_ls_id,
     case OB_NOT_MASTER:
     case OB_SUCCESS: break;
     default:
-      auto commit_version = private_data;
+      share::SCN commit_version = private_data;
       if (OB_FAIL(handle_tx_commit_result(tx_id, status, commit_version))) {
         TRANS_LOG(WARN, "handle tx commit fail", K(ret), K(tx_id));
       }
@@ -2293,7 +2293,7 @@ int ObTransService::handle_trans_msg_callback(const share::ObLSID &sender_ls_id,
       }
     }
   }
-  auto elapsed_ts = ObClockGenerator::getClock() - start_ts;
+  int64_t elapsed_ts = ObClockGenerator::getClock() - start_ts;
 #ifndef NDEBUG
   TRANS_LOG(INFO, "handle trans msg callback", K(ret), K(elapsed_ts),
             K(tx_id), K(sender_ls_id), K(receiver_ls_id),
@@ -2769,7 +2769,7 @@ int ObTransService::handle_timeout_for_xa(ObTxDesc &tx, const int64_t delay)
   int ret = OB_SUCCESS;
   int64_t now = ObClockGenerator::getClock();
   bool cb_executed = false;
-  auto tx_id = tx.tx_id_;
+  ObTransID tx_id = tx.tx_id_;
   if (OB_FAIL(tx.lock_.lock(5000000))) {
     TRANS_LOG(WARN, "failed to acquire lock in specified time", K(tx));
     // FIXME: how to handle it without lock protection
diff --git a/src/storage/tx/ob_tx_api.cpp b/src/storage/tx/ob_tx_api.cpp
index 96a61e5dfb..bb4b548c97 100644
--- a/src/storage/tx/ob_tx_api.cpp
+++ b/src/storage/tx/ob_tx_api.cpp
@@ -193,7 +193,7 @@ int ObTransService::reuse_tx(ObTxDesc &tx)
       }
     }
     // it is safe to operate tx without lock when not shared
-    auto session_id = tx.sess_id_;
+    uint32_t session_id = tx.sess_id_;
     tx.reset();
     init_tx_(tx, session_id);
   }
@@ -260,7 +260,7 @@ int ObTransService::start_tx(ObTxDesc &tx, const ObTxParam &tx_param, const ObTr
       tx.active_ts_       = ObClockGenerator::getClock();
       tx.timeout_us_      = tx_param.timeout_us_;
       tx.lock_timeout_us_ = tx_param.lock_timeout_us_;
-      auto a = tx.timeout_us_ + tx.active_ts_;
+      int64_t a = tx.timeout_us_ + tx.active_ts_;
       tx.expire_ts_       = a < 0 ? INT64_MAX : a;
       // start tx need reacquire snapshot
       tx.snapshot_version_.reset();
@@ -373,7 +373,7 @@ namespace {
 int ObTransService::commit_tx(ObTxDesc &tx, const int64_t expire_ts, const ObString *trace_info)
 {
   int ret = OB_SUCCESS;
-  auto start_ts = ObTimeUtility::current_time();
+  int64_t start_ts = ObTimeUtility::current_time();
   SyncTxCommitCb cb;
   if (OB_SUCC(submit_commit_tx(tx, expire_ts, cb, trace_info))) {
     int result = 0;
@@ -388,7 +388,7 @@ int ObTransService::commit_tx(ObTxDesc &tx, const int64_t expire_ts, const ObStr
       ret = result;
     }
   }
-  auto elapsed_us = ObTimeUtility::current_time() - start_ts;
+  int64_t elapsed_us = ObTimeUtility::current_time() - start_ts;
 #ifndef NDEBUG
   TRANS_LOG(INFO, "sync commit tx", K(ret), K(tx), K(expire_ts));
 #else
@@ -497,7 +497,7 @@ int ObTransService::submit_commit_tx(ObTxDesc &tx,
   if (OB_SUCC(ret) && (
       tx.state_ == ObTxDesc::State::ACTIVE ||
       tx.state_ == ObTxDesc::State::IMPLICIT_ACTIVE)) {
-    auto state0 = tx.state_;
+    ObTxDesc::State state0 = tx.state_;
     tx.state_ = ObTxDesc::State::IN_TERMINATE;
     // record trace_info
     if (OB_NOT_NULL(trace_info) &&
@@ -817,7 +817,7 @@ int ObTransService::release_snapshot(ObTxDesc &tx)
 int ObTransService::register_tx_snapshot_verify(ObTxReadSnapshot &snapshot)
 {
   int ret = OB_SUCCESS;
-  const auto &tx_id = snapshot.core_.tx_id_;
+  const ObTransID &tx_id = snapshot.core_.tx_id_;
   if (tx_id.is_valid()) {
     ObTxDesc *tx = NULL;
     if (OB_SUCC(tx_desc_mgr_.get(tx_id, tx))) {
@@ -854,7 +854,7 @@ int ObTransService::register_tx_snapshot_verify(ObTxReadSnapshot &snapshot)
 void ObTransService::unregister_tx_snapshot_verify(ObTxReadSnapshot &snapshot)
 {
   int ret = OB_SUCCESS;
-  const auto &tx_id = snapshot.core_.tx_id_;
+  const ObTransID &tx_id = snapshot.core_.tx_id_;
   if (tx_id.is_valid()) {
     ObTxDesc *tx = NULL;
     if (OB_SUCC(tx_desc_mgr_.get(tx_id, tx))) {
@@ -1014,7 +1014,7 @@ int ObTransService::rollback_to_local_implicit_savepoint_(ObTxDesc &tx,
 {
   int ret = OB_SUCCESS;
   ObTxPartRefList parts;
-  auto start_ts = ObTimeUtility::current_time();
+  int64_t start_ts = ObTimeUtility::current_time();
   if (OB_FAIL(find_parts_after_sp_(tx, parts, savepoint))) {
     TRANS_LOG(WARN, "find rollback parts fail", K(ret), K(savepoint), K(tx));
   } else {
@@ -1035,7 +1035,7 @@ int ObTransService::rollback_to_local_implicit_savepoint_(ObTxDesc &tx,
       }
     }
   }
-  auto elapsed_us = ObTimeUtility::current_time() - start_ts;
+  int64_t elapsed_us = ObTimeUtility::current_time() - start_ts;
 #ifndef NDEBUG
   TRANS_LOG(INFO, "rollback local implicit savepoint", K(ret), K(savepoint));
 #else
@@ -1059,7 +1059,7 @@ int ObTransService::rollback_to_global_implicit_savepoint_(ObTxDesc &tx,
                                                            const share::ObLSArray *extra_touched_ls)
 {
   int ret = OB_SUCCESS;
-  auto start_ts = ObTimeUtility::current_time();
+  int64_t start_ts = ObTimeUtility::current_time();
   tx.inc_op_sn();
   bool reset_tx = false, normal_rollback = false;
   // merge extra touched ls
@@ -1143,7 +1143,7 @@ int ObTransService::rollback_to_global_implicit_savepoint_(ObTxDesc &tx,
       TRANS_LOG(WARN, "switch tx to idle fail", K(ret), K(tx));
     }
   }
-  auto elapsed_us = ObTimeUtility::current_time() - start_ts;
+  int64_t elapsed_us = ObTimeUtility::current_time() - start_ts;
 #ifndef NDEBUG
   TRANS_LOG(INFO, "rollback to implicit savepoint", K(ret), K(savepoint), K(elapsed_us), K(tx));
 #else
@@ -1171,7 +1171,7 @@ int ObTransService::ls_sync_rollback_savepoint__(ObPartTransCtx *part_ctx,
   int ret = OB_SUCCESS;
   int64_t retry_cnt = 0;
   bool blockable = expire_ts > 0;
-  const auto from_scn = savepoint.clone_with_seq(ObSequence::inc_and_get_max_seq_no());
+  const ObTxSEQ 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) {
@@ -1209,7 +1209,7 @@ int ObTransService::create_explicit_savepoint(ObTxDesc &tx,
   int ret = OB_SUCCESS;
   ObSpinLockGuard guard(tx.lock_);
   tx.inc_op_sn();
-  const auto scn = tx.inc_and_get_tx_seq(0);
+  const ObTxSEQ 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))) {
@@ -1252,7 +1252,7 @@ int ObTransService::rollback_to_explicit_savepoint(ObTxDesc &tx,
                                                    const uint32_t session_id)
 {
   int ret = OB_SUCCESS;
-  auto start_ts = ObTimeUtility::current_time();
+  int64_t start_ts = ObTimeUtility::current_time();
   ObTxSEQ sp_scn;
   ObSpinLockGuard guard(tx.lock_);
   if (OB_SUCC(tx_sanity_check_(tx))) {
@@ -1297,7 +1297,7 @@ int ObTransService::rollback_to_explicit_savepoint(ObTxDesc &tx,
     }
   }
   tx.state_change_flags_.EXTRA_CHANGED_ = true;
-  auto elapsed_us = ObTimeUtility::current_time() - start_ts;
+  int64_t elapsed_us = ObTimeUtility::current_time() - start_ts;
   ObTransTraceLog &tlog = tx.get_tlog();
   REC_TRANS_TRACE_EXT(&tlog, rollback_explicit_savepoint, OB_Y(ret),
                       OB_ID(id), savepoint,
@@ -1355,7 +1355,7 @@ int ObTransService::create_stash_savepoint(ObTxDesc &tx, const ObString &name)
   int ret = OB_SUCCESS;
   ObSpinLockGuard guard(tx.lock_);
   tx.inc_op_sn();
-  const auto seq_no = tx.inc_and_get_tx_seq(0);
+  const ObTxSEQ 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))) {
@@ -1575,7 +1575,7 @@ inline int ObTransService::rollback_savepoint_slowpath_(ObTxDesc &tx,
   }
   if (OB_SUCC(ret)) {
     // setup state before release lock
-    auto save_state = tx.state_;
+    ObTxDesc::State save_state = tx.state_;
     tx.state_ = ObTxDesc::State::ROLLBACK_SAVEPOINT;
     tx.flags_.BLOCK_ = true;
     // release lock before blocking
@@ -1598,7 +1598,7 @@ inline int ObTransService::rollback_savepoint_slowpath_(ObTxDesc &tx,
     tmp_tx_desc->~ObTxDesc();
     ob_free(tmp_tx_desc);
   }
-  auto elapsed_us = ObTimeUtility::current_time() - start_ts;
+  int64_t elapsed_us = ObTimeUtility::current_time() - start_ts;
   TRANS_LOG(INFO, "rollback savepoint slowpath", K(ret),
             K_(tx.tx_id), K(start_ts), K(retries),
             K(savepoint), K(expire_ts), K(tx), K(parts.count()));
@@ -1625,14 +1625,14 @@ inline int ObTransService::sync_rollback_savepoint__(ObTxDesc &tx,
   expire_ts = std::max(ObTimeUtility::current_time() + MIN_WAIT_TIME, expire_ts);
   while (OB_SUCC(ret)) {
     int64_t retry_intval = std::min(min_retry_intval * (1 + retries), max_retry_intval);
-    auto waittime = std::min(expire_ts - ObTimeUtility::current_time(), retry_intval);
+    int64_t waittime = std::min(expire_ts - ObTimeUtility::current_time(), retry_intval);
     if (waittime <=0) {
       ret = OB_TIMEOUT;
       TRANS_LOG(WARN, "tx rpc wait result timeout", K(ret), K(expire_ts), K(retries));
     } else {
       ObSEArray<ObTxLSEpochPair, 4> remain;
       mask_set.get_not_mask(remain);
-      auto remain_cnt = remain.count();
+      int64_t remain_cnt = remain.count();
       TRANS_LOG(DEBUG, "unmasked parts", K(remain), K(tx), K(retries));
       // post msg to participants
       if (remain_cnt > 0) {
diff --git a/src/storage/tx/ob_tx_data_functor.cpp b/src/storage/tx/ob_tx_data_functor.cpp
index 8368aeb175..6234b956e6 100644
--- a/src/storage/tx/ob_tx_data_functor.cpp
+++ b/src/storage/tx/ob_tx_data_functor.cpp
@@ -320,8 +320,8 @@ int LockForReadFunctor::operator()(const ObTxData &tx_data, ObTxCCCtx *tx_cc_ctx
 {
   int ret = OB_ERR_SHARED_LOCK_CONFLICT;
   const int64_t MAX_SLEEP_US = 1000;
-  auto &acc_ctx = lock_for_read_arg_.mvcc_acc_ctx_;
-  auto lock_expire_ts = acc_ctx.eval_lock_expire_ts();
+  ObMvccAccessCtx &acc_ctx = lock_for_read_arg_.mvcc_acc_ctx_;
+  int64_t lock_expire_ts = acc_ctx.eval_lock_expire_ts();
   // check lock_for_read blocked or not every 1ms * 100 = 100ms
   int64_t retry_cnt = 0;
   const int64_t MAX_RETRY_CNT = 100;
diff --git a/src/storage/tx/ob_tx_free_route.cpp b/src/storage/tx/ob_tx_free_route.cpp
index 5e7a44852c..53506b4898 100644
--- a/src/storage/tx/ob_tx_free_route.cpp
+++ b/src/storage/tx/ob_tx_free_route.cpp
@@ -51,7 +51,7 @@ void ObTxnFreeRouteCtx::init_before_handle_request(ObTxDesc *tx)
   audit_record_.proxy_flag_ = is_proxy_support_;
   if (OB_NOT_NULL(tx)) {
     if (tx->flags_.DEFER_ABORT_) {
-      auto txs = MTL_WITH_CHECK_TENANT(ObTransService*, tx->tenant_id_);
+      ObTransService *txs = MTL_WITH_CHECK_TENANT(ObTransService*, tx->tenant_id_);
       if (OB_ISNULL(txs)) {
         int ret = OB_ERR_UNEXPECTED;
         TRANS_LOG(WARN, "[tx free route] MTL(txs) is null", K(ret), K(tx->tenant_id_));
@@ -155,7 +155,7 @@ inline int ObTxnFreeRouteCtx::state_update_verify_by_version(const TxnFreeRouteS
     TRANS_LOG(ERROR, "the state is stale", K(ret));
   }
   dup_sync = false;
-  auto &sync_info = state_sync_infos_[state];
+  const StateSyncInfo &sync_info = state_sync_infos_[state];
   if (sync_info.last_version_ > version) {
     // stale
     ret = OB_ERR_UNEXPECTED;
@@ -289,7 +289,7 @@ static int encode_header_(const ObTxnFreeRouteCtx &ctx, char* buf, const int64_t
 {
   int ret = OB_SUCCESS;
   TxStateHeader header;
-  auto &tx_id = ctx.get_prev_tx_id().is_valid() ? ctx.get_prev_tx_id() : ctx.get_tx_id();
+  ObTransID tx_id = ctx.get_prev_tx_id().is_valid() ? ctx.get_prev_tx_id() : ctx.get_tx_id();
   if (OB_FAIL(OB_E(EventTable::EN_TX_FREE_ROUTE_ENCODE_STATE_ERROR, ctx.get_session_id()) OB_SUCCESS)) {
     TRANS_LOG(ERROR, "inject failure", K(ret), K(ctx));
   } else if (!tx_id.is_valid()) {
@@ -337,7 +337,7 @@ int ObTransService::txn_free_route__handle_tx_exist_(const ObTransID &tx_id, ObT
   } else if (!tmp_tx->is_xa_trans()) {
     // some session hold this txn already, close the session and release this txn
     // then continue with retry
-    auto assoc_sess_id = tmp_tx->assoc_sess_id_;
+    uint32_t assoc_sess_id = tmp_tx->assoc_sess_id_;
     TRANS_LOG(WARN, "tx found associate with other session, will kill the session",
               K(assoc_sess_id), K(tx_id));
     if (OB_FAIL(txn_free_route__kill_session_(assoc_sess_id))) {
@@ -386,9 +386,9 @@ int ObTransService::txn_free_route__update_static_state(const uint32_t session_i
 {
   int ret = OB_SUCCESS;
   bool need_add_tx = false;
-  auto &audit_record = ctx.audit_record_;
+  ObTxnFreeRouteAuditRecord &audit_record = ctx.audit_record_;
   audit_record.upd_static_ = true;
-  auto before_tx_id = OB_NOT_NULL(tx) ? tx->tx_id_ : ObTransID();
+  ObTransID before_tx_id = OB_NOT_NULL(tx) ? tx->tx_id_ : ObTransID();
   TXN_FREE_ROUTE_PROCESS_HEADER(TxnFreeRouteState::STATIC);
   if (OB_FAIL(ret)) {
   } else if (header.flag_.is_tx_terminated()) {
@@ -430,7 +430,7 @@ int ObTransService::txn_free_route__update_static_state(const uint32_t session_i
       }
     }
     if (OB_SUCC(ret)) {
-      auto start_ts = ObTimeUtility::current_time();
+      int64_t start_ts = ObTimeUtility::current_time();
       ObSpinLockGuard guard(tx->lock_);
       if (OB_FAIL(tx->decode_static_state(buf, len, pos))) {
         // unretryable
@@ -450,7 +450,7 @@ int ObTransService::txn_free_route__update_static_state(const uint32_t session_i
       } else if (FALSE_IT(tx->flags_.SHADOW_ = tx->is_xa_trans() && tx->addr_ != self_)) {
         // mark as SHADOW_ for XA's temporary node, exclude XA orig node
       }
-      auto elapsed_us = ObTimeUtility::current_time() - start_ts;
+      int64_t elapsed_us = ObTimeUtility::current_time() - start_ts;
       ObTransTraceLog &tlog = tx->get_tlog();
       REC_TRANS_TRACE_EXT(&tlog, tx_free_route_update_static, OB_Y(ret),
                           OB_ID(txid), header.tx_id_.get_id(),
@@ -502,7 +502,7 @@ int ObTransService::txn_free_route__update_dynamic_state(const uint32_t session_
                                                          int64_t &pos)
 {
   int ret = OB_SUCCESS;
-  auto &audit_record = ctx.audit_record_;
+  ObTxnFreeRouteAuditRecord &audit_record = ctx.audit_record_;
   audit_record.upd_dyn_ = true;
   int64_t logic_clock = 0;
   TXN_FREE_ROUTE_PROCESS_HEADER(TxnFreeRouteState::DYNAMIC);
@@ -520,7 +520,7 @@ int ObTransService::txn_free_route__update_dynamic_state(const uint32_t session_
     ret = OB_ERR_UNEXPECTED;
     TRANS_LOG(ERROR, "tx should not be null", K(ret), K(session_id));
   } else {
-    auto start_ts = ObTimeUtility::current_time();
+    int64_t start_ts = ObTimeUtility::current_time();
     ObSpinLockGuard guard(tx->lock_);
     if (!tx->tx_id_.is_valid()) {
       // bug, dynamic state exist, txn should be active
@@ -533,7 +533,7 @@ int ObTransService::txn_free_route__update_dynamic_state(const uint32_t session_
     } else if (OB_FAIL(tx->decode_dynamic_state(buf, len, pos))) {
       TRANS_LOG(ERROR, "decode dynamic state fail", K(ret));
     }
-    auto elapsed_us = ObTimeUtility::current_time() - start_ts;
+    int64_t elapsed_us = ObTimeUtility::current_time() - start_ts;
     ObTransTraceLog &tlog = tx->get_tlog();
     REC_TRANS_TRACE_EXT(&tlog, tx_free_route_update_dynamic, OB_Y(ret),
                         OB_ID(time_used), elapsed_us,
@@ -561,7 +561,7 @@ int ObTransService::txn_free_route__update_parts_state(const uint32_t session_id
                                                        int64_t &pos)
 {
   int ret = OB_SUCCESS;
-  auto &audit_record = ctx.audit_record_;
+  ObTxnFreeRouteAuditRecord &audit_record = ctx.audit_record_;
   audit_record.upd_parts_ = true;
   TXN_FREE_ROUTE_PROCESS_HEADER(TxnFreeRouteState::PARTICIPANT);
   if (OB_FAIL(ret)) {
@@ -583,7 +583,7 @@ int ObTransService::txn_free_route__update_parts_state(const uint32_t session_id
     ret = OB_ERR_UNEXPECTED;
     TRANS_LOG(ERROR, "tx should not be null", K(ret), K(session_id));
   } else {
-    auto start_ts = ObTimeUtility::current_time();
+    int64_t start_ts = ObTimeUtility::current_time();
     ObSpinLockGuard guard(tx->lock_);
     if (!tx->tx_id_.is_valid()) {
       // bug, dynamic state exist, txn should be active
@@ -592,7 +592,7 @@ int ObTransService::txn_free_route__update_parts_state(const uint32_t session_id
     } else if (OB_FAIL(tx->decode_parts_state(buf, len, pos))) {
       TRANS_LOG(WARN, "decode participants fail", K(ret));
     }
-    auto elapsed_us = ObTimeUtility::current_time() - start_ts;
+    int64_t elapsed_us = ObTimeUtility::current_time() - start_ts;
     ObTransTraceLog &tlog = tx->get_tlog();
     REC_TRANS_TRACE_EXT(&tlog, tx_free_route_update_participants, OB_Y(ret),
                         OB_ID(txid), header.tx_id_.get_id(),
@@ -619,7 +619,7 @@ int ObTransService::txn_free_route__update_extra_state(const uint32_t session_id
 {
   int ret = OB_SUCCESS;
   int64_t logic_clock = 0;
-  auto &audit_record = ctx.audit_record_;
+  ObTxnFreeRouteAuditRecord &audit_record = ctx.audit_record_;
   audit_record.upd_extra_ = true;
   TXN_FREE_ROUTE_PROCESS_HEADER(TxnFreeRouteState::EXTRA);
   if (OB_FAIL(ret)) {
@@ -642,7 +642,7 @@ int ObTransService::txn_free_route__update_extra_state(const uint32_t session_id
   } else {
     bool add_tx = OB_ISNULL(tx);
     bool replace_tx = OB_NOT_NULL(tx) && tx->tx_id_ != header.tx_id_;
-    auto before_tx_id = OB_NOT_NULL(tx) ? tx->tx_id_ : ObTransID();
+    ObTransID before_tx_id = OB_NOT_NULL(tx) ? tx->tx_id_ : ObTransID();
     audit_record.replace_tx_ = replace_tx;
     audit_record.alloc_tx_ = add_tx;
     if (OB_FAIL(decode_i64(buf, len, pos, &logic_clock))) {
@@ -664,7 +664,7 @@ int ObTransService::txn_free_route__update_extra_state(const uint32_t session_id
       }
     }
     if (OB_SUCC(ret)) {
-      auto start_ts = ObTimeUtility::current_time();
+      int64_t start_ts = ObTimeUtility::current_time();
       ObSpinLockGuard guard(tx->lock_);
       if (OB_FAIL(tx->decode_extra_state(buf, len, pos))) {
         TRANS_LOG(ERROR, "decode extra fail", K(ret));
@@ -676,7 +676,7 @@ int ObTransService::txn_free_route__update_extra_state(const uint32_t session_id
         release_tx(*tx);
         tx = NULL;
       } else {
-        auto elapsed_us = ObTimeUtility::current_time() - start_ts;
+        int64_t elapsed_us = ObTimeUtility::current_time() - start_ts;
         ObTransTraceLog &tlog = tx->get_tlog();
         REC_TRANS_TRACE_EXT(&tlog, tx_free_route_update_extra, OB_Y(ret),
                             OB_ID(txid), header.tx_id_.get_id(),
@@ -850,7 +850,7 @@ int ObTransService::calc_txn_free_route(ObTxDesc *tx, ObTxnFreeRouteCtx &ctx)
   //
   // if niether of these flag was setted, the detailed changed txn state is exist as the content of
   // normal state, otherwise it's empty
-  auto &audit_record = ctx.audit_record_;
+  ObTxnFreeRouteAuditRecord &audit_record = ctx.audit_record_;
   if (OB_NOT_NULL(tx)) {
     tx->lock_.lock();
   }
@@ -1078,7 +1078,7 @@ bool ObTransService::need_fallback_(ObTxDesc &tx, int64_t &total_size)
 int ObTransService::push_tx_state_to_remote_(ObTxDesc &tx, const ObAddr &txn_addr)
 {
   int ret = OB_SUCCESS;
-  auto start_ts = ObTimeUtility::current_time();
+  int64_t start_ts = ObTimeUtility::current_time();
   ObTxFreeRoutePushState state;
   state.tenant_id_ = tenant_id_;
   int64_t len = 0;
@@ -1121,7 +1121,7 @@ int ObTransService::push_tx_state_to_remote_(ObTxDesc &tx, const ObAddr &txn_add
       TRANS_LOG(INFO, "[tx free route] push txn state success", K(txn_addr), K(tx));
     }
   }
-  auto elapsed_us = ObTimeUtility::current_time() - start_ts;
+  int64_t elapsed_us = ObTimeUtility::current_time() - start_ts;
   ObTransTraceLog &tlog = tx.get_tlog();
   REC_TRANS_TRACE_EXT(&tlog, tx_free_route_send_state, OB_Y(ret),
                       OB_ID(time_used), elapsed_us,
@@ -1146,7 +1146,7 @@ int ObTransService::tx_free_route_handle_push_state(const ObTxFreeRoutePushState
     ret = OB_ERR_UNEXPECTED;
     TRANS_LOG(WARN, "tx is null", K(ret));
   } else {
-    auto start_ts = ObTimeUtility::current_time();
+    int64_t start_ts = ObTimeUtility::current_time();
     const char *buf = state.buf_.ptr();
     int64_t buf_len = state.buf_.length();
     int64_t static_len = state.dynamic_offset_;
@@ -1193,7 +1193,7 @@ int ObTransService::tx_free_route_handle_push_state(const ObTxFreeRoutePushState
         ret = COVER_SUCC(tmp_ret);
       }
     }
-    auto elapsed_us = ObTimeUtility::current_time() - start_ts;
+    int64_t elapsed_us = ObTimeUtility::current_time() - start_ts;
     ObTransTraceLog &tlog = tx->get_tlog();
     REC_TRANS_TRACE_EXT(&tlog, tx_free_route_recv_state, OB_Y(ret),
                         OB_ID(time_used), elapsed_us,
diff --git a/src/storage/tx/ob_tx_free_route_rpc.cpp b/src/storage/tx/ob_tx_free_route_rpc.cpp
index 543b5226e4..f86e740eb1 100644
--- a/src/storage/tx/ob_tx_free_route_rpc.cpp
+++ b/src/storage/tx/ob_tx_free_route_rpc.cpp
@@ -39,7 +39,7 @@ int ObTxFreeRouteCheckAliveP::process()
       session->get_query_lock().unlock();
     }
   }
-  auto txs = MTL(transaction::ObTransService*);
+  transaction::ObTransService *txs = MTL(transaction::ObTransService*);
   if (OB_ISNULL(txs)) {
     ret = OB_ERR_UNEXPECTED;
     TRANS_LOG(ERROR, "can not get trans service", KR(ret));
@@ -100,8 +100,8 @@ int ObTxFreeRouteCheckAliveRespP::release_session_tx_()
   } else if (OB_FAIL(session->try_lock_thread_data())) {
     session->unlock_query();
   } else {
-    auto &ctx = session->get_txn_free_route_ctx();
-    auto &tx_desc = session->get_tx_desc();
+    transaction::ObTxnFreeRouteCtx &ctx = session->get_txn_free_route_ctx();
+    transaction::ObTxDesc *&tx_desc = session->get_tx_desc();
     if (ctx.get_local_version() != arg_.request_id_) {
       TRANS_LOG(INFO, "skip handle checkAliveResp, staled", K(arg_), K(ctx.get_local_version()));
     } else if (OB_NOT_NULL(tx_desc) && tx_desc->get_tx_id() == arg_.tx_id_) {
@@ -137,7 +137,7 @@ int ObTxFreeRoutePushStateP::process()
   int ret = OB_SUCCESS;
   transaction::ObTxFreeRoutePushState &tx_state = arg_;
   transaction::ObTxFreeRoutePushStateResp &resp = result_;
-  auto txs = MTL(transaction::ObTransService*);
+  transaction::ObTransService *txs = MTL(transaction::ObTransService*);
   if (OB_ISNULL(txs)) {
     ret = OB_ERR_UNEXPECTED;
     TRANS_LOG(WARN, "fail to get trans service", K(ret));
diff --git a/src/storage/tx_storage/ob_access_service.cpp b/src/storage/tx_storage/ob_access_service.cpp
index b3cc9c8047..d787b4589f 100755
--- a/src/storage/tx_storage/ob_access_service.cpp
+++ b/src/storage/tx_storage/ob_access_service.cpp
@@ -350,7 +350,7 @@ int ObAccessService::get_write_store_ctx_guard_(
     ret = OB_ERR_UNEXPECTED;
     LOG_ERROR("ls should not be null", K(ret), K(ls_id), K_(tenant_id));
   } else {
-    auto &ctx = ctx_guard.get_store_ctx();
+    ObStoreCtx &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, spec_seq_no))) {
@@ -400,7 +400,7 @@ int ObAccessService::get_source_ls_tx_table_guard_(ObStoreCtxGuard &ctx_guard)
       ret = OB_ERR_UNEXPECTED;
       LOG_WARN("transfer_scn or source ls tx_table_guard is invalid", K(ret), K(src_tx_table_guard), K(user_data));
     } else {
-      auto &ctx = ctx_guard.get_store_ctx();
+      ObStoreCtx &ctx = ctx_guard.get_store_ctx();
       ctx.mvcc_acc_ctx_.set_src_tx_table_guard(src_tx_table_guard);
       ctx.mvcc_acc_ctx_.set_transfer_scn(user_data.transfer_scn_);
       LOG_DEBUG("succ get src tx table guard", K(ret), K(src_ls->get_ls_id()), K(src_tx_table_guard), K(user_data));
@@ -463,7 +463,7 @@ int ObAccessService::check_read_allowed_(
     ret = OB_ERR_UNEXPECTED;
     LOG_ERROR("ls should not be null", K(ret), K(ls_id), K_(tenant_id));
   } else {
-    auto &ctx = ctx_guard.get_store_ctx();
+    ObStoreCtx &ctx = ctx_guard.get_store_ctx();
     ctx.ls_ = ls;
     ctx.timeout_ = scan_param.timeout_;
     ctx.tablet_id_ = tablet_id;
@@ -576,7 +576,7 @@ int ObAccessService::check_write_allowed_(
     LOG_WARN("failed to check replica allow to read", K(ret), K(tablet_id));
   } else {
     // TODO: this may confuse user, because of txn timeout won't notify user proactively
-    auto lock_expired_ts = MIN(dml_param.timeout_, tx_desc.get_expire_ts());
+    int64_t lock_expired_ts = MIN(dml_param.timeout_, tx_desc.get_expire_ts());
     if (OB_FAIL(get_lock_id(tablet_id, lock_id))) {
       LOG_WARN("get lock id failed", K(ret), K(tablet_id));
     } else if (OB_FAIL(lock_param.set(lock_id,