Fix build error and refactor code

Former-commit-id: 242ffb4a0ba8fc299acb522ce3ba330d5d1b305c

cpp/src/db/Options.h

@@ -20,14 +20,13 @@ static constexpr uint64_t ONE_KB = 1024;
 static constexpr uint64_t ONE_MB = ONE_KB*ONE_KB;
 static constexpr uint64_t ONE_GB = ONE_KB*ONE_MB;
 
-static const std::string ARCHIVE_CONF_DISK = "disk";
-static const std::string ARCHIVE_CONF_DAYS = "days";
-static const std::string ARCHIVE_CONF_DEFAULT = "";
+static const char* ARCHIVE_CONF_DISK = "disk";
+static const char* ARCHIVE_CONF_DAYS = "days";
 
 struct ArchiveConf {
     using CriteriaT = std::map<std::string, int>;
 
-    ArchiveConf(const std::string& type, const std::string& criterias = ARCHIVE_CONF_DEFAULT);
+    ArchiveConf(const std::string& type, const std::string& criterias = std::string());
 
     const std::string& GetType() const { return type_; }
     const CriteriaT GetCriterias() const { return criterias_; }

cpp/src/db/Utils.cpp

@@ -18,10 +18,10 @@ namespace utils {
 
 namespace {
 
-static const std::string TABLES_FOLDER = "/tables/";
+const char* TABLES_FOLDER = "/tables/";
 
-static uint64_t index_file_counter = 0;
-static std::mutex index_file_counter_mutex;
+uint64_t index_file_counter = 0;
+std::mutex index_file_counter_mutex;
 
 std::string ConstructParentFolder(const std::string& db_path, const meta::TableFileSchema& table_file) {
     std::string table_path = db_path + TABLES_FOLDER + table_file.table_id_;

cpp/src/grpc/gen-milvus/milvus.grpc.pb.cc

@@ -58,11 +58,19 @@ MilvusService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& chan
 }
 
 void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, std::move(f));
 }
 
 void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, reactor);
 }
 
 ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) {
@@ -78,11 +86,19 @@ void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext*
 }
 
 void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, std::move(f));
 }
 
 void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, reactor);
 }
 
 ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* MilvusService::Stub::AsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
@@ -98,11 +114,19 @@ void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* co
 }
 
 void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, std::move(f));
 }
 
 void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, reactor);
 }
 
 ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
@@ -118,11 +142,19 @@ void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* c
 }
 
 void MilvusService::Stub::experimental_async::BuildIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_BuildIndex_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_BuildIndex_, context, request, response, std::move(f));
 }
 
 void MilvusService::Stub::experimental_async::BuildIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_BuildIndex_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_BuildIndex_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::BuildIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_BuildIndex_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::BuildIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_BuildIndex_, context, request, response, reactor);
 }
 
 ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncBuildIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
@@ -138,11 +170,19 @@ void MilvusService::Stub::experimental_async::BuildIndex(::grpc::ClientContext*
 }
 
 void MilvusService::Stub::experimental_async::InsertVector(::grpc::ClientContext* context, const ::milvus::grpc::InsertInfos* request, ::milvus::grpc::VectorIds* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_InsertVector_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_InsertVector_, context, request, response, std::move(f));
 }
 
 void MilvusService::Stub::experimental_async::InsertVector(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_InsertVector_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_InsertVector_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::InsertVector(::grpc::ClientContext* context, const ::milvus::grpc::InsertInfos* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_InsertVector_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::InsertVector(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_InsertVector_, context, request, response, reactor);
 }
 
 ::grpc::ClientAsyncResponseReader< ::milvus::grpc::VectorIds>* MilvusService::Stub::AsyncInsertVectorRaw(::grpc::ClientContext* context, const ::milvus::grpc::InsertInfos& request, ::grpc::CompletionQueue* cq) {
@@ -190,11 +230,19 @@ void MilvusService::Stub::experimental_async::SearchVectorInFiles(::grpc::Client
 }
 
 void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, std::move(f));
 }
 
 void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, reactor);
 }
 
 ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>* MilvusService::Stub::AsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
