Merge branch 'branch-0.4.0' into 'branch-0.4.0'

MS-313: add GRPC

See merge request megasearch/milvus!311

Former-commit-id: d488459184731d5c12599d1ecd5f3774b747ae69

cpp/CHANGELOG.md

@@ -51,6 +51,9 @@ Please mark all change in change log and use the ticket from JIRA.
 - MS-261 - Update faiss version to 1.5.3 and add BUILD_FAISS_WITH_MKL as an option
 - MS-266 - Improve topk reduce time by using multi-threads
 - MS-275 - Avoid sqlite logic error excetion
+- MS-278 - add IndexStatsHelper
+- MS-313 - add GRPC
+- MS-325 - add grpc status return for C++ sdk and modify some format
 - MS-278 - Add IndexStatsHelper
 - MS-312 - Set openmp thread number by config
 - MS-305 - Add CPU core percent metric

cpp/build.sh

@@ -11,6 +11,7 @@ PROFILING="OFF"
 BUILD_FAISS_WITH_MKL="OFF"
 USE_JFROG_CACHE="OFF"
 KNOWHERE_OPTS=""
+MILVUS_WITH_THRIFT="OFF"
 
 while getopts "p:d:t:uhlrcgmj" arg
 do
@@ -50,6 +51,9 @@ do
                 USE_JFROG_CACHE="ON"
                 KNOWHERE_OPTS="${KNOWHERE_OPTS} -j"
                 ;;
+             e)
+                MILVUS_WITH_THRIFT="ON"
+                ;;
              h) # help
                 echo "
 
@@ -64,6 +68,7 @@ parameter:
 -g: profiling(default: OFF)
 -m: build faiss with MKL(default: OFF)
 -j: use jfrog cache build directory
+-e: enable thrift
 
 usage:
 ./build.sh -t \${BUILD_TYPE} [-u] [-h] [-g] [-r] [-c] [-m] [-j]
@@ -102,6 +107,7 @@ if [[ ${MAKE_CLEAN} == "ON" ]]; then
     -DMILVUS_DB_PATH=${DB_PATH} \
     -DMILVUS_ENABLE_PROFILING=${PROFILING} \
     -DBUILD_FAISS_WITH_MKL=${BUILD_FAISS_WITH_MKL} \
+    -DMILVUS_WITH_THRIFT=${MILVUS_WITH_THRIFT} \
     -DKNOWHERE_BUILD_DIR=${KNOWHERE_BUILD_DIR} \
     -DUSE_JFROG_CACHE=${USE_JFROG_CACHE} \
     $@ ../"

cpp/cmake/DefineOptions.cmake

@@ -90,7 +90,7 @@ define_option(MILVUS_WITH_SQLITE_ORM "Build with SQLite ORM library" ON)
 
 define_option(MILVUS_WITH_MYSQLPP "Build with MySQL++" ON)
 
-define_option(MILVUS_WITH_THRIFT "Build with Apache Thrift library" ON)
+define_option(MILVUS_WITH_THRIFT "Build with Apache Thrift library" OFF)
 
 define_option(MILVUS_WITH_YAMLCPP "Build with yaml-cpp library" ON)
 

cpp/cmake/ThirdPartyPackages.cmake

@@ -39,7 +39,8 @@ set(MILVUS_THIRDPARTY_DEPENDENCIES
         ZSTD
         AWS
         libunwind
-        gperftools)
+        gperftools
+        GRPC)
 
 message(STATUS "Using ${MILVUS_DEPENDENCY_SOURCE} approach to find dependencies")
 
@@ -97,6 +98,8 @@ macro(build_dependency DEPENDENCY_NAME)
         build_libunwind()
     elseif("${DEPENDENCY_NAME}" STREQUAL "gperftools")
         build_gperftools()
+    elseif("${DEPENDENCY_NAME}" STREQUAL "GRPC")
+        build_grpc()
     else()
         message(FATAL_ERROR "Unknown thirdparty dependency to build: ${DEPENDENCY_NAME}")
     endif ()
@@ -451,6 +454,13 @@ else()
 endif()
 set(GPERFTOOLS_MD5 "c6a852a817e9160c79bdb2d3101b4601")
 
+if(DEFINED ENV{MILVUS_GRPC_URL})
+    set(GRPC_SOURCE_URL "$ENV{MILVUS_GRPC_URL}")
+else()
+    set(GRPC_SOURCE_URL
+            "http://git.zilliz.tech/kun.yu/grpc/-/archive/master/grpc-master.tar.gz")
+endif()
+
 # ----------------------------------------------------------------------
 # ARROW
 
@@ -2480,7 +2490,6 @@ endmacro()
 if(MILVUS_WITH_LIBUNWIND)
     resolve_dependency(libunwind)
 
-    # TODO: Don't use global includes but rather target_include_directories
     get_target_property(LIBUNWIND_INCLUDE_DIR libunwind INTERFACE_INCLUDE_DIRECTORIES)
     include_directories(SYSTEM ${LIBUNWIND_INCLUDE_DIR})
 endif()
@@ -2546,8 +2555,6 @@ macro(build_gperftools)
                 ${GPERFTOOLS_STATIC_LIB})
     endif()
 
-    ExternalProject_Add_StepDependencies(gperftools_ep build libunwind_ep)
-
     file(MAKE_DIRECTORY "${GPERFTOOLS_INCLUDE_DIR}")
 
     add_library(gperftools STATIC IMPORTED)
@@ -2563,8 +2570,85 @@ endmacro()
 if(MILVUS_WITH_GPERFTOOLS)
     resolve_dependency(gperftools)
 
-    # TODO: Don't use global includes but rather target_include_directories
     get_target_property(GPERFTOOLS_INCLUDE_DIR gperftools INTERFACE_INCLUDE_DIRECTORIES)
     include_directories(SYSTEM ${GPERFTOOLS_INCLUDE_DIR})
     link_directories(SYSTEM ${GPERFTOOLS_PREFIX}/lib)
 endif()
