diff --git a/cpp/src/db/DB.cpp b/cpp/src/db/DB.cpp
deleted file mode 100644
index 2d922dd33b26cdbd5aac6b3e817e4a36d096319a..0000000000000000000000000000000000000000
--- a/cpp/src/db/DB.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-/*******************************************************************************
- * Copyright 上海赜睿信息科技有限公司(Zilliz) - All Rights Reserved
- * Unauthorized copying of this file, via any medium is strictly prohibited.
- * Proprietary and confidential.
- ******************************************************************************/
-
-#include "DBImpl.h"
-#include "Factories.h"
-
-namespace zilliz {
-namespace milvus {
-namespace engine {
-
-DB::~DB() = default;
-
-void DB::Open(const Options& options, DB** dbptr) {
-    *dbptr = DBFactory::Build(options);
-}
-
-} // namespace engine
-} // namespace milvus
-} // namespace zilliz
diff --git a/cpp/src/db/DB.h b/cpp/src/db/DB.h
index d493c0f78cad2cacc77ac5edd7085dbe78a122b6..5ca80f972e59c87e581165c4687cc7c7c11f2199 100644
--- a/cpp/src/db/DB.h
+++ b/cpp/src/db/DB.h
@@ -20,7 +20,11 @@ class Env;
 
 class DB {
 public:
-    static void Open(const Options& options, DB** dbptr);
+    DB() = default;
+    DB(const DB&) = delete;
+    DB& operator=(const DB&) = delete;
+
+    virtual ~DB() = default;
 
     virtual Status Start() = 0;
     virtual Status Stop() = 0;
@@ -55,11 +59,6 @@ public:
 
     virtual Status DropAll() = 0;
 
-    DB() = default;
-    DB(const DB&) = delete;
-    DB& operator=(const DB&) = delete;
-
-    virtual ~DB() = 0;
 }; // DB
 
 } // namespace engine