@@ -210,11 +258,19 @@ void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContex
 }
 
 void MilvusService::Stub::experimental_async::GetTableRowCount(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetTableRowCount_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetTableRowCount_, context, request, response, std::move(f));
 }
 
 void MilvusService::Stub::experimental_async::GetTableRowCount(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetTableRowCount_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetTableRowCount_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::GetTableRowCount(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_GetTableRowCount_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::GetTableRowCount(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_GetTableRowCount_, context, request, response, reactor);
 }
 
 ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>* MilvusService::Stub::AsyncGetTableRowCountRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
@@ -246,11 +302,19 @@ void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext*
 }
 
 void MilvusService::Stub::experimental_async::Ping(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::ServerStatus* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Ping_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Ping_, context, request, response, std::move(f));
 }
 
 void MilvusService::Stub::experimental_async::Ping(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::ServerStatus* response, std::function<void(::grpc::Status)> f) {
-  return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Ping_, context, request, response, std::move(f));
+  ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Ping_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::Ping(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::ServerStatus* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Ping_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::Ping(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::ServerStatus* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Ping_, context, request, response, reactor);
 }
 
 ::grpc::ClientAsyncResponseReader< ::milvus::grpc::ServerStatus>* MilvusService::Stub::AsyncPingRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {

cpp/src/grpc/gen-milvus/milvus.grpc.pb.h

@@ -11,20 +11,28 @@
 #include <grpcpp/impl/codegen/async_stream.h>
 #include <grpcpp/impl/codegen/async_unary_call.h>
 #include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/client_context.h>
 #include <grpcpp/impl/codegen/method_handler_impl.h>
 #include <grpcpp/impl/codegen/proto_utils.h>
 #include <grpcpp/impl/codegen/rpc_method.h>
 #include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_context.h>
 #include <grpcpp/impl/codegen/service_type.h>
 #include <grpcpp/impl/codegen/status.h>
 #include <grpcpp/impl/codegen/stub_options.h>
 #include <grpcpp/impl/codegen/sync_stream.h>
 
-namespace grpc {
+namespace grpc_impl {
 class CompletionQueue;
-class Channel;
 class ServerCompletionQueue;
 class ServerContext;
+}  // namespace grpc_impl
+
+namespace grpc {
+namespace experimental {
+template <typename RequestT, typename ResponseT>
+class MessageAllocator;
+}  // namespace experimental
 }  // namespace grpc
 
 namespace milvus {
@@ -221,6 +229,8 @@ class MilvusService final {
       //
       virtual void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
       virtual void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
       // *
       // @brief Test table existence method
       //
@@ -230,6 +240,8 @@ class MilvusService final {
       //
       virtual void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, std::function<void(::grpc::Status)>) = 0;
       virtual void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
       // *
       // @brief Delete table method
       //
@@ -239,6 +251,8 @@ class MilvusService final {
       //
       virtual void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
       virtual void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
       // *
       // @brief Build index by table method
       //
@@ -248,6 +262,8 @@ class MilvusService final {
       //
       virtual void BuildIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
       virtual void BuildIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void BuildIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void BuildIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
       // *
       // @brief Add vector array to table
       //
@@ -259,6 +275,8 @@ class MilvusService final {
       // @return vector id array
       virtual void InsertVector(::grpc::ClientContext* context, const ::milvus::grpc::InsertInfos* request, ::milvus::grpc::VectorIds* response, std::function<void(::grpc::Status)>) = 0;
       virtual void InsertVector(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void InsertVector(::grpc::ClientContext* context, const ::milvus::grpc::InsertInfos* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void InsertVector(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
       // *
       // @brief Query vector
       //
@@ -293,6 +311,8 @@ class MilvusService final {
       // @return table schema
       virtual void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, std::function<void(::grpc::Status)>) = 0;
       virtual void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
       // *
       // @brief Get table schema
       //
@@ -303,6 +323,8 @@ class MilvusService final {
       // @return table schema
       virtual void GetTableRowCount(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, std::function<void(::grpc::Status)>) = 0;
       virtual void GetTableRowCount(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void GetTableRowCount(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void GetTableRowCount(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
       // *
       // @brief List all tables in database
       //
@@ -319,6 +341,8 @@ class MilvusService final {
       // @return Server status.
       virtual void Ping(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::ServerStatus* response, std::function<void(::grpc::Status)>) = 0;
       virtual void Ping(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::ServerStatus* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void Ping(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::ServerStatus* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void Ping(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::ServerStatus* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
     };
     virtual class experimental_async_interface* experimental_async() { return nullptr; }
   private:
@@ -439,23 +463,39 @@ class MilvusService final {
      public:
       void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
       void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
+      void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
       void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, std::function<void(::grpc::Status)>) override;
       void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function<void(::grpc::Status)>) override;
+      void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
       void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
       void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
+      void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
       void BuildIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
       void BuildIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
+      void BuildIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void BuildIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
       void InsertVector(::grpc::ClientContext* context, const ::milvus::grpc::InsertInfos* request, ::milvus::grpc::VectorIds* response, std::function<void(::grpc::Status)>) override;
       void InsertVector(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, std::function<void(::grpc::Status)>) override;
+      void InsertVector(::grpc::ClientContext* context, const ::milvus::grpc::InsertInfos* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void InsertVector(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
       void SearchVector(::grpc::ClientContext* context, ::milvus::grpc::SearchVectorInfos* request, ::grpc::experimental::ClientReadReactor< ::milvus::grpc::TopKQueryResult>* reactor) override;
       void SearchVectorInFiles(::grpc::ClientContext* context, ::milvus::grpc::SearchVectorInFilesInfos* request, ::grpc::experimental::ClientReadReactor< ::milvus::grpc::TopKQueryResult>* reactor) override;
       void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, std::function<void(::grpc::Status)>) override;
       void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, std::function<void(::grpc::Status)>) override;
+      void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
       void GetTableRowCount(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, std::function<void(::grpc::Status)>) override;
       void GetTableRowCount(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, std::function<void(::grpc::Status)>) override;
+      void GetTableRowCount(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void GetTableRowCount(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
       void ShowTables(::grpc::ClientContext* context, ::milvus::grpc::Command* request, ::grpc::experimental::ClientReadReactor< ::milvus::grpc::TableName>* reactor) override;
       void Ping(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::ServerStatus* response, std::function<void(::grpc::Status)>) override;
       void Ping(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::ServerStatus* response, std::function<void(::grpc::Status)>) override;
+      void Ping(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::ServerStatus* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void Ping(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::ServerStatus* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
      private:
       friend class Stub;
       explicit experimental_async(Stub* stub): stub_(stub) { }
@@ -846,6 +886,12 @@ class MilvusService final {
                    return this->CreateTable(context, request, response, controller);
                  }));
     }
+    void SetMessageAllocatorFor_CreateTable(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableSchema, ::milvus::grpc::Status>* allocator) {
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::milvus::grpc::TableSchema, ::milvus::grpc::Status>*>(
+          ::grpc::Service::experimental().GetHandler(0))
+              ->SetMessageAllocator(allocator);
+    }
     ~ExperimentalWithCallbackMethod_CreateTable() override {
       BaseClassMustBeDerivedFromService(this);
     }
@@ -871,6 +917,12 @@ class MilvusService final {
                    return this->HasTable(context, request, response, controller);
                  }));
     }
+    void SetMessageAllocatorFor_HasTable(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>* allocator) {
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>*>(
+          ::grpc::Service::experimental().GetHandler(1))
+              ->SetMessageAllocator(allocator);
+    }
     ~ExperimentalWithCallbackMethod_HasTable() override {
       BaseClassMustBeDerivedFromService(this);
     }
@@ -896,6 +948,12 @@ class MilvusService final {
                    return this->DropTable(context, request, response, controller);
                  }));
     }
+    void SetMessageAllocatorFor_DropTable(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::Status>* allocator) {
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>*>(
+          ::grpc::Service::experimental().GetHandler(2))
+              ->SetMessageAllocator(allocator);
+    }
     ~ExperimentalWithCallbackMethod_DropTable() override {
       BaseClassMustBeDerivedFromService(this);
     }
@@ -921,6 +979,12 @@ class MilvusService final {
                    return this->BuildIndex(context, request, response, controller);
                  }));
     }
+    void SetMessageAllocatorFor_BuildIndex(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::Status>* allocator) {
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>*>(
+          ::grpc::Service::experimental().GetHandler(3))
+              ->SetMessageAllocator(allocator);
+    }
     ~ExperimentalWithCallbackMethod_BuildIndex() override {
       BaseClassMustBeDerivedFromService(this);
     }
@@ -946,6 +1010,12 @@ class MilvusService final {
                    return this->InsertVector(context, request, response, controller);
                  }));
     }
+    void SetMessageAllocatorFor_InsertVector(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::InsertInfos, ::milvus::grpc::VectorIds>* allocator) {
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::milvus::grpc::InsertInfos, ::milvus::grpc::VectorIds>*>(
+          ::grpc::Service::experimental().GetHandler(4))
+              ->SetMessageAllocator(allocator);
+    }
     ~ExperimentalWithCallbackMethod_InsertVector() override {
       BaseClassMustBeDerivedFromService(this);
     }
@@ -1015,6 +1085,12 @@ class MilvusService final {
                    return this->DescribeTable(context, request, response, controller);
                  }));
     }
+    void SetMessageAllocatorFor_DescribeTable(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>* allocator) {
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>*>(
+          ::grpc::Service::experimental().GetHandler(7))
+              ->SetMessageAllocator(allocator);
+    }
     ~ExperimentalWithCallbackMethod_DescribeTable() override {
       BaseClassMustBeDerivedFromService(this);
     }
@@ -1040,6 +1116,12 @@ class MilvusService final {
                    return this->GetTableRowCount(context, request, response, controller);
                  }));
     }