+
+# ----------------------------------------------------------------------
+# GRPC
+
+macro(build_grpc)
+    message(STATUS "Building GRPC-${GRPC_VERSION} from source")
+    set(GRPC_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/grpc_ep-prefix/src/grpc_ep/install")
+    set(GRPC_INCLUDE_DIR "${GRPC_PREFIX}/include")
+    set(GRPC_STATIC_LIB "${GRPC_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}grpc${CMAKE_STATIC_LIBRARY_SUFFIX}")
+    set(GRPC++_STATIC_LIB "${GRPC_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}grpc++${CMAKE_STATIC_LIBRARY_SUFFIX}")
+    set(GRPCPP_CHANNELZ_STATIC_LIB "${GRPC_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}grpcpp_channelz${CMAKE_STATIC_LIBRARY_SUFFIX}")
+    set(GRPC_PROTOBUF_LIB_DIR "${CMAKE_CURRENT_BINARY_DIR}/grpc_ep-prefix/src/grpc_ep/libs/opt/protobuf")
+    set(GRPC_PROTOBUF_STATIC_LIB "${GRPC_PROTOBUF_LIB_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}protobuf${CMAKE_STATIC_LIBRARY_SUFFIX}")
+    set(GRPC_PROTOC_STATIC_LIB "${GRPC_PROTOBUF_LIB_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}protoc${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+    externalproject_add(grpc_ep
+            URL
+            ${GRPC_SOURCE_URL}
+            ${EP_LOG_OPTIONS}
+            CONFIGURE_COMMAND
+            ""
+            BUILD_IN_SOURCE
+            1
+            BUILD_COMMAND
+            ${MAKE} ${MAKE_BUILD_ARGS} prefix=${GRPC_PREFIX}
+            INSTALL_COMMAND
+            ${MAKE} install prefix=${GRPC_PREFIX}
+            BUILD_BYPRODUCTS
+            ${GRPC_STATIC_LIB}
+            ${GRPC++_STATIC_LIB}
+            ${GRPCPP_CHANNELZ_STATIC_LIB}
+            ${GRPC_PROTOBUF_STATIC_LIB}
+            ${GRPC_PROTOC_STATIC_LIB})
+
+    file(MAKE_DIRECTORY "${GRPC_INCLUDE_DIR}")
+
+    add_library(grpc STATIC IMPORTED)
+    set_target_properties(grpc
+            PROPERTIES IMPORTED_LOCATION "${GRPC_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${GRPC_INCLUDE_DIR}")
+
+    add_library(grpc++ STATIC IMPORTED)
+    set_target_properties(grpc++
+            PROPERTIES IMPORTED_LOCATION "${GRPC++_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${GRPC_INCLUDE_DIR}")
+
+    add_library(grpcpp_channelz STATIC IMPORTED)
+    set_target_properties(grpcpp_channelz
+            PROPERTIES IMPORTED_LOCATION "${GRPCPP_CHANNELZ_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${GRPC_INCLUDE_DIR}")
+
+    add_library(grpc_protobuf STATIC IMPORTED)
+    set_target_properties(grpc_protobuf
+            PROPERTIES IMPORTED_LOCATION "${GRPC_PROTOBUF_STATIC_LIB}")
+
+    add_library(grpc_protoc STATIC IMPORTED)
+    set_target_properties(grpc_protoc
+            PROPERTIES IMPORTED_LOCATION "${GRPC_PROTOC_STATIC_LIB}")
+
+    add_dependencies(grpc grpc_ep)
+    add_dependencies(grpc++ grpc_ep)
+    add_dependencies(grpcpp_channelz grpc_ep)
+    add_dependencies(grpc_protobuf grpc_ep)
+    add_dependencies(grpc_protoc grpc_ep)
+endmacro()
+
+if(NOT MILVUS_WITH_THRIFT STREQUAL "ON")
+    resolve_dependency(GRPC)
+
+    get_target_property(GRPC_INCLUDE_DIR grpc INTERFACE_INCLUDE_DIRECTORIES)
+    include_directories(SYSTEM ${GRPC_INCLUDE_DIR})
+    link_directories(SYSTEM ${GRPC_PREFIX}/lib)
+
+    set(GRPC_THIRD_PARTY_DIR ${CMAKE_CURRENT_BINARY_DIR}/grpc_ep-prefix/src/grpc_ep/third_party)
+    include_directories(SYSTEM ${GRPC_THIRD_PARTY_DIR}/protobuf/src)
+    link_directories(SYSTEM ${GRPC_PROTOBUF_LIB_DIR})
+
+endif()

cpp/src/CMakeLists.txt

@@ -8,6 +8,8 @@
 aux_source_directory(cache cache_files)
 aux_source_directory(config config_files)
 aux_source_directory(server server_files)
+aux_source_directory(server/grpc_impl grpcserver_files)
+aux_source_directory(server/thrift_impl thriftserver_files)
 aux_source_directory(utils utils_files)
 aux_source_directory(db db_main_files)
 aux_source_directory(db/engine db_engine_files)
@@ -24,15 +26,33 @@ set(db_scheduler_files
         ${scheduler_context_files}
         ${scheduler_task_files}
         )
+set(license_check_files
+        license/LicenseLibrary.cpp
+        license/LicenseCheck.cpp
+        )
+
+set(license_generator_files
+        license/LicenseGenerator.cpp
+        license/LicenseLibrary.cpp
+        )
 
-set(service_files
+set(thrift_service_files
         thrift/gen-cpp/MilvusService.cpp
         thrift/gen-cpp/milvus_constants.cpp
         thrift/gen-cpp/milvus_types.cpp
         metrics/SystemInfo.cpp
         metrics/SystemInfo.h
-        server/ThreadPoolServer.cpp
-        server/ThreadPoolServer.h
+        server/thrift_impl/ThreadPoolServer.cpp
+        server/thrift_impl/ThreadPoolServer.h
+        )
+
+set(grpc_service_files
+        metrics/SystemInfo.cpp
+        metrics/SystemInfo.h
+        grpc/gen-milvus/milvus.grpc.pb.cc
+        grpc/gen-milvus/milvus.pb.cc
+        grpc/gen-status/status.grpc.pb.cc
+        grpc/gen-status/status.pb.cc
         )
 
 set(db_files
@@ -55,6 +75,20 @@ include_directories(/usr/include)
 include_directories("${CUDA_TOOLKIT_ROOT_DIR}/include")
 include_directories(thrift/gen-cpp)
 include_directories(/usr/include/mysql)
+include_directories(grpc/gen-status)
+include_directories(grpc/gen-milvus)
+
+if (MILVUS_WITH_THRIFT STREQUAL "ON")
+    set(client_lib
+            thrift)
+else()
+    set(client_lib
+            grpcpp_channelz
+            grpc++
+            grpc
+            grpc_protobuf
+            grpc_protoc)
+endif()
 
 set(third_party_libs
         knowhere
@@ -66,7 +100,7 @@ set(third_party_libs
         lapack
         easyloggingpp
         sqlite
-        thrift
+        ${client_lib}
         yaml-cpp
         prometheus-cpp-push
         prometheus-cpp-pull
@@ -163,22 +197,52 @@ set(knowhere_libs
         tbb
         )
 
-add_executable(milvus_server
-        ${config_files}
-        ${server_files}
-        ${utils_files}
-        ${service_files}
-        ${metrics_files}
-        )
+if (MILVUS_WITH_THRIFT STREQUAL "ON")
+    add_executable(milvus_thrift_server
+            ${config_files}
+            ${server_files}
+            ${thriftserver_files}
+            ${utils_files}
+            ${thrift_service_files}
+            ${metrics_files}
+            )
+else()
+    add_executable(milvus_grpc_server
+            ${config_files}
+            ${server_files}
+            ${grpcserver_files}
+            ${utils_files}
+            ${grpc_service_files}
+            ${metrics_files}
+            )
+endif()
 
+if (ENABLE_LICENSE STREQUAL "ON")
+	add_executable(get_sys_info ${get_sys_info_files})
+	add_executable(license_generator ${license_generator_files})
+
+	target_link_libraries(get_sys_info ${license_libs} license_check ${third_party_libs})
+	target_link_libraries(license_generator ${license_libs} ${third_party_libs})
+
+    if(MILVUS_WITH_THRIFT STREQUAL "ON")
+        target_link_libraries(milvus_thrift_server ${server_libs} license_check ${knowhere_libs} ${third_party_libs})
+    else()
+        target_link_libraries(milvus_grpc_server ${server_libs} license_check ${knowhere_libs} ${third_party_libs})
+    endif()
+else ()
+    if(MILVUS_WITH_THRIFT STREQUAL "ON")
+        target_link_libraries(milvus_thrift_server ${server_libs} ${knowhere_libs} ${third_party_libs})
+    else()
+        target_link_libraries(milvus_grpc_server ${server_libs} ${knowhere_libs} ${third_party_libs})
+    endif()
 
-target_link_libraries(milvus_server
-        ${server_libs}
-        ${third_party_libs}
-        ${knowhere_libs}
-        )
+endif()
 
-install(TARGETS milvus_server DESTINATION bin)
+if (MILVUS_WITH_THRIFT STREQUAL "ON")
+    install(TARGETS milvus_thrift_server DESTINATION bin)
+else()
+    install(TARGETS milvus_grpc_server DESTINATION bin)
+endif()
 
 install(FILES
         ${KNOWHERE_BUILD_DIR}/lib/${CMAKE_SHARED_LIBRARY_PREFIX}tbb${CMAKE_SHARED_LIBRARY_SUFFIX}

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/cpp_gen.sh

+#!/bin/bash
+
+protoc -I . --grpc_out=./gen-status --plugin=protoc-gen-grpc=`which grpc_cpp_plugin` status.proto
+
+protoc -I . --cpp_out=./gen-status status.proto
+
+protoc -I . --grpc_out=./gen-milvus --plugin=protoc-gen-grpc=`which grpc_cpp_plugin` milvus.proto
+
+protoc -I . --cpp_out=./gen-milvus milvus.proto
\ No newline at end of file

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

+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: status.proto
+
+#include "status.pb.h"
+#include "status.grpc.pb.h"
+
+#include <functional>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+namespace milvus {
+namespace grpc {
+
+}  // namespace milvus
+}  // namespace grpc
+

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

+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: status.proto
+#ifndef GRPC_status_2eproto__INCLUDED
+#define GRPC_status_2eproto__INCLUDED
+
+#include "status.pb.h"
+
+#include <functional>
+#include <grpcpp/impl/codegen/async_generic_service.h>
+#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/completion_queue.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_impl {
+class CompletionQueue;
+class ServerCompletionQueue;
+class ServerContext;
+}  // namespace grpc_impl
+
+namespace grpc {
+namespace experimental {
+template <typename RequestT, typename ResponseT>
+class MessageAllocator;
+}  // namespace experimental
+}  // namespace grpc
+
+namespace milvus {
+namespace grpc {
+
+}  // namespace grpc
+}  // namespace milvus
+
+
+#endif  // GRPC_status_2eproto__INCLUDED

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

+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: status.proto
+
+#include "status.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+namespace milvus {
+namespace grpc {
+class StatusDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Status> _instance;
+} _Status_default_instance_;
+}  // namespace grpc
+}  // namespace milvus
+static void InitDefaultsscc_info_Status_status_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_Status_default_instance_;
+    new (ptr) ::milvus::grpc::Status();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::Status::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Status_status_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Status_status_2eproto}, {}};
+
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_status_2eproto[1];
+static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_status_2eproto[1];
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_status_2eproto = nullptr;
+
+const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_status_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::Status, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::Status, error_code_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::Status, reason_),
+};
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, -1, sizeof(::milvus::grpc::Status)},
+};
+
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_Status_default_instance_),
+};
+
+const char descriptor_table_protodef_status_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\014status.proto\022\013milvus.grpc\"D\n\006Status\022*\n"
+  "\nerror_code\030\001 \001(\0162\026.milvus.grpc.ErrorCod"
+  "e\022\016\n\006reason\030\002 \001(\t*\354\003\n\tErrorCode\022\013\n\007SUCCE"
+  "SS\020\000\022\024\n\020UNEXPECTED_ERROR\020\001\022\022\n\016CONNECT_FA"
+  "ILED\020\002\022\025\n\021PERMISSION_DENIED\020\003\022\024\n\020TABLE_N"
+  "OT_EXISTS\020\004\022\024\n\020ILLEGAL_ARGUMENT\020\005\022\021\n\rILL"
+  "EGAL_RANGE\020\006\022\025\n\021ILLEGAL_DIMENSION\020\007\022\026\n\022I"
+  "LLEGAL_INDEX_TYPE\020\010\022\026\n\022ILLEGAL_TABLE_NAM"
+  "E\020\t\022\020\n\014ILLEGAL_TOPK\020\n\022\025\n\021ILLEGAL_ROWRECO"
+  "RD\020\013\022\025\n\021ILLEGAL_VECTOR_ID\020\014\022\031\n\025ILLEGAL_S"
+  "EARCH_RESULT\020\r\022\022\n\016FILE_NOT_FOUND\020\016\022\017\n\013ME"
+  "TA_FAILED\020\017\022\020\n\014CACHE_FAILED\020\020\022\030\n\024CANNOT_"
+  "CREATE_FOLDER\020\021\022\026\n\022CANNOT_CREATE_FILE\020\022\022"
+  "\030\n\024CANNOT_DELETE_FOLDER\020\023\022\026\n\022CANNOT_DELE"
+  "TE_FILE\020\024\022\025\n\021BUILD_INDEX_ERROR\020\025b\006proto3"
+  ;
+static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_status_2eproto_deps[1] = {
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_status_2eproto_sccs[1] = {
+  &scc_info_Status_status_2eproto.base,
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_status_2eproto_once;
+static bool descriptor_table_status_2eproto_initialized = false;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_status_2eproto = {
+  &descriptor_table_status_2eproto_initialized, descriptor_table_protodef_status_2eproto, "status.proto", 600,
+  &descriptor_table_status_2eproto_once, descriptor_table_status_2eproto_sccs, descriptor_table_status_2eproto_deps, 1, 0,
+  schemas, file_default_instances, TableStruct_status_2eproto::offsets,
+  file_level_metadata_status_2eproto, 1, file_level_enum_descriptors_status_2eproto, file_level_service_descriptors_status_2eproto,
+};
+
+// Force running AddDescriptors() at dynamic initialization time.
+static bool dynamic_init_dummy_status_2eproto = (  ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_status_2eproto), true);
+namespace milvus {
+namespace grpc {
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ErrorCode_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_status_2eproto);
+  return file_level_enum_descriptors_status_2eproto[0];
+}
+bool ErrorCode_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case 8:
+    case 9:
+    case 10:
+    case 11:
+    case 12:
+    case 13:
+    case 14:
+    case 15:
+    case 16:
+    case 17:
+    case 18:
+    case 19:
+    case 20:
+    case 21:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// ===================================================================
+
+void Status::InitAsDefaultInstance() {
+}
+class Status::_Internal {
+ public:
+};
+
+Status::Status()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.Status)
+}
+Status::Status(const Status& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from.reason().empty()) {
+    reason_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.reason_);
+  }
+  error_code_ = from.error_code_;
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.Status)
+}
+
+void Status::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Status_status_2eproto.base);
+  reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  error_code_ = 0;
+}
+
+Status::~Status() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.Status)
+  SharedDtor();
+}
+
+void Status::SharedDtor() {
+  reason_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void Status::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const Status& Status::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Status_status_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void Status::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.Status)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  reason_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  error_code_ = 0;
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* Status::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // .milvus.grpc.ErrorCode error_code = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
+          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+          CHK_(ptr);
+          set_error_code(static_cast<::milvus::grpc::ErrorCode>(val));
+        } else goto handle_unusual;
+        continue;
+      // string reason = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_reason(), ptr, ctx, "milvus.grpc.Status.reason");
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool Status::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.Status)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // .milvus.grpc.ErrorCode error_code = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
+          int value = 0;
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
+                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          set_error_code(static_cast< ::milvus::grpc::ErrorCode >(value));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // string reason = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
+                input, this->mutable_reason()));
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+            this->reason().data(), static_cast<int>(this->reason().length()),
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
+            "milvus.grpc.Status.reason"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.Status)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.Status)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void Status::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.Status)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.ErrorCode error_code = 1;
+  if (this->error_code() != 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
+      1, this->error_code(), output);
+  }
+
+  // string reason = 2;
+  if (this->reason().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->reason().data(), static_cast<int>(this->reason().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.Status.reason");
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->reason(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.Status)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* Status::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.Status)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.ErrorCode error_code = 1;
+  if (this->error_code() != 0) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      1, this->error_code(), target);
+  }
+
+  // string reason = 2;
+  if (this->reason().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->reason().data(), static_cast<int>(this->reason().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.Status.reason");
+    target =
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
+        2, this->reason(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.Status)
+  return target;
+}
+
+size_t Status::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.Status)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string reason = 2;
+  if (this->reason().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->reason());
+  }
+
+  // .milvus.grpc.ErrorCode error_code = 1;
+  if (this->error_code() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->error_code());
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void Status::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.Status)
+  GOOGLE_DCHECK_NE(&from, this);
+  const Status* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Status>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.Status)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.Status)
+    MergeFrom(*source);
+  }
+}
+
+void Status::MergeFrom(const Status& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.Status)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.reason().size() > 0) {
+
+    reason_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.reason_);
+  }
+  if (from.error_code() != 0) {
+    set_error_code(from.error_code());
+  }
+}
+
+void Status::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.Status)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Status::CopyFrom(const Status& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.Status)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Status::IsInitialized() const {
+  return true;
+}
+
+void Status::InternalSwap(Status* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  reason_.Swap(&other->reason_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+    GetArenaNoVirtual());
+  swap(error_code_, other->error_code_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Status::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace grpc
+}  // namespace milvus
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::milvus::grpc::Status* Arena::CreateMaybeMessage< ::milvus::grpc::Status >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::Status >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>

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

+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: status.proto
+
+#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 < 3009000
+#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 3009000 < 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.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#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
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@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 ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  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[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_status_2eproto;
+namespace milvus {
+namespace grpc {
+class Status;
+class StatusDefaultTypeInternal;
+extern StatusDefaultTypeInternal _Status_default_instance_;
+}  // namespace grpc
+}  // namespace milvus
+PROTOBUF_NAMESPACE_OPEN
+template<> ::milvus::grpc::Status* Arena::CreateMaybeMessage<::milvus::grpc::Status>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace milvus {
+namespace grpc {
+
+enum ErrorCode : int {
+  SUCCESS = 0,
+  UNEXPECTED_ERROR = 1,
+  CONNECT_FAILED = 2,
+  PERMISSION_DENIED = 3,
+  TABLE_NOT_EXISTS = 4,
+  ILLEGAL_ARGUMENT = 5,
+  ILLEGAL_RANGE = 6,
+  ILLEGAL_DIMENSION = 7,
+  ILLEGAL_INDEX_TYPE = 8,
+  ILLEGAL_TABLE_NAME = 9,
+  ILLEGAL_TOPK = 10,
+  ILLEGAL_ROWRECORD = 11,
+  ILLEGAL_VECTOR_ID = 12,
+  ILLEGAL_SEARCH_RESULT = 13,
+  FILE_NOT_FOUND = 14,
+  META_FAILED = 15,
+  CACHE_FAILED = 16,
+  CANNOT_CREATE_FOLDER = 17,
+  CANNOT_CREATE_FILE = 18,
+  CANNOT_DELETE_FOLDER = 19,
+  CANNOT_DELETE_FILE = 20,
+  BUILD_INDEX_ERROR = 21,
+  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);
+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 ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ErrorCode>(
+    ErrorCode_descriptor(), name, value);
+}
+// ===================================================================
+
+class Status :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Status) */ {
+ public:
+  Status();
+  virtual ~Status();
+
+  Status(const Status& from);
+  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);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  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();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Status* internal_default_instance() {
+    return reinterpret_cast<const Status*>(
+               &_Status_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(Status& a, Status& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Status* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Status* New() const final {
+    return CreateMaybeMessage<Status>(nullptr);
+  }
+
+  Status* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<Status>(arena);
+  }
+  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;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::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:
+  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 ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::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 ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kReasonFieldNumber = 2,
+    kErrorCodeFieldNumber = 1,
+  };
+  // string reason = 2;
+  void clear_reason();
+  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);
+
+  // .milvus.grpc.ErrorCode error_code = 1;
+  void clear_error_code();
+  ::milvus::grpc::ErrorCode error_code() const;
+  void set_error_code(::milvus::grpc::ErrorCode value);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.Status)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reason_;
+  int error_code_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_status_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Status
+
+// .milvus.grpc.ErrorCode error_code = 1;
+inline void Status::clear_error_code() {
+  error_code_ = 0;
+}
+inline ::milvus::grpc::ErrorCode Status::error_code() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.Status.error_code)
+  return static_cast< ::milvus::grpc::ErrorCode >(error_code_);
+}
+inline void Status::set_error_code(::milvus::grpc::ErrorCode value) {
+  
+  error_code_ = value;
+  // @@protoc_insertion_point(field_set:milvus.grpc.Status.error_code)
+}
+
+// string reason = 2;
+inline void Status::clear_reason() {
+  reason_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+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) {
+  
+  reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.Status.reason)
+}
+inline void Status::set_reason(std::string&& value) {
+  
+  reason_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Status.reason)
+}
+inline void Status::set_reason(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  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(&::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() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.Status.reason)
+  return reason_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* Status::release_reason() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.Status.reason)
+  
+  return reason_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void Status::set_allocated_reason(std::string* reason) {
+  if (reason != nullptr) {
+    
+  } else {
+    
+  }
+  reason_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), reason);
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Status.reason)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace grpc
+}  // namespace milvus
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::milvus::grpc::ErrorCode> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::ErrorCode>() {
+  return ::milvus::grpc::ErrorCode_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_status_2eproto

cpp/src/grpc/milvus.proto

+syntax = "proto3";
+
+import "status.proto";
+
+package milvus.grpc;
+
+/**
+ * @brief Table Name
+ */
+message TableName {
+    Status status = 1;
+    string table_name = 2;
+}
+
+/**
+ * @brief Table Schema
+ */
+message TableSchema {
+    TableName table_name = 1;
+    int32 index_type = 2;
+    int64 dimension = 3;
+    bool store_raw_vector = 4;
+}
+
+/**
+ * @brief Range Schema
+ */
+message Range {
+    string start_value = 1;
+    string end_value = 2;
+}
+
+/**
+ * @brief Record inserted
+ */
+message RowRecord {
+    repeated float vector_data = 1;             //binary in thrift
+}
+
+/**
+ * @brief Infos to be inserted
+ */
+message InsertInfos {
+    string table_name = 1;
+    repeated RowRecord row_record_array = 2;
+}
+
+/**
+ * @brief Vector ids
+ */
+message VectorIds {
+    Status status = 1;
+    repeated int64 vector_id_array = 2;
+}
+
+/**
+ * @brief Infos for searching vector
+ */
+message SearchVectorInfos {
+    string table_name = 1;
+    repeated RowRecord query_record_array = 2;
+    repeated Range query_range_array = 3;
+    int64 topk = 4;
+}
+
+/**
+ * @brief Infos for searching vector in files
+ */
+message SearchVectorInFilesInfos {
+    repeated string file_id_array = 1;
+    SearchVectorInfos search_vector_infos = 2;
+}
+
+/**
+ * @brief Query result infos
+ */
+message QueryResult {
+    int64 id = 1;
+    double distance = 2;
+}
+
+/**
+ * @brief TopK query result
+ */
+message TopKQueryResult {
+    Status status = 1;
+    repeated QueryResult query_result_arrays = 2;
+}
+
+/**
+ * @brief Server String Reply
+ */
+message StringReply {
+    Status status = 1;
+    string string_reply = 2;
+}
+
+/**
+ * @brief Server bool Reply
+ */
+message BoolReply {
+    Status status = 1;
+    bool bool_reply = 2;
+}
+
+/**
+ * @brief Return table row count
+ */
+message TableRowCount {
+    Status status = 1;
+    int64 table_row_count = 2;
+}
+
+/**
+ * @brief Give Server Command
+ */
+message Command {
+    string cmd = 1;
+}
+
+/**
+ * @brief Give Server Command
+ */
+message ServerStatus{
+    Status status = 1;
+    string info = 2;
+}
+
+service MilvusService {
+    /**
+     * @brief Create table method
+     *
+     * This method is used to create table
+     *
+     * @param param, use to provide table information to be created.
+     *
+     */
+    rpc CreateTable(TableSchema) returns (Status){}
+
+    /**
+     * @brief Test table existence method
+     *
+     * This method is used to test table existence.
+     *
+     * @param table_name, table name is going to be tested.
+     *
+     */
+    rpc HasTable(TableName) returns (BoolReply) {}
+
+    /**
+     * @brief Delete table method
+     *
+     * This method is used to delete table.
+     *
+     * @param table_name, table name is going to be deleted.
+     *
+     */
+    rpc DropTable(TableName) returns (Status) {}
+
+    /**
+     * @brief Build index by table method
+     *
+     * This method is used to build index by table in sync mode.
+     *
+     * @param table_name, table is going to be built index.
+     *
+     */
+    rpc BuildIndex(TableName) returns (Status) {}
+
+    /**
+     * @brief Add vector array to table
+     *
+     * This method is used to add vector array to table.
+     *
+     * @param table_name, table_name is inserted.
+     * @param record_array, vector array is inserted.
+     *
+     * @return vector id array
+     */
+    rpc InsertVector(InsertInfos) returns (VectorIds) {}
+
+    /**
+     * @brief Query vector
+     *
+     * This method is used to query vector in table.
+     *
+     * @param table_name, table_name is queried.
+     * @param query_record_array, all vector are going to be queried.
+     * @param query_range_array, optional ranges for conditional search. If not specified, search whole table
+     * @param topk, how many similarity vectors will be searched.
+     *
+     * @return query result array.
+     */
+    rpc SearchVector(SearchVectorInfos) returns (stream TopKQueryResult) {}
+
+    /**
+     * @brief Internal use query interface
+     *
+     * This method is used to query vector in specified files.
+     *
+     * @param file_id_array, specified files id array, queried.
+     * @param query_record_array, all vector are going to be queried.
+     * @param query_range_array, optional ranges for conditional search. If not specified, search whole table
+     * @param topk, how many similarity vectors will be searched.
+     *
+     * @return query result array.
+     */
+    rpc SearchVectorInFiles(SearchVectorInFilesInfos) returns (stream TopKQueryResult) {}
+
+    /**
+     * @brief Get table schema
+     *
+     * This method is used to get table schema.
+     *
+     * @param table_name, target table name.
+     *
+     * @return table schema
+     */
+    rpc DescribeTable(TableName) returns (TableSchema) {}
+
+    /**
+     * @brief Get table schema
+     *
+     * This method is used to get table schema.
+     *
+     * @param table_name, target table name.
+     *
+     * @return table schema
+     */
+    rpc GetTableRowCount(TableName) returns (TableRowCount) {}
+
+    /**
+     * @brief List all tables in database
+     *
+     * This method is used to list all tables.
+     *
+     *
+     * @return table names.
+     */
+    rpc ShowTables(Command) returns (stream TableName) {}
+
+    /**
+     * @brief Give the server status
+     *
+     * This method is used to give the server status.
+     *
+     * @return Server status.
+     */
+    rpc Ping(Command) returns (ServerStatus) {}
+}

cpp/src/grpc/status.proto

+syntax = "proto3";
+
+package milvus.grpc;
+
+enum ErrorCode {
+    SUCCESS = 0;
+    UNEXPECTED_ERROR = 1;
+    CONNECT_FAILED = 2;
+    PERMISSION_DENIED = 3;
+    TABLE_NOT_EXISTS = 4;
+    ILLEGAL_ARGUMENT = 5;
+    ILLEGAL_RANGE = 6;
+    ILLEGAL_DIMENSION = 7;
+    ILLEGAL_INDEX_TYPE = 8;
+    ILLEGAL_TABLE_NAME = 9;
+    ILLEGAL_TOPK = 10;
+    ILLEGAL_ROWRECORD = 11;
+    ILLEGAL_VECTOR_ID = 12;
+    ILLEGAL_SEARCH_RESULT = 13;
+    FILE_NOT_FOUND = 14;
+    META_FAILED = 15;
+    CACHE_FAILED = 16;
+    CANNOT_CREATE_FOLDER = 17;
+    CANNOT_CREATE_FILE = 18;
+    CANNOT_DELETE_FOLDER = 19;
+    CANNOT_DELETE_FILE = 20;
+    BUILD_INDEX_ERROR = 21;
+}
+
+message Status {
+    ErrorCode error_code = 1;
+    string reason = 2;
+}
\ No newline at end of file

cpp/src/sdk/CMakeLists.txt

@@ -4,32 +4,60 @@
 # Proprietary and confidential.
 #-------------------------------------------------------------------------------
 
-aux_source_directory(src/interface interface_files)
-aux_source_directory(src/client client_files)
-aux_source_directory(src/util util_files)
+aux_source_directory(interface interface_files)
+
+aux_source_directory(util util_files)
 
-include_directories(src)
-include_directories(include)
 include_directories(/usr/include)
-include_directories(${CMAKE_SOURCE_DIR}/src/thrift/gen-cpp)
+include_directories(include)
+include_directories(/usr/local/include)
 
-set(service_files
-        ${CMAKE_SOURCE_DIR}/src/thrift/gen-cpp/MilvusService.cpp
-        ${CMAKE_SOURCE_DIR}/src/thrift/gen-cpp/milvus_constants.cpp
-        ${CMAKE_SOURCE_DIR}/src/thrift/gen-cpp/milvus_types.cpp
-        )
+if (MILVUS_WITH_THRIFT STREQUAL "ON")
+    aux_source_directory(thrift thrift_client_files)
+    include_directories(thrift)
+    include_directories(${CMAKE_SOURCE_DIR}/src/thrift/gen-cpp)
 
-add_library(milvus_sdk STATIC
-        ${interface_files}
-        ${client_files}
-        ${util_files}
-        ${service_files}
-        )
+    set(thrift_service_files
+            ${CMAKE_SOURCE_DIR}/src/thrift/gen-cpp/MilvusService.cpp
+            ${CMAKE_SOURCE_DIR}/src/thrift/gen-cpp/milvus_constants.cpp
+            ${CMAKE_SOURCE_DIR}/src/thrift/gen-cpp/milvus_types.cpp
+            )
 
-target_link_libraries(milvus_sdk
-        ${third_party_libs}
-        )
+    add_library(milvus_thrift_sdk STATIC
+            ${interface_files}
+            ${thrift_client_files}
+            ${util_files}
+            ${thrift_service_files}
+            )
 
-add_subdirectory(examples)
+    target_link_libraries(milvus_thrift_sdk
+            ${third_party_libs}
+            )
+    install(TARGETS milvus_thrift_sdk DESTINATION lib)
+else()
+    aux_source_directory(grpc grpc_client_files)
+
+    include_directories(${CMAKE_SOURCE_DIR}/src/grpc/gen-milvus)
+    include_directories(${CMAKE_SOURCE_DIR}/src/grpc/gen-status)
 
-install(TARGETS milvus_sdk DESTINATION lib)
+    set(grpc_service_files
+            ${CMAKE_SOURCE_DIR}/src/grpc/gen-milvus/milvus.grpc.pb.cc
+            ${CMAKE_SOURCE_DIR}/src/grpc/gen-milvus/milvus.pb.cc
+            ${CMAKE_SOURCE_DIR}/src/grpc/gen-status/status.grpc.pb.cc
+            ${CMAKE_SOURCE_DIR}/src/grpc/gen-status/status.pb.cc
+            )
+
+    add_library(milvus_grpc_sdk STATIC
+            ${interface_files}
+            ${grpc_client_files}
+            ${util_files}
+            ${grpc_service_files}
+            )
+
+    target_link_libraries(milvus_grpc_sdk
+            ${third_party_libs}
+            )
+    install(TARGETS milvus_grpc_sdk DESTINATION lib)
+endif()
+
+add_subdirectory(examples)

cpp/src/sdk/examples/CMakeLists.txt

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

cpp/src/sdk/examples/grpcsimple/CMakeLists.txt

+#-------------------------------------------------------------------------------
+# Copyright 上海赜睿信息科技有限公司(Zilliz) - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited.
+# Proprietary and confidential.
+#-------------------------------------------------------------------------------
+
+aux_source_directory(src src_files)
+
+include_directories(src)
+include_directories(../../include)
+
+link_directories(${CMAKE_BINARY_DIR})
+
+add_executable(grpc_sdk_simple
+        main.cpp
+        ${src_files}
+        )
+
+target_link_libraries(grpc_sdk_simple
+        milvus_grpc_sdk
+        pthread
+        )
+
+install(TARGETS grpc_sdk_simple DESTINATION bin)

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

+/*******************************************************************************
+ * Copyright 上海赜睿信息科技有限公司(Zilliz) - All Rights Reserved
+ * Unauthorized copying of this file, via any medium is strictly prohibited.
+ * Proprietary and confidential.
+ ******************************************************************************/
+#include "ClientTest.h"
+#include "MilvusApi.h"
+
+#include <iostream>
+#include <time.h>
+#include <chrono>
+#include <thread>
+#include <unistd.h>
+
+using namespace milvus;
+
+namespace {
+    std::string GetTableName();
+
+    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 = 1;
+    constexpr int64_t SECONDS_EACH_HOUR = 3600;
+
+#define BLOCK_SPLITER std::cout << "===========================================" << std::endl;
+
+    void PrintTableSchema(const TableSchema& tb_schema) {
+        BLOCK_SPLITER
+        std::cout << "Table name: " << tb_schema.table_name << std::endl;
+        std::cout << "Table index type: " << (int)tb_schema.index_type << std::endl;
+        std::cout << "Table dimension: " << tb_schema.dimension << std::endl;
+        std::cout << "Table store raw data: " << (tb_schema.store_raw_vector ? "true" : "false") << std::endl;
+        BLOCK_SPLITER
+    }
+
+    void PrintSearchResult(const std::vector<std::pair<int64_t, RowRecord>>& search_record_array,
+                           const std::vector<TopKQueryResult>& topk_query_result_array) {
+        BLOCK_SPLITER
+        std::cout << "Returned result count: " << topk_query_result_array.size() << std::endl;
+
+        int32_t index = 0;
+        for(auto& result : topk_query_result_array) {
+            auto search_id = search_record_array[index].first;
+            index++;
+            std::cout << "No." << std::to_string(index) << " vector " << std::to_string(search_id)
+                      << " top " << std::to_string(result.query_result_arrays.size())
+                      << " search result:" << std::endl;
+            for(auto& item : result.query_result_arrays) {
+                std::cout << "\t" << std::to_string(item.id) << "\tdistance:" << std::to_string(item.distance);
+                std::cout << std::endl;
+            }
+        }
+
+        BLOCK_SPLITER
+    }
+
+    std::string CurrentTime() {
+        time_t tt;
+        time( &tt );
+        tt = tt + 8*SECONDS_EACH_HOUR;
+        tm* t= gmtime( &tt );
+
+        std::string str = std::to_string(t->tm_year + 1900) + "_" + std::to_string(t->tm_mon + 1)
+                          + "_" + std::to_string(t->tm_mday) + "_" + std::to_string(t->tm_hour)
+                          + "_" + std::to_string(t->tm_min) + "_" + std::to_string(t->tm_sec);
+
+        return str;
+    }
+
+    std::string CurrentTmDate(int64_t offset_day = 0) {
+        time_t tt;
+        time( &tt );
+        tt = tt + 8*SECONDS_EACH_HOUR;
+        tt = tt + 24*SECONDS_EACH_HOUR*offset_day;
+        tm* t= gmtime( &tt );
+
+        std::string str = std::to_string(t->tm_year + 1900) + "-" + std::to_string(t->tm_mon + 1)
+                          + "-" + std::to_string(t->tm_mday);
+
+        return str;
+    }
+
+    std::string GetTableName() {
+        static std::string s_id(CurrentTime());
+        return "tbl_" + s_id;
+    }
+
+    TableSchema BuildTableSchema() {
+        TableSchema tb_schema;
+        tb_schema.table_name = TABLE_NAME;
+        tb_schema.index_type = IndexType::gpu_ivfflat;
+        tb_schema.dimension = TABLE_DIMENSION;
+        tb_schema.store_raw_vector = true;
+
+        return tb_schema;
+    }
+
+    void BuildVectors(int64_t from, int64_t to,
+                      std::vector<RowRecord>& vector_record_array) {
+        if(to <= from){
+            return;
+        }
+
+        vector_record_array.clear();
+        for (int64_t k = from; k < to; k++) {
+            RowRecord record;
+            record.data.resize(TABLE_DIMENSION);
+            for(int64_t i = 0; i < TABLE_DIMENSION; i++) {
+                record.data[i] = (float)(k%(i+1));
+            }
+
+            vector_record_array.emplace_back(record);
+        }
+    }
+
+    void Sleep(int seconds) {
+        std::cout << "Waiting " << seconds << " seconds ..." << std::endl;
+        sleep(seconds);
+    }
+
+    class TimeRecorder {
+    public:
+        explicit TimeRecorder(const std::string& title)
+                : title_(title) {
+            start_ = std::chrono::system_clock::now();
+        }
+
+        ~TimeRecorder() {
+            std::chrono::system_clock::time_point end = std::chrono::system_clock::now();
+            long span = (std::chrono::duration_cast<std::chrono::milliseconds> (end - start_)).count();
+            std::cout << title_ << " totally cost: " << span << " ms" << std::endl;
+        }
+
+    private:
+        std::string title_;
+        std::chrono::system_clock::time_point start_;
+    };
+
+    void CheckResult(const std::vector<std::pair<int64_t, RowRecord>>& search_record_array,
+                     const std::vector<TopKQueryResult>& topk_query_result_array) {
+        BLOCK_SPLITER
+        int64_t index = 0;
+        for(auto& result : topk_query_result_array) {
+            auto result_id = result.query_result_arrays[0].id;
+            auto search_id = search_record_array[index++].first;
+            if(result_id != search_id) {
+                std::cout << "The top 1 result is wrong: " << result_id
+                          << " vs. " << search_id << std::endl;
+            } else {
+                std::cout << "Check result sucessfully" << std::endl;
+            }
+        }
+        BLOCK_SPLITER
+    }
+
+    void DoSearch(std::shared_ptr<Connection> conn,
+                  const std::vector<std::pair<int64_t, RowRecord>>& search_record_array,
+                  const std::string& phase_name) {
+        std::vector<Range> query_range_array;
+        Range rg;
+        rg.start_value = CurrentTmDate();
+        rg.end_value = CurrentTmDate(1);
+        query_range_array.emplace_back(rg);
+
+        std::vector<RowRecord> record_array;
+        for(auto& pair : search_record_array) {
+            record_array.push_back(pair.second);
+        }
+
+        std::vector<TopKQueryResult> topk_query_result_array;
+        {
+            TimeRecorder rc(phase_name);
+            Status stat = conn->SearchVector(TABLE_NAME, record_array, query_range_array, TOP_K, topk_query_result_array);
+            std::cout << "SearchVector function call status: " << stat.ToString() << std::endl;
+        }
+
+        PrintSearchResult(search_record_array, topk_query_result_array);
+        CheckResult(search_record_array, topk_query_result_array);
+    }
+}
+
+void
+ClientTest::Test(const std::string& address, const std::string& port) {
+    std::shared_ptr<Connection> conn = Connection::Create();
+
+    {//connect server
+        ConnectParam param = {address, port};
+        Status stat = conn->Connect(param);
+        std::cout << "Connect function call status: " << stat.ToString() << std::endl;
+    }
+
+    {//server version
+        std::string version = conn->ServerVersion();
+        std::cout << "Server version: " << version << std::endl;
+    }
+
+    {//sdk version
+        std::string version = conn->ClientVersion();
+        std::cout << "SDK version: " << version << std::endl;
+    }
+
+    {
+        std::vector<std::string> tables;
+        Status stat = conn->ShowTables(tables);
+        std::cout << "ShowTables function call status: " << stat.ToString() << std::endl;
+        std::cout << "All tables: " << std::endl;
+        for(auto& table : tables) {
+            int64_t row_count = 0;
+//            conn->DropTable(table);
+            stat = conn->GetTableRowCount(table, row_count);
+            std::cout << "\t" << table << "(" << row_count << " rows)" << std::endl;
+        }
+    }
+
+    {//create table
+        TableSchema tb_schema = BuildTableSchema();
+        Status stat = conn->CreateTable(tb_schema);
+        std::cout << "CreateTable function call status: " << stat.ToString() << std::endl;
+        PrintTableSchema(tb_schema);
+
+        bool has_table = conn->HasTable(tb_schema.table_name);
+        if(has_table) {
+            std::cout << "Table is created" << std::endl;
+        }
+    }
+
+    {//describe table
+        TableSchema tb_schema;
+        Status stat = conn->DescribeTable(TABLE_NAME, tb_schema);
+        std::cout << "DescribeTable function call status: " << stat.ToString() << std::endl;
+        PrintTableSchema(tb_schema);
+    }
+//
+//    Connection::Destroy(conn);
+
+//    pid_t pid;
+//    for (int i = 0; i < 5; ++i) {
+//        pid = fork();
+//        if (pid == 0 || pid == -1) {
+//            break;
+//        }
+//    }
+//    if (pid == -1) {
+//        std::cout << "fail to fork!\n";
+//        exit(1);
+//    } else if (pid == 0) {
+//        std::shared_ptr<Connection> conn = Connection::Create();
+//
+//        {//connect server
+//            ConnectParam param = {address, port};
+//            Status stat = conn->Connect(param);
+//            std::cout << "Connect function call status: " << stat.ToString() << std::endl;
+//        }
+//
+//        {//server version
+//            std::string version = conn->ServerVersion();
+//            std::cout << "Server version: " << version << std::endl;
+//        }
+//        Connection::Destroy(conn);
+//        exit(0);
+//    } else {
+//        std::shared_ptr<Connection> conn = Connection::Create();
+//
+//        {//connect server
+//            ConnectParam param = {address, port};
+//            Status stat = conn->Connect(param);
+//            std::cout << "Connect function call status: " << stat.ToString() << std::endl;
+//        }
+//
+//        {//server version
+//            std::string version = conn->ServerVersion();
+//            std::cout << "Server version: " << version << std::endl;
+//        }
+//        Connection::Destroy(conn);
+//        std::cout << "in main process\n";
+//        exit(0);
+//    }
+
+    std::vector<std::pair<int64_t, RowRecord>> search_record_array;
+    {//insert vectors
+        for (int i = 0; i < ADD_VECTOR_LOOP; i++) {//add vectors
+            std::vector<RowRecord> record_array;
+            int64_t begin_index = i * BATCH_ROW_COUNT;
+            BuildVectors(begin_index, begin_index + BATCH_ROW_COUNT, record_array);
+            std::vector<int64_t> record_ids;
+
+            auto start = std::chrono::high_resolution_clock::now();
+
+            Status stat = conn->InsertVector(TABLE_NAME, record_array, record_ids);
+            auto finish = std::chrono::high_resolution_clock::now();
+            std::cout << "InsertVector cost: " << std::chrono::duration_cast<std::chrono::duration<double>>(finish - start).count() << "s\n";
+
+
+            std::cout << "InsertVector function call status: " << stat.ToString() << std::endl;
+            std::cout << "Returned id array count: " << record_ids.size() << std::endl;
+
+            if(search_record_array.size() < NQ) {
+                search_record_array.push_back(
+                        std::make_pair(record_ids[SEARCH_TARGET], record_array[SEARCH_TARGET]));
+            }
+        }
+    }
+
+    {//search vectors without index
+        Sleep(2);
+        DoSearch(conn, search_record_array, "Search without index");
+    }
+
+    {//wait unit build index finish
+        std::cout << "Wait until build all index done" << std::endl;
+        Status stat = conn->BuildIndex(TABLE_NAME);
+        std::cout << "BuildIndex function call status: " << stat.ToString() << std::endl;
+    }
+
+    {//search vectors after build index finish
+        DoSearch(conn, search_record_array, "Search after build index finish");
+    }
+
+    {//delete table
+        Status stat = conn->DropTable(TABLE_NAME);
+        std::cout << "DeleteTable function call status: " << stat.ToString() << std::endl;
+    }
+
+    {//server status
+        std::string status = conn->ServerStatus();
+        std::cout << "Server status before disconnect: " << status << std::endl;
+    }
+    Connection::Destroy(conn);
+//    conn->Disconnect();
+    {//server status
+        std::string status = conn->ServerStatus();
+        std::cout << "Server status after disconnect: " << status << std::endl;
+    }
+}
\ No newline at end of file

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

+/*******************************************************************************
+ * Copyright 上海赜睿信息科技有限公司(Zilliz) - All Rights Reserved
+ * Unauthorized copying of this file, via any medium is strictly prohibited.
+ * Proprietary and confidential.
+ ******************************************************************************/
+#pragma once
+
+#include <string>
+
+class ClientTest {
+public:
+    void Test(const std::string& address, const std::string& port);
+};
\ No newline at end of file

cpp/src/sdk/examples/simple/CMakeLists.txt → cpp/src/sdk/examples/thriftsimple/CMakeLists.txt

@@ -11,14 +11,14 @@ include_directories(../../include)
 
 link_directories(${CMAKE_BINARY_DIR})
 
-add_executable(sdk_simple
+add_executable(thrift_sdk_simple
         ./main.cpp
         ${src_files}
         )
 
-target_link_libraries(sdk_simple
-        milvus_sdk
+target_link_libraries(thrift_sdk_simple
+        milvus_thrift_sdk
         pthread
         )
 
-install(TARGETS sdk_simple DESTINATION bin)
+install(TARGETS thrift_sdk_simple DESTINATION bin)

cpp/src/sdk/examples/thriftsimple/main.cpp

+////////////////////////////////////////////////////////////////////////////////
+// Copyright 上海赜睿信息科技有限公司(Zilliz) - All Rights Reserved
+// Unauthorized copying of this file, via any medium is strictly prohibited.
+// Proprietary and confidential.
+////////////////////////////////////////////////////////////////////////////////
+
+#include <getopt.h>
+#include <libgen.h>
+#include <cstring>
+#include <string>
+
+#include "src/ClientTest.h"
+
+void print_help(const std::string &app_name);
+
+
+int
+main(int argc, char *argv[]) {
+    printf("Client start...\n");
+
+    std::string app_name = basename(argv[0]);
+    static struct option long_options[] = {{"server", optional_argument, 0, 's'},
+                                           {"port", optional_argument, 0, 'p'},
+                                           {"help", no_argument, 0, 'h'},
+                                           {NULL, 0, 0, 0}};
+
+    int option_index = 0;
+    std::string address = "127.0.0.1", port = "19530";
+    app_name = argv[0];
+
+    int value;
+    while ((value = getopt_long(argc, argv, "s:p:h", long_options, &option_index)) != -1) {
+        switch (value) {
+            case 's': {
+                char *address_ptr = strdup(optarg);
+                address = address_ptr;
+                free(address_ptr);
+                break;
+            }
+            case 'p': {
+                char *port_ptr = strdup(optarg);
+                port = port_ptr;
+                free(port_ptr);
+                break;
+            }
+            case 'h':
+            default:
+                print_help(app_name);
+                return EXIT_SUCCESS;
+        }
+    }
+
+    ClientTest test;
+    test.Test(address, port);
+
+    printf("Client stop...\n");
+    return 0;
+}
+
+void
+print_help(const std::string &app_name) {
+    printf("\n Usage: %s [OPTIONS]\n\n", app_name.c_str());
+    printf("  Options:\n");
+    printf("   -s --server   Server address, default 127.0.0.1\n");
+    printf("   -p --port     Server port, default 19530\n");
+    printf("   -h --help     Print help information\n");
+    printf("\n");
+}
\ No newline at end of file

cpp/src/sdk/examples/simple/src/ClientTest.cpp → 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/grpc/ClientProxy.cpp

+/*******************************************************************************
+* Copyright 上海赜睿信息科技有限公司(Zilliz) - All Rights Reserved
+* Unauthorized copying of this file, via any medium is strictly prohibited.
+* Proprietary and confidential.
+******************************************************************************/
+#include "ClientProxy.h"
+#include "version.h"
+#include "milvus.grpc.pb.h"
+//#define GRPC_MULTIPLE_THREAD;
+
+namespace milvus {
+
+bool
+UriCheck(const std::string &uri) {
+     size_t index = uri.find_first_of(':', 0);
+    if (index == std::string::npos) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+Status
+ClientProxy::Connect(const ConnectParam &param) {
+    std::string uri = param.ip_address + ":" + param.port;
+
+    channel_ = ::grpc::CreateChannel(uri, ::grpc::InsecureChannelCredentials());
+    if (channel_ != nullptr) {
+        connected_ = true;
+        client_ptr_ = std::make_shared<GrpcClient>(channel_);
+        return Status::OK();
+    } else {
+        std::string reason = "connect failed!";
+        connected_ = false;
+        return Status(StatusCode::NotConnected, reason);
+    }
+}
+
+Status
+ClientProxy::Connect(const std::string &uri) {
+    if (!UriCheck(uri)) {
+        return Status::Invalid("Invalid uri");
+    }
+    size_t index = uri.find_first_of(':', 0);
+
+    ConnectParam param;
+    param.ip_address = uri.substr(0, index);
+    param.port = uri.substr(index + 1);
+
+    return Connect(param);
+}
+
+Status
+ClientProxy::Connected() const {
+    try {
+        std::string info;
+        return client_ptr_->Ping(info, "");
+    } catch (std::exception &ex) {
+        return Status(StatusCode::NotConnected, "connection lost: " + std::string(ex.what()));
+    }
+}
+
+Status
+ClientProxy::Disconnect() {
+    try {
+        Status status = client_ptr_->Disconnect();
+        connected_ = false;
+        channel_.reset();
+        return status;
+    }catch (std::exception &ex) {
+        return Status(StatusCode::UnknownError, "failed to disconnect: " + std::string(ex.what()));
+    }
+}
+
+std::string
+ClientProxy::ClientVersion() const {
+    return MILVUS_VERSION;
+}
+
+Status
+ClientProxy::CreateTable(const TableSchema &param) {
+    try {
+        ::milvus::grpc::TableSchema schema;
+        schema.mutable_table_name()->set_table_name(param.table_name);
+        schema.set_index_type((int) param.index_type);
+        schema.set_dimension(param.dimension);
+        schema.set_store_raw_vector(param.store_raw_vector);
+
+        return client_ptr_->CreateTable(schema);
+    } catch (std::exception &ex) {
+        return Status(StatusCode::UnknownError, "failed to create table: " + std::string(ex.what()));
+    }
+}
+
+bool
+ClientProxy::HasTable(const std::string &table_name) {
+    Status status = Status::OK();
+    ::milvus::grpc::TableName grpc_table_name;
+    grpc_table_name.set_table_name(table_name);
+    bool result = client_ptr_->HasTable(grpc_table_name, status);
+    return result;
+}
+
+Status
+ClientProxy::DeleteTable(const std::string &table_name) {
+    return this->DropTable(table_name);
+}
+
+Status
+ClientProxy::DropTable(const std::string &table_name) {
+    try {
+        ::milvus::grpc::TableName grpc_table_name;
+        grpc_table_name.set_table_name(table_name);
+        return client_ptr_->DropTable(grpc_table_name);
+    } catch (std::exception &ex) {
+        return Status(StatusCode::UnknownError, "failed to drop table: " + std::string(ex.what()));
+    }
+}
+
+Status
+ClientProxy::BuildIndex(const std::string &table_name) {
+    try {
+        ::milvus::grpc::TableName grpc_table_name;
+        grpc_table_name.set_table_name(table_name);
+        return client_ptr_->BuildIndex(grpc_table_name);
+
+    } catch (std::exception &ex) {
+        return Status(StatusCode::UnknownError, "failed to build index: " + std::string(ex.what()));
+    }
+}
+
+Status
+ClientProxy::AddVector(const std::string &table_name,
+                          const std::vector<RowRecord> &record_array,
+                          std::vector<int64_t> &id_array) {
+    return InsertVector(table_name, record_array, id_array);
+}
+
+Status
+ClientProxy::InsertVector(const std::string &table_name,
+                          const std::vector<RowRecord> &record_array,
+                          std::vector<int64_t> &id_array) {
+    Status status = Status::OK();
+    try {
+////////////////////////////////////////////////////////////////////////////
+#ifdef GRPC_MULTIPLE_THREAD
+        std::vector<std::thread> threads;
+        int thread_count = 10;
+
+        std::shared_ptr<::milvus::grpc::InsertInfos> insert_info_array(
+            new ::milvus::grpc::InsertInfos[thread_count],
+            std::default_delete<::milvus::grpc::InsertInfos[]>() );
+
+        std::shared_ptr<::milvus::grpc::VectorIds> vector_ids_array(
+            new ::milvus::grpc::VectorIds[thread_count],
+                std::default_delete<::milvus::grpc::VectorIds[]>() );
+
+        int64_t record_count = record_array.size() / thread_count;
+
+        for (size_t i = 0; i < thread_count; i++) {
+            insert_info_array.get()[i].set_table_name(table_name);
+            for (size_t j = i * record_count; j < record_count * (i + 1); j++) {
+                ::milvus::grpc::RowRecord *grpc_record =
+                    insert_info_array.get()[i].add_row_record_array();
+                for (size_t k = 0; k < record_array[j].data.size(); k++) {
+                    grpc_record->add_vector_data(record_array[j].data[k]);
+                }
+            }
+        }
+
+        std::cout << "*****************************************************\n";
+        auto start = std::chrono::high_resolution_clock::now();
+        for (size_t j = 0; j < thread_count; j++) {
+            threads.push_back(
+                    std::thread(&GrpcClient::InsertVector, client_ptr_,
+                        std::ref(vector_ids_array.get()[j]), std::ref(insert_info_array.get()[j]),
+                        std::ref(status)));
+        }
+        std::for_each(threads.begin(), threads.end(), std::mem_fn(&std::thread::join));
+        auto finish = std::chrono::high_resolution_clock::now();
+        std::cout << "InsertVector cost: " << std::chrono::duration_cast<std::chrono::duration<double>>(finish - start).count() << "s\n";
+        std::cout << "*****************************************************\n";
+
+        for (size_t i = 0; i < thread_count; i++) {
+            for (size_t j = 0; j < vector_ids_array.get()[i].vector_id_array_size(); j++) {
+                id_array.push_back(vector_ids_array.get()[i].vector_id_array(j));
+            }
+        }
+#else
+        ::milvus::grpc::InsertInfos insert_infos;
+        insert_infos.set_table_name(table_name);
+
+        for (auto &record : record_array) {
+            ::milvus::grpc::RowRecord *grpc_record = insert_infos.add_row_record_array();
+            for (size_t i = 0; i < record.data.size(); i++) {
+                grpc_record->add_vector_data(record.data[i]);
+            }
+        }
+
+        ::milvus::grpc::VectorIds vector_ids;
+
+        //Single thread
+        client_ptr_->InsertVector(vector_ids, insert_infos, status);
+        auto finish = std::chrono::high_resolution_clock::now();
+
+        for (size_t i = 0; i < vector_ids.vector_id_array_size(); i++) {
+            id_array.push_back(vector_ids.vector_id_array(i));
+        }
+#endif
+
+    } catch (std::exception &ex) {
+        return Status(StatusCode::UnknownError, "fail to add vector: " + std::string(ex.what()));
+    }
+
+    return status;
+}
+
+Status
+ClientProxy::SearchVector(const std::string &table_name,
+                          const std::vector<RowRecord> &query_record_array,
+                          const std::vector<Range> &query_range_array,
+                          int64_t topk,
+                          std::vector<TopKQueryResult> &topk_query_result_array) {
+    try {
+        //step 1: convert vectors data
+        ::milvus::grpc::SearchVectorInfos search_vector_infos;
+        search_vector_infos.set_table_name(table_name);
+        search_vector_infos.set_topk(topk);
+        for (auto &record : query_record_array) {
+            ::milvus::grpc::RowRecord *row_record = search_vector_infos.add_query_record_array();
+            for (auto &rec : record.data) {
+                row_record->add_vector_data(rec);
+            }
+        }
+
+        //step 2: convert range array
+        for (auto &range : query_range_array) {
+            ::milvus::grpc::Range *grpc_range = search_vector_infos.add_query_range_array();
+            grpc_range->set_start_value(range.start_value);
+            grpc_range->set_end_value(range.end_value);
+        }
+
+        //step 3: search vectors
+        std::vector<::milvus::grpc::TopKQueryResult> result_array;
+        Status status = client_ptr_->SearchVector(result_array, search_vector_infos);
+
+        //step 4: convert result array
+        for (auto &grpc_topk_result : result_array) {
+            TopKQueryResult result;
+            for (size_t i = 0; i < grpc_topk_result.query_result_arrays_size(); i++) {
+                QueryResult query_result;
+                query_result.id = grpc_topk_result.query_result_arrays(i).id();
+                query_result.distance = grpc_topk_result.query_result_arrays(i).distance();
+                result.query_result_arrays.emplace_back(query_result);
+            }
+
+            topk_query_result_array.emplace_back(result);
+        }
+        return status;
+
+    } catch (std::exception &ex) {
+        return Status(StatusCode::UnknownError, "fail to search vectors: " + std::string(ex.what()));
+    }
+
+}
+
+Status
+ClientProxy::DescribeTable(const std::string &table_name, TableSchema &table_schema) {
+    try {
+        ::milvus::grpc::TableSchema grpc_schema;
+
+        Status status = client_ptr_->DescribeTable(grpc_schema, table_name);
+
+        table_schema.table_name = grpc_schema.table_name().table_name();
+        table_schema.index_type = (IndexType) grpc_schema.index_type();
+        table_schema.dimension = grpc_schema.dimension();
+        table_schema.store_raw_vector = grpc_schema.store_raw_vector();
+
+        return status;
+    } catch (std::exception &ex) {
+        return Status(StatusCode::UnknownError, "fail to describe table: " + std::string(ex.what()));
+    }
+
+}
+
+Status
+ClientProxy::GetTableRowCount(const std::string &table_name, int64_t &row_count) {
+    try {
+        Status status;
+        row_count = client_ptr_->GetTableRowCount(table_name, status);
+        return status;
+    } catch (std::exception &ex) {
+        return Status(StatusCode::UnknownError, "fail to show tables: " + std::string(ex.what()));
+    }
+}
+
+Status
+ClientProxy::ShowTables(std::vector<std::string> &table_array) {
+    try {
+        return client_ptr_->ShowTables(table_array);
+
+    } catch (std::exception &ex) {
+        return Status(StatusCode::UnknownError, "fail to show tables: " + std::string(ex.what()));
+    }
+}
+
+std::string
+ClientProxy::ServerVersion() const {
+    Status status = Status::OK();
+    try {
+        std::string version;
+        Status status = client_ptr_->Ping(version, "version");
+        return version;
+    } catch (std::exception &ex) {
+        return "";
+    }
+}
+
+std::string
+ClientProxy::ServerStatus() const {
+    if (channel_ == nullptr) {
+        return "not connected to server";
+    }
+
+    try {
+        std::string dummy;
+        Status status = client_ptr_->Ping(dummy, "");
+        return "server alive";
+    } catch (std::exception &ex) {
+        return "connection lost";
+    }
+}
+
+}

cpp/start_server.sh

 #!/bin/bash
 
-./cmake_build/src/milvus_server -c ./conf/server_config.yaml -l ./conf/log_config.conf &
+./cmake_build/src/milvus_grpc_server -c ./conf/server_config.yaml -l ./conf/log_config.conf &