Refactor task type name

JinHai-CN · JinHai-CN · commit 66a030c6164a · 2025-09-18T16:31:36.000+08:00
Signed-off-by: Jin Hai &lt;haijin.chn@gmail.com&gt;
diff --git a/src/executor/operator/physical_command_impl.cpp b/src/executor/operator/physical_command_impl.cpp
@@ -299,7 +299,7 @@ bool PhysicalCommand::Execute(QueryContext *query_context, OperatorState *operat
                                 Status status = Status::InvalidCommand(fmt::format("Attempt to set compact segment interval: {}", interval));
                                 RecoverableError(status);
                             }
-                            query_context->storage()->periodic_trigger_thread()->compact_segment_trigger_->UpdateInternal(interval);
+                            query_context->storage()->periodic_trigger_thread()->compact_trigger_->UpdateInternal(interval);
                             config->SetCompactInterval(interval);
                             break;
                         }
diff --git a/src/storage/background_process.cppm b/src/storage/background_process.cppm
@@ -18,7 +18,6 @@ import :blocking_queue;
 
 namespace infinity {
 
-class CleanupPeriodicTrigger;
 class BGTask;
 
 export class BGTaskProcessor {
diff --git a/src/storage/background_process_impl.cpp b/src/storage/background_process_impl.cpp
@@ -75,7 +75,7 @@ void BGTaskProcessor::Process() {
                     running = false;
                     break;
                 }
-                case BGTaskType::kNewCheckpoint: {
+                case BGTaskType::kCheckpoint: {
                     StorageMode storage_mode = InfinityContext::instance().storage()->GetStorageMode();
                     if (storage_mode == StorageMode::kUnInitialized) {
                         UnrecoverableError("Uninitialized storage mode");
@@ -102,7 +102,7 @@ void BGTaskProcessor::Process() {
                     }
                     break;
                 }
-                case BGTaskType::kNewCleanup: {
+                case BGTaskType::kCleanup: {
                     StorageMode storage_mode = InfinityContext::instance().storage()->GetStorageMode();
                     if (storage_mode == StorageMode::kUnInitialized) {
                         UnrecoverableError("Uninitialized storage mode");
@@ -122,8 +122,8 @@ void BGTaskProcessor::Process() {
                         CleanupTxnStore *cleanup_txn_store = static_cast<CleanupTxnStore *>(new_txn_shared->GetTxnStore());
                         if (cleanup_txn_store != nullptr) {
                             TxnTimeStamp clean_ts = cleanup_txn_store->timestamp_;
-                            std::shared_ptr<BGTaskInfo> bg_task_info = std::make_shared<BGTaskInfo>(BGTaskType::kNewCleanup);
-                            std::string task_text = fmt::format("NewCleanup task, cleanup timestamp: {}", clean_ts);
+                            std::shared_ptr<BGTaskInfo> bg_task_info = std::make_shared<BGTaskInfo>(BGTaskType::kCleanup);
+                            std::string task_text = fmt::format("Cleanup task, cleanup timestamp: {}", clean_ts);
                             bg_task_info->task_info_list_.emplace_back(task_text);
                             if (status.ok()) {
                                 bg_task_info->status_list_.emplace_back("OK");
@@ -133,7 +133,7 @@ void BGTaskProcessor::Process() {
                             }
                             new_txn_mgr->AddTaskInfo(bg_task_info);
                         }
-                        LOG_DEBUG("NewCleanup task in background done");
+                        LOG_DEBUG("Cleanup task in background done");
                     }
                     break;
                 }
diff --git a/src/storage/bg_task/bg_task.cppm b/src/storage/bg_task/bg_task.cppm
@@ -93,7 +93,7 @@ export struct CheckpointTaskBase : public BGTask {
 };
 
 export struct NewCheckpointTask final : public CheckpointTaskBase {
-    NewCheckpointTask(i64 wal_size) : CheckpointTaskBase(BGTaskType::kNewCheckpoint, false), wal_size_(wal_size) {}
+    NewCheckpointTask(i64 wal_size) : CheckpointTaskBase(BGTaskType::kCheckpoint, false), wal_size_(wal_size) {}
 
     std::string ToString() const final { return "New catalog"; }
 
@@ -104,11 +104,11 @@ export struct NewCheckpointTask final : public CheckpointTaskBase {
     i64 wal_size_{};
 };
 
-export class NewCleanupTask final : public BGTask {
+export class CleanupTask final : public BGTask {
 public:
-    NewCleanupTask() : BGTask(BGTaskType::kNewCleanup, false) {}
+    CleanupTask() : BGTask(BGTaskType::kCleanup, false) {}
 
-    std::string ToString() const override { return "NewCleanupTask"; }
+    std::string ToString() const override { return "CleanupTask"; }
 
     Status Execute(TxnTimeStamp last_cleanup_ts, TxnTimeStamp &cur_cleanup_ts);
 
diff --git a/src/storage/bg_task/bg_task_impl.cpp b/src/storage/bg_task/bg_task_impl.cpp
@@ -57,7 +57,7 @@ Status NewCheckpointTask::ExecuteWithNewTxn() {
 
         auto *ckp_idx_store = static_cast<CheckpointTxnStore *>(new_txn_shared->GetTxnStore());
         if (ckp_idx_store != nullptr) {
-            std::shared_ptr<BGTaskInfo> bg_task_info = std::make_shared<BGTaskInfo>(BGTaskType::kNewCheckpoint);
+            std::shared_ptr<BGTaskInfo> bg_task_info = std::make_shared<BGTaskInfo>(BGTaskType::kCheckpoint);
             for (const std::shared_ptr<FlushDataEntry> &flush_data_entry : ckp_idx_store->entries_) {
                 std::string task_text = fmt::format("Txn: {}, commit: {}, checkpoint data: {}.{}.{}.{} {}",
                                                     new_txn_shared->TxnID(),
@@ -76,7 +76,7 @@ Status NewCheckpointTask::ExecuteWithNewTxn() {
     return status;
 }
 
-Status NewCleanupTask::Execute(TxnTimeStamp last_cleanup_ts, TxnTimeStamp &cur_cleanup_ts) {
+Status CleanupTask::Execute(TxnTimeStamp last_cleanup_ts, TxnTimeStamp &cur_cleanup_ts) {
     auto *new_txn_mgr = InfinityContext::instance().storage()->new_txn_manager();
     auto *txn = new_txn_mgr->BeginTxn(std::make_unique<std::string>("cleanup"), TransactionType::kCleanup);
     Status status = txn->Cleanup();
@@ -88,7 +88,7 @@ Status NewCleanupTask::Execute(TxnTimeStamp last_cleanup_ts, TxnTimeStamp &cur_c
 }
 
 NewCompactTask::NewCompactTask(NewTxn *new_txn, std::string db_name, std::string table_name)
-    : BGTask(BGTaskType::kNewCompact, false), new_txn_(new_txn), db_name_(db_name), table_name_(table_name) {}
+    : BGTask(BGTaskType::kCompact, false), new_txn_(new_txn), db_name_(db_name), table_name_(table_name) {}
 
 DumpMemIndexTask::DumpMemIndexTask(const std::string &db_name,
                                    const std::string &table_name,
diff --git a/src/storage/bg_task/bg_task_type.cppm b/src/storage/bg_task/bg_task_type.cppm
@@ -27,11 +27,11 @@ namespace infinity {
 
 export enum class BGTaskType {
     kStopProcessor,
-    kNewCheckpoint,
+    kCheckpoint,
     kNotifyCompact,
-    kNewCompact,
+    kCompact,
     kNotifyOptimize,
-    kNewCleanup,
+    kCleanup,
     kUpdateSegmentBloomFilterData, // Not used
     kDumpMemIndex,
     kAppendMemIndex,
diff --git a/src/storage/bg_task/bg_task_type_impl.cpp b/src/storage/bg_task/bg_task_type_impl.cpp
@@ -34,24 +34,24 @@ std::string ToString(BGTaskType type) {
             return "StopProcessor";
             break;
         }
-        case BGTaskType::kNewCheckpoint: {
-            return "NewCheckpoint";
+        case BGTaskType::kCheckpoint: {
+            return "Checkpoint";
             break;
         }
         case BGTaskType::kNotifyCompact: {
             return "NotifyCompact";
             break;
         }
-        case BGTaskType::kNewCompact: {
-            return "NewCompact";
+        case BGTaskType::kCompact: {
+            return "Compact";
             break;
         }
         case BGTaskType::kNotifyOptimize: {
             return "NotifyOptimize";
             break;
         }
-        case BGTaskType::kNewCleanup: {
-            return "NewCleanup";
+        case BGTaskType::kCleanup: {
+            return "Cleanup";
             break;
         }
         case BGTaskType::kUpdateSegmentBloomFilterData: {
diff --git a/src/storage/bg_task/periodic_trigger.cppm b/src/storage/bg_task/periodic_trigger.cppm
@@ -26,7 +26,7 @@ import global_resource_usage;
 
 namespace infinity {
 
-class NewCleanupTask;
+class CleanupTask;
 class NotifyOptimizeTask;
 class NotifyCompactTask;
 
@@ -58,16 +58,13 @@ protected:
     std::atomic_int64_t duration_{0};
 };
 
-export class NewCleanupPeriodicTrigger final : public PeriodicTrigger {
+export class CleanupPeriodicTrigger final : public PeriodicTrigger {
 public:
-    explicit NewCleanupPeriodicTrigger(const i64 interval) : PeriodicTrigger(interval) {}
+    explicit CleanupPeriodicTrigger(const i64 interval) : PeriodicTrigger(interval) {}
 
-    std::shared_ptr<NewCleanupTask> CreateNewCleanupTask();
+    std::shared_ptr<CleanupTask> CreateCleanupTask();
 
     void Trigger() override;
-
-private:
-    //
 };
 
 export class CheckpointPeriodicTrigger final : public PeriodicTrigger {
@@ -87,7 +84,7 @@ public:
     void Trigger() override;
 
 private:
-    CompactionProcessor *const compact_processor_{};
+    CompactionProcessor *compact_processor_{};
     std::shared_ptr<NotifyCompactTask> compact_task_{};
 };
 
@@ -101,7 +98,7 @@ public:
     void Trigger() override;
 
 private:
-    CompactionProcessor *const compact_processor_ = nullptr;
+    CompactionProcessor *compact_processor_{};
     std::shared_ptr<NotifyOptimizeTask> optimize_task_{};
 };
 
diff --git a/src/storage/bg_task/periodic_trigger_impl.cpp b/src/storage/bg_task/periodic_trigger_impl.cpp
@@ -45,7 +45,7 @@ bool PeriodicTrigger::Check() {
     return true;
 }
 
-std::shared_ptr<NewCleanupTask> NewCleanupPeriodicTrigger::CreateNewCleanupTask() {
+std::shared_ptr<CleanupTask> CleanupPeriodicTrigger::CreateCleanupTask() {
     auto *bg_processor = InfinityContext::instance().storage()->bg_processor();
     auto *new_txn_mgr = InfinityContext::instance().storage()->new_txn_manager();
 
@@ -55,11 +55,11 @@ std::shared_ptr<NewCleanupTask> NewCleanupPeriodicTrigger::CreateNewCleanupTask(
         return nullptr;
     }
 
-    return std::make_shared<NewCleanupTask>();
+    return std::make_shared<CleanupTask>();
 }
 
-void NewCleanupPeriodicTrigger::Trigger() {
-    auto cleanup_task = CreateNewCleanupTask();
+void CleanupPeriodicTrigger::Trigger() {
+    auto cleanup_task = CreateCleanupTask();
     if (!cleanup_task) {
         return;
     }
diff --git a/src/storage/compaction_process_impl.cpp b/src/storage/compaction_process_impl.cpp
@@ -327,7 +327,7 @@ void CompactionProcessor::Process() {
                     running = false;
                     break;
                 }
-                case BGTaskType::kNewCompact: {
+                case BGTaskType::kCompact: {
                     // Triggered by compact command
                     StorageMode storage_mode = InfinityContext::instance().storage()->GetStorageMode();
                     if (storage_mode == StorageMode::kUnInitialized) {
diff --git a/src/storage/periodic_trigger_thread.cppm b/src/storage/periodic_trigger_thread.cppm
@@ -31,9 +31,9 @@ public:
     void Run();
 
 public:
-    std::shared_ptr<NewCleanupPeriodicTrigger> new_cleanup_trigger_;
+    std::shared_ptr<CleanupPeriodicTrigger> new_cleanup_trigger_;
     std::shared_ptr<CheckpointPeriodicTrigger> checkpoint_trigger_;
-    std::shared_ptr<CompactPeriodicTrigger> compact_segment_trigger_;
+    std::shared_ptr<CompactPeriodicTrigger> compact_trigger_;
     std::shared_ptr<OptimizeIndexPeriodicTrigger> optimize_index_trigger_;
 
 private:
diff --git a/src/storage/periodic_trigger_thread_impl.cpp b/src/storage/periodic_trigger_thread_impl.cpp
@@ -59,8 +59,8 @@ void PeriodicTriggerThread::Run() {
             checkpoint_trigger_->Trigger();
         }
 
-        if (compact_segment_trigger_ != nullptr && compact_segment_trigger_->Check()) {
-            compact_segment_trigger_->Trigger();
+        if (compact_trigger_ != nullptr && compact_trigger_->Check()) {
+            compact_trigger_->Trigger();
         }
 
         if (optimize_index_trigger_ != nullptr && optimize_index_trigger_->Check()) {
diff --git a/src/storage/storage_impl.cpp b/src/storage/storage_impl.cpp
@@ -367,15 +367,15 @@ Status Storage::AdminToWriter() {
     periodic_trigger_thread_ = std::make_unique<PeriodicTriggerThread>();
 
     i64 cleanup_interval = config_ptr_->CleanupInterval() > 0 ? config_ptr_->CleanupInterval() : 0;
-    periodic_trigger_thread_->new_cleanup_trigger_ = std::make_shared<NewCleanupPeriodicTrigger>(cleanup_interval);
+    periodic_trigger_thread_->new_cleanup_trigger_ = std::make_shared<CleanupPeriodicTrigger>(cleanup_interval);
 
     i64 optimize_interval = config_ptr_->OptimizeIndexInterval() > 0 ? config_ptr_->OptimizeIndexInterval() : 0;
     periodic_trigger_thread_->optimize_index_trigger_ = std::make_shared<OptimizeIndexPeriodicTrigger>(optimize_interval, compact_processor_.get());
 
     i64 checkpoint_interval_sec = config_ptr_->CheckpointInterval() > 0 ? config_ptr_->CheckpointInterval() : 0;
     periodic_trigger_thread_->checkpoint_trigger_ = std::make_shared<CheckpointPeriodicTrigger>(checkpoint_interval_sec);
 
-    periodic_trigger_thread_->compact_segment_trigger_ = std::make_shared<CompactPeriodicTrigger>(compact_interval, compact_processor_.get());
+    periodic_trigger_thread_->compact_trigger_ = std::make_shared<CompactPeriodicTrigger>(compact_interval, compact_processor_.get());
 
     periodic_trigger_thread_->Start();
 
@@ -506,7 +506,7 @@ Status Storage::ReaderToWriter() {
     //                i64 cleanup_interval = config_ptr_->CleanupInterval() > 0 ? config_ptr_->CleanupInterval() : 0;
     i64 checkpoint_interval_sec = config_ptr_->CheckpointInterval() > 0 ? config_ptr_->CheckpointInterval() : 0;
     periodic_trigger_thread_->checkpoint_trigger_ = std::make_shared<CheckpointPeriodicTrigger>(checkpoint_interval_sec);
-    periodic_trigger_thread_->compact_segment_trigger_ = std::make_shared<CompactPeriodicTrigger>(compact_interval, compact_processor_.get());
+    periodic_trigger_thread_->compact_trigger_ = std::make_shared<CompactPeriodicTrigger>(compact_interval, compact_processor_.get());
     periodic_trigger_thread_->optimize_index_trigger_ = std::make_shared<OptimizeIndexPeriodicTrigger>(optimize_interval, compact_processor_.get());
     periodic_trigger_thread_->Start();
 
@@ -604,7 +604,7 @@ Status Storage::WriterToReader() {
     i64 cleanup_interval = config_ptr_->CleanupInterval() > 0 ? config_ptr_->CleanupInterval() : 0;
 
     periodic_trigger_thread_ = std::make_unique<PeriodicTriggerThread>();
-    periodic_trigger_thread_->new_cleanup_trigger_ = std::make_shared<NewCleanupPeriodicTrigger>(cleanup_interval);
+    periodic_trigger_thread_->new_cleanup_trigger_ = std::make_shared<CleanupPeriodicTrigger>(cleanup_interval);
 
     periodic_trigger_thread_->Start();
 
@@ -821,7 +821,7 @@ Status Storage::AdminToReaderBottom(TxnTimeStamp system_start_ts) {
     periodic_trigger_thread_ = std::make_unique<PeriodicTriggerThread>();
 
     i64 cleanup_interval = config_ptr_->CleanupInterval() > 0 ? config_ptr_->CleanupInterval() : 0;
-    periodic_trigger_thread_->new_cleanup_trigger_ = std::make_shared<NewCleanupPeriodicTrigger>(cleanup_interval);
+    periodic_trigger_thread_->new_cleanup_trigger_ = std::make_shared<CleanupPeriodicTrigger>(cleanup_interval);
 
     periodic_trigger_thread_->Start();
     reader_init_phase_ = ReaderInitPhase::kPhase2;
diff --git a/src/unit_test/storage/buffer/buffer_obj_ut.cpp b/src/unit_test/storage/buffer/buffer_obj_ut.cpp
@@ -78,7 +78,7 @@ class BufferObjTest : public BaseTest {
     void SaveBufferObj(BufferObj *buffer_obj) { buffer_obj->Save(); };
 
     void WaitCleanup(Storage *storage) {
-        auto cleanup_task = std::make_shared<NewCleanupTask>();
+        auto cleanup_task = std::make_shared<CleanupTask>();
         TxnTimeStamp cur_cleanup_ts;
         cleanup_task->Execute(0, cur_cleanup_ts);
     }

Original file line number	Diff line number	Diff line change
`@@ -299,7 +299,7 @@ bool PhysicalCommand::Execute(QueryContext query_context, OperatorState operat`
`299`	`299`	`Status status = Status::InvalidCommand(fmt::format("Attempt to set compact segment interval: {}", interval));`
`300`	`300`	`RecoverableError(status);`
`301`	`301`	`}`
`302`		`- query_context->storage()->periodic_trigger_thread()->compact_segment_trigger_->UpdateInternal(interval);`
	`302`	`+ query_context->storage()->periodic_trigger_thread()->compact_trigger_->UpdateInternal(interval);`
`303`	`303`	`config->SetCompactInterval(interval);`
`304`	`304`	`break;`
`305`	`305`	`}`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ void BGTaskProcessor::Process() {`
`75`	`75`	`running = false;`
`76`	`76`	`break;`
`77`	`77`	`}`
`78`		`- case BGTaskType::kNewCheckpoint: {`
	`78`	`+ case BGTaskType::kCheckpoint: {`
`79`	`79`	`StorageMode storage_mode = InfinityContext::instance().storage()->GetStorageMode();`
`80`	`80`	`if (storage_mode == StorageMode::kUnInitialized) {`
`81`	`81`	`UnrecoverableError("Uninitialized storage mode");`
`@@ -102,7 +102,7 @@ void BGTaskProcessor::Process() {`
`102`	`102`	`}`
`103`	`103`	`break;`
`104`	`104`	`}`
`105`		`- case BGTaskType::kNewCleanup: {`
	`105`	`+ case BGTaskType::kCleanup: {`
`106`	`106`	`StorageMode storage_mode = InfinityContext::instance().storage()->GetStorageMode();`
`107`	`107`	`if (storage_mode == StorageMode::kUnInitialized) {`
`108`	`108`	`UnrecoverableError("Uninitialized storage mode");`
`@@ -122,8 +122,8 @@ void BGTaskProcessor::Process() {`
`122`	`122`	`CleanupTxnStore cleanup_txn_store = static_cast<CleanupTxnStore >(new_txn_shared->GetTxnStore());`
`123`	`123`	`if (cleanup_txn_store != nullptr) {`
`124`	`124`	`TxnTimeStamp clean_ts = cleanup_txn_store->timestamp_;`
`125`		`- std::shared_ptr<BGTaskInfo> bg_task_info = std::make_shared<BGTaskInfo>(BGTaskType::kNewCleanup);`
`126`		`- std::string task_text = fmt::format("NewCleanup task, cleanup timestamp: {}", clean_ts);`
	`125`	`+ std::shared_ptr<BGTaskInfo> bg_task_info = std::make_shared<BGTaskInfo>(BGTaskType::kCleanup);`
	`126`	`+ std::string task_text = fmt::format("Cleanup task, cleanup timestamp: {}", clean_ts);`
`127`	`127`	`bg_task_info->task_info_list_.emplace_back(task_text);`
`128`	`128`	`if (status.ok()) {`
`129`	`129`	`bg_task_info->status_list_.emplace_back("OK");`
`@@ -133,7 +133,7 @@ void BGTaskProcessor::Process() {`
`133`	`133`	`}`
`134`	`134`	`new_txn_mgr->AddTaskInfo(bg_task_info);`
`135`	`135`	`}`
`136`		`- LOG_DEBUG("NewCleanup task in background done");`
	`136`	`+ LOG_DEBUG("Cleanup task in background done");`
`137`	`137`	`}`
`138`	`138`	`break;`
`139`	`139`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,24 +34,24 @@ std::string ToString(BGTaskType type) {`
`34`	`34`	`return "StopProcessor";`
`35`	`35`	`break;`
`36`	`36`	`}`
`37`		`- case BGTaskType::kNewCheckpoint: {`
`38`		`- return "NewCheckpoint";`
	`37`	`+ case BGTaskType::kCheckpoint: {`
	`38`	`+ return "Checkpoint";`
`39`	`39`	`break;`
`40`	`40`	`}`
`41`	`41`	`case BGTaskType::kNotifyCompact: {`
`42`	`42`	`return "NotifyCompact";`
`43`	`43`	`break;`
`44`	`44`	`}`
`45`		`- case BGTaskType::kNewCompact: {`
`46`		`- return "NewCompact";`
	`45`	`+ case BGTaskType::kCompact: {`
	`46`	`+ return "Compact";`
`47`	`47`	`break;`
`48`	`48`	`}`
`49`	`49`	`case BGTaskType::kNotifyOptimize: {`
`50`	`50`	`return "NotifyOptimize";`
`51`	`51`	`break;`
`52`	`52`	`}`
`53`		`- case BGTaskType::kNewCleanup: {`
`54`		`- return "NewCleanup";`
	`53`	`+ case BGTaskType::kCleanup: {`
	`54`	`+ return "Cleanup";`
`55`	`55`	`break;`
`56`	`56`	`}`
`57`	`57`	`case BGTaskType::kUpdateSegmentBloomFilterData: {`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ bool PeriodicTrigger::Check() {`
`45`	`45`	`return true;`
`46`	`46`	`}`
`47`	`47`
`48`		`-std::shared_ptr<NewCleanupTask> NewCleanupPeriodicTrigger::CreateNewCleanupTask() {`
	`48`	`+std::shared_ptr<CleanupTask> CleanupPeriodicTrigger::CreateCleanupTask() {`
`49`	`49`	`auto *bg_processor = InfinityContext::instance().storage()->bg_processor();`
`50`	`50`	`auto *new_txn_mgr = InfinityContext::instance().storage()->new_txn_manager();`
`51`	`51`
`@@ -55,11 +55,11 @@ std::shared_ptr<NewCleanupTask> NewCleanupPeriodicTrigger::CreateNewCleanupTask(`
`55`	`55`	`return nullptr;`
`56`	`56`	`}`
`57`	`57`
`58`		`- return std::make_shared<NewCleanupTask>();`
	`58`	`+ return std::make_shared<CleanupTask>();`
`59`	`59`	`}`
`60`	`60`
`61`		`-void NewCleanupPeriodicTrigger::Trigger() {`
`62`		`- auto cleanup_task = CreateNewCleanupTask();`
	`61`	`+void CleanupPeriodicTrigger::Trigger() {`
	`62`	`+ auto cleanup_task = CreateCleanupTask();`
`63`	`63`	`if (!cleanup_task) {`
`64`	`64`	`return;`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -327,7 +327,7 @@ void CompactionProcessor::Process() {`
`327`	`327`	`running = false;`
`328`	`328`	`break;`
`329`	`329`	`}`
`330`		`- case BGTaskType::kNewCompact: {`
	`330`	`+ case BGTaskType::kCompact: {`
`331`	`331`	`// Triggered by compact command`
`332`	`332`	`StorageMode storage_mode = InfinityContext::instance().storage()->GetStorageMode();`
`333`	`333`	`if (storage_mode == StorageMode::kUnInitialized) {`