+    void SetMessageAllocatorFor_GetTableRowCount(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>* allocator) {
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>*>(
+          ::grpc::Service::experimental().GetHandler(8))
+              ->SetMessageAllocator(allocator);
+    }
     ~ExperimentalWithCallbackMethod_GetTableRowCount() override {
       BaseClassMustBeDerivedFromService(this);
     }
@@ -1087,6 +1169,12 @@ class MilvusService final {
                    return this->Ping(context, request, response, controller);
                  }));
     }
+    void SetMessageAllocatorFor_Ping(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::Command, ::milvus::grpc::ServerStatus>* allocator) {
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::ServerStatus>*>(
+          ::grpc::Service::experimental().GetHandler(10))
+              ->SetMessageAllocator(allocator);
+    }
     ~ExperimentalWithCallbackMethod_Ping() override {
       BaseClassMustBeDerivedFromService(this);
     }

cpp/src/grpc/gen-status/status.grpc.pb.h

@@ -11,20 +11,28 @@
 #include <grpcpp/impl/codegen/async_stream.h>
 #include <grpcpp/impl/codegen/async_unary_call.h>
 #include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/client_context.h>
 #include <grpcpp/impl/codegen/method_handler_impl.h>
 #include <grpcpp/impl/codegen/proto_utils.h>
 #include <grpcpp/impl/codegen/rpc_method.h>
 #include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_context.h>
 #include <grpcpp/impl/codegen/service_type.h>
 #include <grpcpp/impl/codegen/status.h>
 #include <grpcpp/impl/codegen/stub_options.h>
 #include <grpcpp/impl/codegen/sync_stream.h>
 
