diff --git a/src/logservice/palf/scn.cpp b/src/logservice/palf/scn.cpp
index 66a4c50a4..2be6321a7 100644
--- a/src/logservice/palf/scn.cpp
+++ b/src/logservice/palf/scn.cpp
@@ -277,7 +277,8 @@ int SCN::convert_for_lsn_allocator(uint64_t scn_val)
   int ret = OB_SUCCESS;
   if (OB_UNLIKELY(OB_MAX_SCN_TS_NS < scn_val)) {
     ret = OB_INVALID_ARGUMENT;
-    PALF_LOG(WARN, "invalid argument", K(scn_val), K(ret));
+    PALF_LOG(WARN, "invalid argument", K(scn_val), K(ret), K(lbt()));
+    // TODO(yaoying.yyy):remove lbt() later
   } else {
     val_ = scn_val;
   }
diff --git a/src/observer/virtual_table/ob_all_virtual_tablet_info.cpp b/src/observer/virtual_table/ob_all_virtual_tablet_info.cpp
index 5410848c7..4e2ee2cee 100644
--- a/src/observer/virtual_table/ob_all_virtual_tablet_info.cpp
+++ b/src/observer/virtual_table/ob_all_virtual_tablet_info.cpp
@@ -189,11 +189,11 @@ int ObAllVirtualTabletInfo::process_curr_tenant(ObNewRow *&row)
           break;
         case OB_APP_MIN_COLUMN_ID + 8:
           // snapshot_version
-          cur_row_.cells_[i].set_uint64(tablet_meta.snapshot_version_.get_val_for_inner_table_field());
+          cur_row_.cells_[i].set_uint64(tablet_meta.snapshot_version_);
           break;
         case OB_APP_MIN_COLUMN_ID + 9:
           // multi_version_start
-          cur_row_.cells_[i].set_uint64(tablet_meta.multi_version_start_.get_val_for_inner_table_field());
+          cur_row_.cells_[i].set_uint64(tablet_meta.multi_version_start_);
           break;
         default:
           ret = OB_ERR_UNEXPECTED;
diff --git a/src/storage/access/ob_single_merge.cpp b/src/storage/access/ob_single_merge.cpp
index 4529013de..66c659822 100644
--- a/src/storage/access/ob_single_merge.cpp
+++ b/src/storage/access/ob_single_merge.cpp
@@ -236,7 +236,7 @@ int ObSingleMerge::inner_get_next_row(ObDatumRow &row)
     const int64_t read_snapshot_version = access_ctx_->trans_version_range_.snapshot_version_;
     const bool enable_fuse_row_cache = access_ctx_->use_fuse_row_cache_ &&
                                        access_param_->iter_param_.enable_fuse_row_cache(access_ctx_->query_flag_) &&
-                                       read_snapshot_version >= tablet_meta.snapshot_version_.get_val_for_gts();
+                                       read_snapshot_version >= tablet_meta.snapshot_version_;
     bool need_update_fuse_cache = false;
     access_ctx_->query_flag_.set_not_use_row_cache();
     nop_pos_.reset();
