diff --git a/src/share/ob_rpc_struct.cpp b/src/share/ob_rpc_struct.cpp
index b7a023315e..b405bd0871 100644
--- a/src/share/ob_rpc_struct.cpp
+++ b/src/share/ob_rpc_struct.cpp
@@ -6666,7 +6666,7 @@ int ObRpcRemoteWriteDDLRedoLogArg::init(const uint64_t tenant_id,
 OB_SERIALIZE_MEMBER(ObRpcRemoteWriteDDLRedoLogArg, tenant_id_, ls_id_, redo_info_);
 
 ObRpcRemoteWriteDDLPrepareLogArg::ObRpcRemoteWriteDDLPrepareLogArg()
-  : tenant_id_(OB_INVALID_ID), ls_id_(), table_key_(), start_scn_(),
+  : tenant_id_(OB_INVALID_ID), ls_id_(), table_key_(), start_scn_(SCN::min_scn()),
     table_id_(0), execution_id_(0), ddl_task_id_(0)
 {}
 
@@ -6679,7 +6679,7 @@ int ObRpcRemoteWriteDDLPrepareLogArg::init(const uint64_t tenant_id,
                                           const int64_t ddl_task_id)
 {
   int ret = OB_SUCCESS;
-  if (OB_UNLIKELY(tenant_id == OB_INVALID_ID || !ls_id.is_valid() || !table_key.is_valid() || !start_scn.is_valid()
+  if (OB_UNLIKELY(tenant_id == OB_INVALID_ID || !ls_id.is_valid() || !table_key.is_valid() || !start_scn.is_valid_and_not_min()
                   || table_id <= 0 || execution_id <= 0 || ddl_task_id <= 0)) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("tablet id is not valid", K(ret), K(tenant_id), K(ls_id), K(table_key), K(start_scn),
@@ -6700,7 +6700,7 @@ OB_SERIALIZE_MEMBER(ObRpcRemoteWriteDDLPrepareLogArg, tenant_id_, ls_id_, table_
                     table_id_, execution_id_, ddl_task_id_);
 
 ObRpcRemoteWriteDDLCommitLogArg::ObRpcRemoteWriteDDLCommitLogArg()
-  : tenant_id_(OB_INVALID_ID), ls_id_(), table_key_(), start_scn_(), prepare_scn_()
+  : tenant_id_(OB_INVALID_ID), ls_id_(), table_key_(), start_scn_(SCN::min_scn()), prepare_scn_(SCN::min_scn())
 {}
 
 int ObRpcRemoteWriteDDLCommitLogArg::init(const uint64_t tenant_id,
@@ -6710,8 +6710,8 @@ int ObRpcRemoteWriteDDLCommitLogArg::init(const uint64_t tenant_id,
                                           const SCN &prepare_scn)
 {
   int ret = OB_SUCCESS;
-  if (OB_UNLIKELY(tenant_id == OB_INVALID_ID || !ls_id.is_valid() || !table_key.is_valid() || !start_scn.is_valid()
-                  || !prepare_scn.is_valid())) {
+  if (OB_UNLIKELY(tenant_id == OB_INVALID_ID || !ls_id.is_valid() || !table_key.is_valid() || !start_scn.is_valid_and_not_min()
+                  || !prepare_scn.is_valid_and_not_min())) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("tablet id is not valid", K(ret), K(tenant_id), K(ls_id), K(table_key), K(start_scn), K(prepare_scn));
   } else {
diff --git a/src/share/ob_rpc_struct.h b/src/share/ob_rpc_struct.h
index 603b5e41df..9f0adc4af7 100644
--- a/src/share/ob_rpc_struct.h
+++ b/src/share/ob_rpc_struct.h
@@ -7470,7 +7470,7 @@ public:
            const int64_t ddl_task_id);
   bool is_valid() const
   {
-    return tenant_id_ != OB_INVALID_ID && ls_id_.is_valid() && table_key_.is_valid() && start_scn_.is_valid()
+    return tenant_id_ != OB_INVALID_ID && ls_id_.is_valid() && table_key_.is_valid() && start_scn_.is_valid_and_not_min()
            && table_id_ > 0 && execution_id_ > 0 && ddl_task_id_ > 0;
   }
   TO_STRING_KV(K_(tenant_id), K_(ls_id), K_(table_key), K_(start_scn), K_(table_id),
@@ -7500,8 +7500,8 @@ public:
            const share::SCN &prepare_scn);
   bool is_valid() const
   {
-    return tenant_id_ != OB_INVALID_ID && ls_id_.is_valid() && table_key_.is_valid() && start_scn_.is_valid()
-           && prepare_scn_.is_valid();
+    return tenant_id_ != OB_INVALID_ID && ls_id_.is_valid() && table_key_.is_valid() && start_scn_.is_valid_and_not_min()
+           && prepare_scn_.is_valid_and_not_min();
   }
   TO_STRING_KV(K_(tenant_id), K_(ls_id), K_(table_key), K_(start_scn), K_(prepare_scn));
 public:
diff --git a/src/storage/blocksstable/ob_block_sstable_struct.cpp b/src/storage/blocksstable/ob_block_sstable_struct.cpp
index 11042ae2ff..1d9fbc64bb 100644
--- a/src/storage/blocksstable/ob_block_sstable_struct.cpp
+++ b/src/storage/blocksstable/ob_block_sstable_struct.cpp
@@ -793,14 +793,14 @@ int ObRecordHeaderV3::deserialize(const char *buf, int64_t buf_len, int64_t &pos
 }
 
 ObDDLMacroBlockRedoInfo::ObDDLMacroBlockRedoInfo()
-  : table_key_(), data_buffer_(), block_type_(ObDDLMacroBlockType::DDL_MB_INVALID_TYPE), start_scn_()
+  : table_key_(), data_buffer_(), block_type_(ObDDLMacroBlockType::DDL_MB_INVALID_TYPE), start_scn_(SCN::min_scn())
 {
 }
 
 bool ObDDLMacroBlockRedoInfo::is_valid() const
 {
   return table_key_.is_valid() && data_buffer_.ptr() != nullptr && block_type_ != ObDDLMacroBlockType::DDL_MB_INVALID_TYPE
-         && logic_id_.is_valid() && start_scn_.is_valid();
+         && logic_id_.is_valid() && start_scn_.is_valid_and_not_min();
 }
 
 OB_SERIALIZE_MEMBER(ObDDLMacroBlockRedoInfo, table_key_, data_buffer_, block_type_, logic_id_, start_scn_);
diff --git a/src/storage/blocksstable/ob_sstable_meta.cpp b/src/storage/blocksstable/ob_sstable_meta.cpp
index e46060e9bb..b23bbff7b6 100644
--- a/src/storage/blocksstable/ob_sstable_meta.cpp
+++ b/src/storage/blocksstable/ob_sstable_meta.cpp
@@ -51,7 +51,7 @@ ObSSTableBasicMeta::ObSSTableBasicMeta()
     upper_trans_version_(0),
     max_merged_trans_version_(0),
     recycle_version_(0),
-    ddl_scn_(),
+    ddl_scn_(SCN::min_scn()),
     filled_tx_scn_(SCN::min_scn()),
     data_index_tree_height_(0),
     table_mode_(),
@@ -154,7 +154,7 @@ void ObSSTableBasicMeta::reset()
   upper_trans_version_ = 0;
   max_merged_trans_version_ = 0;
   recycle_version_ = 0;
-  ddl_scn_.reset();
+  ddl_scn_.set_min();
   filled_tx_scn_.set_min();
   data_index_tree_height_ = 0;
   table_mode_.reset();
diff --git a/src/storage/ddl/ob_ddl_clog.cpp b/src/storage/ddl/ob_ddl_clog.cpp
index 5186593eaf..85e7d6f8ec 100644
--- a/src/storage/ddl/ob_ddl_clog.cpp
+++ b/src/storage/ddl/ob_ddl_clog.cpp
@@ -236,7 +236,7 @@ int ObDDLRedoLog::init(const blocksstable::ObDDLMacroBlockRedoInfo &redo_info)
 OB_SERIALIZE_MEMBER(ObDDLRedoLog, redo_info_);
 
 ObDDLPrepareLog::ObDDLPrepareLog()
-  : table_key_(), start_scn_()
+  : table_key_(), start_scn_(SCN::min_scn())
 {
 }
 
@@ -244,7 +244,7 @@ int ObDDLPrepareLog::init(const ObITable::TableKey &table_key,
                          const SCN &start_scn)
 {
   int ret = OB_SUCCESS;
-  if (!table_key.is_valid() || !start_scn.is_valid()) {
+  if (!table_key.is_valid() || !start_scn.is_valid_and_not_min()) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid argument", K(ret), K(table_key), K(start_scn));
   } else {
@@ -257,7 +257,7 @@ int ObDDLPrepareLog::init(const ObITable::TableKey &table_key,
 OB_SERIALIZE_MEMBER(ObDDLPrepareLog, table_key_, start_scn_);
 
 ObDDLCommitLog::ObDDLCommitLog()
-  : table_key_(), start_scn_(), prepare_scn_()
+  : table_key_(), start_scn_(SCN::min_scn()), prepare_scn_(SCN::min_scn())
 {
 }
 
@@ -266,7 +266,7 @@ int ObDDLCommitLog::init(const ObITable::TableKey &table_key,
                          const SCN &prepare_scn)
 {
   int ret = OB_SUCCESS;
-  if (!table_key.is_valid() || !start_scn.is_valid() || !prepare_scn.is_valid()) {
+  if (!table_key.is_valid() || !start_scn.is_valid_and_not_min() || !prepare_scn.is_valid_and_not_min()) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid argument", K(ret), K(table_key), K(start_scn), K(prepare_scn));
   } else {
diff --git a/src/storage/ddl/ob_ddl_clog.h b/src/storage/ddl/ob_ddl_clog.h
index 03d5cf7ccf..09880187e7 100644
--- a/src/storage/ddl/ob_ddl_clog.h
+++ b/src/storage/ddl/ob_ddl_clog.h
@@ -154,7 +154,7 @@ public:
   ~ObDDLPrepareLog() = default;
   int init(const ObITable::TableKey &table_key,
            const share::SCN &start_scn);
-  bool is_valid() const { return table_key_.is_valid() && start_scn_.is_valid(); }
+  bool is_valid() const { return table_key_.is_valid() && start_scn_.is_valid_and_not_min(); }
   ObITable::TableKey get_table_key() const { return table_key_; }
   share::SCN get_start_scn() const { return start_scn_; }
   TO_STRING_KV(K_(table_key), K_(start_scn));
diff --git a/src/storage/ddl/ob_ddl_merge_task.cpp b/src/storage/ddl/ob_ddl_merge_task.cpp
index a983c6775f..fde8dd30ae 100644
--- a/src/storage/ddl/ob_ddl_merge_task.cpp
+++ b/src/storage/ddl/ob_ddl_merge_task.cpp
@@ -205,7 +205,7 @@ bool ObDDLTableMergeDag::ignore_warning()
 /******************             ObDDLTableDumpTask             *****************/
 ObDDLTableDumpTask::ObDDLTableDumpTask()
   : ObITask(ObITaskType::TASK_TYPE_DDL_KV_DUMP),
-    is_inited_(false), ls_id_(), tablet_id_(), freeze_scn_()
+    is_inited_(false), ls_id_(), tablet_id_(), freeze_scn_(SCN::min_scn())
 {
 
 }
@@ -222,7 +222,7 @@ int ObDDLTableDumpTask::init(const share::ObLSID &ls_id,
   if (OB_UNLIKELY(is_inited_)) {
     ret = OB_INIT_TWICE;
     LOG_WARN("init twice", K(ret), K(tablet_id_));
-  } else if (OB_UNLIKELY(!ls_id.is_valid() || !tablet_id.is_valid() || !freeze_scn.is_valid())) {
+  } else if (OB_UNLIKELY(!ls_id.is_valid() || !tablet_id.is_valid() || !freeze_scn.is_valid_and_not_min())) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid argument", K(ret), K(ls_id), K(tablet_id), K(freeze_scn));
   } else {
@@ -386,7 +386,7 @@ int ObDDLTableMergeTask::process()
       sstable = static_cast<ObSSTable *>(table_handle.get_table());
     }
 
-    if (OB_SUCC(ret) && merge_param_.rec_scn_.is_valid()) {
+    if (OB_SUCC(ret) && merge_param_.rec_scn_.is_valid_and_not_min()) {
       // when the ddl dag is self scheduled when ddl kv is full, the rec_scn is invalid
       // but no worry, the formmer ddl dump task will also release ddl kvs
       if (OB_FAIL(ddl_kv_mgr_handle.get_obj()->release_ddl_kvs(merge_param_.rec_scn_))) {
@@ -429,7 +429,7 @@ int ObDDLTableMergeTask::check_data_integrity(const ObTablesHandleArray &ddl_sst
 {
   int ret = OB_SUCCESS;
   is_data_complete = false;
-  if (OB_UNLIKELY(ddl_sstables.empty() || !start_scn.is_valid() || !prepare_scn.is_valid())) {
+  if (OB_UNLIKELY(ddl_sstables.empty() || !start_scn.is_valid_and_not_min() || !prepare_scn.is_valid_and_not_min())) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid argument", K(ret), K(ddl_sstables.get_count()), K(start_scn), K(prepare_scn));
   } else {
@@ -458,7 +458,7 @@ int ObDDLTableMergeTask::check_data_integrity(const ObTablesHandleArray &ddl_sst
 }
 
 ObTabletDDLParam::ObTabletDDLParam()
-  : tenant_id_(0), ls_id_(), table_key_(), start_scn_(), snapshot_version_(0), cluster_version_(0)
+  : tenant_id_(0), ls_id_(), table_key_(), start_scn_(SCN::min_scn()), snapshot_version_(0), cluster_version_(0)
 {
 
 }
@@ -473,7 +473,7 @@ bool ObTabletDDLParam::is_valid() const
   return tenant_id_ > 0  && tenant_id_ != OB_INVALID_ID
     && ls_id_.is_valid()
     && table_key_.is_valid()
-    && start_scn_.is_valid()
+    && start_scn_.is_valid_and_not_min()
     && snapshot_version_ > 0
     && cluster_version_ >= 0;
 }
diff --git a/src/storage/ddl/ob_ddl_merge_task.h b/src/storage/ddl/ob_ddl_merge_task.h
index ec854c3fd4..d7e55fb26c 100644
--- a/src/storage/ddl/ob_ddl_merge_task.h
+++ b/src/storage/ddl/ob_ddl_merge_task.h
@@ -42,14 +42,13 @@ public:
   ObDDLTableMergeDagParam()
     : ls_id_(),
       tablet_id_(),
-      rec_scn_(),
+      rec_scn_(share::SCN::min_scn()),
       is_commit_(false),
+      start_scn_(share::SCN::min_scn()),
       table_id_(0),
       execution_id_(0),
       ddl_task_id_(0)
-  {
-    start_scn_.set_min();
-  }
+  { }
   bool is_valid() const
   {
     return ls_id_.is_valid() && tablet_id_.is_valid() && start_scn_.is_valid_and_not_min();
diff --git a/src/storage/ddl/ob_ddl_redo_log_writer.cpp b/src/storage/ddl/ob_ddl_redo_log_writer.cpp
index cbbdf88c37..7796b16844 100644
--- a/src/storage/ddl/ob_ddl_redo_log_writer.cpp
+++ b/src/storage/ddl/ob_ddl_redo_log_writer.cpp
@@ -621,7 +621,7 @@ int ObDDLRedoLogWriter::write_ddl_start_log(ObDDLKvMgrHandle &ddl_kv_mgr_handle,
                                             SCN &start_scn)
 {
   int ret = OB_SUCCESS;
-  start_scn.reset();
+  start_scn.set_min();
   const enum ObReplayBarrierType replay_barrier_type = ObReplayBarrierType::STRICT_BARRIER;
   logservice::ObLogBaseHeader base_header(logservice::ObLogBaseType::DDL_LOG_BASE_TYPE,
                                           replay_barrier_type);
@@ -635,7 +635,7 @@ int ObDDLRedoLogWriter::write_ddl_start_log(ObDDLKvMgrHandle &ddl_kv_mgr_handle,
 
   palf::LSN lsn;
   const bool need_nonblock= false;
-  SCN scn;
+  SCN scn = SCN::min_scn();
   bool is_external_consistent = false;
   ObBucketHashWLockGuard guard(bucket_lock_, log.get_table_key().get_tablet_id().hash());
   if (ddl_kv_mgr_handle.get_obj()->is_execution_id_older(log.get_execution_id())) {
@@ -652,7 +652,7 @@ int ObDDLRedoLogWriter::write_ddl_start_log(ObDDLKvMgrHandle &ddl_kv_mgr_handle,
     LOG_WARN("fail to seriaize ddl start log", K(ret));
   } else if (OB_FAIL(log_handler->append(buffer,
                                          buffer_size,
-                                         SCN::base_scn(),
+                                         SCN::min_scn(),
                                          need_nonblock,
                                          cb,
                                          lsn,
@@ -722,8 +722,8 @@ int ObDDLRedoLogWriter::write_ddl_finish_log(const T &log, const ObDDLClogType c
 
   palf::LSN lsn;
   const bool need_nonblock= false;
-  SCN base_scn = SCN::base_scn();
-  SCN scn;
+  SCN base_scn = SCN::min_scn();
+  SCN scn = SCN::min_scn();
   bool is_external_consistent = false;
   if (OB_ISNULL(buffer = static_cast<char *>(ob_malloc(buffer_size)))) {
     ret = OB_ALLOCATE_MEMORY_FAILED;
@@ -784,7 +784,7 @@ int ObDDLRedoLogWriter::write_ddl_finish_log(const T &log, const ObDDLClogType c
 }
 
 ObDDLRedoLogHandle::ObDDLRedoLogHandle()
-  : cb_(nullptr), scn_()
+  : cb_(nullptr), scn_(SCN::min_scn())
 {
 }
 
@@ -829,7 +829,7 @@ int ObDDLRedoLogHandle::wait(const int64_t timeout)
 }
 
 ObDDLCommitLogHandle::ObDDLCommitLogHandle()
-  : cb_(nullptr), commit_scn_()
+  : cb_(nullptr), commit_scn_(SCN::min_scn())
 {
 }
 
@@ -921,7 +921,7 @@ int ObDDLMacroBlockRedoWriter::remote_write_macro_redo(const ObAddr &leader_addr
 }
 
 ObDDLSSTableRedoWriter::ObDDLSSTableRedoWriter()
-  : is_inited_(false), remote_write_(false), start_scn_(),
+  : is_inited_(false), remote_write_(false), start_scn_(SCN::min_scn()),
     ls_id_(), tablet_id_(), ddl_redo_handle_(), leader_addr_(), leader_ls_id_(), buffer_(nullptr)
 {
 }
@@ -1059,7 +1059,7 @@ int ObDDLSSTableRedoWriter::write_prepare_log(const ObITable::TableKey &table_ke
                         "ddl_task_id", ddl_task_id);
   DEBUG_SYNC(BEFORE_DDL_WRITE_PREPARE_LOG);
 #endif
-  prepare_scn.reset();
+  prepare_scn.set_min();
   ObLSHandle ls_handle;
   ObLS *ls = nullptr;
   ObDDLPrepareLog log;
@@ -1067,7 +1067,7 @@ int ObDDLSSTableRedoWriter::write_prepare_log(const ObITable::TableKey &table_ke
   if (OB_UNLIKELY(!is_inited_)) {
     ret = OB_NOT_INIT;
     LOG_WARN("ObDDLSSTableRedoWriter has not been inited", K(ret));
-  } else if (OB_UNLIKELY(!table_key.is_valid() || !start_scn_.is_valid())) {
+  } else if (OB_UNLIKELY(!table_key.is_valid() || !start_scn_.is_valid_and_not_min())) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid arguments", K(ret), K(table_key), K(start_scn_));
   } else if (OB_FAIL(log.init(table_key, get_start_scn()))) {
@@ -1121,7 +1121,7 @@ int ObDDLSSTableRedoWriter::write_commit_log(const ObITable::TableKey &table_key
   if (OB_UNLIKELY(!is_inited_)) {
     ret = OB_NOT_INIT;
     LOG_WARN("ObDDLSSTableRedoWriter has not been inited", K(ret));
-  } else if (OB_UNLIKELY(!table_key.is_valid() || SCN::min_scn() == start_scn_ || !prepare_scn.is_valid())) {
+  } else if (OB_UNLIKELY(!table_key.is_valid() || !start_scn_.is_valid_and_not_min() || !prepare_scn.is_valid_and_not_min())) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid arguments", K(ret), K(table_key), K(start_scn_), K(prepare_scn));
   } else if (OB_FAIL(log.init(table_key, get_start_scn(), prepare_scn))) {
diff --git a/src/storage/ddl/ob_ddl_redo_log_writer.h b/src/storage/ddl/ob_ddl_redo_log_writer.h
index e445f8a23d..289c4efc69 100644
--- a/src/storage/ddl/ob_ddl_redo_log_writer.h
+++ b/src/storage/ddl/ob_ddl_redo_log_writer.h
@@ -163,7 +163,7 @@ public:
   ~ObDDLRedoLogHandle();
   int wait(const int64_t timeout = DDL_REDO_LOG_TIMEOUT);
   void reset();
-  bool is_valid() const { return nullptr != cb_  && scn_.is_valid(); }
+  bool is_valid() const { return nullptr != cb_  && scn_.is_valid_and_not_min(); }
 public:
   ObDDLMacroBlockClogCb *cb_;
   share::SCN scn_;
diff --git a/src/storage/ddl/ob_ddl_struct.cpp b/src/storage/ddl/ob_ddl_struct.cpp
index 5653af6be0..2e32d05df3 100644
--- a/src/storage/ddl/ob_ddl_struct.cpp
+++ b/src/storage/ddl/ob_ddl_struct.cpp
@@ -87,7 +87,7 @@ int ObDDLMacroHandle::reset_macro_block_ref()
 }
 
 ObDDLMacroBlock::ObDDLMacroBlock()
-  : block_handle_(), logic_id_(), block_type_(DDL_MB_INVALID_TYPE), ddl_start_scn_(), scn_(), buf_(nullptr), size_(0)
+  : block_handle_(), logic_id_(), block_type_(DDL_MB_INVALID_TYPE), ddl_start_scn_(SCN::min_scn()), scn_(SCN::min_scn()), buf_(nullptr), size_(0)
 {
 }
 
@@ -123,21 +123,19 @@ bool ObDDLMacroBlock::is_valid() const
   return block_handle_.get_block_id().is_valid()
     && logic_id_.is_valid()
     && DDL_MB_INVALID_TYPE != block_type_
-    && ddl_start_scn_.is_valid()
-    && scn_.is_valid()
+    && ddl_start_scn_.is_valid_and_not_min()
+    && scn_.is_valid_and_not_min()
     && nullptr != buf_
     && size_ > 0;
 }
 
 
 ObDDLKV::ObDDLKV()
-  : is_inited_(false), ls_id_(), tablet_id_(), ddl_start_scn_(), snapshot_version_(0),
-    lock_(), allocator_("DDL_KV"), is_freezed_(false), is_closed_(false), last_freezed_scn_(),
-    max_scn_(), pending_cnt_(0), cluster_version_(0), ref_cnt_(0),
-    sstable_index_builder_(nullptr), index_block_rebuilder_(nullptr), is_rebuilder_closed_(false)
+  : is_inited_(false), ls_id_(), tablet_id_(), ddl_start_scn_(SCN::min_scn()), snapshot_version_(0),
+    lock_(), allocator_("DDL_KV"), is_freezed_(false), is_closed_(false), last_freezed_scn_(SCN::min_scn()),
+    min_scn_(SCN::max_scn()), max_scn_(SCN::min_scn()), freeze_scn_(SCN::max_scn()), pending_cnt_(0), cluster_version_(0),
+    ref_cnt_(0), sstable_index_builder_(nullptr), index_block_rebuilder_(nullptr), is_rebuilder_closed_(false)
 {
-  min_scn_ = SCN::max_scn();
-  freeze_scn_ = SCN::max_scn();
 }
 
 ObDDLKV::~ObDDLKV()
@@ -159,9 +157,9 @@ int ObDDLKV::init(const share::ObLSID &ls_id,
     LOG_WARN("ObDDLKV has been inited twice", K(ret));
   } else if (OB_UNLIKELY(!ls_id.is_valid()
         || !tablet_id.is_valid()
-        || !ddl_start_scn.is_valid()
+        || !ddl_start_scn.is_valid_and_not_min()
         || snapshot_version <= 0
-        || !last_freezed_scn.is_valid()
+        || !last_freezed_scn.is_valid_and_not_min()
         || cluster_version < 0)) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid argument", K(ret), K(ls_id), K(tablet_id), K(ddl_start_scn), K(snapshot_version), K(last_freezed_scn), K(cluster_version));
@@ -258,11 +256,11 @@ int ObDDLKV::set_macro_block(const ObDDLMacroBlock &macro_block)
     if (macro_block.ddl_start_scn_ != ddl_start_scn_) {
       if (macro_block.ddl_start_scn_ > ddl_start_scn_) {
         ret = OB_EAGAIN;
-        LOG_INFO("ddl start log ts too large, retry", K(ret),
+        LOG_INFO("ddl start scn too large, retry", K(ret),
             K(ls_id_), K(tablet_id_), K(ddl_start_scn_), K(macro_block));
       } else {
         // filter out and do nothing
-        LOG_INFO("ddl start log ts too small, maybe from old build task, ignore", K(ret),
+        LOG_INFO("ddl start scn too small, maybe from old build task, ignore", K(ret),
             K(ls_id_), K(tablet_id_), K(ddl_start_scn_), K(macro_block));
       }
     } else if (macro_block.scn_ > freeze_scn_) {
@@ -293,9 +291,9 @@ int ObDDLKV::freeze(const SCN &freeze_scn)
     if (is_freezed_) {
       // do nothing
     } else {
-      if (freeze_scn.is_valid()) {
+      if (freeze_scn.is_valid_and_not_min()) {
         freeze_scn_ = freeze_scn;
-      } else if (max_scn_.is_valid()) {
+      } else if (max_scn_.is_valid_and_not_min()) {
         freeze_scn_ = max_scn_;
       } else {
         ret = OB_EAGAIN;
@@ -511,12 +509,12 @@ int ObDDLKVsHandle::get_ddl_kv(const int64_t idx, ObDDLKV *&kv)
 }
 
 ObDDLKVPendingGuard::ObDDLKVPendingGuard(ObTablet *tablet, const SCN &scn)
-  : tablet_(tablet), kv_handle_(), ret_(OB_SUCCESS)
+  : tablet_(tablet), scn_(scn), kv_handle_(), ret_(OB_SUCCESS)
 {
   int ret = OB_SUCCESS;
   ObDDLKV *curr_kv = nullptr;
   ObDDLKvMgrHandle ddl_kv_mgr_handle;
-  if (OB_UNLIKELY(nullptr == tablet || !scn.is_valid())) {
+  if (OB_UNLIKELY(nullptr == tablet || !scn.is_valid_and_not_min())) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid arguments", K(ret), KP(tablet), K(scn));
   } else if (OB_FAIL(tablet->get_ddl_kv_mgr(ddl_kv_mgr_handle))) {
@@ -529,7 +527,6 @@ ObDDLKVPendingGuard::ObDDLKVPendingGuard(ObTablet *tablet, const SCN &scn)
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("error unexpected, active ddl kv must not be nullptr", K(ret));
   } else {
-    scn_ = scn;
     curr_kv->inc_pending_cnt();
   }
   if (OB_FAIL(ret)) {
diff --git a/src/storage/ddl/ob_ddl_struct.h b/src/storage/ddl/ob_ddl_struct.h
index d0191b1f40..39a416f011 100644
--- a/src/storage/ddl/ob_ddl_struct.h
+++ b/src/storage/ddl/ob_ddl_struct.h
@@ -76,7 +76,7 @@ public:
   ~ObDDLKV();
   int init(const share::ObLSID &ls_id,
            const common::ObTabletID &tablet_id,
-           const share::SCN &ddl_start_log_ts,
+           const share::SCN &ddl_start_scn,
            const int64_t snapshot_version,
            const share::SCN &last_freezed_scn,
            const int64_t cluster_version);
diff --git a/src/storage/ddl/ob_direct_insert_sstable_ctx.cpp b/src/storage/ddl/ob_direct_insert_sstable_ctx.cpp
index afe8c4de70..926b81049b 100644
--- a/src/storage/ddl/ob_direct_insert_sstable_ctx.cpp
+++ b/src/storage/ddl/ob_direct_insert_sstable_ctx.cpp
@@ -259,7 +259,7 @@ int ObSSTableInsertTabletContext::update(const int64_t snapshot_version)
     } else if (OB_UNLIKELY(!table_key.is_valid())) {
       ret = OB_INVALID_ARGUMENT;
       LOG_WARN("invalid argument", K(ret), K(table_key));
-    } else if (data_sstable_redo_writer_.get_start_scn().is_valid()) {
+    } else if (data_sstable_redo_writer_.get_start_scn().is_valid_and_not_min()) {
       // ddl start log is already written, do nothing
     } else if (OB_FAIL(data_sstable_redo_writer_.start_ddl_redo(table_key, build_param_.execution_id_, ddl_kv_mgr_handle_))) {
       LOG_WARN("fail write start log", K(ret), K(table_key), K(build_param_));
@@ -704,7 +704,7 @@ int ObSSTableInsertTabletContext::create_sstable_with_clog(
                                                                 build_param_.ddl_task_id_))) {
       if (OB_TASK_EXPIRED == ret) {
         LOG_INFO("ddl task expired", K(ret), K(ls_id), K(tablet_id),
-            K(ddl_start_scn), "new_ddl_start_log_ts", ddl_kv_mgr_handle.get_obj()->get_start_scn());
+            K(ddl_start_scn), "new_ddl_start_scn", ddl_kv_mgr_handle.get_obj()->get_start_scn());
       } else {
         LOG_WARN("failed to do ddl kv prepare", K(ret), K(ddl_start_scn), K(prepare_scn), K(build_param_));
       }
diff --git a/src/storage/ddl/ob_tablet_barrier_log.cpp b/src/storage/ddl/ob_tablet_barrier_log.cpp
index 6e35896f25..d9f4fac5d4 100644
--- a/src/storage/ddl/ob_tablet_barrier_log.cpp
+++ b/src/storage/ddl/ob_tablet_barrier_log.cpp
@@ -20,7 +20,7 @@ using namespace share;
 namespace storage
 {
 ObTabletBarrierLogState::ObTabletBarrierLogState()
-  : state_(TABLET_BARRIER_LOG_INIT), scn_(), schema_version_(0)
+  : state_(TABLET_BARRIER_LOG_INIT), scn_(SCN::min_scn()), schema_version_(0)
 {
 }
 
@@ -46,7 +46,7 @@ ObTabletBarrierLogStateEnum ObTabletBarrierLogState::to_persistent_state() const
 void ObTabletBarrierLogState::reset()
 {
   state_ = TABLET_BARRIER_LOG_INIT;
-  scn_.reset();
+  scn_.set_min();
   schema_version_ = 0;
 }
 
diff --git a/src/storage/ddl/ob_tablet_ddl_kv_mgr.cpp b/src/storage/ddl/ob_tablet_ddl_kv_mgr.cpp
index 88f33b6288..2a4710d221 100644
--- a/src/storage/ddl/ob_tablet_ddl_kv_mgr.cpp
+++ b/src/storage/ddl/ob_tablet_ddl_kv_mgr.cpp
@@ -59,7 +59,7 @@ void ObTabletDDLKvMgr::destroy()
   table_key_.reset();
   cluster_version_ = 0;
   start_scn_.set_min();
-  max_freeze_scn_.reset();
+  max_freeze_scn_.set_min();
   table_id_ = 0;
   execution_id_ = 0;
   is_commit_success_ = false;
@@ -107,7 +107,7 @@ int ObTabletDDLKvMgr::ddl_start(const ObITable::TableKey &table_key,
   } else if (table_key.get_tablet_id() != tablet_id_) {
     ret = OB_ERR_SYS;
     LOG_WARN("tablet id not same", K(ret), K(table_key), K(tablet_id_));
-  } else if (start_scn_.is_valid()) {
+  } else if (start_scn_.is_valid_and_not_min()) {
     if (execution_id >= execution_id_ && start_scn >= start_scn_) {
       LOG_INFO("execution id changed, need cleanup", K(ls_id_), K(tablet_id_), K(execution_id_), K(execution_id), K(start_scn_), K(start_scn));
       cleanup_unlock();
@@ -129,7 +129,7 @@ int ObTabletDDLKvMgr::ddl_start(const ObITable::TableKey &table_key,
     start_scn_ = start_scn;
     max_freeze_scn_ = SCN::max(start_scn, checkpoint_scn);
   }
-  if (OB_SUCC(ret) && !checkpoint_scn.is_valid()) {
+  if (OB_SUCC(ret) && !checkpoint_scn.is_valid_and_not_min()) {
     // remove ddl sstable if exists and flush ddl start log ts and snapshot version into tablet meta
     if (OB_FAIL(update_tablet(start_scn_, table_key_.get_snapshot_version(), start_scn_))) {
       LOG_WARN("clean up ddl sstable failed", K(ret), K(ls_id_), K(tablet_id_));
@@ -246,7 +246,7 @@ int ObTabletDDLKvMgr::wait_ddl_commit(const SCN &start_scn, const SCN &prepare_s
   if (OB_UNLIKELY(!is_inited_)) {
     ret = OB_NOT_INIT;
     LOG_WARN("not init", K(ret), K(is_inited_));
-  } else if (OB_UNLIKELY(!start_scn.is_valid() || !prepare_scn.is_valid())) {
+  } else if (OB_UNLIKELY(!start_scn.is_valid_and_not_min() || !prepare_scn.is_valid_and_not_min())) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid argument", K(ret), K(start_scn), K(prepare_scn));
   } else if (!is_started()) {
diff --git a/src/storage/ddl/ob_tablet_ddl_kv_mgr.h b/src/storage/ddl/ob_tablet_ddl_kv_mgr.h
index 80c03bd0ae..c2ace43d84 100644
--- a/src/storage/ddl/ob_tablet_ddl_kv_mgr.h
+++ b/src/storage/ddl/ob_tablet_ddl_kv_mgr.h
@@ -38,7 +38,7 @@ public:
   ObTabletDDLKvMgr();
   ~ObTabletDDLKvMgr();
   int init(const share::ObLSID &ls_id, const common::ObTabletID &tablet_id); // init before memtable mgr
-  int ddl_start(const ObITable::TableKey &table_key, const share::SCN &start_log_ts, const int64_t cluster_version, const int64_t execution_id, const share::SCN &checkpoint_scn);
+  int ddl_start(const ObITable::TableKey &table_key, const share::SCN &start_scn, const int64_t cluster_version, const int64_t execution_id, const share::SCN &checkpoint_scn);
   int ddl_prepare(const share::SCN &start_scn, const share::SCN &commit_scn, const uint64_t table_id = 0, const int64_t ddl_task_id = 0); // schedule build a major sstable
   int ddl_commit(const share::SCN &start_scn, const share::SCN &prepare_scn, const bool is_replay); // try wait build major sstable
   int wait_ddl_commit(const share::SCN &start_scn, const share::SCN &prepare_scn);
@@ -46,12 +46,12 @@ public:
   int get_or_create_ddl_kv(const share::SCN &scn, ObDDLKVHandle &kv_handle); // used in active ddl kv guard
   int get_freezed_ddl_kv(const share::SCN &freeze_scn, ObDDLKVHandle &kv_handle); // locate ddl kv with exeact freeze log ts
   int get_ddl_kvs(const bool frozen_only, ObDDLKVsHandle &ddl_kvs_handle); // get all freeze ddl kvs
-  int freeze_ddl_kv(const share::SCN &freeze_scn = share::SCN::invalid_scn()); // freeze the active ddl kv, when memtable freeze or ddl commit
+  int freeze_ddl_kv(const share::SCN &freeze_scn = share::SCN::min_scn()); // freeze the active ddl kv, when memtable freeze or ddl commit
   int release_ddl_kvs(const share::SCN &rec_scn); // release persistent ddl kv, used in ddl merge task for free ddl kv
   int check_has_effective_ddl_kv(bool &has_ddl_kv); // used in ddl log handler for checkpoint
   int get_ddl_kv_min_scn(share::SCN &min_scn); // for calculate rec_scn of ls
   share::SCN get_start_scn() const { return start_scn_; }
-  bool is_started() const { return start_scn_.is_valid(); }
+  bool is_started() const { return start_scn_.is_valid_and_not_min(); }
   int set_commit_success();
   bool is_commit_success() const { return is_commit_success_; }
   common::ObTabletID get_tablet_id() const { return tablet_id_; }
diff --git a/src/storage/ob_storage_struct.cpp b/src/storage/ob_storage_struct.cpp
index b5bd5cb1bd..239deeedc3 100644
--- a/src/storage/ob_storage_struct.cpp
+++ b/src/storage/ob_storage_struct.cpp
@@ -219,8 +219,8 @@ ObUpdateTableStoreParam::ObUpdateTableStoreParam(
     rebuild_seq_(rebuild_seq),
     update_with_major_flag_(false),
     need_check_sstable_(false),
-    ddl_checkpoint_scn_(),
-    ddl_start_scn_(),
+    ddl_checkpoint_scn_(SCN::min_scn()),
+    ddl_start_scn_(SCN::min_scn()),
     ddl_snapshot_version_(0),
     ddl_execution_id_(0),
     ddl_cluster_version_(0),
@@ -250,8 +250,8 @@ ObUpdateTableStoreParam::ObUpdateTableStoreParam(
     rebuild_seq_(rebuild_seq),
     update_with_major_flag_(false),
     need_check_sstable_(need_check_sstable),
-    ddl_checkpoint_scn_(),
-    ddl_start_scn_(),
+    ddl_checkpoint_scn_(SCN::min_scn()),
+    ddl_start_scn_(SCN::min_scn()),
     ddl_snapshot_version_(0),
     ddl_execution_id_(0),
     ddl_cluster_version_(0),
@@ -280,8 +280,8 @@ ObUpdateTableStoreParam::ObUpdateTableStoreParam(
     rebuild_seq_(rebuild_seq),
     update_with_major_flag_(update_with_major_flag),
     need_check_sstable_(false),
-    ddl_checkpoint_scn_(),
-    ddl_start_scn_(),
+    ddl_checkpoint_scn_(SCN::min_scn()),
+    ddl_start_scn_(SCN::min_scn()),
     ddl_snapshot_version_(0),
     ddl_execution_id_(0),
     ddl_cluster_version_(0),
diff --git a/src/storage/tablet/ob_tablet_create_sstable_param.cpp b/src/storage/tablet/ob_tablet_create_sstable_param.cpp
index 519d8791b3..f0ba7959c7 100644
--- a/src/storage/tablet/ob_tablet_create_sstable_param.cpp
+++ b/src/storage/tablet/ob_tablet_create_sstable_param.cpp
@@ -51,7 +51,7 @@ ObTabletCreateSSTableParam::ObTabletCreateSSTableParam()
     occupy_size_(0),
     original_size_(0),
     max_merged_trans_version_(0),
-    ddl_scn_(),
+    ddl_scn_(SCN::min_scn()),
     filled_tx_scn_(SCN::min_scn()),
     contain_uncommitted_row_(false),
     compressor_type_(ObCompressorType::INVALID_COMPRESSOR),
diff --git a/src/storage/tablet/ob_tablet_ddl_info.cpp b/src/storage/tablet/ob_tablet_ddl_info.cpp
index 40aa5566ef..31f6a83988 100644
--- a/src/storage/tablet/ob_tablet_ddl_info.cpp
+++ b/src/storage/tablet/ob_tablet_ddl_info.cpp
@@ -26,7 +26,7 @@ namespace storage
 ObTabletDDLInfo::ObTabletDDLInfo()
   : ddl_schema_version_(0),
     ddl_schema_refreshed_ts_(OB_INVALID_TIMESTAMP),
-    schema_version_change_scn_(),
+    schema_version_change_scn_(SCN::min_scn()),
     rwlock_()
 {
 }
@@ -43,7 +43,7 @@ void ObTabletDDLInfo::reset()
 {
   ddl_schema_version_ = 0;
   ddl_schema_refreshed_ts_ = OB_INVALID_TIMESTAMP;
-  schema_version_change_scn_.reset();
+  schema_version_change_scn_.set_min();
 }
 
 int ObTabletDDLInfo::get(int64_t &schema_version, int64_t &schema_refreshed_ts)
@@ -60,7 +60,7 @@ int ObTabletDDLInfo::update(const int64_t schema_version,
 {
   int ret = OB_SUCCESS;
   TCWLockGuard guard(rwlock_);
-  if (schema_version <= 0 || !scn.is_valid()) {
+  if (schema_version <= 0 || !scn.is_valid_and_not_min()) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid arguments", K(ret), K(schema_version), K(scn));
   } else if (ddl_schema_version_ < schema_version) {
diff --git a/src/storage/tablet/ob_tablet_meta.cpp b/src/storage/tablet/ob_tablet_meta.cpp
index e6e3610cef..eace057214 100644
--- a/src/storage/tablet/ob_tablet_meta.cpp
+++ b/src/storage/tablet/ob_tablet_meta.cpp
@@ -43,7 +43,7 @@ ObTabletMeta::ObTabletMeta()
     create_scn_(ObTabletMeta::INVALID_CREATE_SCN),
     start_scn_(),
     clog_checkpoint_scn_(),
-    ddl_checkpoint_scn_(),
+    ddl_checkpoint_scn_(SCN::min_scn()),
     snapshot_version_(OB_INVALID_TIMESTAMP),
     multi_version_start_(OB_INVALID_TIMESTAMP),
     compat_mode_(lib::Worker::CompatMode::INVALID),
@@ -53,7 +53,7 @@ ObTabletMeta::ObTabletMeta()
     tx_data_(),
     ddl_data_(),
     table_store_flag_(),
-    ddl_start_scn_(),
+    ddl_start_scn_(SCN::min_scn()),
     ddl_snapshot_version_(OB_INVALID_TIMESTAMP),
     max_sync_storage_schema_version_(0),
     ddl_execution_id_(0),
@@ -342,7 +342,7 @@ void ObTabletMeta::reset()
   create_scn_ = ObTabletMeta::INVALID_CREATE_SCN;
   start_scn_.reset();
   clog_checkpoint_scn_.reset();
-  ddl_checkpoint_scn_ .reset();
+  ddl_checkpoint_scn_.set_min();
   snapshot_version_ = OB_INVALID_TIMESTAMP;
   multi_version_start_ = OB_INVALID_TIMESTAMP;
   compat_mode_ = lib::Worker::CompatMode::INVALID;
@@ -352,7 +352,7 @@ void ObTabletMeta::reset()
   tx_data_.reset();
   ddl_data_.reset();
   table_store_flag_.reset();
-  ddl_start_scn_.reset();
+  ddl_start_scn_.set_min();
   ddl_snapshot_version_ = OB_INVALID_TIMESTAMP;
   max_sync_storage_schema_version_ = 0;
   ddl_execution_id_ = 0;
@@ -729,7 +729,7 @@ ObMigrationTabletParam::ObMigrationTabletParam()
     create_scn_(ObTabletMeta::INVALID_CREATE_SCN),
     start_scn_(),
     clog_checkpoint_scn_(),
-    ddl_checkpoint_scn_(),
+    ddl_checkpoint_scn_(SCN::min_scn()),
     snapshot_version_(OB_INVALID_TIMESTAMP),
     multi_version_start_(OB_INVALID_TIMESTAMP),
     compat_mode_(lib::Worker::CompatMode::INVALID),
@@ -741,7 +741,7 @@ ObMigrationTabletParam::ObMigrationTabletParam()
     storage_schema_(),
     medium_info_list_(compaction::ObMediumCompactionInfoList::MEDIUM_LIST_IN_STORAGE),
     table_store_flag_(),
-    ddl_start_scn_(),
+    ddl_start_scn_(SCN::min_scn()),
     ddl_snapshot_version_(OB_INVALID_TIMESTAMP),
     max_sync_storage_schema_version_(0),
     ddl_execution_id_(0),
@@ -942,7 +942,7 @@ void ObMigrationTabletParam::reset()
   create_scn_ = ObTabletMeta::INVALID_CREATE_SCN;
   start_scn_.reset();
   clog_checkpoint_scn_.reset();
-  ddl_checkpoint_scn_.reset();
+  ddl_checkpoint_scn_.set_min();
   snapshot_version_ = OB_INVALID_TIMESTAMP;
   multi_version_start_ = OB_INVALID_TIMESTAMP;
   compat_mode_ = lib::Worker::CompatMode::INVALID;
@@ -954,7 +954,7 @@ void ObMigrationTabletParam::reset()
   storage_schema_.reset();
   medium_info_list_.reset();
   table_store_flag_.reset();
-  ddl_start_scn_.reset();
+  ddl_start_scn_.set_min();
   ddl_snapshot_version_ = OB_INVALID_TIMESTAMP;
   max_sync_storage_schema_version_ = 0;
   ddl_execution_id_ = 0;