-namespace grpc {
+namespace grpc_impl {
 class CompletionQueue;
-class Channel;
 class ServerCompletionQueue;
 class ServerContext;
+}  // namespace grpc_impl
+
+namespace grpc {
+namespace experimental {
+template <typename RequestT, typename ResponseT>
+class MessageAllocator;
+}  // namespace experimental
 }  // namespace grpc
 
 namespace milvus {

cpp/src/grpc/gen-status/status.pb.h

 // Generated by the protocol buffer compiler.  DO NOT EDIT!
 // source: status.proto
 
-#ifndef PROTOBUF_INCLUDED_status_2eproto
-#define PROTOBUF_INCLUDED_status_2eproto
+#ifndef GOOGLE_PROTOBUF_INCLUDED_status_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_status_2eproto
 
 #include <limits>
 #include <string>
 
 #include <google/protobuf/port_def.inc>
-#if PROTOBUF_VERSION < 3007000
+#if PROTOBUF_VERSION < 3008000
 #error This file was generated by a newer version of protoc which is
 #error incompatible with your Protocol Buffer headers. Please update
 #error your headers.
 #endif
-#if 3007000 < PROTOBUF_MIN_PROTOC_VERSION
+#if 3008000 < PROTOBUF_MIN_PROTOC_VERSION
 #error This file was generated by an older version of protoc which is
 #error incompatible with your Protocol Buffer headers. Please
 #error regenerate this file with a newer version of protoc.
@@ -27,6 +27,7 @@
 #include <google/protobuf/generated_message_util.h>
 #include <google/protobuf/inlined_string_field.h>
 #include <google/protobuf/metadata.h>
+#include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
 #include <google/protobuf/extension_set.h>  // IWYU pragma: export
@@ -35,20 +36,25 @@
 // @@protoc_insertion_point(includes)
 #include <google/protobuf/port_def.inc>
 #define PROTOBUF_INTERNAL_EXPORT_status_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
 
 // Internal implementation detail -- do not use these members.
 struct TableStruct_status_2eproto {
-  static const ::google::protobuf::internal::ParseTableField entries[]
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::google::protobuf::internal::AuxillaryParseTableField aux[]
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::google::protobuf::internal::ParseTable schema[1]
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
-  static const ::google::protobuf::internal::SerializationTable serialization_table[];
-  static const ::google::protobuf::uint32 offsets[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
 };
-void AddDescriptors_status_2eproto();
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_status_2eproto;
 namespace milvus {
 namespace grpc {
 class Status;
@@ -56,15 +62,13 @@ class StatusDefaultTypeInternal;
 extern StatusDefaultTypeInternal _Status_default_instance_;
 }  // namespace grpc
 }  // namespace milvus
-namespace google {
-namespace protobuf {
+PROTOBUF_NAMESPACE_OPEN
 template<> ::milvus::grpc::Status* Arena::CreateMaybeMessage<::milvus::grpc::Status>(Arena*);
-}  // namespace protobuf
-}  // namespace google
+PROTOBUF_NAMESPACE_CLOSE
 namespace milvus {
 namespace grpc {
 
-enum ErrorCode {
+enum ErrorCode : int {
   SUCCESS = 0,
   UNEXPECTED_ERROR = 1,
   CONNECT_FAILED = 2,
@@ -87,44 +91,46 @@ enum ErrorCode {
   CANNOT_DELETE_FOLDER = 19,
   CANNOT_DELETE_FILE = 20,
   BUILD_INDEX_ERROR = 21,
-  ErrorCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::min(),
-  ErrorCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::max()
+  ErrorCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  ErrorCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
 };
 bool ErrorCode_IsValid(int value);
-const ErrorCode ErrorCode_MIN = SUCCESS;
-const ErrorCode ErrorCode_MAX = BUILD_INDEX_ERROR;
-const int ErrorCode_ARRAYSIZE = ErrorCode_MAX + 1;
-
-const ::google::protobuf::EnumDescriptor* ErrorCode_descriptor();
-inline const ::std::string& ErrorCode_Name(ErrorCode value) {
-  return ::google::protobuf::internal::NameOfEnum(
-    ErrorCode_descriptor(), value);
+constexpr ErrorCode ErrorCode_MIN = SUCCESS;
+constexpr ErrorCode ErrorCode_MAX = BUILD_INDEX_ERROR;
+constexpr int ErrorCode_ARRAYSIZE = ErrorCode_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ErrorCode_descriptor();
+template<typename T>
+inline const std::string& ErrorCode_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ErrorCode>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ErrorCode_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ErrorCode_descriptor(), enum_t_value);
 }
 inline bool ErrorCode_Parse(
-    const ::std::string& name, ErrorCode* value) {
-  return ::google::protobuf::internal::ParseNamedEnum<ErrorCode>(
+    const std::string& name, ErrorCode* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ErrorCode>(
     ErrorCode_descriptor(), name, value);
 }
 // ===================================================================
 
-class Status final :
-    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Status) */ {
+class Status :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Status) */ {
  public:
   Status();
   virtual ~Status();
 
   Status(const Status& from);
-
-  inline Status& operator=(const Status& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  #if LANG_CXX11
   Status(Status&& from) noexcept
     : Status() {
     *this = ::std::move(from);
   }
 
+  inline Status& operator=(const Status& from) {
+    CopyFrom(from);
+    return *this;
+  }
   inline Status& operator=(Status&& from) noexcept {
     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
       if (this != &from) InternalSwap(&from);
@@ -133,9 +139,15 @@ class Status final :
     }
     return *this;
   }
-  #endif
-  static const ::google::protobuf::Descriptor* descriptor() {
-    return default_instance().GetDescriptor();
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
   }
   static const Status& default_instance();
 
@@ -158,11 +170,11 @@ class Status final :
     return CreateMaybeMessage<Status>(nullptr);
   }
 
-  Status* New(::google::protobuf::Arena* arena) const final {
+  Status* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
     return CreateMaybeMessage<Status>(arena);
   }
-  void CopyFrom(const ::google::protobuf::Message& from) final;
-  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
   void CopyFrom(const Status& from);
   void MergeFrom(const Status& from);
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
@@ -170,25 +182,28 @@ class Status final :
 
   size_t ByteSizeLong() const final;
   #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
-  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
-  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
   #else
   bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input) final;
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
   #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
   void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const final;
-  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
-      ::google::protobuf::uint8* target) const final;
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
   int GetCachedSize() const final { return _cached_size_.Get(); }
 
   private:
-  void SharedCtor();
-  void SharedDtor();
+  inline void SharedCtor();
+  inline void SharedDtor();
   void SetCachedSize(int size) const final;
   void InternalSwap(Status* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.Status";
+  }
   private:
-  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
     return nullptr;
   }
   inline void* MaybeArenaPtr() const {
@@ -196,7 +211,14 @@ class Status final :
   }
   public:
 
-  ::google::protobuf::Metadata GetMetadata() const final;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_status_2eproto);
+    return ::descriptor_table_status_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
 
   // nested types ----------------------------------------------------
 
@@ -205,16 +227,14 @@ class Status final :
   // string reason = 2;
   void clear_reason();
   static const int kReasonFieldNumber = 2;
-  const ::std::string& reason() const;
-  void set_reason(const ::std::string& value);
-  #if LANG_CXX11
-  void set_reason(::std::string&& value);
-  #endif
+  const std::string& reason() const;
+  void set_reason(const std::string& value);
+  void set_reason(std::string&& value);
   void set_reason(const char* value);
   void set_reason(const char* value, size_t size);
-  ::std::string* mutable_reason();
-  ::std::string* release_reason();
-  void set_allocated_reason(::std::string* reason);
+  std::string* mutable_reason();
+  std::string* release_reason();
+  void set_allocated_reason(std::string* reason);
 
   // .milvus.grpc.ErrorCode error_code = 1;
   void clear_error_code();
@@ -226,10 +246,10 @@ class Status final :
  private:
   class HasBitSetters;
 
-  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
-  ::google::protobuf::internal::ArenaStringPtr reason_;
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reason_;
   int error_code_;
-  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   friend struct ::TableStruct_status_2eproto;
 };
 // ===================================================================
@@ -259,54 +279,52 @@ inline void Status::set_error_code(::milvus::grpc::ErrorCode value) {
 
 // string reason = 2;
 inline void Status::clear_reason() {
-  reason_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  reason_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 }
-inline const ::std::string& Status::reason() const {
+inline const std::string& Status::reason() const {
   // @@protoc_insertion_point(field_get:milvus.grpc.Status.reason)
   return reason_.GetNoArena();
 }
-inline void Status::set_reason(const ::std::string& value) {
+inline void Status::set_reason(const std::string& value) {
   
-  reason_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
   // @@protoc_insertion_point(field_set:milvus.grpc.Status.reason)
 }
-#if LANG_CXX11
-inline void Status::set_reason(::std::string&& value) {
+inline void Status::set_reason(std::string&& value) {
   
   reason_.SetNoArena(
-    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
   // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Status.reason)
 }
-#endif
 inline void Status::set_reason(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   
-  reason_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
   // @@protoc_insertion_point(field_set_char:milvus.grpc.Status.reason)
 }
 inline void Status::set_reason(const char* value, size_t size) {
   
-  reason_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+  reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
       ::std::string(reinterpret_cast<const char*>(value), size));
   // @@protoc_insertion_point(field_set_pointer:milvus.grpc.Status.reason)
 }
-inline ::std::string* Status::mutable_reason() {
+inline std::string* Status::mutable_reason() {
   
   // @@protoc_insertion_point(field_mutable:milvus.grpc.Status.reason)
-  return reason_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  return reason_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 }
-inline ::std::string* Status::release_reason() {
+inline std::string* Status::release_reason() {
   // @@protoc_insertion_point(field_release:milvus.grpc.Status.reason)
   
-  return reason_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  return reason_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 }
-inline void Status::set_allocated_reason(::std::string* reason) {
+inline void Status::set_allocated_reason(std::string* reason) {
   if (reason != nullptr) {
     
   } else {
     
   }
-  reason_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reason);
+  reason_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), reason);
   // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Status.reason)
 }
 
@@ -319,8 +337,7 @@ inline void Status::set_allocated_reason(::std::string* reason) {
 }  // namespace grpc
 }  // namespace milvus
 
-namespace google {
-namespace protobuf {
+PROTOBUF_NAMESPACE_OPEN
 
 template <> struct is_proto_enum< ::milvus::grpc::ErrorCode> : ::std::true_type {};
 template <>
@@ -328,10 +345,9 @@ inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::ErrorCode>() {
   return ::milvus::grpc::ErrorCode_descriptor();
 }
 
-}  // namespace protobuf
-}  // namespace google
+PROTOBUF_NAMESPACE_CLOSE
 
 // @@protoc_insertion_point(global_scope)
 
 #include <google/protobuf/port_undef.inc>
-#endif  // PROTOBUF_INCLUDED_status_2eproto
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_status_2eproto

cpp/src/sdk/CMakeLists.txt

@@ -33,6 +33,7 @@ if (MILVUS_ENABLE_THRIFT STREQUAL "ON")
     target_link_libraries(milvus_thrift_sdk
             ${third_party_libs}
             )
+    install(TARGETS milvus_thrift_sdk DESTINATION lib)
 else()
     aux_source_directory(grpc grpc_client_files)
 
@@ -56,12 +57,6 @@ else()
     target_link_libraries(milvus_grpc_sdk
             ${third_party_libs}
             )
-
-endif()
-
-if (MILVUS_ENABLE_THRIFT STREQUAL "ON")
-    install(TARGETS milvus_thrift_sdk DESTINATION lib)
-else()
     install(TARGETS milvus_grpc_sdk DESTINATION lib)
 endif()
 

cpp/src/sdk/examples/CMakeLists.txt

@@ -4,5 +4,8 @@
 # Proprietary and confidential.
 #-------------------------------------------------------------------------------
 
-add_subdirectory(thriftsimple)
-add_subdirectory(grpcsimple)
\ No newline at end of file
+if (MILVUS_ENABLE_THRIFT STREQUAL "ON")
+    add_subdirectory(thriftsimple)
+else()
+    add_subdirectory(grpcsimple)
+endif()
\ No newline at end of file

cpp/src/sdk/examples/grpcsimple/src/ClientTest.cpp

@@ -17,14 +17,14 @@ using namespace milvus;
 namespace {
     std::string GetTableName();
 
-    static const std::string TABLE_NAME = GetTableName();
-    static constexpr int64_t TABLE_DIMENSION = 512;
-    static constexpr int64_t BATCH_ROW_COUNT = 100000;
-    static constexpr int64_t NQ = 10;
-    static constexpr int64_t TOP_K = 10;
-    static constexpr int64_t SEARCH_TARGET = 5000; //change this value, result is different
-    static constexpr int64_t ADD_VECTOR_LOOP = 5;
-    static constexpr int64_t SECONDS_EACH_HOUR = 3600;
+    const std::string TABLE_NAME = GetTableName();
+    constexpr int64_t TABLE_DIMENSION = 512;
+    constexpr int64_t BATCH_ROW_COUNT = 100000;
+    constexpr int64_t NQ = 10;
+    constexpr int64_t TOP_K = 10;
+    constexpr int64_t SEARCH_TARGET = 5000; //change this value, result is different
+    constexpr int64_t ADD_VECTOR_LOOP = 5;
+    constexpr int64_t SECONDS_EACH_HOUR = 3600;
 
 #define BLOCK_SPLITER std::cout << "===========================================" << std::endl;
 
@@ -124,7 +124,7 @@ namespace {
 
     class TimeRecorder {
     public:
-        TimeRecorder(const std::string& title)
+        explicit TimeRecorder(const std::string& title)
                 : title_(title) {
             start_ = std::chrono::system_clock::now();
         }

cpp/src/sdk/examples/thriftsimple/src/ClientTest.cpp

@@ -17,13 +17,13 @@ namespace {
     std::string GetTableName();
 
     static const std::string TABLE_NAME = GetTableName();
-    static constexpr int64_t TABLE_DIMENSION = 512;
-    static constexpr int64_t BATCH_ROW_COUNT = 100000;
-    static constexpr int64_t NQ = 10;
-    static constexpr int64_t TOP_K = 10;
-    static constexpr int64_t SEARCH_TARGET = 5000; //change this value, result is different
-    static constexpr int64_t ADD_VECTOR_LOOP = 10;
-    static constexpr int64_t SECONDS_EACH_HOUR = 3600;
+    constexpr int64_t TABLE_DIMENSION = 512;
+    constexpr int64_t BATCH_ROW_COUNT = 100000;
+    constexpr int64_t NQ = 10;
+    constexpr int64_t TOP_K = 10;
+    constexpr int64_t SEARCH_TARGET = 5000; //change this value, result is different
+    constexpr int64_t ADD_VECTOR_LOOP = 10;
+    constexpr int64_t SECONDS_EACH_HOUR = 3600;
 
 #define BLOCK_SPLITER std::cout << "===========================================" << std::endl;
 

cpp/src/sdk/thrift/ThriftClient.h

@@ -14,9 +14,9 @@ namespace milvus {
 
 using ServiceClientPtr = std::shared_ptr<::milvus::thrift::MilvusServiceClient>;
 
-static const std::string THRIFT_PROTOCOL_JSON = "json";
-static const std::string THRIFT_PROTOCOL_BINARY = "binary";
-static const std::string THRIFT_PROTOCOL_COMPACT = "compact";
+static const char* THRIFT_PROTOCOL_JSON = "json";
+static const char* THRIFT_PROTOCOL_BINARY = "binary";
+static const char* THRIFT_PROTOCOL_COMPACT = "compact";
 
 class ThriftClient {
 public:

cpp/src/server/ServerConfig.h

@@ -14,45 +14,45 @@ namespace zilliz {
 namespace milvus {
 namespace server {
 
-static const std::string CONFIG_SERVER = "server_config";
-static const std::string CONFIG_SERVER_ADDRESS = "address";
-static const std::string CONFIG_SERVER_PORT = "port";
-static const std::string CONFIG_SERVER_PROTOCOL = "transfer_protocol";
-static const std::string CONFIG_CLUSTER_MODE = "mode";
-static const std::string CONFIG_GPU_INDEX = "gpu_index";
+static const char* CONFIG_SERVER = "server_config";
+static const char* CONFIG_SERVER_ADDRESS = "address";
+static const char* CONFIG_SERVER_PORT = "port";
+static const char* CONFIG_SERVER_PROTOCOL = "transfer_protocol";
+static const char* CONFIG_CLUSTER_MODE = "mode";
+static const char* CONFIG_GPU_INDEX = "gpu_index";
 
-static const std::string CONFIG_DB = "db_config";
-static const std::string CONFIG_DB_URL = "db_backend_url";
-static const std::string CONFIG_DB_PATH = "db_path";
-static const std::string CONFIG_DB_SLAVE_PATH = "db_slave_path";
-static const std::string CONFIG_DB_INDEX_TRIGGER_SIZE = "index_building_threshold";
-static const std::string CONFIG_DB_ARCHIVE_DISK = "archive_disk_threshold";
-static const std::string CONFIG_DB_ARCHIVE_DAYS = "archive_days_threshold";
-static const std::string CONFIG_DB_INSERT_BUFFER_SIZE = "insert_buffer_size";
-static const std::string CONFIG_DB_PARALLEL_REDUCE = "parallel_reduce";
+static const char* CONFIG_DB = "db_config";
+static const char* CONFIG_DB_URL = "db_backend_url";
+static const char* CONFIG_DB_PATH = "db_path";
+static const char* CONFIG_DB_SLAVE_PATH = "db_slave_path";
+static const char* CONFIG_DB_INDEX_TRIGGER_SIZE = "index_building_threshold";
+static const char* CONFIG_DB_ARCHIVE_DISK = "archive_disk_threshold";
+static const char* CONFIG_DB_ARCHIVE_DAYS = "archive_days_threshold";
+static const char* CONFIG_DB_INSERT_BUFFER_SIZE = "insert_buffer_size";
+static const char* CONFIG_DB_PARALLEL_REDUCE = "parallel_reduce";
 
-static const std::string CONFIG_LOG = "log_config";
+static const char* CONFIG_LOG = "log_config";
 
-static const std::string CONFIG_CACHE = "cache_config";
-static const std::string CONFIG_CPU_CACHE_CAPACITY = "cpu_cache_capacity";
-static const std::string CONFIG_GPU_CACHE_CAPACITY = "gpu_cache_capacity";
-static const std::string CACHE_FREE_PERCENT = "cache_free_percent";
-static const std::string CONFIG_INSERT_CACHE_IMMEDIATELY = "insert_cache_immediately";
+static const char* CONFIG_CACHE = "cache_config";
+static const char* CONFIG_CPU_CACHE_CAPACITY = "cpu_cache_capacity";
+static const char* CONFIG_GPU_CACHE_CAPACITY = "gpu_cache_capacity";
+static const char* CACHE_FREE_PERCENT = "cache_free_percent";
+static const char* CONFIG_INSERT_CACHE_IMMEDIATELY = "insert_cache_immediately";
 
-static const std::string CONFIG_LICENSE = "license_config";
-static const std::string CONFIG_LICENSE_PATH = "license_path";
+static const char* CONFIG_LICENSE = "license_config";
+static const char* CONFIG_LICENSE_PATH = "license_path";
 
-static const std::string CONFIG_METRIC = "metric_config";
-static const std::string CONFIG_METRIC_IS_STARTUP = "is_startup";
-static const std::string CONFIG_METRIC_COLLECTOR = "collector";
-static const std::string CONFIG_PROMETHEUS = "prometheus_config";
-static const std::string CONFIG_METRIC_PROMETHEUS_PORT = "port";
+static const char* CONFIG_METRIC = "metric_config";
+static const char* CONFIG_METRIC_IS_STARTUP = "is_startup";
+static const char* CONFIG_METRIC_COLLECTOR = "collector";
+static const char* CONFIG_PROMETHEUS = "prometheus_config";
+static const char* CONFIG_METRIC_PROMETHEUS_PORT = "port";
 
-static const std::string CONFIG_ENGINE = "engine_config";
-static const std::string CONFIG_NPROBE = "nprobe";
-static const std::string CONFIG_NLIST = "nlist";
-static const std::string CONFIG_DCBT = "use_blas_threshold";
-static const std::string CONFIG_METRICTYPE = "metric_type";
+static const char* CONFIG_ENGINE = "engine_config";
+static const char* CONFIG_NPROBE = "nprobe";
+static const char* CONFIG_NLIST = "nlist";
+static const char* CONFIG_DCBT = "use_blas_threshold";
+static const char* CONFIG_METRICTYPE = "metric_type";
 
 class ServerConfig {
  public:

cpp/src/server/thrift_impl/RequestTask.cpp

@@ -22,9 +22,9 @@ namespace server {
 
 using namespace ::milvus;
 
-static const std::string DQL_TASK_GROUP = "dql";
-static const std::string DDL_DML_TASK_GROUP = "ddl_dml";
-static const std::string PING_TASK_GROUP = "ping";
+static const char* DQL_TASK_GROUP = "dql";
+static const char* DDL_DML_TASK_GROUP = "ddl_dml";
+static const char* PING_TASK_GROUP = "ping";
 
 using DB_META = zilliz::milvus::engine::meta::Meta;
 using DB_DATE = zilliz::milvus::engine::meta::DateT;

cpp/unittest/db/db_tests.cpp

@@ -21,7 +21,7 @@ using namespace zilliz::milvus;
 
 namespace {
 
-    static const std::string TABLE_NAME = "test_group";
+    static const char* TABLE_NAME = "test_group";
     static constexpr int64_t TABLE_DIM = 256;
     static constexpr int64_t VECTOR_COUNT = 250000;
     static constexpr int64_t INSERT_LOOP = 10000;

cpp/unittest/db/mem_test.cpp

@@ -21,7 +21,7 @@ using namespace zilliz::milvus;
 
 namespace {
 
-static const std::string TABLE_NAME = "test_group";
+static const char* TABLE_NAME = "test_group";
 static constexpr int64_t TABLE_DIM = 256;
 static constexpr int64_t VECTOR_COUNT = 250000;
 static constexpr int64_t INSERT_LOOP = 10000;

cpp/unittest/db/mysql_db_test.cpp

@@ -20,7 +20,7 @@ using namespace zilliz::milvus;
 
 namespace {
 
-    static const std::string TABLE_NAME = "test_group";
+    static const char* TABLE_NAME = "test_group";
     static constexpr int64_t TABLE_DIM = 256;
     static constexpr int64_t VECTOR_COUNT = 250000;
     static constexpr int64_t INSERT_LOOP = 10000;

cpp/unittest/metrics/metrics_test.cpp

@@ -35,7 +35,7 @@ TEST_F(MetricTest, Metric_Tes) {
     zilliz::milvus::cache::CpuCacheMgr::GetInstance()->SetCapacity(1UL*1024*1024*1024);
     std::cout<<zilliz::milvus::cache::CpuCacheMgr::GetInstance()->CacheCapacity()<<std::endl;
 
-    static const std::string group_name = "test_group";
+    static const char* group_name = "test_group";
     static const int group_dim = 256;
 
     engine::meta::TableSchema group_info;

cpp/unittest/server/config_test.cpp

@@ -12,8 +12,8 @@ using namespace zilliz::milvus;
 
 namespace {
 
-static const std::string CONFIG_FILE_PATH = "./milvus/conf/server_config.yaml";
-static const std::string LOG_FILE_PATH = "./milvus/conf/log_config.conf";
+static const char* CONFIG_FILE_PATH = "./milvus/conf/server_config.yaml";
+static const char* LOG_FILE_PATH = "./milvus/conf/log_config.conf";
 
 }
 

cpp/unittest/server/util_test.cpp

@@ -17,7 +17,7 @@ using namespace zilliz::milvus;
 
 namespace {
 
-static const std::string LOG_FILE_PATH = "./milvus/conf/log_config.conf";
+static const char* LOG_FILE_PATH = "./milvus/conf/log_config.conf";
 
 }