@@ -273,7 +273,7 @@ int ObSingleMerge::inner_get_next_row(ObDatumRow &row)
 #endif
     } else if (enable_fuse_row_cache) {
       if (OB_FAIL(get_and_fuse_cache_row(read_snapshot_version,
-                                         tablet_meta.multi_version_start_.get_val_for_gts(),
+                                         tablet_meta.multi_version_start_,
                                          full_row_,
                                          final_result,
                                          have_uncommited_row,
diff --git a/src/storage/high_availability/ob_ls_restore.cpp b/src/storage/high_availability/ob_ls_restore.cpp
index f76bbec73..309e953be 100644
--- a/src/storage/high_availability/ob_ls_restore.cpp
+++ b/src/storage/high_availability/ob_ls_restore.cpp
@@ -2025,8 +2025,8 @@ int ObTabletGroupMetaRestoreTask::create_or_update_tablet_(
     param.data_tablet_id_ = tablet_id;
     param.clog_checkpoint_scn_.reset();
     param.compat_mode_ = lib::Worker::get_compatibility_mode();
-    param.multi_version_start_.set_min();
-    param.snapshot_version_.set_min();
+    param.multi_version_start_ = 0;
+    param.snapshot_version_ = 0;
     param.tx_data_.tablet_status_ = ObTabletStatus::NORMAL;
 
     if (OB_FAIL(param.ha_status_.set_restore_status(restore_status))) {
diff --git a/src/storage/high_availability/ob_storage_ha_reader.cpp b/src/storage/high_availability/ob_storage_ha_reader.cpp
index d9f36c6a5..12133ad27 100644
--- a/src/storage/high_availability/ob_storage_ha_reader.cpp
+++ b/src/storage/high_availability/ob_storage_ha_reader.cpp
@@ -1011,8 +1011,8 @@ int ObCopyTabletInfoObProducer::build_deleted_tablet_info_(
     tablet_info.param_.start_scn_.set_base();
     tablet_info.param_.clog_checkpoint_scn_.set_base();
     tablet_info.param_.compat_mode_ = lib::Worker::get_compatibility_mode();
-    tablet_info.param_.multi_version_start_.set_min();
-    tablet_info.param_.snapshot_version_.set_min();
+    tablet_info.param_.multi_version_start_ = 0;
+    tablet_info.param_.snapshot_version_ = 0;
     tablet_info.param_.tx_data_.tablet_status_ = ObTabletStatus::DELETING;
     tablet_info.param_.tx_data_.tx_scn_ = palf::SCN::min_scn();
 
diff --git a/src/storage/ob_storage_schema_recorder.cpp b/src/storage/ob_storage_schema_recorder.cpp
index 12ee0c3a5..f34788279 100644
--- a/src/storage/ob_storage_schema_recorder.cpp
+++ b/src/storage/ob_storage_schema_recorder.cpp
@@ -150,7 +150,7 @@ int ObStorageSchemaRecorder::init(
 
 // schema log is barrier, there is no concurrency problem, no need to lock
 int ObStorageSchemaRecorder::replay_schema_log(
-    const int64_t log_ts,
+    const palf::SCN &scn,
     const char *buf,
     const int64_t size,
     int64_t &pos)
@@ -164,11 +164,7 @@ int ObStorageSchemaRecorder::replay_schema_log(
     int64_t table_version = OB_INVALID_VERSION;
     ObArenaAllocator tmp_allocator;
     ObStorageSchema replay_storage_schema;
-    // TODO: fix it
-    palf::SCN scn;
-    if (OB_FAIL(scn.convert_for_lsn_allocator(log_ts))) {
-      LOG_WARN("convert failed", K(log_ts), K(ret));
-    } else if (tablet_id_.is_special_merge_tablet()) {
+    if (tablet_id_.is_special_merge_tablet()) {
       // do nothing
     } else if (OB_FAIL(serialization::decode_i64(buf, size, pos, &table_version))) {
       // table_version
@@ -176,8 +172,8 @@ int ObStorageSchemaRecorder::replay_schema_log(
     } else if (table_version <= ATOMIC_LOAD(&max_saved_table_version_)) {
       LOG_INFO("skip schema log with smaller table version", K_(tablet_id), K(table_version),
           K(max_saved_table_version_));
-    } else if (OB_FAIL(replay_get_tablet_handle(log_ts, tablet_handle_))) {
-      LOG_WARN("failed to get tablet handle", K(ret), K_(tablet_id), K(log_ts));
+    } else if (OB_FAIL(replay_get_tablet_handle(scn, tablet_handle_))) {
+      LOG_WARN("failed to get tablet handle", K(ret), K_(tablet_id), K(scn));
     } else if (OB_FAIL(replay_storage_schema.deserialize(tmp_allocator, buf, size, pos))) {
       LOG_WARN("fail to deserialize storage schema", K(ret), K_(tablet_id));
     } else if (FALSE_IT(replay_storage_schema.set_sync_finish(true))) {
@@ -314,15 +310,12 @@ int ObStorageSchemaRecorder::get_tablet_handle(ObTabletHandle &tablet_handle)
   return ret;
 }
 
-int ObStorageSchemaRecorder::replay_get_tablet_handle(const int64_t log_ts, ObTabletHandle &tablet_handle)
+int ObStorageSchemaRecorder::replay_get_tablet_handle(const palf::SCN &scn, ObTabletHandle &tablet_handle)
 {
   int ret = OB_SUCCESS;
   ObLSHandle ls_handle;
-  palf::SCN scn;
   if (OB_FAIL(MTL(ObLSService *)->get_ls(ls_id_, ls_handle, ObLSGetMod::STORAGE_MOD))) {
     LOG_WARN("failed to get log stream", K(ret), K(ls_id_));
-  } else if (OB_FAIL(scn.convert_for_lsn_allocator(log_ts))) {
-    LOG_WARN("convert failed", K(log_ts), K(ret));
   } else if (OB_FAIL(ls_handle.get_ls()->replay_get_tablet(tablet_id_, scn, tablet_handle))) {
     LOG_WARN("failed to get tablet", K(ret), K_(ls_id), K_(tablet_id), K(scn));
   }
diff --git a/src/storage/ob_storage_schema_recorder.h b/src/storage/ob_storage_schema_recorder.h
index 33916ab25..68c3e9428 100644
--- a/src/storage/ob_storage_schema_recorder.h
+++ b/src/storage/ob_storage_schema_recorder.h
@@ -61,7 +61,7 @@ public:
   void reset();
 
   // follower
-  int replay_schema_log(const int64_t log_ts, const char *buf, const int64_t size, int64_t &pos);
+  int replay_schema_log(const palf::SCN &scn, const char *buf, const int64_t size, int64_t &pos);
   // leader
   int try_update_storage_schema(
       const int64_t table_id,
@@ -109,7 +109,7 @@ private:
   void free_allocated_info();
   int try_update_with_lock(const int64_t table_id, const int64_t table_version, const int64_t expire_ts);
   int get_tablet_handle(ObTabletHandle &tablet_handle);
-  int replay_get_tablet_handle(const int64_t log_ts, ObTabletHandle &tablet_handle);
+  int replay_get_tablet_handle(const palf::SCN &scn, ObTabletHandle &tablet_handle);
   // clog callback
   void update_table_schema_fail();
   void update_table_schema_succ(const int64_t table_version, bool &finish_flag);
diff --git a/src/storage/tablet/ob_tablet.cpp b/src/storage/tablet/ob_tablet.cpp
index c01523063..e8220d446 100644
--- a/src/storage/tablet/ob_tablet.cpp
+++ b/src/storage/tablet/ob_tablet.cpp
@@ -152,7 +152,7 @@ int ObTablet::init(
     LOG_WARN("failed to init shared params", K(ret), K(ls_id), K(tablet_id), KP(freezer));
   } else if (OB_FAIL(tablet_meta_.init(*allocator_, ls_id, tablet_id, data_tablet_id,
       lob_meta_tablet_id, lob_piece_tablet_id,
-      create_scn, snapshot_version, compat_mode, store_flag, table_schema.get_schema_version()))) {
+      create_scn, snapshot_version.get_val_for_tx(), compat_mode, store_flag, table_schema.get_schema_version()))) {
     LOG_WARN("failed to init tablet meta", K(ret), K(ls_id), K(tablet_id), K(data_tablet_id),
         K(lob_meta_tablet_id), K(lob_piece_tablet_id),
         K(create_scn), K(snapshot_version), K(compat_mode), K(store_flag));
@@ -201,8 +201,8 @@ int ObTablet::init(
   SCN snapshot_scn;
   if (OB_FAIL(scn.convert_tmp(create_scn))) {
     LOG_WARN("failed to convert_tmp", K(ret), K(create_scn));
-  } else if (OB_FAIL(snapshot_scn.convert_tmp(snapshot_version))) {
-    LOG_WARN("failed to convert_tmp", K(ret), K(snapshot_version));
+  } else if (OB_FAIL(snapshot_scn.convert_for_lsn_allocator(snapshot_version))) {
+    LOG_WARN("failed to convert scn", K(ret), K(snapshot_version));
   } else if (OB_FAIL(init(ls_id, tablet_id, data_tablet_id, lob_meta_tablet_id, lob_piece_tablet_id,
       scn, snapshot_scn, table_schema, compat_mode, store_flag, table_handle, freezer))) {
     LOG_WARN("failed to init tablet", K(ret), K(scn));
@@ -636,6 +636,24 @@ int ObTablet::load_deserialize(
   return ret;
 }
 
+int ObTablet::get_multi_version_start(SCN &scn) const
+{
+  int ret = OB_SUCCESS;
+  if (OB_FAIL(scn.convert_for_tx(tablet_meta_.multi_version_start_))) {
+    LOG_WARN("fail to convert scn", K(ret), K(tablet_meta_.multi_version_start_));
+  }
+  return ret;
+}
+
+int ObTablet::get_snapshot_version(SCN &scn) const
+{
+  int ret = OB_SUCCESS;
+  if (OB_FAIL(scn.convert_for_tx(tablet_meta_.snapshot_version_))) {
+    LOG_WARN("fail to convert scn", K(ret), K(tablet_meta_.snapshot_version_));
+  }
+  return ret;
+}
+
 int64_t ObTablet::get_serialize_size() const
 {
   int64_t size = get_self_size();
@@ -1503,36 +1521,6 @@ int ObTablet::assign_pointer_handle(const ObTabletPointerHandle &ptr_hdl)
   return ret;
 }
 
-int ObTablet::replay_update_storage_schema(
-    const int64_t log_ts,
-    const char *buf,
-    const int64_t buf_size,
-    int64_t &pos)
-{
-  int ret = OB_SUCCESS;
-  int64_t new_pos = pos;
-  ObIMemtableMgr *memtable_mgr = nullptr;
-  ObTabletMemtableMgr *data_memtable_mgr = nullptr;
-
-  if (IS_NOT_INIT) {
-    ret = OB_NOT_INIT;
-    LOG_WARN("not inited", K(ret));
-  } else if (tablet_meta_.tablet_id_.is_special_merge_tablet()) {
-    // do nothing
-  } else if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
-  } else if (FALSE_IT(data_memtable_mgr = static_cast<ObTabletMemtableMgr *>(memtable_mgr))) {
-  } else if (OB_FAIL(data_memtable_mgr->get_storage_schema_recorder().replay_schema_log(log_ts, buf, buf_size, new_pos))) {
-    LOG_WARN("storage schema recorder replay fail", K(ret), K(log_ts));
-  } else {
-    pos = new_pos;
-  }
-  if (OB_TIMEOUT == ret) {
-    ret = OB_EAGAIN; // need retry.
-  }
-  return ret;
-}
-
 int ObTablet::replay_update_storage_schema(
     const palf::SCN &scn,
     const char *buf,
@@ -1552,7 +1540,7 @@ int ObTablet::replay_update_storage_schema(
   } else if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
     LOG_WARN("failed to get memtable mgr", K(ret));
   } else if (FALSE_IT(data_memtable_mgr = static_cast<ObTabletMemtableMgr *>(memtable_mgr))) {
-  } else if (OB_FAIL(data_memtable_mgr->get_storage_schema_recorder().replay_schema_log(scn.get_val_for_gts(), buf, buf_size, new_pos))) {
+  } else if (OB_FAIL(data_memtable_mgr->get_storage_schema_recorder().replay_schema_log(scn, buf, buf_size, new_pos))) {
     LOG_WARN("storage schema recorder replay fail", K(ret), K(scn));
   } else {
     pos = new_pos;
@@ -2364,7 +2352,7 @@ int ObTablet::start_ddl_if_need()
     table_key.table_type_ = ObITable::TableType::MAJOR_SSTABLE;
     table_key.tablet_id_ = tablet_meta_.tablet_id_;
     table_key.version_range_.base_version_ = 0;
-    table_key.version_range_.snapshot_version_ = tablet_meta_.ddl_snapshot_version_.get_val_for_gts();
+    table_key.version_range_.snapshot_version_ = tablet_meta_.ddl_snapshot_version_;
     const SCN start_scn = tablet_meta_.ddl_start_scn_;
     if (OB_FAIL(ddl_kv_mgr->ddl_start(table_key, start_scn.get_val_for_gts(), GET_MIN_CLUSTER_VERSION(), tablet_meta_.ddl_checkpoint_scn_.get_val_for_gts()))) {
       LOG_WARN("start ddl kv manager failed", K(ret), K(table_key), K(start_scn));
diff --git a/src/storage/tablet/ob_tablet.h b/src/storage/tablet/ob_tablet.h
index d3806e0ff..859d3c310 100644
--- a/src/storage/tablet/ob_tablet.h
+++ b/src/storage/tablet/ob_tablet.h
@@ -327,8 +327,10 @@ public:
   const ObTabletTableStore &get_table_store() const { return table_store_; }
   int64_t get_clog_checkpoint_ts() const { return tablet_meta_.clog_checkpoint_scn_.get_val_for_gts(); }
   palf::SCN get_clog_checkpoint_scn() const { return tablet_meta_.clog_checkpoint_scn_; }
-  int64_t get_snapshot_version() const { return tablet_meta_.snapshot_version_.get_val_for_gts(); }
-  int64_t get_multi_version_start() const { return tablet_meta_.multi_version_start_.get_val_for_gts(); }
+  int64_t get_snapshot_version() const { return tablet_meta_.snapshot_version_; }
+  int64_t get_multi_version_start() const { return tablet_meta_.multi_version_start_; }
+  int get_multi_version_start(palf::SCN &scn) const;
+  int get_snapshot_version(palf::SCN &scn) const;
 
   // deprecated later, DO NOT use it!
   ObTabletTableStore &get_table_store() { return table_store_; }
@@ -344,11 +346,6 @@ public:
 
   int assign_pointer_handle(const ObTabletPointerHandle &ptr_hdl);
 
-  int replay_update_storage_schema(
-      const int64_t log_ts,
-      const char *buf,
-      const int64_t buf_size,
-      int64_t &pos);
   int replay_update_storage_schema(
       const palf::SCN &scn,
       const char *buf,
diff --git a/src/storage/tablet/ob_tablet_create_delete_helper.cpp b/src/storage/tablet/ob_tablet_create_delete_helper.cpp
index e83229e8c..de95e97e4 100644
--- a/src/storage/tablet/ob_tablet_create_delete_helper.cpp
+++ b/src/storage/tablet/ob_tablet_create_delete_helper.cpp
@@ -2255,7 +2255,6 @@ int ObTabletCreateDeleteHelper::do_create_tablet(
   int ret = OB_SUCCESS;
   ObTenantMetaMemMgr *t3m = MTL(ObTenantMetaMemMgr*);
   SCN snapshot_version;
-  snapshot_version.convert_tmp(arg.frozen_timestamp_);
   const ObLSID &ls_id = arg.id_;
   const ObTabletMapKey key(ls_id, tablet_id);
   ObTablet *tablet = nullptr;
@@ -2271,7 +2270,9 @@ int ObTabletCreateDeleteHelper::do_create_tablet(
   ObMetaDiskAddr mem_addr;
   ObTabletTableStoreFlag table_store_flag;
   table_store_flag.set_with_major_sstable();
-  if (OB_FAIL(mem_addr.set_mem_addr(0, sizeof(ObTablet)))) {
+  if (OB_FAIL(snapshot_version.convert_tmp(arg.frozen_timestamp_))) {
+    LOG_WARN("fail to convert scn", K(ret), K(arg.frozen_timestamp_));
+  } else if (OB_FAIL(mem_addr.set_mem_addr(0, sizeof(ObTablet)))) {
     LOG_WARN("fail to set memory address", K(ret));
   } else if (OB_FAIL(acquire_tablet(key, tablet_handle, false/*only acquire*/))) {
     LOG_WARN("failed to acquire tablet", K(ret), K(key));
diff --git a/src/storage/tablet/ob_tablet_meta.cpp b/src/storage/tablet/ob_tablet_meta.cpp
index e8ba9cc23..6f4fa2604 100644
--- a/src/storage/tablet/ob_tablet_meta.cpp
+++ b/src/storage/tablet/ob_tablet_meta.cpp
@@ -40,8 +40,8 @@ ObTabletMeta::ObTabletMeta()
     start_scn_(),
     clog_checkpoint_scn_(),
     ddl_checkpoint_scn_(),
-    snapshot_version_(),
-    multi_version_start_(),
+    snapshot_version_(OB_INVALID_TIMESTAMP),
+    multi_version_start_(OB_INVALID_TIMESTAMP),
     compat_mode_(lib::Worker::CompatMode::INVALID),
     autoinc_seq_(),
     ha_status_(),
@@ -50,7 +50,7 @@ ObTabletMeta::ObTabletMeta()
     ddl_data_(),
     table_store_flag_(),
     ddl_start_scn_(),
-    ddl_snapshot_version_(),
+    ddl_snapshot_version_(OB_INVALID_TIMESTAMP),
     max_sync_storage_schema_version_(0),
     is_inited_(false)
 {
@@ -100,11 +100,11 @@ int ObTabletMeta::init(
     clog_checkpoint_scn_.set_base();
     ddl_checkpoint_scn_.set_base();
     compat_mode_ = compat_mode;
-    snapshot_version_.convert_tmp(snapshot_version);
-    multi_version_start_.convert_tmp(snapshot_version);
+    snapshot_version_ = snapshot_version;
+    multi_version_start_ = snapshot_version;
     table_store_flag_ = table_store_flag;
     ddl_start_scn_.set_min();
-    ddl_snapshot_version_.set_min();
+    ddl_snapshot_version_ = 0;
     max_sync_storage_schema_version_ = max_sync_storage_schema_version;
 
     report_status_.merge_snapshot_version_ = snapshot_version;
@@ -136,7 +136,7 @@ int ObTabletMeta::init(
     const common::ObTabletID &lob_meta_tablet_id,
     const common::ObTabletID &lob_piece_tablet_id,
     const palf::SCN create_scn,
-    const palf::SCN snapshot_version,
+    const int64_t snapshot_version,
     const lib::Worker::CompatMode compat_mode,
     const ObTabletTableStoreFlag &table_store_flag,
     const int64_t max_sync_storage_schema_version)
@@ -151,7 +151,7 @@ int ObTabletMeta::init(
       || OB_UNLIKELY(!data_tablet_id.is_valid())
       // TODO: fix it after multi source data refactor
       // || OB_UNLIKELY(!create_scn.is_valid())
-      || OB_UNLIKELY(!snapshot_version.is_valid())
+      || OB_UNLIKELY(OB_INVALID_TIMESTAMP == snapshot_version)
       || OB_UNLIKELY(lib::Worker::CompatMode::INVALID == compat_mode)) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid args", K(ret), K(ls_id), K(tablet_id), K(data_tablet_id),
@@ -172,11 +172,11 @@ int ObTabletMeta::init(
     multi_version_start_ = snapshot_version;
     table_store_flag_ = table_store_flag;
     ddl_start_scn_.set_min();
-    ddl_snapshot_version_.set_min();
+    ddl_snapshot_version_ = 0;
     max_sync_storage_schema_version_ = max_sync_storage_schema_version;
 
-    report_status_.merge_snapshot_version_ = snapshot_version.get_val_for_gts();
-    report_status_.cur_report_version_ = snapshot_version.get_val_for_gts();
+    report_status_.merge_snapshot_version_ = snapshot_version;
+    report_status_.cur_report_version_ = snapshot_version;
     report_status_.data_checksum_ = 0;
     report_status_.row_count_ = 0;
 
@@ -239,12 +239,12 @@ int ObTabletMeta::init(
     compat_mode_ = old_tablet_meta.compat_mode_;
     ha_status_ = old_tablet_meta.ha_status_;
     report_status_ = old_tablet_meta.report_status_;
-    snapshot_version_.convert_tmp(MAX(snapshot_version, old_tablet_meta.snapshot_version_.get_val_for_gts()));
-    multi_version_start_.convert_tmp(MIN(MAX(multi_version_start, old_tablet_meta.multi_version_start_.get_val_for_gts()), snapshot_version_.get_val_for_gts()));
+    snapshot_version_ = MAX(snapshot_version, old_tablet_meta.snapshot_version_);
+    multi_version_start_ = MIN(MAX(multi_version_start, old_tablet_meta.multi_version_start_), snapshot_version_);
     tx_data_ = tx_data;
     table_store_flag_ = old_tablet_meta.table_store_flag_;
     max_sync_storage_schema_version_ = max_sync_storage_schema_version;
-    ddl_snapshot_version_.convert_tmp(MAX(old_tablet_meta.ddl_snapshot_version_.get_val_for_gts(), ddl_snapshot_version));
+    ddl_snapshot_version_ = MAX(old_tablet_meta.ddl_snapshot_version_, ddl_snapshot_version);
     is_inited_ = true;
   }
 
@@ -257,8 +257,8 @@ int ObTabletMeta::init(
 int ObTabletMeta::init(
     common::ObIAllocator &allocator,
     const ObTabletMeta &old_tablet_meta,
-    const palf::SCN &snapshot_version,
-    const palf::SCN multi_version_start,
+    const int64_t snapshot_version,
+    const int64_t multi_version_start,
     const ObTabletTxMultiSourceDataUnit &tx_data,
     const ObTabletBindingInfo &ddl_data,
     const ObTabletAutoincSeq &autoinc_seq,
@@ -266,7 +266,7 @@ int ObTabletMeta::init(
     const palf::SCN clog_checkpoint_scn,
     const palf::SCN ddl_checkpoint_scn,
     const palf::SCN ddl_start_scn,
-    const palf::SCN ddl_snapshot_version)
+    const int64_t ddl_snapshot_version)
 {
   int ret = OB_SUCCESS;
 
@@ -367,8 +367,8 @@ void ObTabletMeta::reset()
   start_scn_.reset();
   clog_checkpoint_scn_.reset();
   ddl_checkpoint_scn_ .reset();
-  snapshot_version_.reset();
-  multi_version_start_.reset();
+  snapshot_version_ = OB_INVALID_TIMESTAMP;
+  multi_version_start_ = OB_INVALID_TIMESTAMP;
   compat_mode_ = lib::Worker::CompatMode::INVALID;
   autoinc_seq_.reset();
   ha_status_.reset();
@@ -377,7 +377,7 @@ void ObTabletMeta::reset()
   ddl_data_.reset();
   table_store_flag_.reset();
   ddl_start_scn_.reset();
-  ddl_snapshot_version_.reset();
+  ddl_snapshot_version_ = OB_INVALID_TIMESTAMP;
   max_sync_storage_schema_version_ = 0;
   is_inited_ = false;
 }
@@ -389,7 +389,7 @@ bool ObTabletMeta::is_valid() const
       && tablet_id_.is_valid()
       && data_tablet_id_.is_valid()
       //&& create_scn_ > OB_INVALID_TIMESTAMP
-      && multi_version_start_ >= SCN::min_scn()
+      && multi_version_start_ >= 0
       && multi_version_start_ <= snapshot_version_
       && compat_mode_ != lib::Worker::CompatMode::INVALID
       && max_sync_storage_schema_version_ >= 0
@@ -447,9 +447,9 @@ int ObTabletMeta::serialize(char *buf, const int64_t len, int64_t &pos)
     LOG_WARN("failed to serialize clog checkpoint ts", K(ret), K(len), K(new_pos), K_(clog_checkpoint_scn));
   } else if (new_pos - pos < length_ && OB_FAIL(ddl_checkpoint_scn_.fixed_serialize(buf, len, new_pos))) {
     LOG_WARN("failed to serialize ddl checkpoint ts", K(ret), K(len), K(new_pos), K_(ddl_checkpoint_scn));
-  } else if (new_pos - pos < length_ && OB_FAIL(snapshot_version_.fixed_serialize(buf, len, new_pos))) {
+  } else if (new_pos - pos < length_ && OB_FAIL(serialization::encode_i64(buf, len, new_pos, snapshot_version_))) {
     LOG_WARN("failed to serialize snapshot version", K(ret), K(len), K(new_pos), K_(snapshot_version));
-  } else if (new_pos - pos < length_ && OB_FAIL(multi_version_start_.fixed_serialize(buf, len, new_pos))) {
+  } else if (new_pos - pos < length_ && OB_FAIL(serialization::encode_i64(buf, len, new_pos, multi_version_start_))) {
     LOG_WARN("failed to serialize multi version start", K(ret), K(len), K(new_pos), K_(multi_version_start));
   } else if (new_pos - pos < length_ && OB_FAIL(serialization::encode_i8(buf, len, new_pos, static_cast<int8_t>(compat_mode_)))) {
     LOG_WARN("failed to serialize auto inc seq", K(ret), K(len), K(new_pos));
@@ -467,7 +467,7 @@ int ObTabletMeta::serialize(char *buf, const int64_t len, int64_t &pos)
     LOG_WARN("failed to serialize table store flag", K(ret), K(len), K(new_pos));
   } else if (new_pos - pos < length_ && OB_FAIL(ddl_start_scn_.fixed_serialize(buf, len, new_pos))) {
     LOG_WARN("failed to serialize ddl start log ts", K(ret), K(len), K(new_pos), K_(ddl_start_scn));
-  } else if (new_pos - pos < length_ && OB_FAIL(ddl_snapshot_version_.fixed_serialize(buf, len, new_pos))) {
+  } else if (new_pos - pos < length_ && OB_FAIL(serialization::encode_i64(buf, len, new_pos, ddl_snapshot_version_))) {
     LOG_WARN("failed to serialize ddl snapshot version", K(ret), K(len), K(new_pos), K_(ddl_snapshot_version));
   } else if (new_pos - pos < length_ && OB_FAIL(serialization::encode_i64(buf, len, new_pos, max_sync_storage_schema_version_))) {
     LOG_WARN("failed to serialize max_sync_storage_schema_version", K(ret), K(len), K(new_pos), K_(max_sync_storage_schema_version));
@@ -526,9 +526,9 @@ int ObTabletMeta::deserialize(
       LOG_WARN("failed to deserialize clog checkpoint ts", K(ret), K(len), K(new_pos));
     } else if (new_pos - pos < length_ && OB_FAIL(ddl_checkpoint_scn_.fixed_deserialize(buf, len, new_pos))) {
       LOG_WARN("failed to deserialize ddl checkpoint ts", K(ret), K(len), K(new_pos));
-    } else if (new_pos - pos < length_ && OB_FAIL(snapshot_version_.fixed_deserialize(buf, len, new_pos))) {
+    } else if (new_pos - pos < length_ && OB_FAIL(serialization::decode_i64(buf, len, new_pos, &snapshot_version_))) {
       LOG_WARN("failed to deserialize snapshot version", K(ret), K(len));
-    } else if (new_pos - pos < length_ && OB_FAIL(multi_version_start_.fixed_deserialize(buf, len, new_pos))) {
+    } else if (new_pos - pos < length_ && OB_FAIL(serialization::decode_i64(buf, len, new_pos, &multi_version_start_))) {
       LOG_WARN("failed to deserialize multi version start", K(ret), K(len));
     } else if (new_pos - pos < length_ && OB_FAIL(serialization::decode_i8(buf, len, new_pos, (int8_t*)(&compat_mode)))) {
       LOG_WARN("failed to deserialize compat mode", K(ret), K(len), K(new_pos));
@@ -546,7 +546,7 @@ int ObTabletMeta::deserialize(
       LOG_WARN("failed to deserialize table store flag", K(ret), K(len), K(new_pos));
     } else if (new_pos - pos < length_ && OB_FAIL(ddl_start_scn_.fixed_deserialize(buf, len, new_pos))) {
       LOG_WARN("failed to deserialize ddl start log ts", K(ret), K(len), K(new_pos));
-    } else if (new_pos - pos < length_ && OB_FAIL(ddl_snapshot_version_.fixed_deserialize(buf, len, new_pos))) {
+    } else if (new_pos - pos < length_ && OB_FAIL(serialization::decode_i64(buf, len, new_pos, &ddl_snapshot_version_))) {
       LOG_WARN("failed to deserialize ddl snapshot version", K(ret), K(len), K(new_pos));
     } else if (new_pos - pos < length_ && OB_FAIL(serialization::decode_i64(buf, len, new_pos, &max_sync_storage_schema_version_))) {
       LOG_WARN("failed to deserialize max_sync_storage_schema_version_", K(ret), K(len), K(new_pos));
@@ -580,8 +580,8 @@ int64_t ObTabletMeta::get_serialize_size() const
   size += start_scn_.get_fixed_serialize_size();
   size += clog_checkpoint_scn_.get_fixed_serialize_size();
   size += ddl_checkpoint_scn_.get_fixed_serialize_size();
-  size += snapshot_version_.get_fixed_serialize_size();
-  size += multi_version_start_.get_fixed_serialize_size();
+  size += serialization::encoded_length_i64(snapshot_version_);
+  size += serialization::encoded_length_i64(multi_version_start_);
   size += serialization::encoded_length_i8(static_cast<int8_t>(compat_mode_));
   size += autoinc_seq_.get_serialize_size();
   size += ha_status_.get_serialize_size();
@@ -590,7 +590,7 @@ int64_t ObTabletMeta::get_serialize_size() const
   size += ddl_data_.get_serialize_size();
   size += table_store_flag_.get_serialize_size();
   size += ddl_start_scn_.get_fixed_serialize_size();
-  size += ddl_snapshot_version_.get_fixed_serialize_size();
+  size += serialization::encoded_length_i64(ddl_snapshot_version_);
   size += serialization::encoded_length_i64(max_sync_storage_schema_version_);
   return size;
 }
@@ -734,8 +734,8 @@ ObMigrationTabletParam::ObMigrationTabletParam()
     start_scn_(),
     clog_checkpoint_scn_(),
     ddl_checkpoint_scn_(),
-    snapshot_version_(),
-    multi_version_start_(),
+    snapshot_version_(OB_INVALID_TIMESTAMP),
+    multi_version_start_(OB_INVALID_TIMESTAMP),
     compat_mode_(lib::Worker::CompatMode::INVALID),
     autoinc_seq_(),
     ha_status_(),
@@ -746,7 +746,7 @@ ObMigrationTabletParam::ObMigrationTabletParam()
     medium_info_list_(compaction::ObMediumCompactionInfoList::MEDIUM_LIST_IN_STORAGE),
     table_store_flag_(),
     ddl_start_scn_(),
-    ddl_snapshot_version_(),
+    ddl_snapshot_version_(OB_INVALID_TIMESTAMP),
     max_sync_storage_schema_version_(0)
 {
 }
@@ -757,7 +757,7 @@ bool ObMigrationTabletParam::is_valid() const
       && tablet_id_.is_valid()
       && data_tablet_id_.is_valid()
       //&& create_scn_ > OB_INVALID_TIMESTAMP
-      && multi_version_start_ >= SCN::min_scn()
+      && multi_version_start_ >= 0
       && multi_version_start_ <= snapshot_version_
       && compat_mode_ != lib::Worker::CompatMode::INVALID
       && medium_info_list_.is_valid()
@@ -799,9 +799,9 @@ int ObMigrationTabletParam::serialize(char *buf, const int64_t len, int64_t &pos
     LOG_WARN("failed to serialize clog checkpoint ts", K(ret), K(len), K(new_pos), K_(clog_checkpoint_scn));
   } else if (OB_FAIL(ddl_checkpoint_scn_.fixed_serialize(buf, len, new_pos))) {
     LOG_WARN("failed to serialize ddl checkpoint ts", K(ret), K(len), K(new_pos), K_(ddl_checkpoint_scn));
-  } else if (OB_FAIL(snapshot_version_.fixed_serialize(buf, len, new_pos))) {
+  } else if (OB_FAIL(serialization::encode_i64(buf, len, new_pos, snapshot_version_))) {
     LOG_WARN("failed to serialize clog checkpoint ts", K(ret), K(len), K(new_pos), K_(snapshot_version));
-  } else if (OB_FAIL(multi_version_start_.fixed_serialize(buf, len, new_pos))) {
+  } else if (OB_FAIL(serialization::encode_i64(buf, len, new_pos, multi_version_start_))) {
     LOG_WARN("failed to serialize clog checkpoint ts", K(ret), K(len), K(new_pos), K_(multi_version_start));
   } else if (OB_FAIL(serialization::encode_i8(buf, len, new_pos, static_cast<int8_t>(compat_mode_)))) {
     LOG_WARN("failed to serialize compat mode", K(ret), K(len), K(new_pos));
@@ -823,7 +823,7 @@ int ObMigrationTabletParam::serialize(char *buf, const int64_t len, int64_t &pos
     LOG_WARN("failed to serialize table store flag", K(ret), K(len), K(new_pos));
   } else if (OB_FAIL(ddl_start_scn_.fixed_serialize(buf, len, new_pos))) {
     LOG_WARN("failed to serialize ddl start log ts", K(ret), K(len), K(new_pos), K_(ddl_start_scn));
-  } else if (OB_FAIL(ddl_snapshot_version_.fixed_serialize(buf, len, new_pos))) {
+  } else if (OB_FAIL(serialization::encode_i64(buf, len, new_pos, ddl_snapshot_version_))) {
     LOG_WARN("failed to serialize ddl snapshot version", K(ret), K(len), K(new_pos), K_(ddl_snapshot_version));
   } else if (OB_FAIL(serialization::encode_i64(buf, len, new_pos, max_sync_storage_schema_version_))) {
     LOG_WARN("failed to serialize max_sync_storage_schema_version", K(ret), K(len), K(new_pos), K_(max_sync_storage_schema_version));
@@ -862,9 +862,9 @@ int ObMigrationTabletParam::deserialize(const char *buf, const int64_t len, int6
     LOG_WARN("failed to deserialize clog checkpoint ts", K(ret), K(len), K(new_pos));
   } else if (OB_FAIL(ddl_checkpoint_scn_.fixed_deserialize(buf, len, new_pos))) {
     LOG_WARN("failed to deserialize ddl checkpoint ts", K(ret), K(len), K(new_pos));
-  } else if (OB_FAIL(snapshot_version_.fixed_deserialize(buf, len, new_pos))) {
+  } else if (OB_FAIL(serialization::decode_i64(buf, len, new_pos, &snapshot_version_))) {
     LOG_WARN("failed to deserialize clog checkpoint ts", K(ret), K(len));
-  } else if (OB_FAIL(multi_version_start_.fixed_deserialize(buf, len, new_pos))) {
+  } else if (OB_FAIL(serialization::decode_i64(buf, len, new_pos, &multi_version_start_))) {
     LOG_WARN("failed to deserialize clog checkpoint ts", K(ret), K(len));
   } else if (OB_FAIL(serialization::decode_i8(buf, len, new_pos, (int8_t*)(&compat_mode)))) {
     LOG_WARN("failed to deserialize compat mode", K(ret), K(len), K(new_pos));
@@ -886,7 +886,7 @@ int ObMigrationTabletParam::deserialize(const char *buf, const int64_t len, int6
     LOG_WARN("failed to deserialize table store flag", K(ret), K(len), K(new_pos));
   } else if (OB_FAIL(ddl_start_scn_.fixed_deserialize(buf, len, new_pos))) {
     LOG_WARN("failed to deserialize ddl start log ts", K(ret), K(len), K(new_pos));
-  } else if (OB_FAIL(ddl_snapshot_version_.fixed_deserialize(buf, len, new_pos))) {
+  } else if (OB_FAIL(serialization::decode_i64(buf, len, new_pos, &ddl_snapshot_version_))) {
     LOG_WARN("failed to deserialize ddl snapshot version", K(ret), K(len), K(new_pos));
   } else if (OB_FAIL(serialization::decode_i64(buf, len, new_pos, &max_sync_storage_schema_version_))) {
     LOG_WARN("failed to deserialize max sync storage schema version", K(ret), K(len), K(new_pos));
@@ -909,8 +909,8 @@ int64_t ObMigrationTabletParam::get_serialize_size() const
   size += start_scn_.get_fixed_serialize_size();
   size += clog_checkpoint_scn_.get_fixed_serialize_size();
   size += ddl_checkpoint_scn_.get_fixed_serialize_size();
-  size += snapshot_version_.get_fixed_serialize_size();
-  size += multi_version_start_.get_fixed_serialize_size();
+  size += serialization::encoded_length_i64(snapshot_version_);
+  size += serialization::encoded_length_i64(multi_version_start_);
   size += serialization::encoded_length_i8(static_cast<int8_t>(compat_mode_));
   size += autoinc_seq_.get_serialize_size();
   size += ha_status_.get_serialize_size();
@@ -921,7 +921,7 @@ int64_t ObMigrationTabletParam::get_serialize_size() const
   size += medium_info_list_.get_serialize_size();
   size += table_store_flag_.get_serialize_size();
   size += ddl_start_scn_.get_fixed_serialize_size();
-  size += ddl_snapshot_version_.get_fixed_serialize_size();
+  size += serialization::encoded_length_i64(ddl_snapshot_version_);
   size += serialization::encoded_length_i64(max_sync_storage_schema_version_);
   return size;
 }
@@ -935,8 +935,8 @@ void ObMigrationTabletParam::reset()
   start_scn_.reset();
   clog_checkpoint_scn_.reset();
   ddl_checkpoint_scn_.reset();
-  snapshot_version_.reset();
-  multi_version_start_.reset();
+  snapshot_version_ = OB_INVALID_TIMESTAMP;
+  multi_version_start_ = OB_INVALID_TIMESTAMP;
   compat_mode_ = lib::Worker::CompatMode::INVALID;
   autoinc_seq_.reset();
   ha_status_.reset();
@@ -947,7 +947,7 @@ void ObMigrationTabletParam::reset()
   medium_info_list_.reset();
   table_store_flag_.reset();
   ddl_start_scn_.reset();
-  ddl_snapshot_version_.reset();
+  ddl_snapshot_version_ = OB_INVALID_TIMESTAMP;
   max_sync_storage_schema_version_ = 0;
 }
 
diff --git a/src/storage/tablet/ob_tablet_meta.h b/src/storage/tablet/ob_tablet_meta.h
index 6075aaa5f..f423f83b5 100644
--- a/src/storage/tablet/ob_tablet_meta.h
+++ b/src/storage/tablet/ob_tablet_meta.h
@@ -71,7 +71,7 @@ public:
       const common::ObTabletID &lob_meta_tablet_id,
       const common::ObTabletID &lob_piece_tablet_id,
       const palf::SCN create_scn,
-      const palf::SCN snapshot_version,
+      const int64_t snapshot_version,
       const lib::Worker::CompatMode compat_mode,
       const ObTabletTableStoreFlag &table_store_flag,
       const int64_t max_sync_storage_schema_version);
@@ -91,8 +91,8 @@ public:
   int init(
       common::ObIAllocator &allocator,
       const ObTabletMeta &old_tablet_meta,
-      const palf::SCN &snapshot_version,
-      const palf::SCN multi_version_start,
+      const int64_t snapshot_version,
+      const int64_t multi_version_start,
       const ObTabletTxMultiSourceDataUnit &tx_data,
       const ObTabletBindingInfo &ddl_data,
       const share::ObTabletAutoincSeq &autoinc_seq,
@@ -100,7 +100,7 @@ public:
       const palf::SCN clog_checkpoint_scn = palf::SCN::min_scn(),
       const palf::SCN ddl_checkpoint_scn = palf::SCN::min_scn(),
       const palf::SCN ddl_start_scn = palf::SCN::min_scn(),
-      const palf::SCN ddl_snapshot_version = palf::SCN::min_scn());
+      const int64_t ddl_snapshot_version = 0);
   int init(
       common::ObIAllocator &allocator,
       const ObMigrationTabletParam &param);
@@ -166,8 +166,8 @@ public:
   palf::SCN clog_checkpoint_scn_;
   palf::SCN ddl_checkpoint_scn_;
   // snapshot_version of last minor
-  palf::SCN snapshot_version_;
-  palf::SCN multi_version_start_;
+  int64_t snapshot_version_;
+  int64_t multi_version_start_;
   lib::Worker::CompatMode compat_mode_;
   share::ObTabletAutoincSeq autoinc_seq_;
   ObTabletHAStatus ha_status_;
@@ -176,7 +176,7 @@ public:
   ObTabletBindingInfo ddl_data_;
   ObTabletTableStoreFlag table_store_flag_;
   palf::SCN ddl_start_scn_;
-  palf::SCN ddl_snapshot_version_;
+  int64_t ddl_snapshot_version_;
   int64_t max_sync_storage_schema_version_;
 
 private:
@@ -237,8 +237,8 @@ public:
   palf::SCN start_scn_;              // for migration
   palf::SCN clog_checkpoint_scn_;
   palf::SCN ddl_checkpoint_scn_;
-  palf::SCN snapshot_version_;
-  palf::SCN multi_version_start_;
+  int64_t snapshot_version_;
+  int64_t multi_version_start_;
   lib::Worker::CompatMode compat_mode_;
   share::ObTabletAutoincSeq autoinc_seq_;
   ObTabletHAStatus ha_status_;
@@ -249,7 +249,7 @@ public:
   compaction::ObMediumCompactionInfoList medium_info_list_;
   ObTabletTableStoreFlag table_store_flag_;
   palf::SCN ddl_start_scn_;
-  palf::SCN ddl_snapshot_version_;
+  int64_t ddl_snapshot_version_;
   // max_sync_version may less than storage_schema.schema_version_ when major update schema
   int64_t max_sync_storage_schema_version_;
 };
diff --git a/src/storage/tablet/ob_tablet_service_clog_replay_executor.cpp b/src/storage/tablet/ob_tablet_service_clog_replay_executor.cpp
index 26a7a5326..e9ed6ec11 100644
--- a/src/storage/tablet/ob_tablet_service_clog_replay_executor.cpp
+++ b/src/storage/tablet/ob_tablet_service_clog_replay_executor.cpp
@@ -103,7 +103,7 @@ int ObTabletServiceClogReplayExecutor::replay_update_storage_schema(
     } else {
       LOG_WARN("failed to get tablet", K(ret), K(tablet_id));
     }
-  } else if (OB_FAIL(handle.get_obj()->replay_update_storage_schema(scn.get_val_for_lsn_allocator(), buf, buf_size, tmp_pos))) {
+  } else if (OB_FAIL(handle.get_obj()->replay_update_storage_schema(scn, buf, buf_size, tmp_pos))) {
     LOG_WARN("update tablet storage schema fail", K(ret), K(tablet_id), K(scn));
   }
   return ret;
diff --git a/unittest/storage/test_compaction_policy.cpp b/unittest/storage/test_compaction_policy.cpp
index bd8da556f..b4cdbf4e1 100644
--- a/unittest/storage/test_compaction_policy.cpp
+++ b/unittest/storage/test_compaction_policy.cpp
@@ -362,7 +362,7 @@ int TestCompactionPolicy::mock_tablet(
               K(table_schema), K(compat_mode));
   } else {
     tablet->tablet_meta_.clog_checkpoint_scn_.convert_tmp(clog_checkpoint_ts);
-    tablet->tablet_meta_.snapshot_version_.convert_tmp(snapshot_version);
+    tablet->tablet_meta_.snapshot_version_ = snapshot_version;
   }
   return ret;
 }
@@ -726,7 +726,7 @@ TEST_F(TestCompactionPolicy, check_mini_merge_basic)
   ASSERT_EQ(3, result.handle_.get_count());
 
   tablet_handle_.get_obj()->tablet_meta_.clog_checkpoint_scn_.convert_tmp(300);
-  tablet_handle_.get_obj()->tablet_meta_.snapshot_version_.convert_tmp(300);
+  tablet_handle_.get_obj()->tablet_meta_.snapshot_version_ = 300;
   result.reset();
   ret = ObPartitionMergePolicy::get_mini_merge_tables(param, 0, *tablet_handle_.get_obj(), result);
   ASSERT_EQ(OB_NO_NEED_MERGE, ret);