diff --git a/cpp/src/db/DBImpl.h b/cpp/src/db/DBImpl.h
index 7fb8295b2f37e72054e1acaaa9621f4d94fe3840..a59a866fbe3ce9d738904dd122b41cd5f579d759 100644
--- a/cpp/src/db/DBImpl.h
+++ b/cpp/src/db/DBImpl.h
@@ -35,6 +35,7 @@ class DBImpl : public DB {
     using MetaPtr = meta::Meta::Ptr;
 
     explicit DBImpl(const Options &options);
+    ~DBImpl();
 
     Status Start() override;
     Status Stop() override;
@@ -91,8 +92,6 @@ class DBImpl : public DB {
 
     Status DropIndex(const std::string& table_id) override;
 
-    ~DBImpl() override;
-
  private:
     Status QueryAsync(const std::string &table_id,
                       const meta::TableFilesSchema &files,
diff --git a/cpp/src/metrics/Metrics.h b/cpp/src/metrics/Metrics.h
index eb6e500f26a3439c14a188a33cd5e7da81acfec3..83b082fe46b903cd48b75f39f3ec1488f9611bd4 100644
--- a/cpp/src/metrics/Metrics.h
+++ b/cpp/src/metrics/Metrics.h
@@ -29,17 +29,34 @@ class Metrics {
  private:
     static MetricsBase &CreateMetricsCollector();
 };
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectMetricsBase {
+protected:
+    CollectMetricsBase() {
+        start_time_ = METRICS_NOW_TIME;
+    }
+
+    virtual ~CollectMetricsBase() = default;
+
+    double TimeFromBegine() {
+        auto end_time = METRICS_NOW_TIME;
+        return METRICS_MICROSECONDS(start_time_, end_time);
+    }
+
+protected:
+    using TIME_POINT = std::chrono::system_clock::time_point;
+    TIME_POINT start_time_;
+};
 
-class CollectInsertMetrics {
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectInsertMetrics : CollectMetricsBase {
 public:
     CollectInsertMetrics(size_t n, engine::Status& status) : n_(n), status_(status) {
-        start_time_ = METRICS_NOW_TIME;
     }
 
     ~CollectInsertMetrics() {
         if(n_ > 0) {
-            auto end_time = METRICS_NOW_TIME;
-            auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
+            auto total_time = TimeFromBegine();
             double avg_time = total_time / n_;
             for (int i = 0; i < n_; ++i) {
                 Metrics::GetInstance().AddVectorsDurationHistogramOberve(avg_time);
@@ -57,22 +74,19 @@ public:
     }
 
 private:
-    using TIME_POINT = std::chrono::system_clock::time_point;
-    TIME_POINT start_time_;
     size_t n_;
     engine::Status& status_;
 };
 
-class CollectQueryMetrics {
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectQueryMetrics : CollectMetricsBase {
 public:
     CollectQueryMetrics(size_t nq) : nq_(nq) {
-        start_time_ = METRICS_NOW_TIME;
     }
 
     ~CollectQueryMetrics() {
         if(nq_ > 0) {
-            auto end_time = METRICS_NOW_TIME;
-            auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
+            auto total_time = TimeFromBegine();
             for (int i = 0; i < nq_; ++i) {
                 server::Metrics::GetInstance().QueryResponseSummaryObserve(total_time);
             }
@@ -83,112 +97,90 @@ public:
     }
 
 private:
-    using TIME_POINT = std::chrono::system_clock::time_point;
-    TIME_POINT start_time_;
     size_t nq_;
 };
 
-class CollectMergeFilesMetrics {
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectMergeFilesMetrics : CollectMetricsBase {
 public:
     CollectMergeFilesMetrics() {
-        start_time_ = METRICS_NOW_TIME;
     }
 
     ~CollectMergeFilesMetrics() {
-        auto end_time = METRICS_NOW_TIME;
-        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
+        auto total_time = TimeFromBegine();
         server::Metrics::GetInstance().MemTableMergeDurationSecondsHistogramObserve(total_time);
     }
-
-private:
-    using TIME_POINT = std::chrono::system_clock::time_point;
-    TIME_POINT start_time_;
 };
 
-class CollectBuildIndexMetrics {
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectBuildIndexMetrics : CollectMetricsBase {
 public:
     CollectBuildIndexMetrics() {
-        start_time_ = METRICS_NOW_TIME;
     }
 
     ~CollectBuildIndexMetrics() {
-        auto end_time = METRICS_NOW_TIME;
-        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
+        auto total_time = TimeFromBegine();
         server::Metrics::GetInstance().BuildIndexDurationSecondsHistogramObserve(total_time);
     }
-private:
-    using TIME_POINT = std::chrono::system_clock::time_point;
-    TIME_POINT start_time_;
 };
 
-class CollectExecutionEngineMetrics {
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectExecutionEngineMetrics : CollectMetricsBase {
 public:
     CollectExecutionEngineMetrics(double physical_size) : physical_size_(physical_size) {
-        start_time_ = METRICS_NOW_TIME;
     }
 
     ~CollectExecutionEngineMetrics() {
-        auto end_time = METRICS_NOW_TIME;
-        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
+        auto total_time = TimeFromBegine();
 
         server::Metrics::GetInstance().FaissDiskLoadDurationSecondsHistogramObserve(total_time);
-
         server::Metrics::GetInstance().FaissDiskLoadSizeBytesHistogramObserve(physical_size_);
         server::Metrics::GetInstance().FaissDiskLoadIOSpeedGaugeSet(physical_size_ / double(total_time));
     }
 
 private:
-    using TIME_POINT = std::chrono::system_clock::time_point;
-    TIME_POINT start_time_;
     double physical_size_;
 };
 
-class CollectSerializeMetrics {
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectSerializeMetrics : CollectMetricsBase {
 public:
     CollectSerializeMetrics(size_t size) : size_(size) {
-        start_time_ = METRICS_NOW_TIME;
     }
 
     ~CollectSerializeMetrics() {
-        auto end_time = METRICS_NOW_TIME;
-        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
+        auto total_time = TimeFromBegine();
         server::Metrics::GetInstance().DiskStoreIOSpeedGaugeSet((double) size_ / total_time);
     }
 private:
-    using TIME_POINT = std::chrono::system_clock::time_point;
-    TIME_POINT start_time_;
     size_t size_;
 };
 
-class CollectAddMetrics {
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectAddMetrics : CollectMetricsBase {
 public:
     CollectAddMetrics(size_t n, uint16_t dimension) : n_(n), dimension_(dimension) {
-        start_time_ = METRICS_NOW_TIME;
     }
 
     ~CollectAddMetrics() {
-        auto end_time = METRICS_NOW_TIME;
-        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
+        auto total_time = TimeFromBegine();
         server::Metrics::GetInstance().AddVectorsPerSecondGaugeSet(static_cast<int>(n_),
                                                                    static_cast<int>(dimension_),
                                                                    total_time);
     }
 private:
-    using TIME_POINT = std::chrono::system_clock::time_point;
-    TIME_POINT start_time_;
     size_t n_;
     uint16_t dimension_;
 };
 
-class CollectDurationMetrics {
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectDurationMetrics : CollectMetricsBase {
 public:
     CollectDurationMetrics(int index_type) : index_type_(index_type) {
-        start_time_ = METRICS_NOW_TIME;
     }
 
     ~CollectDurationMetrics() {
-        auto end_time = METRICS_NOW_TIME;
-        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
+        auto total_time = TimeFromBegine();
         switch (index_type_) {
             case engine::meta::TableFileSchema::RAW: {
                 server::Metrics::GetInstance().SearchRawDataDurationSecondsHistogramObserve(total_time);
@@ -205,20 +197,17 @@ public:
         }
     }
 private:
-    using TIME_POINT = std::chrono::system_clock::time_point;
-    TIME_POINT start_time_;
     int index_type_;
 };
 
-class CollectSearchTaskMetrics {
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectSearchTaskMetrics : CollectMetricsBase {
 public:
     CollectSearchTaskMetrics(int index_type) : index_type_(index_type) {
-        start_time_ = METRICS_NOW_TIME;
     }
 
     ~CollectSearchTaskMetrics() {
-        auto end_time = METRICS_NOW_TIME;
-        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
+        auto total_time = TimeFromBegine();
         switch(index_type_) {
             case engine::meta::TableFileSchema::RAW: {
                 server::Metrics::GetInstance().SearchRawDataDurationSecondsHistogramObserve(total_time);
@@ -236,27 +225,20 @@ public:
     }
 
 private:
-    using TIME_POINT = std::chrono::system_clock::time_point;
-    TIME_POINT start_time_;
     int index_type_;
 };
 
-class MetricCollector {
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class MetricCollector : CollectMetricsBase {
 public:
     MetricCollector() {
         server::Metrics::GetInstance().MetaAccessTotalIncrement();
-        start_time_ = METRICS_NOW_TIME;
     }
 
     ~MetricCollector() {
-        auto end_time = METRICS_NOW_TIME;
-        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
+        auto total_time = TimeFromBegine();
         server::Metrics::GetInstance().MetaAccessDurationSecondsHistogramObserve(total_time);
     }
-
-private:
-    using TIME_POINT = std::chrono::system_clock::time_point;
-    TIME_POINT start_time_;
 };
 
 
diff --git a/cpp/src/server/DBWrapper.cpp b/cpp/src/server/DBWrapper.cpp
index 647fea598e9f6879846ce12fc2fefa998473c075..620da3b830ce1ab7882a8c4e41dcabf3a53326b8 100644
--- a/cpp/src/server/DBWrapper.cpp
+++ b/cpp/src/server/DBWrapper.cpp
@@ -6,6 +6,7 @@
 
 #include "DBWrapper.h"
 #include "ServerConfig.h"
+#include "db/Factories.h"
 #include "utils/CommonUtil.h"
 #include "utils/Log.h"
 #include "utils/StringHelpFunctions.h"
@@ -95,8 +96,7 @@ ServerError DBWrapper::StartService() {
     //create db instance
     std::string msg = opt.meta.path;
     try {
-        engine::DB* db = nullptr;
-        zilliz::milvus::engine::DB::Open(opt, &db);
+        engine::DB* db = engine::DBFactory::Build(opt);
         db_.reset(db);
     } catch(std::exception& ex) {
         msg = ex.what();