Merge branch '0.6.0' of github.com:milvus-io/milvus into 0.6.0

.travis.yml

@@ -0,0 +1,20 @@
+language: cpp
+sudo: required
+dist: bionic
+
+cache:
+  directories:
+    - $HOME/.ccache
+
+addons:
+  apt:
+    update: true
+
+before_install:
+  - source ci/travis/before-install.sh
+
+install:
+  - source $TRAVIS_BUILD_DIR/ci/travis/install_dependency.sh
+
+script:
+  - $TRAVIS_BUILD_DIR/ci/travis/travis_build.sh

CHANGELOG.md

@@ -1,10 +1,11 @@
 # Changelog
 
 Please mark all change in change log and use the ticket from JIRA.
-
 # Milvus 0.6.0 (TODO)
 
 ## Bug
+- \#246 - Exclude src/external folder from code coverage for jenkin ci
+- \#248 - Reside src/external in thirdparty
 
 ## Feature
 - \#12 - Pure CPU version for Milvus
@@ -12,11 +13,31 @@ Please mark all change in change log and use the ticket from JIRA.
 - \#226 - Experimental shards middleware for Milvus
 
 ## Improvement
+- \#275 - Rename C++ SDK IndexType
+- \#284 - Change C++ SDK to shared library
+- \#260 - C++ SDK README
+- \#314 - add Find FAISS in CMake
+- \#310 - Add Q&A for 'protocol https not supported or disable in libcurl' issue
 
 ## Task
 
+# Milvus 0.5.3 (2019-11-13)
 
-# Milvus 0.5.2 (TODO)
+## Bug
+- \#258 - Bytes type in proto cause big-endian/little-endian problem
+
+## Feature
+
+## Improvement
+- \#204 - improve grpc performance in search
+- \#207 - Add more unittest for config set/get
+- \#208 - optimize unittest to support run single test more easily
+- \#284 - Change C++ SDK to shared library
+- \#260 - C++ SDK README
+
+## Task
+
+# Milvus 0.5.2 (2019-11-07)
 
 ## Bug
 - \#194 - Search faild: message="Table file doesn't exist"
@@ -24,7 +45,7 @@ Please mark all change in change log and use the ticket from JIRA.
 ## Feature
 
 ## Improvement
-- \#190 - Update default config:use_blas_threshold to 1100 and server version printout to 0.52
+- \#190 - Update default config:use_blas_threshold to 1100 and server version printout to 0.5.2
 
 ## Task
 

ci/jenkins/step/build.groovy

@@ -1,8 +1,7 @@
 timeout(time: 60, unit: 'MINUTES') {
-    dir ("ci/jenkins/scripts") {
-        sh "./build.sh -l"
+    dir ("ci/scripts") {
         withCredentials([usernamePassword(credentialsId: "${params.JFROG_CREDENTIALS_ID}", usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')]) {
-            sh "export JFROG_ARTFACTORY_URL='${params.JFROG_ARTFACTORY_URL}' && export JFROG_USER_NAME='${USERNAME}' && export JFROG_PASSWORD='${PASSWORD}' && ./build.sh -t ${params.BUILD_TYPE} -o /opt/milvus -d /opt/milvus -j -u -c"
+            sh "export JFROG_ARTFACTORY_URL='${params.JFROG_ARTFACTORY_URL}' && export JFROG_USER_NAME='${USERNAME}' && export JFROG_PASSWORD='${PASSWORD}' && ./build.sh -t ${params.BUILD_TYPE} -o /opt/milvus -l -g -j -u -c"
         }
     }
 }

ci/jenkins/step/coverage.groovy

@@ -1,5 +1,5 @@
 timeout(time: 30, unit: 'MINUTES') {
-    dir ("ci/jenkins/scripts") {
+    dir ("ci/scripts") {
         sh "./coverage.sh -o /opt/milvus -u root -p 123456 -t \$POD_IP"
         // Set some env variables so codecov detection script works correctly
         withCredentials([[$class: 'StringBinding', credentialsId: "${env.PIPELINE_NAME}-codecov-token", variable: 'CODECOV_TOKEN']]) {

ci/scripts/build.sh

@@ -1,5 +1,7 @@
 #!/bin/bash
 
+set -e
+
 SOURCE="${BASH_SOURCE[0]}"
 while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
   DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
@@ -8,38 +10,37 @@ while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symli
 done
 SCRIPTS_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
 
-CMAKE_BUILD_DIR="${SCRIPTS_DIR}/../../../core/cmake_build"
+MILVUS_CORE_DIR="${SCRIPTS_DIR}/../../core"
+CORE_BUILD_DIR="${MILVUS_CORE_DIR}/cmake_build"
 BUILD_TYPE="Debug"
 BUILD_UNITTEST="OFF"
 INSTALL_PREFIX="/opt/milvus"
+FAISS_ROOT=""
 BUILD_COVERAGE="OFF"
-DB_PATH="/opt/milvus"
-PROFILING="OFF"
 USE_JFROG_CACHE="OFF"
 RUN_CPPLINT="OFF"
-CUSTOMIZATION="OFF" # default use ori faiss
+GPU_VERSION="OFF"
+WITH_MKL="OFF"
 CUDA_COMPILER=/usr/local/cuda/bin/nvcc
 
-CUSTOMIZED_FAISS_URL="${FAISS_URL:-NONE}"
-wget -q --method HEAD ${CUSTOMIZED_FAISS_URL}
-if [ $? -eq 0 ]; then
-  CUSTOMIZATION="ON"
-else
-  CUSTOMIZATION="OFF"
-fi
-
-while getopts "o:d:t:ulcgjhx" arg
+while getopts "o:t:b:f:gulcjmh" arg
 do
         case $arg in
              o)
                 INSTALL_PREFIX=$OPTARG
                 ;;
-             d)
-                DB_PATH=$OPTARG
-                ;;
              t)
                 BUILD_TYPE=$OPTARG # BUILD_TYPE
                 ;;
+             b)
+                CORE_BUILD_DIR=$OPTARG # CORE_BUILD_DIR
+                ;;
+             f)
+                FAISS_ROOT=$OPTARG # FAISS ROOT PATH
+                ;;
+             g)
+                GPU_VERSION="ON";
+                ;;
              u)
                 echo "Build and run unittest cases" ;
                 BUILD_UNITTEST="ON";
@@ -50,31 +51,30 @@ do
              c)
                 BUILD_COVERAGE="ON"
                 ;;
-             g)
-                PROFILING="ON"
-                ;;
              j)
                 USE_JFROG_CACHE="ON"
                 ;;
-             x)
-                CUSTOMIZATION="OFF" # force use ori faiss
+             m)
+                WITH_MKL="ON"
                 ;;
              h) # help
                 echo "
 
 parameter:
 -o: install prefix(default: /opt/milvus)
--d: db data path(default: /opt/milvus)
 -t: build type(default: Debug)
+-b: core code build directory
+-f: faiss root path
+-g: gpu version
 -u: building unit test options(default: OFF)
 -l: run cpplint, clang-format and clang-tidy(default: OFF)
 -c: code coverage(default: OFF)
--g: profiling(default: OFF)
 -j: use jfrog cache build directory(default: OFF)
+-m: build with MKL(default: OFF)
 -h: help
 
 usage:
-./build.sh -p \${INSTALL_PREFIX} -t \${BUILD_TYPE} [-u] [-l] [-r] [-c] [-g] [-j] [-h]
+./build.sh -o \${INSTALL_PREFIX} -t \${BUILD_TYPE} -b \${CORE_BUILD_DIR} -f \${FAISS_ROOT} [-u] [-l] [-c] [-j] [-m] [-h]
                 "
                 exit 0
                 ;;
@@ -85,31 +85,29 @@ usage:
         esac
 done
 
-if [[ ! -d ${CMAKE_BUILD_DIR} ]]; then
-    mkdir ${CMAKE_BUILD_DIR}
+if [[ ! -d ${CORE_BUILD_DIR} ]]; then
+    mkdir ${CORE_BUILD_DIR}
 fi
 
-cd ${CMAKE_BUILD_DIR}
-
-# remove make cache since build.sh -l use default variables
-# force update the variables each time
-make rebuild_cache
+cd ${CORE_BUILD_DIR}
 
 CMAKE_CMD="cmake \
--DBUILD_UNIT_TEST=${BUILD_UNITTEST} \
 -DCMAKE_INSTALL_PREFIX=${INSTALL_PREFIX}
 -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
 -DCMAKE_CUDA_COMPILER=${CUDA_COMPILER} \
+-DMILVUS_GPU_VERSION=${GPU_VERSION} \
+-DBUILD_UNIT_TEST=${BUILD_UNITTEST} \
 -DBUILD_COVERAGE=${BUILD_COVERAGE} \
--DMILVUS_DB_PATH=${DB_PATH} \
--DMILVUS_ENABLE_PROFILING=${PROFILING} \
 -DUSE_JFROG_CACHE=${USE_JFROG_CACHE} \
--DCUSTOMIZATION=${CUSTOMIZATION} \
--DFAISS_URL=${CUSTOMIZED_FAISS_URL} \
-.."
+-DFAISS_ROOT=${FAISS_ROOT} \
+-DFAISS_WITH_MKL=${WITH_MKL} \
+-DArrow_SOURCE=AUTO \
+-DFAISS_SOURCE=AUTO \
+${MILVUS_CORE_DIR}"
 echo ${CMAKE_CMD}
 ${CMAKE_CMD}
 
+
 if [[ ${RUN_CPPLINT} == "ON" ]]; then
     # cpplint check
     make lint
@@ -135,8 +133,8 @@ if [[ ${RUN_CPPLINT} == "ON" ]]; then
 #        exit 1
 #    fi
 #    echo "clang-tidy check passed!"
-else
-    # compile and build
-    make -j8 || exit 1
-    make install || exit 1
 fi
+
+# compile and build
+make -j8 || exit 1
+make install || exit 1

ci/scripts/coverage.sh

@@ -9,18 +9,22 @@ done
 SCRIPTS_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
 
 INSTALL_PREFIX="/opt/milvus"
-CMAKE_BUILD_DIR="${SCRIPTS_DIR}/../../../core/cmake_build"
+MILVUS_CORE_DIR="${SCRIPTS_DIR}/../../core"
+CORE_BUILD_DIR="${MILVUS_CORE_DIR}/cmake_build"
 MYSQL_USER_NAME=root
 MYSQL_PASSWORD=123456
 MYSQL_HOST='127.0.0.1'
 MYSQL_PORT='3306'
 
-while getopts "o:u:p:t:h" arg
+while getopts "o:b:u:p:t:h" arg
 do
         case $arg in
              o)
                 INSTALL_PREFIX=$OPTARG
                 ;;
+             b)
+                CORE_BUILD_DIR=$OPTARG # CORE_BUILD_DIR
+                ;;
              u)
                 MYSQL_USER_NAME=$OPTARG
                 ;;
@@ -35,13 +39,14 @@ do
 
 parameter:
 -o: milvus install prefix(default: /opt/milvus)
+-b: core code build directory
 -u: mysql account
 -p: mysql password
 -t: mysql host
 -h: help
 
 usage:
-./coverage.sh -o \${INSTALL_PREFIX} -u \${MYSQL_USER} -p \${MYSQL_PASSWORD} -t \${MYSQL_HOST} [-h]
+./coverage.sh -o \${INSTALL_PREFIX} -b \${CORE_BUILD_DIR} -u \${MYSQL_USER} -p \${MYSQL_PASSWORD} -t \${MYSQL_HOST} [-h]
                 "
                 exit 0
                 ;;
@@ -63,12 +68,14 @@ FILE_INFO_OUTPUT="output.info"
 FILE_INFO_OUTPUT_NEW="output_new.info"
 DIR_LCOV_OUTPUT="lcov_out"
 
-DIR_GCNO="${CMAKE_BUILD_DIR}"
+DIR_GCNO="${CORE_BUILD_DIR}"
 DIR_UNITTEST="${INSTALL_PREFIX}/unittest"
 
+cd ${SCRIPTS_DIR}
+
 # delete old code coverage info files
-rm -rf lcov_out
-rm -f FILE_INFO_BASE FILE_INFO_MILVUS FILE_INFO_OUTPUT FILE_INFO_OUTPUT_NEW
+rm -rf ${DIR_LCOV_OUTPUT}
+rm -f ${FILE_INFO_BASE} ${FILE_INFO_MILVUS} ${FILE_INFO_OUTPUT} ${FILE_INFO_OUTPUT_NEW}
 
 MYSQL_DB_NAME=milvus_`date +%s%N`
 
@@ -132,8 +139,7 @@ ${LCOV_CMD} -r "${FILE_INFO_OUTPUT}" -o "${FILE_INFO_OUTPUT_NEW}" \
     "*/src/server/Server.cpp" \
     "*/src/server/DBWrapper.cpp" \
     "*/src/server/grpc_impl/GrpcServer.cpp" \
-    "*/src/external/easyloggingpp/easylogging++.h" \
-    "*/src/external/easyloggingpp/easylogging++.cc"
+    "*/thirdparty/*"
 
 if [ $? -ne 0 ]; then
     echo "gen ${FILE_INFO_OUTPUT_NEW} failed"

ci/travis/before-install.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+set -ex
+
+if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
+  export CCACHE_COMPRESS=1
+  export CCACHE_COMPRESSLEVEL=5
+  export CCACHE_COMPILERCHECK=content
+  export PATH=/usr/lib/ccache/:$PATH
+  ccache --show-stats
+fi
+
+set +ex

ci/travis/install_dependency.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+
+set -e
+
+wget -P /tmp https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2019.PUB
+
+sudo apt-key add /tmp/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2019.PUB
+
+echo "deb https://apt.repos.intel.com/mkl all main" | \
+  sudo tee /etc/apt/sources.list.d/intel-mkl.list
+
+sudo wget -O /usr/share/keyrings/apache-arrow-keyring.gpg https://dl.bintray.com/apache/arrow/$(lsb_release --id --short | tr 'A-Z' 'a-z')/apache-arrow-keyring.gpg
+
+sudo tee /etc/apt/sources.list.d/apache-arrow.list <<APT_LINE
+deb [arch=amd64 signed-by=/usr/share/keyrings/apache-arrow-keyring.gpg] https://dl.bintray.com/apache/arrow/$(lsb_release --id --short | tr 'A-Z' 'a-z')/ $(lsb_release --codename --short) main
+deb-src [signed-by=/usr/share/keyrings/apache-arrow-keyring.gpg] https://dl.bintray.com/apache/arrow/$(lsb_release --id --short | tr 'A-Z' 'a-z')/ $(lsb_release --codename --short) main
+APT_LINE
+
+sudo apt-get update -qq
+
+sudo apt-get install -y -q --no-install-recommends \
+  gfortran \
+  lsb-core \
+  libtool \
+  automake \
+  ccache \
+  pkg-config \
+  libarrow-dev \
+  libjemalloc-dev \
+  libboost-serialization-dev \
+  libboost-filesystem-dev \
+  libboost-system-dev \
+  libboost-regex-dev \
+  intel-mkl-gnu-2019.5-281 \
+  intel-mkl-core-2019.5-281 \
+  libmysqlclient-dev \
+  clang-format-6.0 \
+  clang-tidy-6.0 \
+  lcov
+
+sudo ln -s /usr/lib/x86_64-linux-gnu/libmysqlclient.so \
+  /usr/lib/x86_64-linux-gnu/libmysqlclient_r.so
+
+export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/opt/intel/compilers_and_libraries_2019.5.281/linux/mkl/lib/intel64

ci/travis/travis_build.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+
+set -ex
+
+source $TRAVIS_BUILD_DIR/ci/travis/travis_env_common.sh
+
+only_library_mode=no
+
+while true; do
+    case "$1" in
+	--only-library)
+	    only_library_mode=yes
+	    shift ;;
+	*) break ;;
+    esac
+done
+
+BUILD_COMMON_FLAGS="-t ${MILVUS_BUILD_TYPE} -o ${MILVUS_INSTALL_PREFIX} -b ${MILVUS_BUILD_DIR}"
+
+if [ $only_library_mode == "yes" ]; then
+  ${TRAVIS_BUILD_DIR}/ci/scripts/build.sh ${BUILD_COMMON_FLAGS} -m
+else
+  ${TRAVIS_BUILD_DIR}/ci/scripts/build.sh ${BUILD_COMMON_FLAGS} -m -u -c
+fi

ci/travis/travis_env_common.sh

@@ -0,0 +1,10 @@
+export MILVUS_CORE_DIR=${TRAVIS_BUILD_DIR}/core
+export MILVUS_BUILD_DIR=${TRAVIS_BUILD_DIR}/core/cmake_build
+export MILVUS_INSTALL_PREFIX=/opt/milvus
+export MILVUS_TRAVIS_COVERAGE=${MILVUS_TRAVIS_COVERAGE:=0}
+
+if [ "${MILVUS_TRAVIS_COVERAGE}" == "1" ]; then
+  export MILVUS_CPP_COVERAGE_FILE=${TRAVIS_BUILD_DIR}/output_new.info
+fi
+
+export MILVUS_BUILD_TYPE=${MILVUS_BUILD_TYPE:=Release}

core/.gitignore

@@ -2,7 +2,7 @@ milvus/
 conf/server_config.yaml
 conf/log_config.conf
 src/config.h
-version.h
+src/version.h
 lcov_out/
 base.info
 output.info

core/CMakeLists.txt

@@ -18,7 +18,7 @@
 #-------------------------------------------------------------------------------
 
 
-cmake_minimum_required(VERSION 3.14)
+cmake_minimum_required(VERSION 3.12)
 message(STATUS "Building using CMake version: ${CMAKE_VERSION}")
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
@@ -32,10 +32,8 @@ string(REGEX REPLACE "\n" "" BUILD_TIME ${BUILD_TIME})
 message(STATUS "Build time = ${BUILD_TIME}")
 
 MACRO(GET_GIT_BRANCH_NAME GIT_BRANCH_NAME)
-    execute_process(COMMAND "git" rev-parse --abbrev-ref HEAD OUTPUT_VARIABLE ${GIT_BRANCH_NAME})
-    if (GIT_BRANCH_NAME STREQUAL "")
-        execute_process(COMMAND "git" symbolic-ref --short -q HEAD OUTPUT_VARIABLE ${GIT_BRANCH_NAME})
-    endif ()
+    execute_process(COMMAND sh "-c" "git log --decorate | head -n 1 | sed 's/.*(\\(.*\\))/\\1/' | sed 's/.* \\(.*\\),.*/\\1/' | sed 's=[a-zA-Z]*\/==g'"
+                    OUTPUT_VARIABLE ${GIT_BRANCH_NAME})
 ENDMACRO(GET_GIT_BRANCH_NAME)
 
 GET_GIT_BRANCH_NAME(GIT_BRANCH_NAME)
@@ -69,7 +67,7 @@ if (MILVUS_VERSION_MAJOR STREQUAL ""
         OR MILVUS_VERSION_PATCH STREQUAL "")
     message(WARNING "Failed to determine Milvus version from git branch name")
     set(MILVUS_VERSION "0.6.0")
-endif ()
+endif()
 
 message(STATUS "Build version = ${MILVUS_VERSION}")
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/config.h.in ${CMAKE_CURRENT_SOURCE_DIR}/src/config.h @ONLY)
@@ -112,12 +110,25 @@ endif ()
 set(MILVUS_SOURCE_DIR ${PROJECT_SOURCE_DIR})
 set(MILVUS_BINARY_DIR ${PROJECT_BINARY_DIR})
 set(MILVUS_ENGINE_SRC ${PROJECT_SOURCE_DIR}/src)
+set(MILVUS_THIRDPARTY_SRC ${PROJECT_SOURCE_DIR}/thirdparty)
 
 include(ExternalProject)
 include(DefineOptions)
 include(BuildUtils)
 include(ThirdPartyPackages)
 
+if(MILVUS_USE_CCACHE)
+  find_program(CCACHE_FOUND ccache)
+  if(CCACHE_FOUND)
+    message(STATUS "Using ccache: ${CCACHE_FOUND}")
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE_FOUND})
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE_FOUND})
+    # let ccache preserve C++ comments, because some of them may be
+    # meaningful to the compiler
+    set(ENV{CCACHE_COMMENTS} "1")
+  endif(CCACHE_FOUND)
+endif()
+
 set(MILVUS_CPU_VERSION false)
 if (MILVUS_GPU_VERSION)
     message(STATUS "Building Milvus GPU version")
@@ -162,7 +173,13 @@ add_custom_target(Clean-All COMMAND ${CMAKE_BUILD_TOOL} clean)
 if ("${MILVUS_DB_PATH}" STREQUAL "")
     set(MILVUS_DB_PATH "/tmp/milvus")
 endif ()
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/conf/server_config.template ${CMAKE_CURRENT_SOURCE_DIR}/conf/server_config.yaml)
+
+if (MILVUS_GPU_VERSION)
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/conf/server_gpu_config.template ${CMAKE_CURRENT_SOURCE_DIR}/conf/server_config.yaml)
+else()
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/conf/server_cpu_config.template ${CMAKE_CURRENT_SOURCE_DIR}/conf/server_config.yaml)
+endif()
+
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/conf/log_config.template ${CMAKE_CURRENT_SOURCE_DIR}/conf/log_config.conf)
 
 install(DIRECTORY scripts/
@@ -273,4 +290,4 @@ if (${CLANG_TIDY_FOUND})
             --source_dir
             ${CMAKE_CURRENT_SOURCE_DIR}/src
             ${MILVUS_LINT_QUIET})
-endif ()
+endif ()

core/build-support/lint_exclusions.txt

@@ -6,5 +6,5 @@
 *easylogging++*
 *SqliteMetaImpl.cpp
 *src/grpc*
-*src/external*
+*thirdparty*
 *milvus/include*

core/build.sh

@@ -14,16 +14,10 @@ CUSTOMIZATION="OFF" # default use ori faiss
 CUDA_COMPILER=/usr/local/cuda/bin/nvcc
 GPU_VERSION="OFF" #defaults to CPU version
 WITH_MKL="OFF"
+FAISS_ROOT=""
+FAISS_SOURCE="BUNDLED"
 
-CUSTOMIZED_FAISS_URL="${FAISS_URL:-NONE}"
-wget -q --method HEAD ${CUSTOMIZED_FAISS_URL}
-if [ $? -eq 0 ]; then
-  CUSTOMIZATION="ON"
-else
-  CUSTOMIZATION="OFF"
-fi
-
-while getopts "p:d:t:ulrcgjhxzm" arg
+while getopts "p:d:t:f:ulrcgjhxzm" arg
 do
         case $arg in
              p)
@@ -35,6 +29,10 @@ do
              t)
                 BUILD_TYPE=$OPTARG # BUILD_TYPE
                 ;;
+             f)
+                FAISS_ROOT=$OPTARG
+                FAISS_SOURCE="AUTO"
+                ;;
              u)
                 echo "Build and run unittest cases" ;
                 BUILD_UNITTEST="ON";
@@ -73,6 +71,7 @@ parameter:
 -p: install prefix(default: $(pwd)/milvus)
 -d: db data path(default: /tmp/milvus)
 -t: build type(default: Debug)
+-f: faiss root path(default: empty)
 -u: building unit test options(default: OFF)
 -l: run cpplint, clang-format and clang-tidy(default: OFF)
 -r: remove previous build directory(default: OFF)
@@ -84,7 +83,7 @@ parameter:
 -h: help
 
 usage:
-./build.sh -p \${INSTALL_PREFIX} -t \${BUILD_TYPE} [-u] [-l] [-r] [-c] [-z] [-j] [-g] [-m] [-h]
+./build.sh -p \${INSTALL_PREFIX} -t \${BUILD_TYPE} -f \${FAISS_ROOT} [-u] [-l] [-r] [-c] [-z] [-j] [-g] [-m] [-h]
                 "
                 exit 0
                 ;;
@@ -109,15 +108,16 @@ CMAKE_CMD="cmake \
 -DBUILD_UNIT_TEST=${BUILD_UNITTEST} \
 -DCMAKE_INSTALL_PREFIX=${INSTALL_PREFIX}
 -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
+-DFAISS_ROOT=${FAISS_ROOT} \
+-DFAISS_SOURCE=${FAISS_SOURCE} \
 -DCMAKE_CUDA_COMPILER=${CUDA_COMPILER} \
 -DBUILD_COVERAGE=${BUILD_COVERAGE} \
 -DMILVUS_DB_PATH=${DB_PATH} \
 -DMILVUS_ENABLE_PROFILING=${PROFILING} \
 -DUSE_JFROG_CACHE=${USE_JFROG_CACHE} \
 -DCUSTOMIZATION=${CUSTOMIZATION} \
--DFAISS_URL=${CUSTOMIZED_FAISS_URL} \
 -DMILVUS_GPU_VERSION=${GPU_VERSION} \
--DBUILD_FAISS_WITH_MKL=${WITH_MKL} \
+-DFAISS_WITH_MKL=${WITH_MKL} \
 ../"
 echo ${CMAKE_CMD}
 ${CMAKE_CMD}

core/cmake/DefineOptions.cmake

@@ -48,7 +48,7 @@ define_option(MILVUS_GPU_VERSION "Build GPU version" OFF)
 #----------------------------------------------------------------------
 set_option_category("Thirdparty")
 
-set(MILVUS_DEPENDENCY_SOURCE_DEFAULT "AUTO")
+set(MILVUS_DEPENDENCY_SOURCE_DEFAULT "BUNDLED")
 
 define_option_string(MILVUS_DEPENDENCY_SOURCE
         "Method to use for acquiring MILVUS's build dependencies"
@@ -57,6 +57,8 @@ define_option_string(MILVUS_DEPENDENCY_SOURCE
         "BUNDLED"
         "SYSTEM")
 
+define_option(MILVUS_USE_CCACHE "Use ccache when compiling (if available)" ON)
+
 define_option(MILVUS_VERBOSE_THIRDPARTY_BUILD
         "Show output from ExternalProjects rather than just logging to files" ON)
 

core/cmake/ThirdPartyPackages.cmake

@@ -164,8 +164,10 @@ endif ()
 
 macro(resolve_dependency DEPENDENCY_NAME)
     if (${DEPENDENCY_NAME}_SOURCE STREQUAL "AUTO")
-        #disable find_package for now
-        build_dependency(${DEPENDENCY_NAME})
+        find_package(${DEPENDENCY_NAME} MODULE)
+        if(NOT ${${DEPENDENCY_NAME}_FOUND})
+          build_dependency(${DEPENDENCY_NAME})
+        endif()
     elseif (${DEPENDENCY_NAME}_SOURCE STREQUAL "BUNDLED")
         build_dependency(${DEPENDENCY_NAME})
     elseif (${DEPENDENCY_NAME}_SOURCE STREQUAL "SYSTEM")

core/conf/server_cpu_config.template

@@ -0,0 +1,43 @@
+# Default values are used when you make no changes to the following parameters.
+
+server_config:
+  address: 0.0.0.0                  # milvus server ip address (IPv4)
+  port: 19530                       # milvus server port, must in range [1025, 65534]
+  deploy_mode: single               # deployment type: single, cluster_readonly, cluster_writable
+  time_zone: UTC+8                  # time zone, must be in format: UTC+X
+
+db_config:
+  primary_path: @MILVUS_DB_PATH@    # path used to store data and meta
+  secondary_path:                   # path used to store data only, split by semicolon
+
+  backend_url: sqlite://:@:/        # URI format: dialect://username:password@host:port/database
+                                    # Keep 'dialect://:@:/', and replace other texts with real values
+                                    # Replace 'dialect' with 'mysql' or 'sqlite'
+
+  insert_buffer_size: 4             # GB, maximum insert buffer size allowed, must be a positive integer
+                                    # sum of insert_buffer_size and cpu_cache_capacity cannot exceed total memory
+
+  preload_table:                    # preload data at startup, '*' means load all tables, empty value means no preload
+                                    # you can specify preload tables like this: table1,table2,table3
+
+metric_config:
+  enable_monitor: false             # enable monitoring or not, must be a boolean
+  collector: prometheus             # prometheus
+  prometheus_config:
+    port: 8080                      # port prometheus uses to fetch metrics, must in range [1025, 65534]
+
+cache_config:
+
+  cpu_cache_capacity: 16            # GB, CPU memory used for cache, must be a positive integer
+  cpu_cache_threshold: 0.85         # percentage of data that will be kept when cache cleanup is triggered, must be in range (0.0, 1.0]
+  cache_insert_data: false          # whether to load inserted data into cache, must be a boolean
+
+engine_config:
+  use_blas_threshold: 1100          # if nq <  use_blas_threshold, use SSE, faster with fluctuated response times
+                                    # if nq >= use_blas_threshold, use OpenBlas, slower with stable response times
+  gpu_search_threshold: 1000        # threshold beyond which the search computation is executed on GPUs only
+
+resource_config:
+  search_resources:                 # define the device used for search computation
+    - cpu
+  index_build_device: cpu           # CPU used for building index

core/conf/server_gpu_config.template

@@ -27,15 +27,12 @@ metric_config:
     port: 8080                      # port prometheus uses to fetch metrics, must in range [1025, 65534]
 
 cache_config:
-
   cpu_cache_capacity: 16            # GB, CPU memory used for cache, must be a positive integer
   cpu_cache_threshold: 0.85         # percentage of data that will be kept when cache cleanup is triggered, must be in range (0.0, 1.0]
+  gpu_cache_capacity: 4             # GB, GPU memory used for cache, must be a positive integer
+  gpu_cache_threshold: 0.85         # percentage of data that will be kept when cache cleanup is triggered, must be in range (0.0, 1.0]
   cache_insert_data: false          # whether to load inserted data into cache, must be a boolean
 
-#Uncomment the following config if you are using GPU version
-#  gpu_cache_capacity: 4             # GB, GPU memory used for cache, must be a positive integer
-#  gpu_cache_threshold: 0.85         # percentage of data that will be kept when cache cleanup is triggered, must be in range (0.0, 1.0]
-
 engine_config:
   use_blas_threshold: 1100          # if nq <  use_blas_threshold, use SSE, faster with fluctuated response times
                                     # if nq >= use_blas_threshold, use OpenBlas, slower with stable response times
@@ -44,4 +41,5 @@ engine_config:
 resource_config:
   search_resources:                 # define the devices used for search computation, must be in format: cpu or gpux
     - cpu
-  index_build_device: cpu           # CPU / GPU used for building index, must be in format: cpu / gpux
+    - gpu0
+  index_build_device: gpu0          # CPU / GPU used for building index, must be in format: cpu or gpux

core/coverage.sh

@@ -122,9 +122,7 @@ ${LCOV_CMD} -r "${FILE_INFO_OUTPUT}" -o "${FILE_INFO_OUTPUT_NEW}" \
     "*/src/server/Server.cpp" \
     "*/src/server/DBWrapper.cpp" \
     "*/src/server/grpc_impl/GrpcServer.cpp" \
-    "*/easylogging++.h" \
-    "*/easylogging++.cc" \
-    "*/src/external/*"
+    "*/thirdparty/*"
 
 if [ $? -ne 0 ]; then
     echo "generate ${FILE_INFO_OUTPUT_NEW} failed"

core/src/CMakeLists.txt

@@ -19,12 +19,13 @@
 
 include_directories(${MILVUS_SOURCE_DIR})
 include_directories(${MILVUS_ENGINE_SRC})
+include_directories(${MILVUS_THIRDPARTY_SRC})
 
 include_directories(${MILVUS_ENGINE_SRC}/grpc/gen-status)
 include_directories(${MILVUS_ENGINE_SRC}/grpc/gen-milvus)
 
 add_subdirectory(index)
-if (BUILD_FAISS_WITH_MKL)
+if (FAISS_WITH_MKL)
     add_compile_definitions("WITH_MKL")
 endif ()
 
@@ -65,11 +66,11 @@ set(scheduler_files
         ${scheduler_task_files}
         )
 
-aux_source_directory(${MILVUS_ENGINE_SRC}/external/easyloggingpp external_easyloggingpp_files)
-aux_source_directory(${MILVUS_ENGINE_SRC}/external/nlohmann external_nlohmann_files)
-set(external_files
-        ${external_easyloggingpp_files}
-        ${external_nlohmann_files}
+aux_source_directory(${MILVUS_THIRDPARTY_SRC}/easyloggingpp thirdparty_easyloggingpp_files)
+aux_source_directory(${MILVUS_THIRDPARTY_SRC}/nlohmann thirdparty_nlohmann_files)
+set(thirdparty_files
+        ${thirdparty_easyloggingpp_files}
+        ${thirdparty_nlohmann_files}
         )
 
 aux_source_directory(${MILVUS_ENGINE_SRC}/server server_files)
@@ -85,7 +86,7 @@ set(engine_files
         ${db_insert_files}
         ${db_meta_files}
         ${metrics_files}
-        ${external_files}
+        ${thirdparty_files}
         ${utils_files}
         ${wrapper_files}
         )

core/src/grpc/README.md

@@ -0,0 +1,6 @@
+We manually change two APIs in "milvus.pd.h":
+    add_vector_data()
+    add_row_id_array()
+    add_ids()
+    add_distances()
+If proto files need be generated again, remember to re-change above APIs.

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

@@ -431,60 +431,60 @@ void MilvusService::Stub::experimental_async::Insert(::grpc::ClientContext* cont
   return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::VectorIds>::Create(channel_.get(), cq, rpcmethod_Insert_, context, request, false);
 }
 
-::grpc::Status MilvusService::Stub::Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::milvus::grpc::TopKQueryResultList* response) {
+::grpc::Status MilvusService::Stub::Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::milvus::grpc::TopKQueryResult* response) {
   return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_Search_, context, request, response);
 }
 
-void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)> f) {
+void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)> f) {
   ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Search_, context, request, response, std::move(f));
 }
 
-void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)> f) {
+void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)> f) {
   ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Search_, context, request, response, std::move(f));
 }
 
-void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
   ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Search_, context, request, response, reactor);
 }
 
-void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
   ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Search_, context, request, response, reactor);
 }
 
-::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* MilvusService::Stub::AsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
-  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResultList>::Create(channel_.get(), cq, rpcmethod_Search_, context, request, true);
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::AsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_Search_, context, request, true);
 }
 
-::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* MilvusService::Stub::PrepareAsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
-  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResultList>::Create(channel_.get(), cq, rpcmethod_Search_, context, request, false);
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::PrepareAsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_Search_, context, request, false);
 }
 
-::grpc::Status MilvusService::Stub::SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::milvus::grpc::TopKQueryResultList* response) {
+::grpc::Status MilvusService::Stub::SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::milvus::grpc::TopKQueryResult* response) {
   return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_SearchInFiles_, context, request, response);
 }
 
-void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)> f) {
+void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)> f) {
   ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_SearchInFiles_, context, request, response, std::move(f));
 }
 
-void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)> f) {
+void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)> f) {
   ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_SearchInFiles_, context, request, response, std::move(f));
 }
 
-void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
   ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_SearchInFiles_, context, request, response, reactor);
 }
 
-void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
   ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_SearchInFiles_, context, request, response, reactor);
 }
 
-::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* MilvusService::Stub::AsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
-  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResultList>::Create(channel_.get(), cq, rpcmethod_SearchInFiles_, context, request, true);
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::AsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_SearchInFiles_, context, request, true);
 }
 
-::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* MilvusService::Stub::PrepareAsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
-  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResultList>::Create(channel_.get(), cq, rpcmethod_SearchInFiles_, context, request, false);
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::PrepareAsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_SearchInFiles_, context, request, false);
 }
 
 ::grpc::Status MilvusService::Stub::Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::StringReply* response) {
@@ -640,12 +640,12 @@ MilvusService::Service::Service() {
   AddMethod(new ::grpc::internal::RpcServiceMethod(
       MilvusService_method_names[13],
       ::grpc::internal::RpcMethod::NORMAL_RPC,
-      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResultList>(
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResult>(
           std::mem_fn(&MilvusService::Service::Search), this)));
   AddMethod(new ::grpc::internal::RpcServiceMethod(
       MilvusService_method_names[14],
       ::grpc::internal::RpcMethod::NORMAL_RPC,
-      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResultList>(
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResult>(
           std::mem_fn(&MilvusService::Service::SearchInFiles), this)));
   AddMethod(new ::grpc::internal::RpcServiceMethod(
       MilvusService_method_names[15],
@@ -758,14 +758,14 @@ MilvusService::Service::~Service() {
   return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
 }
 
-::grpc::Status MilvusService::Service::Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response) {
+::grpc::Status MilvusService::Service::Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResult* response) {
   (void) context;
   (void) request;
   (void) response;
   return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
 }
 
-::grpc::Status MilvusService::Service::SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response) {
+::grpc::Status MilvusService::Service::SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResult* response) {
   (void) context;
   (void) request;
   (void) response;

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

@@ -221,26 +221,26 @@ class MilvusService final {
     //
     // @param SearchParam, search parameters.
     //
-    // @return TopKQueryResultList
-    virtual ::grpc::Status Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::milvus::grpc::TopKQueryResultList* response) = 0;
-    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>> AsyncSearch(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>>(AsyncSearchRaw(context, request, cq));
+    // @return TopKQueryResult
+    virtual ::grpc::Status Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::milvus::grpc::TopKQueryResult* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>> AsyncSearch(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>>(AsyncSearchRaw(context, request, cq));
     }
-    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>> PrepareAsyncSearch(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>>(PrepareAsyncSearchRaw(context, request, cq));
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>> PrepareAsyncSearch(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>>(PrepareAsyncSearchRaw(context, request, cq));
     }
     // *
     // @brief This method is used to query vector in specified files.
     //
     // @param SearchInFilesParam, search in files paremeters.
     //
-    // @return TopKQueryResultList
-    virtual ::grpc::Status SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::milvus::grpc::TopKQueryResultList* response) = 0;
-    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>> AsyncSearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>>(AsyncSearchInFilesRaw(context, request, cq));
+    // @return TopKQueryResult
+    virtual ::grpc::Status SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::milvus::grpc::TopKQueryResult* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>> AsyncSearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>>(AsyncSearchInFilesRaw(context, request, cq));
     }
-    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>> PrepareAsyncSearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>>(PrepareAsyncSearchInFilesRaw(context, request, cq));
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>> PrepareAsyncSearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>>(PrepareAsyncSearchInFilesRaw(context, request, cq));
     }
     // *
     // @brief This method is used to give the server status.
@@ -419,21 +419,21 @@ class MilvusService final {
       //
       // @param SearchParam, search parameters.
       //
-      // @return TopKQueryResultList
-      virtual void Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) = 0;
-      virtual void Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) = 0;
-      virtual void Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
-      virtual void Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // @return TopKQueryResult
+      virtual void Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
       // *
       // @brief This method is used to query vector in specified files.
       //
       // @param SearchInFilesParam, search in files paremeters.
       //
-      // @return TopKQueryResultList
-      virtual void SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) = 0;
-      virtual void SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) = 0;
-      virtual void SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
-      virtual void SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // @return TopKQueryResult
+      virtual void SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
       // *
       // @brief This method is used to give the server status.
       //
@@ -493,10 +493,10 @@ class MilvusService final {
     virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDropPartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) = 0;
     virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::VectorIds>* AsyncInsertRaw(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) = 0;
     virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::VectorIds>* PrepareAsyncInsertRaw(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) = 0;
-    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>* AsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) = 0;
-    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>* PrepareAsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) = 0;
-    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>* AsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) = 0;
-    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>* PrepareAsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>* AsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>* PrepareAsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>* AsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>* PrepareAsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) = 0;
     virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::StringReply>* AsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0;
     virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::StringReply>* PrepareAsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0;
     virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDeleteByDateRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByDateParam& request, ::grpc::CompletionQueue* cq) = 0;
@@ -598,19 +598,19 @@ class MilvusService final {
     std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::VectorIds>> PrepareAsyncInsert(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) {
       return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::VectorIds>>(PrepareAsyncInsertRaw(context, request, cq));
     }
-    ::grpc::Status Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::milvus::grpc::TopKQueryResultList* response) override;
-    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>> AsyncSearch(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>>(AsyncSearchRaw(context, request, cq));
+    ::grpc::Status Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::milvus::grpc::TopKQueryResult* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>> AsyncSearch(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>>(AsyncSearchRaw(context, request, cq));
     }
-    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>> PrepareAsyncSearch(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>>(PrepareAsyncSearchRaw(context, request, cq));
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>> PrepareAsyncSearch(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>>(PrepareAsyncSearchRaw(context, request, cq));
     }
-    ::grpc::Status SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::milvus::grpc::TopKQueryResultList* response) override;
-    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>> AsyncSearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>>(AsyncSearchInFilesRaw(context, request, cq));
+    ::grpc::Status SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::milvus::grpc::TopKQueryResult* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>> AsyncSearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>>(AsyncSearchInFilesRaw(context, request, cq));
     }
-    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>> PrepareAsyncSearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>>(PrepareAsyncSearchInFilesRaw(context, request, cq));
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>> PrepareAsyncSearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>>(PrepareAsyncSearchInFilesRaw(context, request, cq));
     }
     ::grpc::Status Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::StringReply* response) override;
     std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>> AsyncCmd(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
@@ -688,14 +688,14 @@ class MilvusService final {
       void Insert(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, std::function<void(::grpc::Status)>) override;
       void Insert(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
       void Insert(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
-      void Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) override;
-      void Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) override;
-      void Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
-      void Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
-      void SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) override;
-      void SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) override;
-      void SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
-      void SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)>) override;
+      void Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)>) override;
+      void Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)>) override;
+      void SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)>) override;
+      void SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
       void Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response, std::function<void(::grpc::Status)>) override;
       void Cmd(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::StringReply* response, std::function<void(::grpc::Status)>) override;
       void Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
@@ -745,10 +745,10 @@ class MilvusService final {
     ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDropPartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) override;
     ::grpc::ClientAsyncResponseReader< ::milvus::grpc::VectorIds>* AsyncInsertRaw(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) override;
     ::grpc::ClientAsyncResponseReader< ::milvus::grpc::VectorIds>* PrepareAsyncInsertRaw(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) override;
-    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* AsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) override;
-    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* PrepareAsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) override;
-    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* AsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) override;
-    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* PrepareAsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* AsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* PrepareAsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* AsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* PrepareAsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) override;
     ::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>* AsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override;
     ::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>* PrepareAsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override;
     ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDeleteByDateRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByDateParam& request, ::grpc::CompletionQueue* cq) override;
@@ -876,15 +876,15 @@ class MilvusService final {
     //
     // @param SearchParam, search parameters.
     //
-    // @return TopKQueryResultList
-    virtual ::grpc::Status Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response);
+    // @return TopKQueryResult
+    virtual ::grpc::Status Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResult* response);
     // *
     // @brief This method is used to query vector in specified files.
     //
     // @param SearchInFilesParam, search in files paremeters.
     //
-    // @return TopKQueryResultList
-    virtual ::grpc::Status SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response);
+    // @return TopKQueryResult
+    virtual ::grpc::Status SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResult* response);
     // *
     // @brief This method is used to give the server status.
     //
@@ -1179,11 +1179,11 @@ class MilvusService final {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status Search(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchParam* /*request*/, ::milvus::grpc::TopKQueryResultList* /*response*/) override {
+    ::grpc::Status Search(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestSearch(::grpc::ServerContext* context, ::milvus::grpc::SearchParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TopKQueryResultList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+    void RequestSearch(::grpc::ServerContext* context, ::milvus::grpc::SearchParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TopKQueryResult>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
       ::grpc::Service::RequestAsyncUnary(13, context, request, response, new_call_cq, notification_cq, tag);
     }
   };
@@ -1199,11 +1199,11 @@ class MilvusService final {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status SearchInFiles(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchInFilesParam* /*request*/, ::milvus::grpc::TopKQueryResultList* /*response*/) override {
+    ::grpc::Status SearchInFiles(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchInFilesParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestSearchInFiles(::grpc::ServerContext* context, ::milvus::grpc::SearchInFilesParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TopKQueryResultList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+    void RequestSearchInFiles(::grpc::ServerContext* context, ::milvus::grpc::SearchInFilesParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TopKQueryResult>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
       ::grpc::Service::RequestAsyncUnary(14, context, request, response, new_call_cq, notification_cq, tag);
     }
   };
@@ -1678,17 +1678,17 @@ class MilvusService final {
    public:
     ExperimentalWithCallbackMethod_Search() {
       ::grpc::Service::experimental().MarkMethodCallback(13,
-        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResultList>(
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResult>(
           [this](::grpc::ServerContext* context,
                  const ::milvus::grpc::SearchParam* request,
-                 ::milvus::grpc::TopKQueryResultList* response,
+                 ::milvus::grpc::TopKQueryResult* response,
                  ::grpc::experimental::ServerCallbackRpcController* controller) {
                    return this->Search(context, request, response, controller);
                  }));
     }
     void SetMessageAllocatorFor_Search(
-        ::grpc::experimental::MessageAllocator< ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResultList>* allocator) {
-      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResultList>*>(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResult>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResult>*>(
           ::grpc::Service::experimental().GetHandler(13))
               ->SetMessageAllocator(allocator);
     }
@@ -1696,11 +1696,11 @@ class MilvusService final {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status Search(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchParam* /*request*/, ::milvus::grpc::TopKQueryResultList* /*response*/) override {
+    ::grpc::Status Search(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    virtual void Search(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchParam* /*request*/, ::milvus::grpc::TopKQueryResultList* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+    virtual void Search(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
   };
   template <class BaseClass>
   class ExperimentalWithCallbackMethod_SearchInFiles : public BaseClass {
@@ -1709,17 +1709,17 @@ class MilvusService final {
    public:
     ExperimentalWithCallbackMethod_SearchInFiles() {
       ::grpc::Service::experimental().MarkMethodCallback(14,
-        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResultList>(
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResult>(
           [this](::grpc::ServerContext* context,
                  const ::milvus::grpc::SearchInFilesParam* request,
-                 ::milvus::grpc::TopKQueryResultList* response,
+                 ::milvus::grpc::TopKQueryResult* response,
                  ::grpc::experimental::ServerCallbackRpcController* controller) {
                    return this->SearchInFiles(context, request, response, controller);
                  }));
     }
     void SetMessageAllocatorFor_SearchInFiles(
-        ::grpc::experimental::MessageAllocator< ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResultList>* allocator) {
-      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResultList>*>(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResult>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResult>*>(
           ::grpc::Service::experimental().GetHandler(14))
               ->SetMessageAllocator(allocator);
     }
@@ -1727,11 +1727,11 @@ class MilvusService final {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status SearchInFiles(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchInFilesParam* /*request*/, ::milvus::grpc::TopKQueryResultList* /*response*/) override {
+    ::grpc::Status SearchInFiles(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchInFilesParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    virtual void SearchInFiles(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchInFilesParam* /*request*/, ::milvus::grpc::TopKQueryResultList* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+    virtual void SearchInFiles(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchInFilesParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
   };
   template <class BaseClass>
   class ExperimentalWithCallbackMethod_Cmd : public BaseClass {
@@ -2060,7 +2060,7 @@ class MilvusService final {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status Search(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchParam* /*request*/, ::milvus::grpc::TopKQueryResultList* /*response*/) override {
+    ::grpc::Status Search(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -2077,7 +2077,7 @@ class MilvusService final {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status SearchInFiles(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchInFilesParam* /*request*/, ::milvus::grpc::TopKQueryResultList* /*response*/) override {
+    ::grpc::Status SearchInFiles(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchInFilesParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -2405,7 +2405,7 @@ class MilvusService final {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status Search(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchParam* /*request*/, ::milvus::grpc::TopKQueryResultList* /*response*/) override {
+    ::grpc::Status Search(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -2425,7 +2425,7 @@ class MilvusService final {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status SearchInFiles(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchInFilesParam* /*request*/, ::milvus::grpc::TopKQueryResultList* /*response*/) override {
+    ::grpc::Status SearchInFiles(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchInFilesParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -2837,7 +2837,7 @@ class MilvusService final {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status Search(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchParam* /*request*/, ::milvus::grpc::TopKQueryResultList* /*response*/) override {
+    ::grpc::Status Search(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -2862,7 +2862,7 @@ class MilvusService final {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status SearchInFiles(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchInFilesParam* /*request*/, ::milvus::grpc::TopKQueryResultList* /*response*/) override {
+    ::grpc::Status SearchInFiles(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchInFilesParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -3210,18 +3210,18 @@ class MilvusService final {
    public:
     WithStreamedUnaryMethod_Search() {
       ::grpc::Service::MarkMethodStreamed(13,
-        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResultList>(std::bind(&WithStreamedUnaryMethod_Search<BaseClass>::StreamedSearch, this, std::placeholders::_1, std::placeholders::_2)));
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResult>(std::bind(&WithStreamedUnaryMethod_Search<BaseClass>::StreamedSearch, this, std::placeholders::_1, std::placeholders::_2)));
     }
     ~WithStreamedUnaryMethod_Search() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable regular version of this method
-    ::grpc::Status Search(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchParam* /*request*/, ::milvus::grpc::TopKQueryResultList* /*response*/) override {
+    ::grpc::Status Search(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
     // replace default version of method with streamed unary
-    virtual ::grpc::Status StreamedSearch(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::SearchParam,::milvus::grpc::TopKQueryResultList>* server_unary_streamer) = 0;
+    virtual ::grpc::Status StreamedSearch(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::SearchParam,::milvus::grpc::TopKQueryResult>* server_unary_streamer) = 0;
   };
   template <class BaseClass>
   class WithStreamedUnaryMethod_SearchInFiles : public BaseClass {
@@ -3230,18 +3230,18 @@ class MilvusService final {
    public:
     WithStreamedUnaryMethod_SearchInFiles() {
       ::grpc::Service::MarkMethodStreamed(14,
-        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResultList>(std::bind(&WithStreamedUnaryMethod_SearchInFiles<BaseClass>::StreamedSearchInFiles, this, std::placeholders::_1, std::placeholders::_2)));
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResult>(std::bind(&WithStreamedUnaryMethod_SearchInFiles<BaseClass>::StreamedSearchInFiles, this, std::placeholders::_1, std::placeholders::_2)));
     }
     ~WithStreamedUnaryMethod_SearchInFiles() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable regular version of this method
-    ::grpc::Status SearchInFiles(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchInFilesParam* /*request*/, ::milvus::grpc::TopKQueryResultList* /*response*/) override {
+    ::grpc::Status SearchInFiles(::grpc::ServerContext* /*context*/, const ::milvus::grpc::SearchInFilesParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
     // replace default version of method with streamed unary
-    virtual ::grpc::Status StreamedSearchInFiles(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::SearchInFilesParam,::milvus::grpc::TopKQueryResultList>* server_unary_streamer) = 0;
+    virtual ::grpc::Status StreamedSearchInFiles(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::SearchInFilesParam,::milvus::grpc::TopKQueryResult>* server_unary_streamer) = 0;
   };
   template <class BaseClass>
   class WithStreamedUnaryMethod_Cmd : public BaseClass {

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

@@ -48,7 +48,7 @@ struct TableStruct_milvus_2eproto {
     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[22]
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[20]
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
   static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
   static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
@@ -84,9 +84,6 @@ extern PartitionNameDefaultTypeInternal _PartitionName_default_instance_;
 class PartitionParam;
 class PartitionParamDefaultTypeInternal;
 extern PartitionParamDefaultTypeInternal _PartitionParam_default_instance_;
-class QueryResult;
-class QueryResultDefaultTypeInternal;
-extern QueryResultDefaultTypeInternal _QueryResult_default_instance_;
 class Range;
 class RangeDefaultTypeInternal;
 extern RangeDefaultTypeInternal _Range_default_instance_;
@@ -117,9 +114,6 @@ extern TableSchemaDefaultTypeInternal _TableSchema_default_instance_;
 class TopKQueryResult;
 class TopKQueryResultDefaultTypeInternal;
 extern TopKQueryResultDefaultTypeInternal _TopKQueryResult_default_instance_;
-class TopKQueryResultList;
-class TopKQueryResultListDefaultTypeInternal;
-extern TopKQueryResultListDefaultTypeInternal _TopKQueryResultList_default_instance_;
 class VectorIds;
 class VectorIdsDefaultTypeInternal;
 extern VectorIdsDefaultTypeInternal _VectorIds_default_instance_;
@@ -135,7 +129,6 @@ template<> ::milvus::grpc::InsertParam* Arena::CreateMaybeMessage<::milvus::grpc
 template<> ::milvus::grpc::PartitionList* Arena::CreateMaybeMessage<::milvus::grpc::PartitionList>(Arena*);
 template<> ::milvus::grpc::PartitionName* Arena::CreateMaybeMessage<::milvus::grpc::PartitionName>(Arena*);
 template<> ::milvus::grpc::PartitionParam* Arena::CreateMaybeMessage<::milvus::grpc::PartitionParam>(Arena*);
-template<> ::milvus::grpc::QueryResult* Arena::CreateMaybeMessage<::milvus::grpc::QueryResult>(Arena*);
 template<> ::milvus::grpc::Range* Arena::CreateMaybeMessage<::milvus::grpc::Range>(Arena*);
 template<> ::milvus::grpc::RowRecord* Arena::CreateMaybeMessage<::milvus::grpc::RowRecord>(Arena*);
 template<> ::milvus::grpc::SearchInFilesParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchInFilesParam>(Arena*);
@@ -146,7 +139,6 @@ template<> ::milvus::grpc::TableNameList* Arena::CreateMaybeMessage<::milvus::gr
 template<> ::milvus::grpc::TableRowCount* Arena::CreateMaybeMessage<::milvus::grpc::TableRowCount>(Arena*);
 template<> ::milvus::grpc::TableSchema* Arena::CreateMaybeMessage<::milvus::grpc::TableSchema>(Arena*);
 template<> ::milvus::grpc::TopKQueryResult* Arena::CreateMaybeMessage<::milvus::grpc::TopKQueryResult>(Arena*);
-template<> ::milvus::grpc::TopKQueryResultList* Arena::CreateMaybeMessage<::milvus::grpc::TopKQueryResultList>(Arena*);
 template<> ::milvus::grpc::VectorIds* Arena::CreateMaybeMessage<::milvus::grpc::VectorIds>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 namespace milvus {
@@ -2021,144 +2013,6 @@ class SearchInFilesParam :
 };
 // -------------------------------------------------------------------
 
-class QueryResult :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.QueryResult) */ {
- public:
-  QueryResult();
-  virtual ~QueryResult();
-
-  QueryResult(const QueryResult& from);
-  QueryResult(QueryResult&& from) noexcept
-    : QueryResult() {
-    *this = ::std::move(from);
-  }
-
-  inline QueryResult& operator=(const QueryResult& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline QueryResult& operator=(QueryResult&& 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 QueryResult& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const QueryResult* internal_default_instance() {
-    return reinterpret_cast<const QueryResult*>(
-               &_QueryResult_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    12;
-
-  friend void swap(QueryResult& a, QueryResult& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(QueryResult* other) {
-    if (other == this) return;
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline QueryResult* New() const final {
-    return CreateMaybeMessage<QueryResult>(nullptr);
-  }
-
-  QueryResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<QueryResult>(arena);
-  }
-  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void CopyFrom(const QueryResult& from);
-  void MergeFrom(const QueryResult& 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(QueryResult* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "milvus.grpc.QueryResult";
-  }
-  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_milvus_2eproto);
-    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
-  }
-
-  public:
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kIdFieldNumber = 1,
-    kDistanceFieldNumber = 2,
-  };
-  // int64 id = 1;
-  void clear_id();
-  ::PROTOBUF_NAMESPACE_ID::int64 id() const;
-  void set_id(::PROTOBUF_NAMESPACE_ID::int64 value);
-
-  // double distance = 2;
-  void clear_distance();
-  double distance() const;
-  void set_distance(double value);
-
-  // @@protoc_insertion_point(class_scope:milvus.grpc.QueryResult)
- private:
-  class _Internal;
-
-  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
-  ::PROTOBUF_NAMESPACE_ID::int64 id_;
-  double distance_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_milvus_2eproto;
-};
-// -------------------------------------------------------------------
-
 class TopKQueryResult :
     public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TopKQueryResult) */ {
  public:
@@ -2201,7 +2055,7 @@ class TopKQueryResult :
                &_TopKQueryResult_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    13;
+    12;
 
   friend void swap(TopKQueryResult& a, TopKQueryResult& b) {
     a.Swap(&b);
@@ -2272,156 +2126,32 @@ class TopKQueryResult :
   // accessors -------------------------------------------------------
 
   enum : int {
-    kQueryResultArraysFieldNumber = 1,
-  };
-  // repeated .milvus.grpc.QueryResult query_result_arrays = 1;
-  int query_result_arrays_size() const;
-  void clear_query_result_arrays();
-  ::milvus::grpc::QueryResult* mutable_query_result_arrays(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::QueryResult >*
-      mutable_query_result_arrays();
-  const ::milvus::grpc::QueryResult& query_result_arrays(int index) const;
-  ::milvus::grpc::QueryResult* add_query_result_arrays();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::QueryResult >&
-      query_result_arrays() const;
-
-  // @@protoc_insertion_point(class_scope:milvus.grpc.TopKQueryResult)
- private:
-  class _Internal;
-
-  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::QueryResult > query_result_arrays_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  friend struct ::TableStruct_milvus_2eproto;
-};
-// -------------------------------------------------------------------
-
-class TopKQueryResultList :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TopKQueryResultList) */ {
- public:
-  TopKQueryResultList();
-  virtual ~TopKQueryResultList();
-
-  TopKQueryResultList(const TopKQueryResultList& from);
-  TopKQueryResultList(TopKQueryResultList&& from) noexcept
-    : TopKQueryResultList() {
-    *this = ::std::move(from);
-  }
-
-  inline TopKQueryResultList& operator=(const TopKQueryResultList& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline TopKQueryResultList& operator=(TopKQueryResultList&& 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 TopKQueryResultList& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const TopKQueryResultList* internal_default_instance() {
-    return reinterpret_cast<const TopKQueryResultList*>(
-               &_TopKQueryResultList_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    14;
-
-  friend void swap(TopKQueryResultList& a, TopKQueryResultList& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(TopKQueryResultList* other) {
-    if (other == this) return;
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline TopKQueryResultList* New() const final {
-    return CreateMaybeMessage<TopKQueryResultList>(nullptr);
-  }
-
-  TopKQueryResultList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<TopKQueryResultList>(arena);
-  }
-  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void CopyFrom(const TopKQueryResultList& from);
-  void MergeFrom(const TopKQueryResultList& 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(TopKQueryResultList* other);
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "milvus.grpc.TopKQueryResultList";
-  }
-  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_milvus_2eproto);
-    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
-  }
-
-  public:
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kTopkQueryResultFieldNumber = 2,
+    kIdsFieldNumber = 3,
+    kDistancesFieldNumber = 4,
     kStatusFieldNumber = 1,
+    kRowNumFieldNumber = 2,
   };
-  // repeated .milvus.grpc.TopKQueryResult topk_query_result = 2;
-  int topk_query_result_size() const;
-  void clear_topk_query_result();
-  ::milvus::grpc::TopKQueryResult* mutable_topk_query_result(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::TopKQueryResult >*
-      mutable_topk_query_result();
-  const ::milvus::grpc::TopKQueryResult& topk_query_result(int index) const;
-  ::milvus::grpc::TopKQueryResult* add_topk_query_result();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::TopKQueryResult >&
-      topk_query_result() const;
+  // repeated int64 ids = 3;
+  int ids_size() const;
+  void clear_ids();
+  ::PROTOBUF_NAMESPACE_ID::int64 ids(int index) const;
+  void set_ids(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
+  void add_ids(::PROTOBUF_NAMESPACE_ID::int64 value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+      ids() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+      mutable_ids();
+
+  // repeated float distances = 4;
+  int distances_size() const;
+  void clear_distances();
+  float distances(int index) const;
+  void set_distances(int index, float value);
+  void add_distances(float value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+      distances() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+      mutable_distances();
 
   // .milvus.grpc.Status status = 1;
   bool has_status() const;
@@ -2431,13 +2161,22 @@ class TopKQueryResultList :
   ::milvus::grpc::Status* mutable_status();
   void set_allocated_status(::milvus::grpc::Status* status);
 
-  // @@protoc_insertion_point(class_scope:milvus.grpc.TopKQueryResultList)
+  // int64 row_num = 2;
+  void clear_row_num();
+  ::PROTOBUF_NAMESPACE_ID::int64 row_num() const;
+  void set_row_num(::PROTOBUF_NAMESPACE_ID::int64 value);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.TopKQueryResult)
  private:
   class _Internal;
 
   ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::TopKQueryResult > topk_query_result_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > ids_;
+  mutable std::atomic<int> _ids_cached_byte_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > distances_;
+  mutable std::atomic<int> _distances_cached_byte_size_;
   ::milvus::grpc::Status* status_;
+  ::PROTOBUF_NAMESPACE_ID::int64 row_num_;
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   friend struct ::TableStruct_milvus_2eproto;
 };
@@ -2485,7 +2224,7 @@ class StringReply :
                &_StringReply_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    15;
+    13;
 
   friend void swap(StringReply& a, StringReply& b) {
     a.Swap(&b);
@@ -2632,7 +2371,7 @@ class BoolReply :
                &_BoolReply_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    16;
+    14;
 
   friend void swap(BoolReply& a, BoolReply& b) {
     a.Swap(&b);
@@ -2773,7 +2512,7 @@ class TableRowCount :
                &_TableRowCount_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    17;
+    15;
 
   friend void swap(TableRowCount& a, TableRowCount& b) {
     a.Swap(&b);
@@ -2914,7 +2653,7 @@ class Command :
                &_Command_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    18;
+    16;
 
   friend void swap(Command& a, Command& b) {
     a.Swap(&b);
@@ -3051,7 +2790,7 @@ class Index :
                &_Index_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    19;
+    17;
 
   friend void swap(Index& a, Index& b) {
     a.Swap(&b);
@@ -3189,7 +2928,7 @@ class IndexParam :
                &_IndexParam_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    20;
+    18;
 
   friend void swap(IndexParam& a, IndexParam& b) {
     a.Swap(&b);
@@ -3346,7 +3085,7 @@ class DeleteByDateParam :
                &_DeleteByDateParam_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    21;
+    19;
 
   friend void swap(DeleteByDateParam& a, DeleteByDateParam& b) {
     a.Swap(&b);
@@ -4773,101 +4512,35 @@ inline void SearchInFilesParam::set_allocated_search_param(::milvus::grpc::Searc
 
 // -------------------------------------------------------------------
 
-// QueryResult
-
-// int64 id = 1;
-inline void QueryResult::clear_id() {
-  id_ = PROTOBUF_LONGLONG(0);
-}
-inline ::PROTOBUF_NAMESPACE_ID::int64 QueryResult::id() const {
-  // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.id)
-  return id_;
-}
-inline void QueryResult::set_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  
-  id_ = value;
-  // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.id)
-}
-
-// double distance = 2;
-inline void QueryResult::clear_distance() {
-  distance_ = 0;
-}
-inline double QueryResult::distance() const {
-  // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.distance)
-  return distance_;
-}
-inline void QueryResult::set_distance(double value) {
-  
-  distance_ = value;
-  // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.distance)
-}
-
-// -------------------------------------------------------------------
-
 // TopKQueryResult
 
-// repeated .milvus.grpc.QueryResult query_result_arrays = 1;
-inline int TopKQueryResult::query_result_arrays_size() const {
-  return query_result_arrays_.size();
-}
-inline void TopKQueryResult::clear_query_result_arrays() {
-  query_result_arrays_.Clear();
-}
-inline ::milvus::grpc::QueryResult* TopKQueryResult::mutable_query_result_arrays(int index) {
-  // @@protoc_insertion_point(field_mutable:milvus.grpc.TopKQueryResult.query_result_arrays)
-  return query_result_arrays_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::QueryResult >*
-TopKQueryResult::mutable_query_result_arrays() {
-  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TopKQueryResult.query_result_arrays)
-  return &query_result_arrays_;
-}
-inline const ::milvus::grpc::QueryResult& TopKQueryResult::query_result_arrays(int index) const {
-  // @@protoc_insertion_point(field_get:milvus.grpc.TopKQueryResult.query_result_arrays)
-  return query_result_arrays_.Get(index);
-}
-inline ::milvus::grpc::QueryResult* TopKQueryResult::add_query_result_arrays() {
-  // @@protoc_insertion_point(field_add:milvus.grpc.TopKQueryResult.query_result_arrays)
-  return query_result_arrays_.Add();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::QueryResult >&
-TopKQueryResult::query_result_arrays() const {
-  // @@protoc_insertion_point(field_list:milvus.grpc.TopKQueryResult.query_result_arrays)
-  return query_result_arrays_;
-}
-
-// -------------------------------------------------------------------
-
-// TopKQueryResultList
-
 // .milvus.grpc.Status status = 1;
-inline bool TopKQueryResultList::has_status() const {
+inline bool TopKQueryResult::has_status() const {
   return this != internal_default_instance() && status_ != nullptr;
 }
-inline const ::milvus::grpc::Status& TopKQueryResultList::status() const {
+inline const ::milvus::grpc::Status& TopKQueryResult::status() const {
   const ::milvus::grpc::Status* p = status_;
-  // @@protoc_insertion_point(field_get:milvus.grpc.TopKQueryResultList.status)
+  // @@protoc_insertion_point(field_get:milvus.grpc.TopKQueryResult.status)
   return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
       &::milvus::grpc::_Status_default_instance_);
 }
-inline ::milvus::grpc::Status* TopKQueryResultList::release_status() {
-  // @@protoc_insertion_point(field_release:milvus.grpc.TopKQueryResultList.status)
+inline ::milvus::grpc::Status* TopKQueryResult::release_status() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.TopKQueryResult.status)
   
   ::milvus::grpc::Status* temp = status_;
   status_ = nullptr;
   return temp;
 }
-inline ::milvus::grpc::Status* TopKQueryResultList::mutable_status() {
+inline ::milvus::grpc::Status* TopKQueryResult::mutable_status() {
   
   if (status_ == nullptr) {
     auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
     status_ = p;
   }
-  // @@protoc_insertion_point(field_mutable:milvus.grpc.TopKQueryResultList.status)
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.TopKQueryResult.status)
   return status_;
 }
-inline void TopKQueryResultList::set_allocated_status(::milvus::grpc::Status* status) {
+inline void TopKQueryResult::set_allocated_status(::milvus::grpc::Status* status) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
   if (message_arena == nullptr) {
     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
@@ -4883,37 +4556,81 @@ inline void TopKQueryResultList::set_allocated_status(::milvus::grpc::Status* st
     
   }
   status_ = status;
-  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TopKQueryResultList.status)
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TopKQueryResult.status)
 }
 
-// repeated .milvus.grpc.TopKQueryResult topk_query_result = 2;
-inline int TopKQueryResultList::topk_query_result_size() const {
-  return topk_query_result_.size();
+// int64 row_num = 2;
+inline void TopKQueryResult::clear_row_num() {
+  row_num_ = PROTOBUF_LONGLONG(0);
 }
-inline void TopKQueryResultList::clear_topk_query_result() {
-  topk_query_result_.Clear();
+inline ::PROTOBUF_NAMESPACE_ID::int64 TopKQueryResult::row_num() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.TopKQueryResult.row_num)
+  return row_num_;
 }
-inline ::milvus::grpc::TopKQueryResult* TopKQueryResultList::mutable_topk_query_result(int index) {
-  // @@protoc_insertion_point(field_mutable:milvus.grpc.TopKQueryResultList.topk_query_result)
-  return topk_query_result_.Mutable(index);
+inline void TopKQueryResult::set_row_num(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  
+  row_num_ = value;
+  // @@protoc_insertion_point(field_set:milvus.grpc.TopKQueryResult.row_num)
 }
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::TopKQueryResult >*
-TopKQueryResultList::mutable_topk_query_result() {
-  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TopKQueryResultList.topk_query_result)
-  return &topk_query_result_;
+
+// repeated int64 ids = 3;
+inline int TopKQueryResult::ids_size() const {
+  return ids_.size();
 }
-inline const ::milvus::grpc::TopKQueryResult& TopKQueryResultList::topk_query_result(int index) const {
-  // @@protoc_insertion_point(field_get:milvus.grpc.TopKQueryResultList.topk_query_result)
-  return topk_query_result_.Get(index);
+inline void TopKQueryResult::clear_ids() {
+  ids_.Clear();
 }
-inline ::milvus::grpc::TopKQueryResult* TopKQueryResultList::add_topk_query_result() {
-  // @@protoc_insertion_point(field_add:milvus.grpc.TopKQueryResultList.topk_query_result)
-  return topk_query_result_.Add();
+inline ::PROTOBUF_NAMESPACE_ID::int64 TopKQueryResult::ids(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.TopKQueryResult.ids)
+  return ids_.Get(index);
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::TopKQueryResult >&
-TopKQueryResultList::topk_query_result() const {
-  // @@protoc_insertion_point(field_list:milvus.grpc.TopKQueryResultList.topk_query_result)
-  return topk_query_result_;
+inline void TopKQueryResult::set_ids(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
+  ids_.Set(index, value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.TopKQueryResult.ids)
+}
+inline void TopKQueryResult::add_ids(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  ids_.Add(value);
+  // @@protoc_insertion_point(field_add:milvus.grpc.TopKQueryResult.ids)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+TopKQueryResult::ids() const {
+  // @@protoc_insertion_point(field_list:milvus.grpc.TopKQueryResult.ids)
+  return ids_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+TopKQueryResult::mutable_ids() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TopKQueryResult.ids)
+  return &ids_;
+}
+
+// repeated float distances = 4;
+inline int TopKQueryResult::distances_size() const {
+  return distances_.size();
+}
+inline void TopKQueryResult::clear_distances() {
+  distances_.Clear();
+}
+inline float TopKQueryResult::distances(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.TopKQueryResult.distances)
+  return distances_.Get(index);
+}
+inline void TopKQueryResult::set_distances(int index, float value) {
+  distances_.Set(index, value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.TopKQueryResult.distances)
+}
+inline void TopKQueryResult::add_distances(float value) {
+  distances_.Add(value);
+  // @@protoc_insertion_point(field_add:milvus.grpc.TopKQueryResult.distances)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+TopKQueryResult::distances() const {
+  // @@protoc_insertion_point(field_list:milvus.grpc.TopKQueryResult.distances)
+  return distances_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+TopKQueryResult::mutable_distances() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TopKQueryResult.distances)
+  return &distances_;
 }
 
 // -------------------------------------------------------------------
@@ -5527,10 +5244,6 @@ inline void DeleteByDateParam::set_allocated_table_name(std::string* table_name)
 
 // -------------------------------------------------------------------
 
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
 
 // @@protoc_insertion_point(namespace_scope)
 

core/src/grpc/milvus.proto

@@ -110,24 +110,11 @@ message SearchInFilesParam {
 /**
  * @brief Query result params
  */
-message QueryResult {
-    int64 id = 1;
-    double distance = 2;
-}
-
-/**
- * @brief TopK query result
- */
 message TopKQueryResult {
-    repeated QueryResult query_result_arrays = 1;
-}
-
-/**
- * @brief List of topK query result
- */
-message TopKQueryResultList {
     Status status = 1;
-    repeated TopKQueryResult topk_query_result = 2;
+    int64 row_num = 2;
+    repeated int64 ids = 3;
+    repeated float distances = 4;
 }
 
 /**
@@ -311,18 +298,18 @@ service MilvusService {
      *
      * @param SearchParam, search parameters.
      *
-     * @return TopKQueryResultList
+     * @return TopKQueryResult
      */
-    rpc Search(SearchParam) returns (TopKQueryResultList) {}
+    rpc Search(SearchParam) returns (TopKQueryResult) {}
 
     /**
      * @brief This method is used to query vector in specified files.
      *
      * @param SearchInFilesParam, search in files paremeters.
      *
-     * @return TopKQueryResultList
+     * @return TopKQueryResult
      */
-    rpc SearchInFiles(SearchInFilesParam) returns (TopKQueryResultList) {}
+    rpc SearchInFiles(SearchInFilesParam) returns (TopKQueryResult) {}
 
     /**
      * @brief This method is used to give the server status.

core/src/index/CMakeLists.txt

@@ -18,7 +18,7 @@
 #-------------------------------------------------------------------------------
 
 
-cmake_minimum_required(VERSION 3.14)
+cmake_minimum_required(VERSION 3.12)
 message(STATUS "------------------------------KNOWHERE-----------------------------------")
 message(STATUS "Building using CMake version: ${CMAKE_VERSION}")
 

core/src/index/build.sh

@@ -5,7 +5,7 @@ BUILD_UNITTEST="OFF"
 INSTALL_PREFIX=$(pwd)/cmake_build
 MAKE_CLEAN="OFF"
 PROFILING="OFF"
-BUILD_FAISS_WITH_MKL="OFF"
+FAISS_WITH_MKL="OFF"
 USE_JFROG_CACHE="OFF"
 
 while getopts "p:d:t:uhrcgmj" arg
@@ -31,7 +31,7 @@ do
                 PROFILING="ON"
                 ;;
              m)
-                BUILD_FAISS_WITH_MKL="ON"
+                FAISS_WITH_MKL="ON"
                 ;;
              j)
                 USE_JFROG_CACHE="ON"
@@ -74,7 +74,7 @@ if [[ ${MAKE_CLEAN} == "ON" ]]; then
     -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
     -DCMAKE_CUDA_COMPILER=${CUDA_COMPILER} \
     -DMILVUS_ENABLE_PROFILING=${PROFILING} \
-    -DBUILD_FAISS_WITH_MKL=${BUILD_FAISS_WITH_MKL} \
+    -DFAISS_WITH_MKL=${FAISS_WITH_MKL} \
     -DUSE_JFROG_CACHE=${USE_JFROG_CACHE} \
     ../"
     echo ${CMAKE_CMD}

core/src/index/cmake/DefineOptionsCore.cmake

@@ -52,7 +52,7 @@ endif ()
 #----------------------------------------------------------------------
 set_option_category("Thirdparty")
 
-set(KNOWHERE_DEPENDENCY_SOURCE_DEFAULT "AUTO")
+set(KNOWHERE_DEPENDENCY_SOURCE_DEFAULT "BUNDLED")
 
 define_option_string(KNOWHERE_DEPENDENCY_SOURCE
         "Method to use for acquiring KNOWHERE's build dependencies"
@@ -79,7 +79,7 @@ define_option(KNOWHERE_WITH_FAISS "Build with FAISS library" ON)
 
 define_option(KNOWHERE_WITH_FAISS_GPU_VERSION "Build with FAISS GPU version" ON)
 
-define_option(BUILD_FAISS_WITH_MKL "Build FAISS with MKL" OFF)
+define_option(FAISS_WITH_MKL "Build FAISS with MKL" OFF)
 
 #----------------------------------------------------------------------
 set_option_category("Test and benchmark")

core/src/index/cmake/FindArrow.cmake

@@ -0,0 +1,431 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# - Find Arrow (arrow/api.h, libarrow.a, libarrow.so)
+# This module defines
+#  ARROW_FOUND, whether Arrow has been found
+#  ARROW_FULL_SO_VERSION, full shared object version of found Arrow "100.0.0"
+#  ARROW_IMPORT_LIB, path to libarrow's import library (Windows only)
+#  ARROW_INCLUDE_DIR, directory containing headers
+#  ARROW_LIBS, deprecated. Use ARROW_LIB_DIR instead
+#  ARROW_LIB_DIR, directory containing Arrow libraries
+#  ARROW_SHARED_IMP_LIB, deprecated. Use ARROW_IMPORT_LIB instead
+#  ARROW_SHARED_LIB, path to libarrow's shared library
+#  ARROW_SO_VERSION, shared object version of found Arrow such as "100"
+#  ARROW_STATIC_LIB, path to libarrow.a
+#  ARROW_VERSION, version of found Arrow
+#  ARROW_VERSION_MAJOR, major version of found Arrow
+#  ARROW_VERSION_MINOR, minor version of found Arrow
+#  ARROW_VERSION_PATCH, patch version of found Arrow
+
+include(FindPkgConfig)
+include(FindPackageHandleStandardArgs)
+
+set(ARROW_SEARCH_LIB_PATH_SUFFIXES)
+if(CMAKE_LIBRARY_ARCHITECTURE)
+  list(APPEND ARROW_SEARCH_LIB_PATH_SUFFIXES "lib/${CMAKE_LIBRARY_ARCHITECTURE}")
+endif()
+list(APPEND ARROW_SEARCH_LIB_PATH_SUFFIXES
+            "lib64"
+            "lib32"
+            "lib"
+            "bin")
+set(ARROW_CONFIG_SUFFIXES
+    "_RELEASE"
+    "_RELWITHDEBINFO"
+    "_MINSIZEREL"
+    "_DEBUG"
+    "")
+if(CMAKE_BUILD_TYPE)
+  string(TOUPPER ${CMAKE_BUILD_TYPE} ARROW_CONFIG_SUFFIX_PREFERRED)
+  set(ARROW_CONFIG_SUFFIX_PREFERRED "_${ARROW_CONFIG_SUFFIX_PREFERRED}")
+  list(INSERT ARROW_CONFIG_SUFFIXES 0 "${ARROW_CONFIG_SUFFIX_PREFERRED}")
+endif()
+
+if(NOT DEFINED ARROW_MSVC_STATIC_LIB_SUFFIX)
+  if(MSVC)
+    set(ARROW_MSVC_STATIC_LIB_SUFFIX "_static")
+  else()
+    set(ARROW_MSVC_STATIC_LIB_SUFFIX "")
+  endif()
+endif()
+
+# Internal function.
+#
+# Set shared library name for ${base_name} to ${output_variable}.
+#
+# Example:
+#   arrow_build_shared_library_name(ARROW_SHARED_LIBRARY_NAME arrow)
+#   # -> ARROW_SHARED_LIBRARY_NAME=libarrow.so on Linux
+#   # -> ARROW_SHARED_LIBRARY_NAME=libarrow.dylib on macOS
+#   # -> ARROW_SHARED_LIBRARY_NAME=arrow.dll with MSVC on Windows
+#   # -> ARROW_SHARED_LIBRARY_NAME=libarrow.dll with MinGW on Windows
+function(arrow_build_shared_library_name output_variable base_name)
+  set(${output_variable}
+      "${CMAKE_SHARED_LIBRARY_PREFIX}${base_name}${CMAKE_SHARED_LIBRARY_SUFFIX}"
+      PARENT_SCOPE)
+endfunction()
+
+# Internal function.
+#
+# Set import library name for ${base_name} to ${output_variable}.
+# This is useful only for MSVC build. Import library is used only
+# with MSVC build.
+#
+# Example:
+#   arrow_build_import_library_name(ARROW_IMPORT_LIBRARY_NAME arrow)
+#   # -> ARROW_IMPORT_LIBRARY_NAME=arrow on Linux (meaningless)
+#   # -> ARROW_IMPORT_LIBRARY_NAME=arrow on macOS (meaningless)
+#   # -> ARROW_IMPORT_LIBRARY_NAME=arrow.lib with MSVC on Windows
+#   # -> ARROW_IMPORT_LIBRARY_NAME=libarrow.dll.a with MinGW on Windows
+function(arrow_build_import_library_name output_variable base_name)
+  set(${output_variable}
+      "${CMAKE_IMPORT_LIBRARY_PREFIX}${base_name}${CMAKE_IMPORT_LIBRARY_SUFFIX}"
+      PARENT_SCOPE)
+endfunction()
+
+# Internal function.
+#
+# Set static library name for ${base_name} to ${output_variable}.
+#
+# Example:
+#   arrow_build_static_library_name(ARROW_STATIC_LIBRARY_NAME arrow)
+#   # -> ARROW_STATIC_LIBRARY_NAME=libarrow.a on Linux
+#   # -> ARROW_STATIC_LIBRARY_NAME=libarrow.a on macOS
+#   # -> ARROW_STATIC_LIBRARY_NAME=arrow.lib with MSVC on Windows
+#   # -> ARROW_STATIC_LIBRARY_NAME=libarrow.dll.a with MinGW on Windows
+function(arrow_build_static_library_name output_variable base_name)
+  set(
+    ${output_variable}
+    "${CMAKE_STATIC_LIBRARY_PREFIX}${base_name}${ARROW_MSVC_STATIC_LIB_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}"
+    PARENT_SCOPE)
+endfunction()
+
+# Internal function.
+#
+# Set macro value for ${macro_name} in ${header_content} to ${output_variable}.
+#
+# Example:
+#   arrow_extract_macro_value(version_major
+#                             "ARROW_VERSION_MAJOR"
+#                             "#define ARROW_VERSION_MAJOR 1.0.0")
+#   # -> version_major=1.0.0
+function(arrow_extract_macro_value output_variable macro_name header_content)
+  string(REGEX MATCH "#define +${macro_name} +[^\r\n]+" macro_definition
+               "${header_content}")
+  string(REGEX
+         REPLACE "^#define +${macro_name} +(.+)$" "\\1" macro_value "${macro_definition}")
+  set(${output_variable} "${macro_value}" PARENT_SCOPE)
+endfunction()
+
+# Internal macro only for arrow_find_package.
+#
+# Find package in HOME.
+macro(arrow_find_package_home)
+  find_path(${prefix}_include_dir "${header_path}"
+            PATHS "${home}"
+            PATH_SUFFIXES "include"
+            NO_DEFAULT_PATH)
+  set(include_dir "${${prefix}_include_dir}")
+  set(${prefix}_INCLUDE_DIR "${include_dir}" PARENT_SCOPE)
+
+  if(MSVC)
+    set(CMAKE_SHARED_LIBRARY_SUFFIXES_ORIGINAL ${CMAKE_FIND_LIBRARY_SUFFIXES})
+    # .dll isn't found by find_library with MSVC because .dll isn't included in
+    # CMAKE_FIND_LIBRARY_SUFFIXES.
+    list(APPEND CMAKE_FIND_LIBRARY_SUFFIXES "${CMAKE_SHARED_LIBRARY_SUFFIX}")
+  endif()
+  find_library(${prefix}_shared_lib
+               NAMES "${shared_lib_name}"
+               PATHS "${home}"
+               PATH_SUFFIXES ${ARROW_SEARCH_LIB_PATH_SUFFIXES}
+               NO_DEFAULT_PATH)
+  if(MSVC)
+    set(CMAKE_SHARED_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_ORIGINAL})
+  endif()
+  set(shared_lib "${${prefix}_shared_lib}")
+  set(${prefix}_SHARED_LIB "${shared_lib}" PARENT_SCOPE)
+  if(shared_lib)
+    add_library(${target_shared} SHARED IMPORTED)
+    set_target_properties(${target_shared} PROPERTIES IMPORTED_LOCATION "${shared_lib}")
+    if(include_dir)
+      set_target_properties(${target_shared}
+                            PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${include_dir}")
+    endif()
+    find_library(${prefix}_import_lib
+                 NAMES "${import_lib_name}"
+                 PATHS "${home}"
+                 PATH_SUFFIXES ${ARROW_SEARCH_LIB_PATH_SUFFIXES}
+                 NO_DEFAULT_PATH)
+    set(import_lib "${${prefix}_import_lib}")
+    set(${prefix}_IMPORT_LIB "${import_lib}" PARENT_SCOPE)
+    if(import_lib)
+      set_target_properties(${target_shared} PROPERTIES IMPORTED_IMPLIB "${import_lib}")
+    endif()
+  endif()
+
+  find_library(${prefix}_static_lib
+               NAMES "${static_lib_name}"
+               PATHS "${home}"
+               PATH_SUFFIXES ${ARROW_SEARCH_LIB_PATH_SUFFIXES}
+               NO_DEFAULT_PATH)
+  set(static_lib "${${prefix}_static_lib}")
+  set(${prefix}_STATIC_LIB "${static_lib}" PARENT_SCOPE)
+  if(static_lib)
+    add_library(${target_static} STATIC IMPORTED)
+    set_target_properties(${target_static} PROPERTIES IMPORTED_LOCATION "${static_lib}")
+    if(include_dir)
+      set_target_properties(${target_static}
+                            PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${include_dir}")
+    endif()
+  endif()
+endmacro()
+
+# Internal macro only for arrow_find_package.
+#
+# Find package by CMake package configuration.
+macro(arrow_find_package_cmake_package_configuration)
+  # ARROW-5575: We need to split target files for each component
+  if(TARGET ${target_shared} OR TARGET ${target_static})
+    set(${cmake_package_name}_FOUND TRUE)
+  else()
+    find_package(${cmake_package_name} CONFIG)
+  endif()
+  if(${cmake_package_name}_FOUND)
+    set(${prefix}_USE_CMAKE_PACKAGE_CONFIG TRUE PARENT_SCOPE)
+    if(TARGET ${target_shared})
+      foreach(suffix ${ARROW_CONFIG_SUFFIXES})
+        get_target_property(shared_lib ${target_shared} IMPORTED_LOCATION${suffix})
+        if(shared_lib)
+          # Remove shared library version:
+          #   libarrow.so.100.0.0 -> libarrow.so
+          # Because ARROW_HOME and pkg-config approaches don't add
+          # shared library version.
+          string(REGEX
+                 REPLACE "(${CMAKE_SHARED_LIBRARY_SUFFIX})[.0-9]+$" "\\1" shared_lib
+                         "${shared_lib}")
+          set(${prefix}_SHARED_LIB "${shared_lib}" PARENT_SCOPE)
+          break()
+        endif()
+      endforeach()
+    endif()
+    if(TARGET ${target_static})
+      foreach(suffix ${ARROW_CONFIG_SUFFIXES})
+        get_target_property(static_lib ${target_static} IMPORTED_LOCATION${suffix})
+        if(static_lib)
+          set(${prefix}_STATIC_LIB "${static_lib}" PARENT_SCOPE)
+          break()
+        endif()
+      endforeach()
+    endif()
+  endif()
+endmacro()
+
+# Internal macro only for arrow_find_package.
+#
+# Find package by pkg-config.
+macro(arrow_find_package_pkg_config)
+  pkg_check_modules(${prefix}_PC ${pkg_config_name})
+  if(${prefix}_PC_FOUND)
+    set(${prefix}_USE_PKG_CONFIG TRUE PARENT_SCOPE)
+
+    set(include_dir "${${prefix}_PC_INCLUDEDIR}")
+    set(lib_dir "${${prefix}_PC_LIBDIR}")
+    set(shared_lib_paths "${${prefix}_PC_LINK_LIBRARIES}")
+    # Use the first shared library path as the IMPORTED_LOCATION
+    # for ${target_shared}. This assumes that the first shared library
+    # path is the shared library path for this module.
+    list(GET shared_lib_paths 0 first_shared_lib_path)
+    # Use the rest shared library paths as the INTERFACE_LINK_LIBRARIES
+    # for ${target_shared}. This assumes that the rest shared library
+    # paths are dependency library paths for this module.
+    list(LENGTH shared_lib_paths n_shared_lib_paths)
+    if(n_shared_lib_paths LESS_EQUAL 1)
+      set(rest_shared_lib_paths)
+    else()
+      list(SUBLIST
+           shared_lib_paths
+           1
+           -1
+           rest_shared_lib_paths)
+    endif()
+
+    set(${prefix}_VERSION "${${prefix}_PC_VERSION}" PARENT_SCOPE)
+    set(${prefix}_INCLUDE_DIR "${include_dir}" PARENT_SCOPE)
+    set(${prefix}_SHARED_LIB "${first_shared_lib_path}" PARENT_SCOPE)
+
+    add_library(${target_shared} SHARED IMPORTED)
+    set_target_properties(${target_shared}
+                          PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                                     "${include_dir}"
+                                     INTERFACE_LINK_LIBRARIES
+                                     "${rest_shared_lib_paths}"
+                                     IMPORTED_LOCATION
+                                     "${first_shared_lib_path}")
+
+    find_library(${prefix}_static_lib
+                 NAMES "${static_lib_name}"
+                 PATHS "${lib_dir}"
+                 NO_DEFAULT_PATH)
+    set(static_lib "${${prefix}_static_lib}")
+    set(${prefix}_STATIC_LIB "${static_lib}" PARENT_SCOPE)
+    if(static_lib)
+      add_library(${target_static} STATIC IMPORTED)
+      set_target_properties(${target_static}
+                            PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${include_dir}"
+                                       IMPORTED_LOCATION "${static_lib}")
+    endif()
+  endif()
+endmacro()
+
+function(arrow_find_package
+         prefix
+         home
+         base_name
+         header_path
+         cmake_package_name
+         pkg_config_name)
+  arrow_build_shared_library_name(shared_lib_name ${base_name})
+  arrow_build_import_library_name(import_lib_name ${base_name})
+  arrow_build_static_library_name(static_lib_name ${base_name})
+
+  set(target_shared ${base_name}_shared)
+  set(target_static ${base_name}_static)
+
+  if(home)
+    arrow_find_package_home()
+    set(${prefix}_FIND_APPROACH "HOME: ${home}" PARENT_SCOPE)
+  else()
+    arrow_find_package_cmake_package_configuration()
+    if(${cmake_package_name}_FOUND)
+      set(${prefix}_FIND_APPROACH
+          "CMake package configuration: ${cmake_package_name}"
+          PARENT_SCOPE)
+    else()
+      arrow_find_package_pkg_config()
+      set(${prefix}_FIND_APPROACH "pkg-config: ${pkg_config_name}" PARENT_SCOPE)
+    endif()
+  endif()
+
+  if(NOT include_dir)
+    if(TARGET ${target_shared})
+      get_target_property(include_dir ${target_shared} INTERFACE_INCLUDE_DIRECTORIES)
+    elseif(TARGET ${target_static})
+      get_target_property(include_dir ${target_static} INTERFACE_INCLUDE_DIRECTORIES)
+    endif()
+  endif()
+  if(include_dir)
+    set(${prefix}_INCLUDE_DIR "${include_dir}" PARENT_SCOPE)
+  endif()
+
+  if(shared_lib)
+    get_filename_component(lib_dir "${shared_lib}" DIRECTORY)
+  elseif(static_lib)
+    get_filename_component(lib_dir "${static_lib}" DIRECTORY)
+  else()
+    set(lib_dir NOTFOUND)
+  endif()
+  set(${prefix}_LIB_DIR "${lib_dir}" PARENT_SCOPE)
+  # For backward compatibility
+  set(${prefix}_LIBS "${lib_dir}" PARENT_SCOPE)
+endfunction()
+
+if(NOT "$ENV{ARROW_HOME}" STREQUAL "")
+  file(TO_CMAKE_PATH "$ENV{ARROW_HOME}" ARROW_HOME)
+endif()
+arrow_find_package(ARROW
+                   "${ARROW_HOME}"
+                   arrow
+                   arrow/api.h
+                   Arrow
+                   arrow)
+
+if(ARROW_HOME)
+  if(ARROW_INCLUDE_DIR)
+    file(READ "${ARROW_INCLUDE_DIR}/arrow/util/config.h" ARROW_CONFIG_H_CONTENT)
+    arrow_extract_macro_value(ARROW_VERSION_MAJOR "ARROW_VERSION_MAJOR"
+                              "${ARROW_CONFIG_H_CONTENT}")
+    arrow_extract_macro_value(ARROW_VERSION_MINOR "ARROW_VERSION_MINOR"
+                              "${ARROW_CONFIG_H_CONTENT}")
+    arrow_extract_macro_value(ARROW_VERSION_PATCH "ARROW_VERSION_PATCH"
+                              "${ARROW_CONFIG_H_CONTENT}")
+    if("${ARROW_VERSION_MAJOR}" STREQUAL ""
+       OR "${ARROW_VERSION_MINOR}" STREQUAL ""
+       OR "${ARROW_VERSION_PATCH}" STREQUAL "")
+      set(ARROW_VERSION "0.0.0")
+    else()
+      set(ARROW_VERSION
+          "${ARROW_VERSION_MAJOR}.${ARROW_VERSION_MINOR}.${ARROW_VERSION_PATCH}")
+    endif()
+
+    arrow_extract_macro_value(ARROW_SO_VERSION_QUOTED "ARROW_SO_VERSION"
+                              "${ARROW_CONFIG_H_CONTENT}")
+    string(REGEX REPLACE "^\"(.+)\"$" "\\1" ARROW_SO_VERSION "${ARROW_SO_VERSION_QUOTED}")
+    arrow_extract_macro_value(ARROW_FULL_SO_VERSION_QUOTED "ARROW_FULL_SO_VERSION"
+                              "${ARROW_CONFIG_H_CONTENT}")
+    string(REGEX
+           REPLACE "^\"(.+)\"$" "\\1" ARROW_FULL_SO_VERSION
+                   "${ARROW_FULL_SO_VERSION_QUOTED}")
+  endif()
+else()
+  if(ARROW_USE_CMAKE_PACKAGE_CONFIG)
+    find_package(Arrow CONFIG)
+  elseif(ARROW_USE_PKG_CONFIG)
+    pkg_get_variable(ARROW_SO_VERSION arrow so_version)
+    pkg_get_variable(ARROW_FULL_SO_VERSION arrow full_so_version)
+  endif()
+endif()
+
+set(ARROW_ABI_VERSION ${ARROW_SO_VERSION})
+
+mark_as_advanced(ARROW_ABI_VERSION
+                 ARROW_CONFIG_SUFFIXES
+                 ARROW_FULL_SO_VERSION
+                 ARROW_IMPORT_LIB
+                 ARROW_INCLUDE_DIR
+                 ARROW_LIBS
+                 ARROW_LIB_DIR
+                 ARROW_SEARCH_LIB_PATH_SUFFIXES
+                 ARROW_SHARED_IMP_LIB
+                 ARROW_SHARED_LIB
+                 ARROW_SO_VERSION
+                 ARROW_STATIC_LIB
+                 ARROW_VERSION
+                 ARROW_VERSION_MAJOR
+                 ARROW_VERSION_MINOR
+                 ARROW_VERSION_PATCH)
+
+find_package_handle_standard_args(Arrow REQUIRED_VARS
+                                  # The first required variable is shown
+                                  # in the found message. So this list is
+                                  # not sorted alphabetically.
+                                  ARROW_INCLUDE_DIR
+                                  ARROW_LIB_DIR
+                                  ARROW_FULL_SO_VERSION
+                                  ARROW_SO_VERSION
+                                  VERSION_VAR
+                                  ARROW_VERSION)
+set(ARROW_FOUND ${Arrow_FOUND})
+
+if(Arrow_FOUND AND NOT Arrow_FIND_QUIETLY)
+  message(STATUS "Arrow version: ${ARROW_VERSION} (${ARROW_FIND_APPROACH})")
+  message(STATUS "Arrow SO and ABI version: ${ARROW_SO_VERSION}")
+  message(STATUS "Arrow full SO version: ${ARROW_FULL_SO_VERSION}")
+  message(STATUS "Found the Arrow core shared library: ${ARROW_SHARED_LIB}")
+  message(STATUS "Found the Arrow core import library: ${ARROW_IMPORT_LIB}")
+  message(STATUS "Found the Arrow core static library: ${ARROW_STATIC_LIB}")
+endif()

core/src/index/cmake/FindFAISS.cmake

@@ -0,0 +1,44 @@
+set(FAISS_STATIC_LIB_NAME ${CMAKE_STATIC_LIBRARY_PREFIX}faiss${CMAKE_STATIC_LIBRARY_SUFFIX})
+
+# First, find via if specified FAISS_ROOT
+if (FAISS_ROOT)
+    find_library(FAISS_STATIC_LIB
+            NAMES ${FAISS_STATIC_LIB_NAME}
+            PATHS ${FAISS_ROOT}
+            PATH_SUFFIXES "lib"
+            NO_DEFAULT_PATH
+            )
+    find_path(FAISS_INCLUDE_DIR
+            NAMES "faiss/Index.h"
+            PATHS ${FAISS_ROOT}
+            NO_DEFAULT_PATH
+            PATH_SUFFIXES "include"
+            )
+endif ()
+
+find_package_handle_standard_args(FAISS REQUIRED_VARS FAISS_STATIC_LIB FAISS_INCLUDE_DIR)
+
+if (FAISS_FOUND)
+    if (NOT TARGET faiss)
+        add_library(faiss STATIC IMPORTED)
+
+        set_target_properties(
+                faiss
+                PROPERTIES
+                IMPORTED_LOCATION "${FAISS_STATIC_LIB}"
+                INTERFACE_INCLUDE_DIRECTORIES "${FAISS_INCLUDE_DIR}"
+        )
+
+        if (FAISS_WITH_MKL)
+            set_target_properties(
+                    faiss
+                    PROPERTIES
+                    INTERFACE_LINK_LIBRARIES "${MKL_LIBS}")
+        else ()
+            set_target_properties(
+                    faiss
+                    PROPERTIES
+                    INTERFACE_LINK_LIBRARIES "openblas;lapack")
+        endif ()
+    endif ()
+endif ()

core/src/index/cmake/ThirdPartyPackagesCore.cmake

@@ -16,11 +16,12 @@
 
 set(KNOWHERE_THIRDPARTY_DEPENDENCIES
 
-        ARROW
+        Arrow
         FAISS
         GTest
         LAPACK
         OpenBLAS
+        MKL
         )
 
 message(STATUS "Using ${KNOWHERE_DEPENDENCY_SOURCE} approach to find dependencies")
@@ -33,7 +34,7 @@ foreach (DEPENDENCY ${KNOWHERE_THIRDPARTY_DEPENDENCIES})
 endforeach ()
 
 macro(build_dependency DEPENDENCY_NAME)
-    if ("${DEPENDENCY_NAME}" STREQUAL "ARROW")
+    if ("${DEPENDENCY_NAME}" STREQUAL "Arrow")
         build_arrow()
     elseif ("${DEPENDENCY_NAME}" STREQUAL "LAPACK")
         build_lapack()
@@ -43,6 +44,8 @@ macro(build_dependency DEPENDENCY_NAME)
         build_openblas()
     elseif ("${DEPENDENCY_NAME}" STREQUAL "FAISS")
         build_faiss()
+    elseif ("${DEPENDENCY_NAME}" STREQUAL "MKL")
+        build_mkl()
     else ()
         message(FATAL_ERROR "Unknown thirdparty dependency to build: ${DEPENDENCY_NAME}")
     endif ()
@@ -50,9 +53,10 @@ endmacro()
 
 macro(resolve_dependency DEPENDENCY_NAME)
     if (${DEPENDENCY_NAME}_SOURCE STREQUAL "AUTO")
-        #message(STATUS "Finding ${DEPENDENCY_NAME} package")
-        #message(STATUS "${DEPENDENCY_NAME} package not found")
-        build_dependency(${DEPENDENCY_NAME})
+        find_package(${DEPENDENCY_NAME} MODULE)
+        if (NOT ${${DEPENDENCY_NAME}_FOUND})
+            build_dependency(${DEPENDENCY_NAME})
+        endif ()
     elseif (${DEPENDENCY_NAME}_SOURCE STREQUAL "BUNDLED")
         build_dependency(${DEPENDENCY_NAME})
     elseif (${DEPENDENCY_NAME}_SOURCE STREQUAL "SYSTEM")
@@ -131,17 +135,6 @@ if (USE_JFROG_CACHE STREQUAL "ON")
     endif ()
 endif ()
 
-macro(resolve_dependency DEPENDENCY_NAME)
-    if (${DEPENDENCY_NAME}_SOURCE STREQUAL "AUTO")
-        #disable find_package for now
-        build_dependency(${DEPENDENCY_NAME})
-    elseif (${DEPENDENCY_NAME}_SOURCE STREQUAL "BUNDLED")
-        build_dependency(${DEPENDENCY_NAME})
-    elseif (${DEPENDENCY_NAME}_SOURCE STREQUAL "SYSTEM")
-        find_package(${DEPENDENCY_NAME} REQUIRED)
-    endif ()
-endmacro()
-
 # ----------------------------------------------------------------------
 # ExternalProject options
 
@@ -232,28 +225,12 @@ foreach (_VERSION_ENTRY ${TOOLCHAIN_VERSIONS_TXT})
     set(${_LIB_NAME} "${_LIB_VERSION}")
 endforeach ()
 
-if (CUSTOMIZATION)
-    execute_process(COMMAND wget -q --method HEAD ${FAISS_URL} RESULT_VARIABLE return_code)
-    message(STATUS "Check the remote cache file ${FAISS_URL}. return code = ${return_code}")
-    if (NOT return_code EQUAL 0)
-        MESSAGE(FATAL_ERROR "Can't access to ${FAISS_URL}")
-    else ()
-        set(FAISS_SOURCE_URL ${FAISS_URL})
-        # set(FAISS_MD5 "a589663865a8558205533c8ac414278c")
-        # set(FAISS_MD5 "57da9c4f599cc8fa4260488b1c96e1cc") # commit-id 6dbdf75987c34a2c853bd172ea0d384feea8358c branch-0.2.0
-        # set(FAISS_MD5 "21deb1c708490ca40ecb899122c01403") # commit-id 643e48f479637fd947e7b93fa4ca72b38ecc9a39 branch-0.2.0
-        # set(FAISS_MD5 "072db398351cca6e88f52d743bbb9fa0") # commit-id 3a2344d04744166af41ef1a74449d68a315bfe17 branch-0.2.1
-        # set(FAISS_MD5 "c89ea8e655f5cdf58f42486f13614714") # commit-id 9c28a1cbb88f41fa03b03d7204106201ad33276b branch-0.2.1
-        # set(FAISS_MD5 "87fdd86351ffcaf3f80dc26ade63c44b") # commit-id 841a156e67e8e22cd8088e1b58c00afbf2efc30b branch-0.2.1
-        # set(FAISS_MD5 "f3b2ce3364c3fa7febd3aa7fdd0fe380") # commit-id 694e03458e6b69ce8a62502f71f69a614af5af8f branch-0.3.0
-        # set(FAISS_MD5 "bb30722c22390ce5f6759ccb216c1b2a") # commit-id d324db297475286afe107847c7fb7a0f9dc7e90e branch-0.3.0
-        set(FAISS_MD5 "2293cdb209c3718e3b19f3edae8b32b3") # commit-id a13c1205dc52977a9ad3b33a14efa958604a8bff branch-0.3.0
-    endif()
-else()
-    set(FAISS_SOURCE_URL "https://github.com/JinHai-CN/faiss/archive/1.6.0.tar.gz")
+if (DEFINED ENV{FAISS_SOURCE_URL})
+    set(FAISS_SOURCE_URL "$ENV{FAISS_SOURCE_URL}")
+else ()
+    set(FAISS_SOURCE_URL "https://github.com/JinHai-CN/faiss/archive/${FAISS_VERSION}.tar.gz")
     set(FAISS_MD5 "b02c1a53234f5acc9bea1b0c55524f50")
-endif()
-message(STATUS "FAISS URL = ${FAISS_SOURCE_URL}")
+endif ()
 
 if (DEFINED ENV{KNOWHERE_ARROW_URL})
     set(ARROW_SOURCE_URL "$ENV{KNOWHERE_ARROW_URL}")
@@ -296,6 +273,7 @@ macro(build_arrow)
     set(ARROW_STATIC_LIB
             "${ARROW_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}${ARROW_STATIC_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}"
             )
+    set(ARROW_LIB_DIR "${ARROW_PREFIX}/lib")
     set(ARROW_INCLUDE_DIR "${ARROW_PREFIX}/include")
 
     set(ARROW_CMAKE_ARGS
@@ -392,7 +370,7 @@ macro(build_arrow)
                 )
     endif ()
 
-    file(MAKE_DIRECTORY "${ARROW_PREFIX}/include")
+    file(MAKE_DIRECTORY "${ARROW_INCLUDE_DIR}")
     add_library(arrow STATIC IMPORTED)
     set_target_properties(arrow
             PROPERTIES IMPORTED_LOCATION "${ARROW_STATIC_LIB}"
@@ -402,17 +380,17 @@ macro(build_arrow)
     set(JEMALLOC_PREFIX "${INDEX_BINARY_DIR}/arrow_ep-prefix/src/arrow_ep-build/jemalloc_ep-prefix/src/jemalloc_ep")
 
     add_custom_command(TARGET arrow_ep POST_BUILD
-            COMMAND ${CMAKE_COMMAND} -E make_directory ${ARROW_PREFIX}/lib/
-            COMMAND ${CMAKE_COMMAND} -E copy ${JEMALLOC_PREFIX}/lib/libjemalloc_pic.a ${ARROW_PREFIX}/lib/
+            COMMAND ${CMAKE_COMMAND} -E make_directory ${ARROW_LIB_DIR}
+            COMMAND ${CMAKE_COMMAND} -E copy ${JEMALLOC_PREFIX}/lib/libjemalloc_pic.a ${ARROW_LIB_DIR}
             DEPENDS ${JEMALLOC_PREFIX}/lib/libjemalloc_pic.a)
 
 endmacro()
 
 if (KNOWHERE_WITH_ARROW AND NOT TARGET arrow_ep)
 
-    resolve_dependency(ARROW)
+    resolve_dependency(Arrow)
 
-    link_directories(SYSTEM ${ARROW_PREFIX}/lib/)
+    link_directories(SYSTEM ${ARROW_LIB_DIR})
     include_directories(SYSTEM ${ARROW_INCLUDE_DIR})
 endif ()
 
@@ -682,28 +660,46 @@ if (KNOWHERE_BUILD_TESTS AND NOT TARGET googletest_ep)
     include_directories(SYSTEM ${GTEST_INCLUDE_DIR})
 endif ()
 
+# ----------------------------------------------------------------------
+# MKL
+
+macro(build_mkl)
+
+    if (FAISS_WITH_MKL)
+        if (EXISTS "/proc/cpuinfo")
+            FILE(READ /proc/cpuinfo PROC_CPUINFO)
+
+            SET(VENDOR_ID_RX "vendor_id[ \t]*:[ \t]*([a-zA-Z]+)\n")
+            STRING(REGEX MATCH "${VENDOR_ID_RX}" VENDOR_ID "${PROC_CPUINFO}")
+            STRING(REGEX REPLACE "${VENDOR_ID_RX}" "\\1" VENDOR_ID "${VENDOR_ID}")
+
+            if (NOT ${VENDOR_ID} STREQUAL "GenuineIntel")
+                set(FAISS_WITH_MKL OFF)
+            endif ()
+        endif ()
+
+        find_path(MKL_LIB_PATH
+                NAMES "libmkl_intel_ilp64.a" "libmkl_gnu_thread.a" "libmkl_core.a"
+                PATH_SUFFIXES "intel/compilers_and_libraries_${MKL_VERSION}/linux/mkl/lib/intel64/")
+        if (${MKL_LIB_PATH} STREQUAL "MKL_LIB_PATH-NOTFOUND")
+            message(FATAL_ERROR "Could not find MKL libraries")
+        endif ()
+        message(STATUS "MKL lib path = ${MKL_LIB_PATH}")
+
+        set(MKL_LIBS
+                ${MKL_LIB_PATH}/libmkl_intel_ilp64.a
+                ${MKL_LIB_PATH}/libmkl_gnu_thread.a
+                ${MKL_LIB_PATH}/libmkl_core.a
+                )
+    endif ()
+endmacro()
+
 # ----------------------------------------------------------------------
 # FAISS
 
 macro(build_faiss)
     message(STATUS "Building FAISS-${FAISS_VERSION} from source")
 
-    if (NOT DEFINED BUILD_FAISS_WITH_MKL)
-        set(BUILD_FAISS_WITH_MKL OFF)
-    endif ()
-
-    if (EXISTS "/proc/cpuinfo")
-        FILE(READ /proc/cpuinfo PROC_CPUINFO)
-
-        SET(VENDOR_ID_RX "vendor_id[ \t]*:[ \t]*([a-zA-Z]+)\n")
-        STRING(REGEX MATCH "${VENDOR_ID_RX}" VENDOR_ID "${PROC_CPUINFO}")
-        STRING(REGEX REPLACE "${VENDOR_ID_RX}" "\\1" VENDOR_ID "${VENDOR_ID}")
-
-        if (NOT ${VENDOR_ID} STREQUAL "GenuineIntel")
-            set(BUILD_FAISS_WITH_MKL OFF)
-        endif ()
-    endif ()
-
     set(FAISS_PREFIX "${INDEX_BINARY_DIR}/faiss_ep-prefix/src/faiss_ep")
     set(FAISS_INCLUDE_DIR "${FAISS_PREFIX}/include")
     set(FAISS_STATIC_LIB
@@ -715,30 +711,11 @@ macro(build_faiss)
             "CXXFLAGS=${EP_CXX_FLAGS}"
             --without-python)
 
-    set(FAISS_CFLAGS ${EP_C_FLAGS})
-    set(FAISS_CXXFLAGS ${EP_CXX_FLAGS})
-
-    if (BUILD_FAISS_WITH_MKL)
-
-        find_path(MKL_LIB_PATH
-                NAMES "libmkl_intel_ilp64.a" "libmkl_gnu_thread.a" "libmkl_core.a"
-                PATH_SUFFIXES "intel/compilers_and_libraries_${MKL_VERSION}/linux/mkl/lib/intel64/")
-        if (${MKL_LIB_PATH} STREQUAL "MKL_LIB_PATH-NOTFOUND")
-            message(FATAL_ERROR "Could not find MKL libraries")
-        endif ()
-        message(STATUS "Build Faiss with MKL. MKL lib path = ${MKL_LIB_PATH}")
-
-        set(MKL_LIBS
-                ${MKL_LIB_PATH}/libmkl_intel_ilp64.a
-                ${MKL_LIB_PATH}/libmkl_gnu_thread.a
-                ${MKL_LIB_PATH}/libmkl_core.a
-                )
-
+    if (FAISS_WITH_MKL)
         set(FAISS_CONFIGURE_ARGS ${FAISS_CONFIGURE_ARGS}
                 "CPPFLAGS=-DFINTEGER=long -DMKL_ILP64 -m64 -I${MKL_LIB_PATH}/../../include"
                 "LDFLAGS=-L${MKL_LIB_PATH}"
                 )
-
     else ()
         message(STATUS "Build Faiss with OpenBlas/LAPACK")
         set(FAISS_CONFIGURE_ARGS ${FAISS_CONFIGURE_ARGS}
@@ -779,7 +756,7 @@ macro(build_faiss)
                     BUILD_BYPRODUCTS
                     ${FAISS_STATIC_LIB})
 
-            if (NOT BUILD_FAISS_WITH_MKL)
+            if (NOT FAISS_WITH_MKL)
                 ExternalProject_Add_StepDependencies(faiss_ep build openblas_ep lapack_ep)
             endif ()
 
@@ -809,7 +786,7 @@ macro(build_faiss)
                 BUILD_BYPRODUCTS
                 ${FAISS_STATIC_LIB})
 
-        if (NOT BUILD_FAISS_WITH_MKL)
+        if (NOT FAISS_WITH_MKL)
             ExternalProject_Add_StepDependencies(faiss_ep build openblas_ep lapack_ep)
         endif ()
 
@@ -824,7 +801,7 @@ macro(build_faiss)
             IMPORTED_LOCATION "${FAISS_STATIC_LIB}"
             INTERFACE_INCLUDE_DIRECTORIES "${FAISS_INCLUDE_DIR}"
     )
-    if (BUILD_FAISS_WITH_MKL)
+    if (FAISS_WITH_MKL)
         set_target_properties(
                 faiss
                 PROPERTIES
@@ -843,7 +820,9 @@ endmacro()
 
 if (KNOWHERE_WITH_FAISS AND NOT TARGET faiss_ep)
 
-    if (NOT BUILD_FAISS_WITH_MKL)
+    if (FAISS_WITH_MKL)
+        resolve_dependency(MKL)
+    else ()
         resolve_dependency(OpenBLAS)
         get_target_property(OPENBLAS_INCLUDE_DIR openblas INTERFACE_INCLUDE_DIRECTORIES)
         include_directories(SYSTEM "${OPENBLAS_INCLUDE_DIR}")

core/src/index/knowhere/CMakeLists.txt

@@ -49,12 +49,12 @@ set(depend_libs
         SPTAGLibStatic
         faiss
         arrow
-        ${ARROW_PREFIX}/lib/libjemalloc_pic.a
+        ${ARROW_LIB_DIR}/libjemalloc_pic.a
         gomp
         gfortran
         pthread
         )
-if (BUILD_FAISS_WITH_MKL)
+if (FAISS_WITH_MKL)
     set(depend_libs ${depend_libs}
             "-Wl,--start-group \
             ${MKL_LIB_PATH}/libmkl_intel_ilp64.a \

core/src/index/knowhere/knowhere/common/Log.h

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include "external/easyloggingpp/easylogging++.h"
+#include "easyloggingpp/easylogging++.h"
 
 namespace knowhere {
 

core/src/index/thirdparty/versions.txt

@@ -1,6 +1,7 @@
-ARROW_VERSION=apache-arrow-0.14.0
+ARROW_VERSION=apache-arrow-0.15.1
 BOOST_VERSION=1.70.0
 GTEST_VERSION=1.8.1
 LAPACK_VERSION=v3.8.0
 OPENBLAS_VERSION=v0.3.6
-FAISS_VERSION=branch-0.3.0
+FAISS_VERSION=1.6.0
+MKL_VERSION=2019.5.281

core/src/index/unittest/CMakeLists.txt

@@ -6,9 +6,9 @@ include_directories(${INDEX_SOURCE_DIR})
 set(depend_libs
         gtest gmock gtest_main gmock_main
         faiss
-        arrow "${ARROW_PREFIX}/lib/libjemalloc_pic.a"
+        arrow "${ARROW_LIB_DIR}/libjemalloc_pic.a"
         )
-if (BUILD_FAISS_WITH_MKL)
+if (FAISS_WITH_MKL)
     set(depend_libs ${depend_libs}
             "-Wl,--start-group \
             ${MKL_LIB_PATH}/libmkl_intel_ilp64.a \
@@ -27,7 +27,7 @@ set(basic_libs
         )
 
 set(util_srcs
-        ${MILVUS_ENGINE_SRC}/external/easyloggingpp/easylogging++.cc
+        ${MILVUS_THIRDPARTY_SRC}/easyloggingpp/easylogging++.cc
         ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/helpers/FaissIO.cpp
         ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/helpers/IndexParameter.cpp
         ${INDEX_SOURCE_DIR}/knowhere/knowhere/adapter/Structure.cpp

core/src/index/unittest/faiss_benchmark/CMakeLists.txt

@@ -13,9 +13,9 @@ if (KNOWHERE_GPU_VERSION)
 
     set(depend_libs
             faiss hdf5
-            arrow ${ARROW_PREFIX}/lib/libjemalloc_pic.a
+            arrow ${ARROW_LIB_DIR}/libjemalloc_pic.a
             )
-    if (BUILD_FAISS_WITH_MKL)
+    if (FAISS_WITH_MKL)
         set(depend_libs ${depend_libs}
                 "-Wl,--start-group \
                 ${MKL_LIB_PATH}/libmkl_intel_ilp64.a \

core/src/index/unittest/faiss_benchmark/faiss_benchmark_test.cpp

@@ -202,14 +202,14 @@ parse_ann_test_name(const std::string& ann_test_name, size_t& dim, faiss::Metric
 int32_t
 GetResultHitCount(const faiss::Index::idx_t* ground_index, const faiss::Index::idx_t* index, size_t ground_k, size_t k,
                   size_t nq, int32_t index_add_loops) {
-    assert(ground_k <= k);
+    size_t min_k = std::min(ground_k, k);
     int hit = 0;
     for (int i = 0; i < nq; i++) {
         // count the num of results exist in ground truth result set
         // each result replicates INDEX_ADD_LOOPS times
         for (int j_c = 0; j_c < k; j_c++) {
             int r_c = index[i * k + j_c];
-            for (int j_g = 0; j_g < ground_k / index_add_loops; j_g++) {
+            for (int j_g = 0; j_g < min_k / index_add_loops; j_g++) {
                 if (ground_index[i * ground_k + j_g] == r_c) {
                     hit++;
                     continue;
@@ -283,7 +283,11 @@ load_base_data(faiss::Index*& index, const std::string& ann_test_name, const std
         // add index multiple times to get ~1G data set
         for (int i = 0; i < index_add_loops; i++) {
             printf("[%.3f s] No.%d Indexing database, size %ld*%ld\n", elapsed() - t0, i, nb, d);
-            gpu_index->add(nb, xb);
+            std::vector<faiss::Index::idx_t> xids(nb);
+            for (int t = 0; t < nb; t++) {
+                xids[t] = i * nb + t;
+            }
+            gpu_index->add_with_ids(nb, xb, xids.data());
         }
 
         printf("[%.3f s] Coping GPU index to CPU\n", elapsed() - t0);
@@ -359,13 +363,14 @@ test_with_nprobes(const std::string& ann_test_name, const std::string& index_key
                   const int32_t search_loops) {
     double t0 = elapsed();
 
-    const size_t NQ = 1000, NQ_START = 10, NQ_STEP = 10;
-    const size_t K = 1000, K_START = 100, K_STEP = 10;
+    const std::vector<size_t> NQ = {10, 100};
+    const std::vector<size_t> K = {10, 100, 1000};
     const size_t GK = 100;  // topk of ground truth
 
     std::unordered_map<size_t, std::string> mode_str_map = {
         {MODE_CPU, "MODE_CPU"}, {MODE_MIX, "MODE_MIX"}, {MODE_GPU, "MODE_GPU"}};
 
+    double copy_time = 0.0;
     faiss::Index *gpu_index, *index;
     if (query_mode != MODE_CPU) {
         faiss::gpu::GpuClonerOptions option;
@@ -375,7 +380,6 @@ test_with_nprobes(const std::string& ann_test_name, const std::string& index_key
         index_composition.index = cpu_index;
         index_composition.quantizer = nullptr;
 
-        double copy_time;
         switch (query_mode) {
             case MODE_MIX: {
                 index_composition.mode = 1;  // 0: all data, 1: copy quantizer, 2: copy data
@@ -420,34 +424,39 @@ test_with_nprobes(const std::string& ann_test_name, const std::string& index_key
     }
 
     for (auto nprobe : nprobes) {
-        switch (query_mode) {
-            case MODE_CPU:
-            case MODE_MIX: {
-                faiss::ParameterSpace params;
-                std::string nprobe_str = "nprobe=" + std::to_string(nprobe);
-                params.set_index_parameters(index, nprobe_str.c_str());
-                break;
-            }
-            case MODE_GPU: {
-                faiss::gpu::GpuIndexIVF* gpu_index_ivf = dynamic_cast<faiss::gpu::GpuIndexIVF*>(index);
-                gpu_index_ivf->setNumProbes(nprobe);
+        // brute-force need not set nprobe
+        if (index_key.find("IDMap") == std::string::npos) {
+            switch (query_mode) {
+                case MODE_CPU:
+                case MODE_MIX: {
+                    faiss::ParameterSpace params;
+                    std::string nprobe_str = "nprobe=" + std::to_string(nprobe);
+                    params.set_index_parameters(index, nprobe_str.c_str());
+                    break;
+                }
+                case MODE_GPU: {
+                    faiss::gpu::GpuIndexIVF* gpu_index_ivf = dynamic_cast<faiss::gpu::GpuIndexIVF*>(index);
+                    gpu_index_ivf->setNumProbes(nprobe);
+                }
             }
         }
 
         // output buffers
-        faiss::Index::idx_t* I = new faiss::Index::idx_t[NQ * K];
-        faiss::Index::distance_t* D = new faiss::Index::distance_t[NQ * K];
+        faiss::Index::idx_t* I = new faiss::Index::idx_t[NQ.back() * K.back()];
+        faiss::Index::distance_t* D = new faiss::Index::distance_t[NQ.back() * K.back()];
 
         printf("\n%s | %s - %s | nprobe=%lu\n", ann_test_name.c_str(), index_key.c_str(),
                mode_str_map[query_mode].c_str(), nprobe);
         printf("======================================================================================\n");
-        for (size_t t_nq = NQ_START; t_nq <= NQ; t_nq *= NQ_STEP) {  // nq = {10, 100, 1000}
-            for (size_t t_k = K_START; t_k <= K; t_k *= K_STEP) {    //  k = {100, 1000}
+        for (size_t j = 0; j < K.size(); j++) {
+            size_t t_k = K[j];
+            for (size_t i = 0; i < NQ.size(); i++) {
+                size_t t_nq = NQ[i];
                 faiss::indexIVF_stats.quantization_time = 0.0;
                 faiss::indexIVF_stats.search_time = 0.0;
 
                 double t_start = elapsed(), t_end;
-                for (int i = 0; i < search_loops; i++) {
+                for (int s = 0; s < search_loops; s++) {
                     index->search(t_nq, xq, t_k, D, I);
                 }
                 t_end = elapsed();
@@ -466,7 +475,7 @@ test_with_nprobes(const std::string& ann_test_name, const std::string& index_key
                 printf("nq = %4ld, k = %4ld, elapse = %.4fs (quant = %.4fs, search = %.4fs), R@ = %.4f\n", t_nq, t_k,
                        (t_end - t_start) / search_loops, faiss::indexIVF_stats.quantization_time / 1000 / search_loops,
                        faiss::indexIVF_stats.search_time / 1000 / search_loops,
-                       (hit / float(t_nq * GK / index_add_loops)));
+                       (hit / float(t_nq * std::min(GK, t_k) / index_add_loops)));
             }
         }
         printf("======================================================================================\n");
@@ -479,8 +488,9 @@ test_with_nprobes(const std::string& ann_test_name, const std::string& index_key
 }
 
 void
-test_ann_hdf5(const std::string& ann_test_name, const std::string& index_type, const QueryMode query_mode,
-              int32_t index_add_loops, const std::vector<size_t>& nprobes, int32_t search_loops) {
+test_ann_hdf5(const std::string& ann_test_name, const std::string& cluster_type, const std::string& index_type,
+              const QueryMode query_mode, int32_t index_add_loops, const std::vector<size_t>& nprobes,
+              int32_t search_loops) {
     double t0 = elapsed();
 
     faiss::gpu::StandardGpuResources res;
@@ -493,7 +503,7 @@ test_ann_hdf5(const std::string& ann_test_name, const std::string& index_type, c
         return;
     }
 
-    std::string index_key = "IVF16384," + index_type;
+    std::string index_key = cluster_type + "," + index_type;
 
     if (!parse_ann_test_name(ann_test_name, dim, metric_type)) {
         printf("Invalid ann test name: %s\n", ann_test_name.c_str());
@@ -526,7 +536,7 @@ test_ann_hdf5(const std::string& ann_test_name, const std::string& index_type, c
  *
  * Dataset 	Dimensions 	Train_size 	Test_size 	Neighbors 	Distance 	Download
  * Fashion-
- *  MNIST   784         60,000      10,000 	    100         Euclidean   HDF5 (217MB)
+    MNIST   784         60,000      10,000 	    100         Euclidean   HDF5 (217MB)
  * GIST     960         1,000,000   1,000       100         Euclidean   HDF5 (3.6GB)
  * GloVe    100         1,183,514   10,000      100         Angular     HDF5 (463MB)
  * GloVe    200         1,183,514   10,000      100         Angular     HDF5 (918MB)
@@ -542,30 +552,39 @@ TEST(FAISSTEST, BENCHMARK) {
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     const int32_t SIFT_INSERT_LOOPS = 2;  // insert twice to get ~1G data set
 
-    test_ann_hdf5("sift-128-euclidean", "Flat", MODE_CPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("sift-128-euclidean", "Flat", MODE_GPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IDMap", "Flat", MODE_CPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IDMap", "Flat", MODE_GPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
 
-    test_ann_hdf5("sift-128-euclidean", "SQ8", MODE_CPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("sift-128-euclidean", "SQ8", MODE_GPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IVF16384", "Flat", MODE_CPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IVF16384", "Flat", MODE_GPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+
+    test_ann_hdf5("sift-128-euclidean", "IVF16384", "SQ8", MODE_CPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IVF16384", "SQ8", MODE_GPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
 
 #ifdef CUSTOMIZATION
-    test_ann_hdf5("sift-128-euclidean", "SQ8Hybrid", MODE_CPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("sift-128-euclidean", "SQ8Hybrid", MODE_MIX, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("sift-128-euclidean", "SQ8Hybrid", MODE_GPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IVF16384", "SQ8Hybrid", MODE_CPU, SIFT_INSERT_LOOPS, param_nprobes,
+                  SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IVF16384", "SQ8Hybrid", MODE_MIX, SIFT_INSERT_LOOPS, param_nprobes,
+                  SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IVF16384", "SQ8Hybrid", MODE_GPU, SIFT_INSERT_LOOPS, param_nprobes,
+                  SEARCH_LOOPS);
 #endif
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     const int32_t GLOVE_INSERT_LOOPS = 1;
 
-    test_ann_hdf5("glove-200-angular", "Flat", MODE_CPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("glove-200-angular", "Flat", MODE_GPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("glove-200-angular", "IVF16384", "Flat", MODE_CPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("glove-200-angular", "IVF16384", "Flat", MODE_GPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
 
-    test_ann_hdf5("glove-200-angular", "SQ8", MODE_CPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("glove-200-angular", "SQ8", MODE_GPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("glove-200-angular", "IVF16384", "SQ8", MODE_CPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("glove-200-angular", "IVF16384", "SQ8", MODE_GPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
 
 #ifdef CUSTOMIZATION
-    test_ann_hdf5("glove-200-angular", "SQ8Hybrid", MODE_CPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("glove-200-angular", "SQ8Hybrid", MODE_MIX, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("glove-200-angular", "SQ8Hybrid", MODE_GPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("glove-200-angular", "IVF16384", "SQ8Hybrid", MODE_CPU, GLOVE_INSERT_LOOPS, param_nprobes,
+                  SEARCH_LOOPS);
+    test_ann_hdf5("glove-200-angular", "IVF16384", "SQ8Hybrid", MODE_MIX, GLOVE_INSERT_LOOPS, param_nprobes,
+                  SEARCH_LOOPS);
+    test_ann_hdf5("glove-200-angular", "IVF16384", "SQ8Hybrid", MODE_GPU, GLOVE_INSERT_LOOPS, param_nprobes,
+                  SEARCH_LOOPS);
 #endif
 }

core/src/index/unittest/faiss_ori/CMakeLists.txt

@@ -8,9 +8,9 @@ if (KNOWHERE_GPU_VERSION)
 
     set(depend_libs
             faiss
-            arrow ${ARROW_PREFIX}/lib/libjemalloc_pic.a
+            arrow ${ARROW_LIB_DIR}/libjemalloc_pic.a
             )
-    if (BUILD_FAISS_WITH_MKL)
+    if (FAISS_WITH_MKL)
         set(depend_libs ${depend_libs}
                 "-Wl,--start-group \
                 ${MKL_LIB_PATH}/libmkl_intel_ilp64.a \

core/src/index/unittest/test_nsg/CMakeLists.txt

@@ -5,7 +5,7 @@
 add_definitions(-std=c++11 -O3 -lboost -march=native -Wall -DINFO)
 
 find_package(OpenMP REQUIRED)
-if (OPENMP_FOUND)
+if (OpenMP_FOUND)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
 else ()

core/src/main.cpp

@@ -22,7 +22,7 @@
 #include <cstring>
 #include <string>
 
-#include "external/easyloggingpp/easylogging++.h"
+#include "easyloggingpp/easylogging++.h"
 #include "metrics/Metrics.h"
 #include "server/Server.h"
 #include "src/config.h"

core/src/sdk/CMakeLists.txt

@@ -22,7 +22,7 @@ include_directories(include)
 aux_source_directory(interface interface_files)
 aux_source_directory(grpc grpc_client_files)
 
-add_library(milvus_sdk STATIC
+add_library(milvus_sdk SHARED
         ${interface_files}
         ${grpc_client_files}
         ${grpc_service_files}

core/src/sdk/README.md

@@ -0,0 +1,103 @@
+### Build C++ SDK
+
+The C++ SDK source code is under milvus/core/src/sdk. Build entire milvus project will also build the C++ SDK project. 
+If you don't want to build the entire milvus project, follow below steps:
+```shell
+ # generate make files
+ $ cd [Milvus root path]/core
+ $ ./build.sh -l
+ 
+ # build C++ SDK project
+ $ cd [Milvus root path]/core/cmake_build
+ $ make -C src/sdk
+```
+
+### Try C++ example
+
+Firstly, you need to start a Milvus server.
+If you've already built the entire milvus project, just start Milvus server with the following command:
+```shell
+ # start milvus server
+ $ cd [Milvus root path]/core
+ $ ./start_server.sh
+```
+You can also use Docker to start Milvus server:
+```shell
+ # pull milvus docker image and start milvus server
+ $ docker pull milvusdb/milvus:latest
+ $ docker run --runtime=nvidia -p 19530:19530 -d milvusdb/milvus:latest
+```
+
+Run C++ example:
+
+```shell
+ # run milvus C++ example
+ $ cd [Milvus root path]/core/cmake_build/src/sdk/examples/simple
+ $ ./sdk_simple
+```
+
+### Make your own C++ client project
+
+Create a folder for the project, and copy C++ SDK header and library files into it.
+```shell
+ # create project folder
+ $ mkdir MyMilvusClient
+ $ cd MyMilvusClient
+ 
+ # copy necessary files
+ $ cp [Milvus root path]/core/cmake_build/src/sdk/libmilvus_sdk.so .
+ $ cp [Milvus root path]/core/src/sdk/include/MilvusApi.h .
+ $ cp [Milvus root path]/core/src/sdk/include/Status.h .
+```
+
+Create file main.cpp in the project folder, and copy the following code into it:
+```shell
+#include "./MilvusApi.h"
+#include "./Status.h"
+
+int main() {
+  // connect to milvus server
+  std::shared_ptr<milvus::Connection> conn = milvus::Connection::Create();
+  milvus::ConnectParam param = {"127.0.0.1", "19530"};
+  conn->Connect(param);
+  
+  // put your client code here
+  
+  milvus::Connection::Destroy(conn);
+  return 0;
+}
+```
+
+Create file CMakeList.txt in the project folder, and copy the following code into it:
+```shell
+ cmake_minimum_required(VERSION 3.14)
+ project(test)
+ set(CMAKE_CXX_STANDARD 14)
+
+ add_executable(milvus_client main.cpp)
+ target_link_libraries(milvus_client
+         ${PROJECT_SOURCE_DIR}/libmilvus_sdk.so)
+```
+
+Now there are 5 files in your project:
+```shell
+MyMilvusClient
+ |-CMakeList.txt
+ |-main.cpp
+ |-libmilvus_sdk.so
+ |-MilvusApi.h
+ |-Status.h
+  ```
+
+Build the project:
+```shell
+ $ mkdir cmake_build
+ $ cd cmake_build
+ $ cmake ..
+ $ make
+```
+
+Run your client program:
+```shell
+ $ ./milvus_client
+```

core/src/sdk/examples/partition/src/ClientTest.cpp

@@ -41,7 +41,7 @@ constexpr int64_t NQ = 5;
 constexpr int64_t TOP_K = 10;
 constexpr int64_t NPROBE = 32;
 constexpr int64_t SEARCH_TARGET = 5000;  // change this value, result is different
-constexpr milvus::IndexType INDEX_TYPE = milvus::IndexType::gpu_ivfsq8;
+constexpr milvus::IndexType INDEX_TYPE = milvus::IndexType::IVFSQ8;
 constexpr int32_t N_LIST = 15000;
 constexpr int32_t PARTITION_COUNT = 5;
 constexpr int32_t TARGET_PARTITION = 3;
@@ -133,18 +133,18 @@ ClientTest::Test(const std::string& address, const std::string& port) {
     {  // search vectors
         std::cout << "Search in correct partition" << std::endl;
         std::vector<std::string> partiton_tags = {std::to_string(TARGET_PARTITION)};
-        std::vector<milvus::TopKQueryResult> topk_query_result_array;
+        milvus::TopKQueryResult topk_query_result;
         milvus_sdk::Utils::DoSearch(conn, TABLE_NAME, partiton_tags, TOP_K, NPROBE, search_record_array,
-                                    topk_query_result_array);
+                                    topk_query_result);
         std::cout << "Search in wrong partition" << std::endl;
         partiton_tags = {"0"};
         milvus_sdk::Utils::DoSearch(conn, TABLE_NAME, partiton_tags, TOP_K, NPROBE, search_record_array,
-                                    topk_query_result_array);
+                                    topk_query_result);
 
         std::cout << "Search by regex matched partition tag" << std::endl;
         partiton_tags = {"\\d"};
         milvus_sdk::Utils::DoSearch(conn, TABLE_NAME, partiton_tags, TOP_K, NPROBE, search_record_array,
-                                    topk_query_result_array);
+                                    topk_query_result);
     }
 
     {  // wait unit build index finish
@@ -182,9 +182,9 @@ ClientTest::Test(const std::string& address, const std::string& port) {
     {  // search vectors
         std::cout << "Search in whole table" << std::endl;
         std::vector<std::string> partiton_tags;
-        std::vector<milvus::TopKQueryResult> topk_query_result_array;
+        milvus::TopKQueryResult topk_query_result;
         milvus_sdk::Utils::DoSearch(conn, TABLE_NAME, partiton_tags, TOP_K, NPROBE, search_record_array,
-                                    topk_query_result_array);
+                                    topk_query_result);
     }
 
     {  // drop index

core/src/sdk/examples/simple/src/ClientTest.cpp

@@ -41,7 +41,7 @@ constexpr int64_t TOP_K = 10;
 constexpr int64_t NPROBE = 32;
 constexpr int64_t SEARCH_TARGET = 5000;  // change this value, result is different
 constexpr int64_t ADD_VECTOR_LOOP = 5;
-constexpr milvus::IndexType INDEX_TYPE = milvus::IndexType::gpu_ivfsq8;
+constexpr milvus::IndexType INDEX_TYPE = milvus::IndexType::IVFSQ8;
 constexpr int32_t N_LIST = 15000;
 
 milvus::TableSchema
@@ -144,9 +144,9 @@ ClientTest::Test(const std::string& address, const std::string& port) {
     milvus_sdk::Utils::Sleep(3);
     {  // search vectors
         std::vector<std::string> partiton_tags;
-        std::vector<milvus::TopKQueryResult> topk_query_result_array;
+        milvus::TopKQueryResult topk_query_result;
         milvus_sdk::Utils::DoSearch(conn, TABLE_NAME, partiton_tags, TOP_K, NPROBE, search_record_array,
-                                    topk_query_result_array);
+                                    topk_query_result);
     }
 
     {  // wait unit build index finish
@@ -169,9 +169,9 @@ ClientTest::Test(const std::string& address, const std::string& port) {
 
     {  // search vectors
         std::vector<std::string> partiton_tags;
-        std::vector<milvus::TopKQueryResult> topk_query_result_array;
+        milvus::TopKQueryResult topk_query_result;
         milvus_sdk::Utils::DoSearch(conn, TABLE_NAME, partiton_tags, TOP_K, NPROBE, search_record_array,
-                                    topk_query_result_array);
+                                    topk_query_result);
     }
 
     {  // drop index

core/src/sdk/examples/utils/Utils.cpp

@@ -89,14 +89,16 @@ Utils::MetricTypeName(const milvus::MetricType& metric_type) {
 std::string
 Utils::IndexTypeName(const milvus::IndexType& index_type) {
     switch (index_type) {
-        case milvus::IndexType::cpu_idmap:
-            return "cpu idmap";
-        case milvus::IndexType::gpu_ivfflat:
-            return "gpu ivflat";
-        case milvus::IndexType::gpu_ivfsq8:
-            return "gpu ivfsq8";
-        case milvus::IndexType::mix_nsg:
-            return "mix nsg";
+        case milvus::IndexType::FLAT:
+            return "FLAT";
+        case milvus::IndexType::IVFFLAT:
+            return "IVFFLAT";
+        case milvus::IndexType::IVFSQ8:
+            return "IVFSQ8";
+        case milvus::IndexType::NSG:
+            return "NSG";
+        case milvus::IndexType::IVFSQ8H:
+            return "IVFSQ8H";
         default:
             return "Unknown index type";
     }
@@ -153,32 +155,34 @@ Utils::BuildVectors(int64_t from, int64_t to, std::vector<milvus::RowRecord>& ve
 
 void
 Utils::PrintSearchResult(const std::vector<std::pair<int64_t, milvus::RowRecord>>& search_record_array,
-                         const std::vector<milvus::TopKQueryResult>& topk_query_result_array) {
+                         const milvus::TopKQueryResult& topk_query_result) {
     BLOCK_SPLITER
-    std::cout << "Returned result count: " << topk_query_result_array.size() << std::endl;
+    size_t nq = topk_query_result.row_num;
+    size_t topk = topk_query_result.ids.size() / nq;
+    std::cout << "Returned result count: " << nq * topk << std::endl;
 
     int32_t index = 0;
-    for (auto& result : topk_query_result_array) {
+    for (size_t i = 0; i < nq; i++) {
         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;
+        std::cout << "No." << index << " vector " << search_id << " top " << topk << " search result:" << std::endl;
+        for (size_t j = 0; j < topk; j++) {
+            size_t idx = i * nq + j;
+            std::cout << "\t" << topk_query_result.ids[idx] << "\t" << topk_query_result.distances[idx] << std::endl;
         }
     }
-
     BLOCK_SPLITER
 }
 
 void
 Utils::CheckSearchResult(const std::vector<std::pair<int64_t, milvus::RowRecord>>& search_record_array,
-                         const std::vector<milvus::TopKQueryResult>& topk_query_result_array) {
+                         const milvus::TopKQueryResult& topk_query_result) {
     BLOCK_SPLITER
+    size_t nq = topk_query_result.row_num;
+    size_t result_k = topk_query_result.ids.size() / nq;
     int64_t index = 0;
-    for (auto& result : topk_query_result_array) {
-        auto result_id = result.query_result_arrays[0].id;
+    for (size_t i = 0; i < nq; i++) {
+        auto result_id = topk_query_result.ids[i * result_k];
         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;
@@ -193,8 +197,10 @@ void
 Utils::DoSearch(std::shared_ptr<milvus::Connection> conn, const std::string& table_name,
                 const std::vector<std::string>& partiton_tags, int64_t top_k, int64_t nprobe,
                 const std::vector<std::pair<int64_t, milvus::RowRecord>>& search_record_array,
-                std::vector<milvus::TopKQueryResult>& topk_query_result_array) {
-    topk_query_result_array.clear();
+                milvus::TopKQueryResult& topk_query_result) {
+    topk_query_result.distances.clear();
+    topk_query_result.ids.clear();
+    topk_query_result.row_num = 0;
 
     std::vector<milvus::Range> query_range_array;
     milvus::Range rg;
@@ -210,14 +216,14 @@ Utils::DoSearch(std::shared_ptr<milvus::Connection> conn, const std::string& tab
     {
         BLOCK_SPLITER
         milvus_sdk::TimeRecorder rc("search");
-        milvus::Status stat = conn->Search(table_name, partiton_tags, record_array, query_range_array, top_k, nprobe,
-                                           topk_query_result_array);
+        milvus::Status stat =
+            conn->Search(table_name, partiton_tags, record_array, query_range_array, top_k, nprobe, topk_query_result);
         std::cout << "SearchVector function call status: " << stat.message() << std::endl;
         BLOCK_SPLITER
     }
 
-    PrintSearchResult(search_record_array, topk_query_result_array);
-    CheckSearchResult(search_record_array, topk_query_result_array);
+    PrintSearchResult(search_record_array, topk_query_result);
+    CheckSearchResult(search_record_array, topk_query_result);
 }
 
 }  // namespace milvus_sdk

core/src/sdk/examples/utils/Utils.h

@@ -61,17 +61,17 @@ class Utils {
 
     static void
     PrintSearchResult(const std::vector<std::pair<int64_t, milvus::RowRecord>>& search_record_array,
-                      const std::vector<milvus::TopKQueryResult>& topk_query_result_array);
+                      const milvus::TopKQueryResult& topk_query_result);
 
     static void
     CheckSearchResult(const std::vector<std::pair<int64_t, milvus::RowRecord>>& search_record_array,
-                      const std::vector<milvus::TopKQueryResult>& topk_query_result_array);
+                      const milvus::TopKQueryResult& topk_query_result);
 
     static void
     DoSearch(std::shared_ptr<milvus::Connection> conn, const std::string& table_name,
              const std::vector<std::string>& partiton_tags, int64_t top_k, int64_t nprobe,
              const std::vector<std::pair<int64_t, milvus::RowRecord>>& search_record_array,
-             std::vector<milvus::TopKQueryResult>& topk_query_result_array);
+             milvus::TopKQueryResult& topk_query_result);
 };
 
 }  // namespace milvus_sdk

core/src/sdk/grpc/ClientProxy.cpp

@@ -32,6 +32,13 @@ UriCheck(const std::string& uri) {
     return (index != std::string::npos);
 }
 
+void
+CopyRowRecord(::milvus::grpc::RowRecord* target, const RowRecord& src) {
+    auto vector_data = target->mutable_vector_data();
+    vector_data->Resize(static_cast<int>(src.data.size()), 0.0);
+    memcpy(vector_data->mutable_data(), src.data.data(), src.data.size() * sizeof(float));
+}
+
 Status
 ClientProxy::Connect(const ConnectParam& param) {
     std::string uri = param.ip_address + ":" + param.port;
@@ -189,23 +196,22 @@ ClientProxy::Insert(const std::string& table_name, const std::string& partition_
 
         for (auto& record : record_array) {
             ::milvus::grpc::RowRecord* grpc_record = insert_param.add_row_record_array();
-            for (size_t i = 0; i < record.data.size(); i++) {
-                grpc_record->add_vector_data(record.data[i]);
-            }
+            CopyRowRecord(grpc_record, record);
         }
 
         // Single thread
         ::milvus::grpc::VectorIds vector_ids;
         if (!id_array.empty()) {
-            for (auto i = 0; i < id_array.size(); i++) {
-                insert_param.add_row_id_array(id_array[i]);
-            }
+            /* set user's ids */
+            auto row_ids = insert_param.mutable_row_id_array();
+            row_ids->Reserve(static_cast<int>(id_array.size()));
+            memcpy(row_ids->mutable_data(), id_array.data(), id_array.size() * sizeof(int64_t));
+
             client_ptr_->Insert(vector_ids, insert_param, status);
         } else {
             client_ptr_->Insert(vector_ids, insert_param, status);
-            for (size_t i = 0; i < vector_ids.vector_id_array_size(); i++) {
-                id_array.push_back(vector_ids.vector_id_array(i));
-            }
+            /* return Milvus generated ids back to user */
+            id_array.insert(id_array.end(), vector_ids.vector_id_array().begin(), vector_ids.vector_id_array().end());
         }
 #endif
     } catch (std::exception& ex) {
@@ -218,7 +224,7 @@ ClientProxy::Insert(const std::string& table_name, const std::string& partition_
 Status
 ClientProxy::Search(const std::string& table_name, const std::vector<std::string>& partiton_tags,
                     const std::vector<RowRecord>& query_record_array, const std::vector<Range>& query_range_array,
-                    int64_t topk, int64_t nprobe, std::vector<TopKQueryResult>& topk_query_result_array) {
+                    int64_t topk, int64_t nprobe, TopKQueryResult& topk_query_result) {
     try {
         // step 1: convert vectors data
         ::milvus::grpc::SearchParam search_param;
@@ -230,9 +236,7 @@ ClientProxy::Search(const std::string& table_name, const std::vector<std::string
         }
         for (auto& record : query_record_array) {
             ::milvus::grpc::RowRecord* row_record = search_param.add_query_record_array();
-            for (auto& rec : record.data) {
-                row_record->add_vector_data(rec);
-            }
+            CopyRowRecord(row_record, record);
         }
 
         // step 2: convert range array
@@ -243,21 +247,17 @@ ClientProxy::Search(const std::string& table_name, const std::vector<std::string
         }
 
         // step 3: search vectors
-        ::milvus::grpc::TopKQueryResultList topk_query_result_list;
-        Status status = client_ptr_->Search(topk_query_result_list, search_param);
+        ::milvus::grpc::TopKQueryResult result;
+        Status status = client_ptr_->Search(result, search_param);
 
         // step 4: convert result array
-        for (uint64_t i = 0; i < topk_query_result_list.topk_query_result_size(); ++i) {
-            TopKQueryResult result;
-            for (uint64_t j = 0; j < topk_query_result_list.topk_query_result(i).query_result_arrays_size(); ++j) {
-                QueryResult query_result;
-                query_result.id = topk_query_result_list.topk_query_result(i).query_result_arrays(j).id();
-                query_result.distance = topk_query_result_list.topk_query_result(i).query_result_arrays(j).distance();
-                result.query_result_arrays.emplace_back(query_result);
-            }
+        topk_query_result.row_num = result.row_num();
+        topk_query_result.ids.resize(result.ids().size());
+        memcpy(topk_query_result.ids.data(), result.ids().data(), result.ids().size() * sizeof(int64_t));
+        topk_query_result.distances.resize(result.distances().size());
+        memcpy(topk_query_result.distances.data(), result.distances().data(),
+               result.distances().size() * sizeof(float));
 
-            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()));

core/src/sdk/grpc/ClientProxy.h

@@ -60,7 +60,7 @@ class ClientProxy : public Connection {
     Status
     Search(const std::string& table_name, const std::vector<std::string>& partiton_tags,
            const std::vector<RowRecord>& query_record_array, const std::vector<Range>& query_range_array, int64_t topk,
-           int64_t nprobe, std::vector<TopKQueryResult>& topk_query_result_array) override;
+           int64_t nprobe, TopKQueryResult& topk_query_result) override;
 
     Status
     DescribeTable(const std::string& table_name, TableSchema& table_schema) override;

core/src/sdk/grpc/GrpcClient.cpp

@@ -134,20 +134,20 @@ GrpcClient::Insert(::milvus::grpc::VectorIds& vector_ids, const ::milvus::grpc::
 }
 
 Status
-GrpcClient::Search(::milvus::grpc::TopKQueryResultList& topk_query_result_list,
+GrpcClient::Search(::milvus::grpc::TopKQueryResult& topk_query_result,
                    const ::milvus::grpc::SearchParam& search_param) {
     ::milvus::grpc::TopKQueryResult query_result;
     ClientContext context;
-    ::grpc::Status grpc_status = stub_->Search(&context, search_param, &topk_query_result_list);
+    ::grpc::Status grpc_status = stub_->Search(&context, search_param, &topk_query_result);
 
     if (!grpc_status.ok()) {
         std::cerr << "SearchVector rpc failed!" << std::endl;
         std::cerr << grpc_status.error_message() << std::endl;
         return Status(StatusCode::RPCFailed, grpc_status.error_message());
     }
-    if (topk_query_result_list.status().error_code() != grpc::SUCCESS) {
-        std::cerr << topk_query_result_list.status().reason() << std::endl;
-        return Status(StatusCode::ServerFailed, topk_query_result_list.status().reason());
+    if (topk_query_result.status().error_code() != grpc::SUCCESS) {
+        std::cerr << topk_query_result.status().reason() << std::endl;
+        return Status(StatusCode::ServerFailed, topk_query_result.status().reason());
     }
 
     return Status::OK();

core/src/sdk/grpc/GrpcClient.h

@@ -57,7 +57,7 @@ class GrpcClient {
     Insert(grpc::VectorIds& vector_ids, const grpc::InsertParam& insert_param, Status& status);
 
     Status
-    Search(::milvus::grpc::TopKQueryResultList& topk_query_result_list, const grpc::SearchParam& search_param);
+    Search(::milvus::grpc::TopKQueryResult& topk_query_result, const grpc::SearchParam& search_param);
 
     Status
     DescribeTable(grpc::TableSchema& grpc_schema, const std::string& table_name);

core/src/sdk/include/MilvusApi.h

@@ -31,12 +31,12 @@ namespace milvus {
  * @brief Index Type
  */
 enum class IndexType {
-    invalid = 0,
-    cpu_idmap,
-    gpu_ivfflat,
-    gpu_ivfsq8,
-    mix_nsg,
-    ivfsq8h,
+    INVALID = 0,
+    FLAT = 1,
+    IVFFLAT = 2,
+    IVFSQ8 = 3,
+    NSG = 4,
+    IVFSQ8H = 5,
 };
 
 enum class MetricType {
@@ -78,19 +78,13 @@ struct RowRecord {
     std::vector<float> data;  ///< Vector raw data
 };
 
-/**
- * @brief Query result
- */
-struct QueryResult {
-    int64_t id;       ///< Output result
-    double distance;  ///< Vector similarity distance
-};
-
 /**
  * @brief TopK query result
  */
 struct TopKQueryResult {
-    std::vector<QueryResult> query_result_arrays;  ///< TopK query result
+    int64_t row_num;
+    std::vector<int64_t> ids;
+    std::vector<float> distances;
 };
 
 /**
@@ -274,7 +268,7 @@ class Connection {
     virtual Status
     Search(const std::string& table_name, const std::vector<std::string>& partiton_tags,
            const std::vector<RowRecord>& query_record_array, const std::vector<Range>& query_range_array, int64_t topk,
-           int64_t nprobe, std::vector<TopKQueryResult>& topk_query_result_array) = 0;
+           int64_t nprobe, TopKQueryResult& topk_query_result) = 0;
 
     /**
      * @brief Show table description

core/src/sdk/interface/ConnectionImpl.cpp

@@ -91,9 +91,9 @@ ConnectionImpl::Insert(const std::string& table_name, const std::string& partiti
 Status
 ConnectionImpl::Search(const std::string& table_name, const std::vector<std::string>& partiton_tags,
                        const std::vector<RowRecord>& query_record_array, const std::vector<Range>& query_range_array,
-                       int64_t topk, int64_t nprobe, std::vector<TopKQueryResult>& topk_query_result_array) {
+                       int64_t topk, int64_t nprobe, TopKQueryResult& topk_query_result) {
     return client_proxy_->Search(table_name, partiton_tags, query_record_array, query_range_array, topk, nprobe,
-                                 topk_query_result_array);
+                                 topk_query_result);
 }
 
 Status

core/src/sdk/interface/ConnectionImpl.h

@@ -62,7 +62,7 @@ class ConnectionImpl : public Connection {
     Status
     Search(const std::string& table_name, const std::vector<std::string>& partiton_tags,
            const std::vector<RowRecord>& query_record_array, const std::vector<Range>& query_range_array, int64_t topk,
-           int64_t nprobe, std::vector<TopKQueryResult>& topk_query_result_array) override;
+           int64_t nprobe, TopKQueryResult& topk_query_result) override;
 
     Status
     DescribeTable(const std::string& table_name, TableSchema& table_schema) override;

core/src/server/Config.h

@@ -93,11 +93,13 @@ static const char* CONFIG_RESOURCE_MODE = "mode";
 static const char* CONFIG_RESOURCE_MODE_DEFAULT = "simple";
 static const char* CONFIG_RESOURCE_SEARCH_RESOURCES = "search_resources";
 static const char* CONFIG_RESOURCE_SEARCH_RESOURCES_DELIMITER = ",";
+
 #ifdef MILVUS_CPU_VERSION
 static const char* CONFIG_RESOURCE_SEARCH_RESOURCES_DEFAULT = "cpu";
 #else
 static const char* CONFIG_RESOURCE_SEARCH_RESOURCES_DEFAULT = "cpu,gpu0";
 #endif
+
 static const char* CONFIG_RESOURCE_INDEX_BUILD_DEVICE = "index_build_device";
 #ifdef MILVUS_CPU_VERSION
 static const char* CONFIG_RESOURCE_INDEX_BUILD_DEVICE_DEFAULT = "cpu";

core/src/server/grpc_impl/GrpcRequestHandler.cpp

@@ -75,7 +75,7 @@ GrpcRequestHandler::Insert(::grpc::ServerContext* context, const ::milvus::grpc:
 
 ::grpc::Status
 GrpcRequestHandler::Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request,
-                           ::milvus::grpc::TopKQueryResultList* response) {
+                           ::milvus::grpc::TopKQueryResult* response) {
     std::vector<std::string> file_id_array;
     BaseTaskPtr task_ptr = SearchTask::Create(request, file_id_array, response);
     ::milvus::grpc::Status grpc_status;
@@ -87,7 +87,7 @@ GrpcRequestHandler::Search(::grpc::ServerContext* context, const ::milvus::grpc:
 
 ::grpc::Status
 GrpcRequestHandler::SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request,
-                                  ::milvus::grpc::TopKQueryResultList* response) {
+                                  ::milvus::grpc::TopKQueryResult* response) {
     std::vector<std::string> file_id_array;
     for (int i = 0; i < request->file_id_array_size(); i++) {
         file_id_array.push_back(request->file_id_array(i));

core/src/server/grpc_impl/GrpcRequestHandler.h

@@ -153,7 +153,8 @@ class GrpcRequestHandler final : public ::milvus::grpc::MilvusService::Service {
     // @return TopKQueryResultList
     ::grpc::Status
     Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request,
-           ::milvus::grpc::TopKQueryResultList* response) override;
+           ::milvus::grpc::TopKQueryResult* response) override;
+
     // *
     // @brief This method is used to query vector in specified files.
     //
@@ -162,7 +163,8 @@ class GrpcRequestHandler final : public ::milvus::grpc::MilvusService::Service {
     // @return TopKQueryResultList
     ::grpc::Status
     SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request,
-                  ::milvus::grpc::TopKQueryResultList* response) override;
+                  ::milvus::grpc::TopKQueryResult* response) override;
+
     // *
     // @brief This method is used to give the server status.
     //

core/src/server/grpc_impl/GrpcRequestTask.cpp

@@ -20,6 +20,7 @@
 #include <string.h>
 #include <map>
 #include <string>
+#include <utility>
 #include <vector>
 //#include <gperftools/profiler.h>
 
@@ -542,16 +543,16 @@ InsertTask::OnExecute() {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 SearchTask::SearchTask(const ::milvus::grpc::SearchParam* search_vector_infos,
-                       const std::vector<std::string>& file_id_array, ::milvus::grpc::TopKQueryResultList* response)
+                       const std::vector<std::string>& file_id_array, ::milvus::grpc::TopKQueryResult* response)
     : GrpcBaseTask(DQL_TASK_GROUP),
       search_param_(search_vector_infos),
       file_id_array_(file_id_array),
-      topk_result_list(response) {
+      topk_result_(response) {
 }
 
 BaseTaskPtr
 SearchTask::Create(const ::milvus::grpc::SearchParam* search_vector_infos,
-                   const std::vector<std::string>& file_id_array, ::milvus::grpc::TopKQueryResultList* response) {
+                   const std::vector<std::string>& file_id_array, ::milvus::grpc::TopKQueryResult* response) {
     if (search_vector_infos == nullptr) {
         SERVER_LOG_ERROR << "grpc input is null!";
         return nullptr;
@@ -679,18 +680,13 @@ SearchTask::OnExecute() {
             return Status::OK();  // empty table
         }
 
-        size_t result_k = result_ids.size() / record_count;
-
         // step 7: construct result array
-        for (size_t i = 0; i < record_count; i++) {
-            ::milvus::grpc::TopKQueryResult* topk_query_result = topk_result_list->add_topk_query_result();
-            for (size_t j = 0; j < result_k; j++) {
-                ::milvus::grpc::QueryResult* grpc_result = topk_query_result->add_query_result_arrays();
-                size_t idx = i * result_k + j;
-                grpc_result->set_id(result_ids[idx]);
-                grpc_result->set_distance(result_distances[idx]);
-            }
-        }
+        topk_result_->set_row_num(record_count);
+        topk_result_->mutable_ids()->Resize(static_cast<int>(result_ids.size()), 0);
+        memcpy(topk_result_->mutable_ids()->mutable_data(), result_ids.data(), result_ids.size() * sizeof(int64_t));
+        topk_result_->mutable_distances()->Resize(static_cast<int>(result_distances.size()), 0.0);
+        memcpy(topk_result_->mutable_distances()->mutable_data(), result_distances.data(),
+               result_distances.size() * sizeof(float));
 
         // step 8: print time cost percent
         rc.RecordSection("construct result and send");

core/src/server/grpc_impl/GrpcRequestTask.h

@@ -153,11 +153,11 @@ class SearchTask : public GrpcBaseTask {
  public:
     static BaseTaskPtr
     Create(const ::milvus::grpc::SearchParam* search_param, const std::vector<std::string>& file_id_array,
-           ::milvus::grpc::TopKQueryResultList* response);
+           ::milvus::grpc::TopKQueryResult* response);
 
  protected:
     SearchTask(const ::milvus::grpc::SearchParam* search_param, const std::vector<std::string>& file_id_array,
-               ::milvus::grpc::TopKQueryResultList* response);
+               ::milvus::grpc::TopKQueryResult* response);
 
     Status
     OnExecute() override;
@@ -165,7 +165,7 @@ class SearchTask : public GrpcBaseTask {
  private:
     const ::milvus::grpc::SearchParam* search_param_;
     std::vector<std::string> file_id_array_;
-    ::milvus::grpc::TopKQueryResultList* topk_result_list;
+    ::milvus::grpc::TopKQueryResult* topk_result_;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

core/src/server/grpc_impl/GrpcServer.cpp

@@ -93,7 +93,7 @@ GrpcServer::StartService() {
 
     builder.SetCompressionAlgorithmSupportStatus(GRPC_COMPRESS_STREAM_GZIP, true);
     builder.SetDefaultCompressionAlgorithm(GRPC_COMPRESS_STREAM_GZIP);
-    builder.SetDefaultCompressionLevel(GRPC_COMPRESS_LEVEL_HIGH);
+    builder.SetDefaultCompressionLevel(GRPC_COMPRESS_LEVEL_NONE);
 
     GrpcRequestHandler service;
 

core/src/utils/Json.h

@@ -16,7 +16,7 @@
 // under the License.
 #pragma once
 
-#include "external/nlohmann/json.hpp"
+#include "nlohmann/json.hpp"
 
 namespace milvus {
 using json = nlohmann::json;

core/src/utils/Log.h

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include "external/easyloggingpp/easylogging++.h"
+#include "easyloggingpp/easylogging++.h"
 
 namespace milvus {
 

core/src/utils/LogUtil.h

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include "external/easyloggingpp/easylogging++.h"
+#include "easyloggingpp/easylogging++.h"
 #include "utils/Status.h"
 
 #include <sstream>

core/thirdparty/versions.txt

@@ -9,6 +9,5 @@ LIBUNWIND_VERSION=1.3.1
 GPERFTOOLS_VERSION=2.7
 GRPC_VERSION=master
 ZLIB_VERSION=v1.2.11
-MKL_VERSION=2019.5.281
 
 # vim: set filetype=sh:

core/unittest/CMakeLists.txt

@@ -23,6 +23,7 @@ endforeach ()
 
 include_directories(${MILVUS_SOURCE_DIR})
 include_directories(${MILVUS_ENGINE_SRC})
+include_directories(${MILVUS_THIRDPARTY_SRC})
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 aux_source_directory(${MILVUS_ENGINE_SRC}/cache cache_files)
@@ -57,11 +58,11 @@ set(scheduler_files
         ${scheduler_optimizer_files}
         )
 
-aux_source_directory(${MILVUS_ENGINE_SRC}/external/easyloggingpp external_easyloggingpp_files)
-aux_source_directory(${MILVUS_ENGINE_SRC}/external/nlohmann external_nlohmann_files)
-set(external_files
-        ${external_easyloggingpp_files}
-        ${external_nlohmann_files}
+aux_source_directory(${MILVUS_THIRDPARTY_SRC}/easyloggingpp thirdparty_easyloggingpp_files)
+aux_source_directory(${MILVUS_THIRDPARTY_SRC}/nlohmann thirdparty_nlohmann_files)
+set(thirdparty_files
+        ${thirdparty_easyloggingpp_files}
+        ${thirdparty_nlohmann_files}
         )
 
 aux_source_directory(${MILVUS_ENGINE_SRC}/server server_files)
@@ -79,7 +80,7 @@ set(helper_files
         ${MILVUS_ENGINE_SRC}/utils/Status.cpp
         ${MILVUS_ENGINE_SRC}/utils/StringHelpFunctions.cpp
         ${MILVUS_ENGINE_SRC}/utils/ValidationUtil.cpp
-        ${MILVUS_ENGINE_SRC}/external/easyloggingpp/easylogging++.cc
+        ${MILVUS_THIRDPARTY_SRC}/easyloggingpp/easylogging++.cc
         )
 
 set(common_files
@@ -90,7 +91,7 @@ set(common_files
         ${db_insert_files}
         ${db_meta_files}
         ${metrics_files}
-        ${external_files}
+        ${thirdparty_files}
         ${scheduler_files}
         ${wrapper_files}
         ${helper_files}

core/unittest/db/CMakeLists.txt

@@ -17,8 +17,16 @@
 # under the License.
 #-------------------------------------------------------------------------------
 
-
-aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} test_files)
+set(test_files
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_db.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_db_mysql.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_engine.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_mem.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_meta.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_meta_mysql.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_misc.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_search.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/utils.cpp)
 
 add_executable(test_db
         ${common_files}

core/unittest/main.cpp

@@ -18,7 +18,7 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#include "external/easyloggingpp/easylogging++.h"
+#include "easyloggingpp/easylogging++.h"
 
 INITIALIZE_EASYLOGGINGPP
 

core/unittest/metrics/CMakeLists.txt

@@ -17,7 +17,11 @@
 # under the License.
 #-------------------------------------------------------------------------------
 
-aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} test_files)
+set(test_files
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_metricbase.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_metrics.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_prometheus.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/utils.cpp)
 
 add_executable(test_metrics
         ${common_files}

core/unittest/scheduler/CMakeLists.txt

@@ -17,7 +17,17 @@
 # under the License.
 #-------------------------------------------------------------------------------
 
-aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} test_files)
+set(test_files
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_algorithm.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_event.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_node.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_normal.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_resource.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_resource_factory.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_resource_mgr.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_scheduler.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_task.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_tasktable.cpp)
 
 add_executable(test_scheduler
         ${common_files}

core/unittest/server/CMakeLists.txt

@@ -17,7 +17,12 @@
 # under the License.
 #-------------------------------------------------------------------------------
 
-aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} test_files)
+set(test_files
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_cache.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_config.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_rpc.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_util.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/utils.cpp)
 
 include_directories("${CUDA_TOOLKIT_ROOT_DIR}/include")
 link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib64")

core/unittest/server/test_config.cpp

@@ -415,6 +415,9 @@ TEST_F(ConfigTest, SERVER_CONFIG_INVALID_TEST) {
     s = config.SetResourceConfigSearchResources("gpu10");
     ASSERT_FALSE(s.ok());
 
+    s = config.SetResourceConfigSearchResources("cpu");
+    ASSERT_TRUE(s.ok());
+
     s = config.SetResourceConfigIndexBuildDevice("gup2");
     ASSERT_FALSE(s.ok());
     s = config.SetResourceConfigIndexBuildDevice("gpu16");
@@ -435,3 +438,4 @@ TEST_F(ConfigTest, SERVER_CONFIG_TEST) {
     s = config.ResetDefaultConfig();
     ASSERT_TRUE(s.ok());
 }
+

core/unittest/server/test_rpc.cpp

@@ -43,6 +43,12 @@ static constexpr int64_t VECTOR_COUNT = 1000;
 static constexpr int64_t INSERT_LOOP = 10;
 constexpr int64_t SECONDS_EACH_HOUR = 3600;
 
+void CopyRowRecord(::milvus::grpc::RowRecord* target, const std::vector<float>& src) {
+    auto vector_data = target->mutable_vector_data();
+    vector_data->Resize(static_cast<int>(src.size()), 0.0);
+    memcpy(vector_data->mutable_data(), src.data(), src.size()* sizeof(float));
+}
+
 class RpcHandlerTest : public testing::Test {
  protected:
     void
@@ -201,9 +207,7 @@ TEST_F(RpcHandlerTest, INSERT_TEST) {
     ::milvus::grpc::VectorIds vector_ids;
     for (auto& record : record_array) {
         ::milvus::grpc::RowRecord* grpc_record = request.add_row_record_array();
-        for (size_t i = 0; i < record.size(); i++) {
-            grpc_record->add_vector_data(record[i]);
-        }
+        CopyRowRecord(grpc_record, record);
     }
     handler->Insert(&context, &request, &vector_ids);
     ASSERT_EQ(vector_ids.vector_id_array_size(), VECTOR_COUNT);
@@ -212,8 +216,8 @@ TEST_F(RpcHandlerTest, INSERT_TEST) {
 TEST_F(RpcHandlerTest, SEARCH_TEST) {
     ::grpc::ServerContext context;
     ::milvus::grpc::SearchParam request;
-    ::milvus::grpc::TopKQueryResultList response;
-    // test null input
+    ::milvus::grpc::TopKQueryResult response;
+    //test null input
     handler->Search(&context, nullptr, &response);
 
     // test invalid table name
@@ -240,22 +244,17 @@ TEST_F(RpcHandlerTest, SEARCH_TEST) {
     ::milvus::grpc::InsertParam insert_param;
     for (auto& record : record_array) {
         ::milvus::grpc::RowRecord* grpc_record = insert_param.add_row_record_array();
-        for (size_t i = 0; i < record.size(); i++) {
-            grpc_record->add_vector_data(record[i]);
-        }
+        CopyRowRecord(grpc_record, record);
     }
     // insert vectors
     insert_param.set_table_name(TABLE_NAME);
     ::milvus::grpc::VectorIds vector_ids;
     handler->Insert(&context, &insert_param, &vector_ids);
-    sleep(7);
 
     BuildVectors(0, 10, record_array);
     for (auto& record : record_array) {
         ::milvus::grpc::RowRecord* row_record = request.add_query_record_array();
-        for (auto& rec : record) {
-            row_record->add_vector_data(rec);
-        }
+        CopyRowRecord(row_record, record);
     }
     handler->Search(&context, &request, &response);
 
@@ -324,9 +323,7 @@ TEST_F(RpcHandlerTest, TABLES_TEST) {
 
     for (auto& record : record_array) {
         ::milvus::grpc::RowRecord* grpc_record = request.add_row_record_array();
-        for (size_t i = 0; i < record.size(); i++) {
-            grpc_record->add_vector_data(record[i]);
-        }
+        CopyRowRecord(grpc_record, record);
     }
     // test vector_id size not equal to row record size
     vector_ids.clear_vector_id_array();
@@ -341,9 +338,7 @@ TEST_F(RpcHandlerTest, TABLES_TEST) {
     vector_ids.clear_vector_id_array();
     for (uint64_t i = 0; i < 10; ++i) {
         ::milvus::grpc::RowRecord* grpc_record = request.add_row_record_array();
-        for (size_t j = 0; j < 10; j++) {
-            grpc_record->add_vector_data(record_array[i][j]);
-        }
+        CopyRowRecord(grpc_record, record_array[i]);
     }
     handler->Insert(&context, &request, &vector_ids);
 

core/unittest/wrapper/CMakeLists.txt

@@ -32,7 +32,7 @@ set(wrapper_files
 
 set(util_files
         utils.cpp
-        ${MILVUS_ENGINE_SRC}/external/easyloggingpp/easylogging++.cc
+        ${MILVUS_THIRDPARTY_SRC}/easyloggingpp/easylogging++.cc
         ${MILVUS_ENGINE_SRC}/utils/Status.cpp
         )
 

core/unittest/wrapper/test_wrapper.cpp

@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "external/easyloggingpp/easylogging++.h"
+#include "easyloggingpp/easylogging++.h"
 #include "wrapper/VecIndex.h"
 
 #ifdef MILVUS_GPU_VERSION

install.md

@@ -3,7 +3,10 @@
 ## Software requirements
 
 - Ubuntu 18.04 or higher
-- CMake 3.14 or higher
+- CMake 3.12 or higher
+
+##### For GPU version, you will also need:
+
 - CUDA 10.0 or higher
 - NVIDIA driver 418 or higher
 
@@ -12,19 +15,24 @@
 ### Step 1 Install dependencies
 
 ```shell
-$ cd [Milvus sourcecode path]/core
+$ cd [Milvus root path]/core
 $ ./ubuntu_build_deps.sh
 ```
 
 ### Step 2 Build
 
 ```shell
-$ cd [Milvus sourcecode path]/core
+$ cd [Milvus root path]/core
 $ ./build.sh -t Debug
 or 
 $ ./build.sh -t Release
 ```
 
+By default, it will build CPU version. To build GPU version, add `-g` option
+```
+$ ./build.sh -g
+```
+
 When the build is completed, all the stuff that you need in order to run Milvus will be installed under `[Milvus root path]/core/milvus`.
 
 ## Launch Milvus server
@@ -36,7 +44,7 @@ $ cd [Milvus root path]/core/milvus
 Add `lib/` directory to `LD_LIBRARY_PATH`
 
 ```
-$ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/path/to/milvus/lib
+$ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:[Milvus root path]/core/milvus/lib
 ```
 
 Then start Milvus server:
@@ -51,3 +59,15 @@ To stop Milvus server, run:
 ```shell
 $ ./stop_server.sh
 ```
+
+## Troubleshooting
+1. If you encounter the following error when compiling: 
+`protocol https not supported or disabled in libcurl`.
+First, make sure you have `libcurl4-openssl-dev` installed in your system.
+Then try reinstall CMake from source with `--system-curl` option:
+```
+$ ./bootstrap --system-curl 
+$ make 
+$ sudo make install
+```
+

shards/README.md

@@ -0,0 +1,266 @@
+# Mishards - An Experimental Sharding Middleware 
+
+[中文版](README_CN.md)
+
+Milvus aims to achieve efficient similarity search and analytics for massive-scale vectors. A standalone Milvus instance can easily handle vector search among billion-scale vectors. However, for 10 billion, 100 billion or even larger datasets, a Milvus cluster is needed. 
+
+Ideally, this cluster can be accessed and used just as the standalone instance, meanwhile it satisfies the business requirements such as low latency and high concurrency.
+
+This page meant to demonstrates how to use Mishards, an experimental sharding middleware for Milvus, to establish an orchestrated cluster.
+
+## What is Mishards
+
+Mishards is a middleware that is developed using Python. It provides unlimited extension of memory and computation capacity through request forwarding, read/write splitting, horizontal scalability and dynamic extension. It works as the proxy of the Milvus system. 
+
+Using Mishards in Milvus cluster deployment is an experimental feature available for user test and feedback.
+
+## How Mishards works
+
+Mishards splits the upstream requests to sub-requests and forwards them to Milvus servers. When the search computation is completed, all results are collected by Mishards and sent back to the client. 
+
+Below graph is a demonstration of the process:
+
+![mishards](https://raw.githubusercontent.com/milvus-io/docs/master/assets/mishards.png)
+
+## Mishards example codes
+
+Below examples codes demonstrate how to build from source code a Milvus server with Mishards on a standalone machine, as well as how to use Kubernetes to establish Milvus cluster with Mishards. 
+
+Before executing these examples, make sure you meet the prerequisites of [Milvus installation](https://www.milvus.io/docs/en/userguide/install_milvus/). 
+
+### Build from source code
+
+#### Prequisites
+
+Make sure Python 3.6 or higher is installed.
+
+#### Start Milvus and Mishards from source code
+
+Follow below steps to start a standalone Milvus instance with Mishards from source code:
+
+1. Clone milvus repository.
+
+   ```shell
+   git clone <milvus repo http/ssh url>
+   ```
+
+2. Install Mishards dependencies.
+
+   ```shell
+   $ cd milvus/shards
+   $ pip install -r requirements.txt
+   ```
+
+3. Start Milvus server.
+
+   ```shell
+   $ sudo nvidia-docker run --rm -d -p 19530:19530 -v /tmp/milvus/db:/opt/milvus/db milvusdb/milvus:0.5.0-d102119-ede20b
+   ```
+
+4. Update path permissions.
+
+   ```shell
+   $ sudo chown -R $USER:$USER /tmp/milvus
+   ```
+
+5. Configure Mishards environmental variables.
+
+   ```shell
+   $ cp mishards/.env.example mishards/.env
+   ```
+
+6. Start Mishards server.
+
+   ```shell
+   $ python mishards/main.py
+   ```
+
+### Docker example 
+
+The `all_in_one` example shows how to use Docker container to start 2 Milvus instances, 1 Mishards instance and 1 Jaeger instance.  
+
+ 1. Install [Docker Compose](https://docs.docker.com/compose/install/).
+
+ 2. Build docker images for these instances. 
+
+    ```shell
+    $ make build
+    ```
+
+ 3. Start all instances.
+
+    ```shell
+    $ make deploy
+    ```
+
+ 4. Confirm instance status. 
+
+    ```shell
+    $ make probe_deploy
+         Pass ==> Pass: Connected
+         Fail ==> Error: Fail connecting to server on 127.0.0.1:19530. Timeout
+    ```
+
+To check the service tracing, open the [Jaeger page](http://127.0.0.1:16686/) on your browser. 
+
+![jaegerui](https://raw.githubusercontent.com/milvus-io/docs/master/assets/jaegerui.png)
+
+![jaegertraces](https://raw.githubusercontent.com/milvus-io/docs/master/assets/jaegertraces.png)
+
+To stop all instances, use the following command:
+
+```shell
+$ make clean_deploy
+```
+
+### Kubernetes example
+
+Using Kubernetes to deploy Milvus cluster requires that the developers have a basic understanding of [general concepts](https://kubernetes.io/docs/concepts/) of Kubernetes. 
+
+This example mainly demonstrates how to use Kubernetes to establish a Milvus cluster containing 2 Milvus instances（1 read instance and 1 write instance), 1 MySQL instance and 1 Mishards instance. 
+
+This example does not include tasks such as setting up Kubernetes cluster, [installing shared storage](https://kubernetes.io/docs/concepts/storage/volumes/) and using command tools such as [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/).
+
+Below is the architecture of Milvus cluster built upon Kubernetes:
+
+![k8s_arch](https://raw.githubusercontent.com/milvus-io/docs/master/assets/k8s_arch.png)
+
+#### Prerequisites
+
+- A Kubernetes cluster is already established.
+- [nvidia-docker 2.0](https://github.com/nvidia/nvidia-docker/wiki/Installation-(version-2.0)) is already installed.
+- Shared storage is already installed. 
+- kubectl is installed and can access the Kubernetes cluster.
+
+#### Use Kubernetes to build a Milvus cluster
+
+1. Start Milvus cluster
+
+   ```shell
+   $ make cluster
+   ```
+
+2. Confirm that Mishards is connected to Milvus.
+
+   ```shell
+   $ make probe_cluster
+     Pass ==> Pass: Connected
+   ```
+
+To check cluster status:
+
+```shell
+$ make cluster_status
+```
+
+To delete the cluster: 
+
+```shell
+$ make clean_cluster
+```
+
+To add a read instance:
+
+```shell
+$ cd kubernetes_demo
+$ ./start.sh scale-ro-server 2 
+```
+
+To add a proxy instance: 
+
+```shell
+$ cd kubernetes_demo
+$ ./start.sh scale-proxy 2 
+```
+
+To check cluster logs: 
+
+```shell
+$ kubectl logs -f --tail=1000 -n milvus milvus-ro-servers-0 
+```
+
+## Mishards Unit test
+
+**Unit test**
+
+```shell
+$ cd milvus/shards
+$ make test
+```
+
+**Code coverage test**
+
+```shell
+$ cd milvus/shards
+$ make coverage
+```
+
+**Code format check**
+
+```shell
+$ cd milvus/shards
+$ make style
+```
+
+## Mishards configuration
+
+### Overall configuration
+
+| Name          | Required | Type    | Default | Description                                                  |
+| ------------- | -------- | ------- | ------- | ------------------------------------------------------------ |
+| `Debug`       | No       | boolean | `True`  | Choose if to enable `Debug` work mode.                       |
+| `TIMEZONE`    | No       | string  | `UTC`   | Timezone                                                     |
+| `MAX_RETRY`   | No       | integer | `3`     | The maximum retry times allowed to connect to Milvus.        |
+| `SERVER_PORT` | No       | integer | `19530` | Define the server port of Mishards.                          |
+| `WOSERVER`    | **Yes**  | string  | ` `     | Define the address of Milvus write instance. Currently, only static settings are supported. Format for reference: `tcp://127.0.0.1:19530`. |
+
+### Metadata
+
+| Name                           | Required | Type    | Default | Description                                                  |
+| ------------------------------ | -------- | ------- | ------- | ------------------------------------------------------------ |
+| `SQLALCHEMY_DATABASE_URI`      | **Yes**  | string  | ` `     | Define the database address for metadata storage. Format standard: RFC-738-style. For example: `mysql+pymysql://root:root@127.0.0.1:3306/milvus?charset=utf8mb4`. |
+| `SQL_ECHO`                     | No       | boolean | `False` | Choose if to print SQL statements.                           |
+| `SQLALCHEMY_DATABASE_TEST_URI` | No       | string  | ` `     | Define the database address of metadata storage in test environment. |
+| `SQL_TEST_ECHO`                | No       | boolean | `False` | Choose if to print SQL statements in test environment.       |
+
+### Service discovery
+
+| Name                                  | Required | Type    | Default       | Description                                                  |
+| ------------------------------------- | -------- | ------- | ------------- | ------------------------------------------------------------ |
+| `DISCOVERY_PLUGIN_PATH`               | No       | string  | ` `           | Define the search path to locate the plug-in. The default path is used if the value is not set. |
+| `DISCOVERY_CLASS_NAME`                | No       | string  | `static`      | Under the plug-in search path, search the class based on the class name, and instantiate it. Currently, the system provides 2 classes:  `static` and `kubernetes`. |
+| `DISCOVERY_STATIC_HOSTS`              | No       | list    | `[]`          | When `DISCOVERY_CLASS_NAME` is `static` , define a comma-separated service address list, for example`192.168.1.188,192.168.1.190`. |
+| `DISCOVERY_STATIC_PORT`               | No       | integer | `19530`       | When `DISCOVERY_CLASS_NAME` is `static`, define the server port. |
+| `DISCOVERY_KUBERNETES_NAMESPACE`      | No       | string  | ` `           | When `DISCOVERY_CLASS_NAME` is `kubernetes`, define the namespace of Milvus cluster. |
+| `DISCOVERY_KUBERNETES_IN_CLUSTER`     | No       | boolean | `False`       | When `DISCOVERY_CLASS_NAME` is `kubernetes` , choose if to run the server in Kubernetes. |
+| `DISCOVERY_KUBERNETES_POLL_INTERVAL`  | No       | integer | `5` (Seconds) | When `DISCOVERY_CLASS_NAME` is `kubernetes` , define the listening cycle of the server. |
+| `DISCOVERY_KUBERNETES_POD_PATT`       | No       | string  | ` `           | When `DISCOVERY_CLASS_NAME` is `kubernetes` , map the regular expression of Milvus Pod. |
+| `DISCOVERY_KUBERNETES_LABEL_SELECTOR` | No       | string  | ` `           | When `SD_PROVIDER` is `kubernetes`, map the label of Milvus Pod. For example: `tier=ro-servers`. |
+
+### Tracing
+
+| Name                    | Required | Type    | Default    | Description                                                  |
+| ----------------------- | -------- | ------- | ---------- | ------------------------------------------------------------ |
+| `TRACER_PLUGIN_PATH`    | No       | string  | ` `        | Define the search path to locate the  tracing plug-in. The default path is used if the value is not set. |
+| `TRACER_CLASS_NAME`     | No       | string  | ` `        | Under the plug-in search path, search the class based on the class name, and instantiate it. Currently, only `Jaeger` is supported. |
+| `TRACING_SERVICE_NAME`  | No       | string  | `mishards` | When `TRACING_CLASS_NAME` is [`Jaeger`](https://www.jaegertracing.io/docs/1.14/), the name of the tracing service. |
+| `TRACING_SAMPLER_TYPE`  | No       | string  | `const`    | When `TRACING_CLASS_NAME` is [`Jaeger`](https://www.jaegertracing.io/docs/1.14/), the [sampling type](https://www.jaegertracing.io/docs/1.14/sampling/) of the tracing service. |
+| `TRACING_SAMPLER_PARAM` | No       | integer | `1`        | When `TRACING_CLASS_NAME` is [`Jaeger`](https://www.jaegertracing.io/docs/1.14/), the [sampling frequency](https://www.jaegertracing.io/docs/1.14/sampling/) of the tracing service. |
+| `TRACING_LOG_PAYLOAD`   | No       | boolean | `False`    | When `TRACING_CLASS_NAME` is [`Jaeger`](https://www.jaegertracing.io/docs/1.14/), choose if to sample Payload. |
+
+### Logging
+
+| Name        | Required | Type   | Default         | Description                                                  |
+| ----------- | -------- | ------ | --------------- | ------------------------------------------------------------ |
+| `LOG_LEVEL` | No       | string | `DEBUG`         | Log recording levels. Currently supports `DEBUG` ,`INFO` ,`WARNING` and `ERROR`. |
+| `LOG_PATH`  | No       | string | `/tmp/mishards` | Log recording path.                                          |
+| `LOG_NAME`  | No       | string | `logfile`       | Log recording name.                                          |
+
+### Routing
+
+| Name                     | Required | Type   | Default                   | Description                                                  |
+| ------------------------ | -------- | ------ | ------------------------- | ------------------------------------------------------------ |
+| `ROUTER_PLUGIN_PATH`     | No       | string | ` `                       | Define the search path to locate the routing plug-in. The default path is used if the value is not set. |
+| `ROUTER_CLASS_NAME`      | No       | string | `FileBasedHashRingRouter` | Under the plug-in search path, search the class based on the class name, and instantiate it. Currently, only `FileBasedHashRingRouter` is supported. |
+| `ROUTER_CLASS_TEST_NAME` | No       | string | `FileBasedHashRingRouter` | Under the plug-in search path, search the class based on the class name, and instantiate it. Currently, `FileBasedHashRingRouter` is supported for test environment only. |
+

shards/README_CN.md

@@ -0,0 +1,261 @@
+# Mishards - Milvus 集群分片中间件
+
+Milvus 旨在帮助用户实现海量非结构化数据的近似检索和分析。单个 Milvus 实例可处理十亿级数据规模，而对于百亿或者千亿级数据，则需要一个 Milvus 集群实例。该实例对于上层应用可以像单机实例一样使用，同时满足海量数据低延迟、高并发业务需求。
+
+本文主要展示如何使用 Mishards 分片中间件来搭建 Milvus 集群。
+
+## Mishards 是什么
+
+Mishards 是一个用 Python 开发的 Milvus 集群分片中间件，其内部处理请求转发、读写分离、水平扩展、动态扩容，为用户提供内存和算力可以无限扩容的 Milvus 实例。
+
+Mishards 的设计尚未完成，属于试用功能，希望大家多多测试、提供反馈。
+
+## Mishards 如何工作
+
+Mishards 负责将上游请求拆分，并路由到内部各细分子服务，最后将子服务结果汇总，返回给上游。
+
+![mishards](https://raw.githubusercontent.com/milvus-io/docs/master/assets/mishards.png)
+
+## Mishards 相关示例
+
+以下分别向您展示如何使用源代码在单机上启动 Mishards 和 Milvus 服务，以及如何使用 Kubernetes 启动 Milvus 集群和 Mishards。
+
+Milvus 启动的前提条件请参考 [Milvus 安装](https://www.milvus.io/docs/zh-CN/userguide/install_milvus/)。
+
+### 源代码启动示例
+
+#### 前提条件
+
+Python 版本为3.6及以上。
+
+#### 源代码启动 Milvus 和 Mishards 实例
+
+请按照以下步骤在单机上启动单个 Milvus 实例和 Mishards 服务：
+
+1. 将 milvus repository 复制到本地。
+
+   ```shell
+   git clone <ssh url>
+   ```
+
+2. 安装 Mishards 的依赖库。
+
+   ```shell
+   $ cd milvus/shards
+   $ pip install -r requirements.txt
+   ```
+
+3. 启动 Milvus 服务。
+
+   ```shell
+   $ sudo nvidia-docker run --rm -d -p 19530:19530 -v /tmp/milvus/db:/opt/milvus/db milvusdb/milvus:0.5.0-d102119-ede20b
+   ```
+
+4. 更改目录权限。
+
+   ```shell
+   $ sudo chown -R $USER:$USER /tmp/milvus
+   ```
+
+5. 配置 Mishards 环境变量
+
+   ```shell
+   $ cp mishards/.env.example mishards/.env
+   ```
+
+6. 启动 Mishards 服务
+
+   ```shell
+   $ python mishards/main.py
+   ```
+
+### Docker 示例
+
+`all_in_one` 使用 Docker 容器启动2个 Milvus 实例，1个 Mishards 中间件实例，和1个 Jaeger 链路追踪实例。
+
+ 1. 安装 [Docker Compose](https://docs.docker.com/compose/install/)。
+
+ 2. 制作实例镜像。
+
+    ```shell
+    $ make build
+    ```
+
+ 3. 启动所有服务。
+
+    ```shell
+    $ make deploy
+    ```
+
+ 4. 检查确认服务状态。
+
+    ```shell
+    $ make probe_deploy
+         Pass ==> Pass: Connected
+         Fail ==> Error: Fail connecting to server on 127.0.0.1:19530. Timeout
+    ```
+
+若要查看服务踪迹，使用浏览器打开 [Jaeger 页面](http://127.0.0.1:16686/)。
+
+![jaegerui](https://github.com/milvus-io/docs/blob/master/assets/jaegerui.png)
+
+![jaegertraces](https://github.com/milvus-io/docs/blob/master/assets/jaegertraces.png)
+
+若要清理所有服务，请使用如下命令：
+
+```shell
+$ make clean_deploy
+```
+
+### Kubernetes 示例
+
+使用 Kubernetes 部署 Milvus 分布式集群要求开发人员对 Kubernetes 的[基本概念](https://kubernetes.io/docs/concepts/)和操作有基本了解。
+
+本示例主要展示如何使用 Kubernetes 搭建 Milvus 集群，包含2个 Milvus 实例（1个可读实例，1个可写实例）、1个 MySQL 实例和1个 Mishards 实例。
+
+本示例不包括如何搭建 Kubernetes 集群，如何安装[共享存储](https://kubernetes.io/docs/concepts/storage/volumes/)和如何安装 [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/) 命令行工具等。
+
+以下是 Kubernetes 示例架构图：
+
+![k8s_arch](https://github.com/milvus-io/docs/blob/master/assets/k8s_arch.png)
+
+#### 前提条件
+
+使用 Kubernetes 启动多个 Milvus 实例之前，请确保您已满足以下条件：
+
+- 已创建 Kubernetes 集群
+- 已安装 [nvidia-docker 2.0](https://github.com/nvidia/nvidia-docker/wiki/Installation-(version-2.0))
+- 已安装共享存储
+- 已安装 kubectl，且能访问集群
+
+#### Kubernetes 启动集群
+
+1. 启动 Milvus 集群。
+
+   ```shell
+   $ make cluster
+   ```
+
+2. 确认 Mishards 是否可用。
+
+   ```shell
+   $ make probe_cluster
+     Pass ==> Pass: Connected
+   ```
+
+查看集群状态：
+
+```shell
+$ make cluster_status
+```
+
+删除 Milvus 集群：
+
+```shell
+$ make clean_cluster
+```
+
+扩容 Milvus 可读实例到2个：
+
+```shell
+$ cd kubernetes_demo
+$ ./start.sh scale-ro-server 2 
+```
+
+扩容 Mishards（代理）实例到2个：
+
+```shell
+$ cd kubernetes_demo
+$ ./start.sh scale-proxy 2 
+```
+
+查看计算节点 `milvus-ro-servers-0` 日志：
+
+```shell
+$ kubectl logs -f --tail=1000 -n milvus milvus-ro-servers-0 
+```
+
+## 单元测试
+
+**单元测试**
+
+```shell
+$ cd milvus/shards
+$ make test
+```
+
+**代码覆盖率测试**
+
+```shell
+$ cd milvus/shards
+$ make coverage
+```
+
+**代码格式检查**
+
+```shell
+$ cd milvus/shards
+$ make style
+```
+
+## Mishards 配置
+
+### 全局配置
+
+| 参数          | 是否必填 | 类型    | 默认值  | 说明                                                         |
+| ------------- | -------- | ------- | ------- | ------------------------------------------------------------ |
+| `Debug`       | No       | boolean | `True`  | 选择是否启用 `Debug` 工作模式。                              |
+| `TIMEZONE`    | No       | string  | `UTC`   | 时区                                                         |
+| `MAX_RETRY`   | No       | integer | `3`     | Mishards 连接 Milvus 的最大重试次数。                        |
+| `SERVER_PORT` | No       | integer | `19530` | 定义 Mishards 的服务端口。                                   |
+| `WOSERVER`    | **Yes**  | string  | ` `     | 定义 Milvus 可写实例的地址，目前只支持静态设置。参考格式： `tcp://127.0.0.1:19530`。 |
+
+### 元数据
+
+| 参数                           | 是否必填 | 类型    | 默认值  | 说明                                                         |
+| ------------------------------ | -------- | ------- | ------- | ------------------------------------------------------------ |
+| `SQLALCHEMY_DATABASE_URI`      | **Yes**  | string  | ` `     | 定义元数据存储的数据库地址，格式标准为 RFC-738-style。例如：`mysql+pymysql://root:root@127.0.0.1:3306/milvus?charset=utf8mb4`。 |
+| `SQL_ECHO`                     | No       | boolean | `False` | 选择是否打印 SQL 详细语句。                                  |
+| `SQLALCHEMY_DATABASE_TEST_URI` | No       | string  | ` `     | 定义测试环境下元数据存储的数据库地址。                       |
+| `SQL_TEST_ECHO`                | No       | boolean | `False` | 选择测试环境下是否打印 SQL 详细语句。                        |
+
+### 服务发现
+
+| 参数                                  | 是否必填 | 类型    | 默认值   | 说明                                                         |
+| ------------------------------------- | -------- | ------- | -------- | ------------------------------------------------------------ |
+| `DISCOVERY_PLUGIN_PATH`               | No       | string  | ` `      | 用户自定义服务发现插件的搜索路径，默认使用系统搜索路径。     |
+| `DISCOVERY_CLASS_NAME`                | No       | string  | `static` | 在插件搜索路径下，根据类名搜索类，并将其实例化。目前系统提供 `static` 和 `kubernetes` 两种类，默认使用 `static`。 |
+| `DISCOVERY_STATIC_HOSTS`              | No       | list    | `[]`     | `DISCOVERY_CLASS_NAME`为 `static` 时，定义服务地址列表，地址之间以逗号隔开，例如 `192.168.1.188,192.168.1.190`。 |
+| `DISCOVERY_STATIC_PORT`               | No       | integer | `19530`  | `DISCOVERY_CLASS_NAME` 为 `static` 时，定义服务地址监听端口。 |
+| `DISCOVERY_KUBERNETES_NAMESPACE`      | No       | string  | ` `      | `DISCOVERY_CLASS_NAME` 为 `kubernetes`时，定义 Milvus 集群的namespace。 |
+| `DISCOVERY_KUBERNETES_IN_CLUSTER`     | No       | boolean | `False`  | `DISCOVERY_CLASS_NAME` 为 `kubernetes` 时，选择服务发现是否在集群中运行。 |
+| `DISCOVERY_KUBERNETES_POLL_INTERVAL`  | No       | integer | `5`      | `DISCOVERY_CLASS_NAME` 为 `kubernetes` 时，定义服务发现监听周期，单位：second。 |
+| `DISCOVERY_KUBERNETES_POD_PATT`       | No       | string  | ` `      | `DISCOVERY_CLASS_NAME` 为 `kubernetes` 时，匹配 Milvus Pod 名字的正则表达式。 |
+| `DISCOVERY_KUBERNETES_LABEL_SELECTOR` | No       | string  | ` `      | `SD_PROVIDER`为`kubernetes`时，匹配 Milvus Pod 的标签。例如：`tier=ro-servers`。 |
+
+### 链路追踪
+
+| 参数                    | 是否必填 | 类型    | 默认值     | 说明                                                         |
+| ----------------------- | -------- | ------- | ---------- | ------------------------------------------------------------ |
+| `TRACER_PLUGIN_PATH`    | No       | string  | ` `        | 用户自定义链路追踪插件的搜索路径，默认使用系统搜索路径。     |
+| `TRACER_CLASS_NAME`     | No       | string  | ` `        | 在插件搜索路径下，根据类名搜索类，并将其实例化。目前只支持 `Jaeger`, 默认不使用。 |
+| `TRACING_SERVICE_NAME`  | No       | string  | `mishards` | `TRACING_CLASS_NAME` 为 [`Jaeger`](https://www.jaegertracing.io/docs/1.14/)时，链路追踪的 service。 |
+| `TRACING_SAMPLER_TYPE`  | No       | string  | `const`    | `TRACING_CLASS_NAME`为 `Jaeger` 时，链路追踪的[采样类型](https://www.jaegertracing.io/docs/1.14/sampling/)。 |
+| `TRACING_SAMPLER_PARAM` | No       | integer | `1`        | `TRACING_CLASS_NAME` 为 `Jaeger`时，链路追踪的[采样频率](https://www.jaegertracing.io/docs/1.14/sampling/)。 |
+| `TRACING_LOG_PAYLOAD`   | No       | boolean | `False`    | `TRACING_CLASS_NAME`为 `Jaeger`时，链路追踪是否采集 Payload。 |
+
+### 日志
+
+| 参数        | 是否必填 | 类型   | 默认值          | 说明                                                         |
+| ----------- | -------- | ------ | --------------- | ------------------------------------------------------------ |
+| `LOG_LEVEL` | No       | string | `DEBUG`         | 日志记录级别，目前支持 `DEBUG` 、`INFO` 、`WARNING` 和`ERROR`。 |
+| `LOG_PATH`  | No       | string | `/tmp/mishards` | 日志记录路径。                                               |
+| `LOG_NAME`  | No       | string | `logfile`       | 日志记录名。                                                 |
+
+### 路由
+
+| 参数                     | 是否必填 | 类型   | 默认值                    | 说明                                                         |
+| ------------------------ | -------- | ------ | ------------------------- | ------------------------------------------------------------ |
+| `ROUTER_PLUGIN_PATH`     | No       | string | ` `                       | 用户自定义路由插件的搜索路径，默认使用系统搜索路径。         |
+| `ROUTER_CLASS_NAME`      | No       | string | `FileBasedHashRingRouter` | 在插件搜索路径下，根据类名搜索路由的类，并将其实例化。目前系统只提供了 `FileBasedHashRingRouter`。 |
+| `ROUTER_CLASS_TEST_NAME` | No       | string | `FileBasedHashRingRouter` | 在插件搜索路径下，根据类名搜索路由的类，并将其实例化。目前系统只提供了 `FileBasedHashRingRouter`，仅限测试环境下使用。 |

shards/Tutorial_CN.md

@@ -1,147 +0,0 @@
-# Mishards使用文档
----
-Milvus 旨在帮助用户实现海量非结构化数据的近似检索和分析。单个 Milvus 实例可处理十亿级数据规模，而对于百亿或者千亿规模数据的需求，则需要一个 Milvus 集群实例，该实例对于上层应用可以像单机实例一样使用，同时满足海量数据低延迟，高并发业务需求。mishards就是一个集群中间件，其内部处理请求转发，读写分离，水平扩展，动态扩容，为用户提供内存和算力可以无限扩容的 Milvus 实例。
-
-## 运行环境
----
-
-### 单机快速启动实例
-**`python >= 3.4`环境**
-
-```
-1. cd milvus/shards
-2. pip install -r requirements.txt
-3. nvidia-docker run --rm -d -p 19530:19530 -v /tmp/milvus/db:/opt/milvus/db milvusdb/milvus:0.5.0-d102119-ede20b
-4. sudo chown -R $USER:$USER /tmp/milvus
-5. cp mishards/.env.example mishards/.env
-6. 在python mishards/main.py #.env配置mishards监听19532端口
-7. make probe port=19532 #健康检查
-```
-
-### 容器启动实例
-`all_in_one`会在服务器上开启两个milvus实例，一个mishards实例，一个jaeger链路追踪实例
-
-**启动**
-```
-cd milvus/shards
-1. 安装docker-compose
-2. make build
-3. make deploy #监听19531端口
-4. make clean_deploy #清理服务
-5. make probe_deplopy #健康检查
-```
-
-**打开Jaeger UI**
-```
-浏览器打开 "http://127.0.0.1:16686/"
-```
-
-### kubernetes中快速启动
-**准备**
-```
-- kubernetes集群
-- 安装nvidia-docker
-- 共享存储
-- 安装kubectl并能访问集群
-```
-
-**步骤**
-```
-cd milvus/shards
-1. make deploy_cluster #启动集群
-2. make probe_cluster #健康检查
-3. make clean_cluster #关闭集群
-```
-
-**扩容计算实例**
-```
-cd milvus/shards/kubernetes_demo/
-./start.sh scale-ro-server 2 扩容计算实例到2
-```
-
-**扩容代理器实例**
-```
-cd milvus/shards/kubernetes_demo/
-./start.sh scale-proxy 2 扩容代理服务器实例到2
-```
-
-**查看日志**
-```
-kubectl logs -f --tail=1000 -n milvus milvus-ro-servers-0 查看计算节点milvus-ro-servers-0日志
-```
-
-## 测试
-
-**启动单元测试**
-```
-1. cd milvus/shards
-2. make test
-```
-
-**单元测试覆盖率**
-```
-1. cd milvus/shards
-2. make coverage
-```
-
-**代码风格检查**
-```
-1. cd milvus/shards
-2. make style
-```
-
-## mishards配置详解
-
-### 全局
-| Name | Required  | Type | Default Value | Explanation |
-| --------------------------- | -------- | -------- | ------------- | ------------- |
-| Debug | No | bool | True | 是否Debug工作模式 |
-| TIMEZONE | No | string | "UTC" | 时区 |
-| MAX_RETRY | No | int | 3 | 最大连接重试次数 |
-| SERVER_PORT | No | int | 19530 | 配置服务端口 |
-| WOSERVER | **Yes** | str | - | 配置后台可写Milvus实例地址。目前只支持静态设置,例"tcp://127.0.0.1:19530" |
-
-### 元数据
-| Name | Required  | Type | Default Value | Explanation |
-| --------------------------- | -------- | -------- | ------------- | ------------- |
-| SQLALCHEMY_DATABASE_URI | **Yes** | string | - | 配置元数据存储数据库地址 |
-| SQL_ECHO | No | bool | False | 是否打印Sql详细语句 |
-| SQLALCHEMY_DATABASE_TEST_URI | No | string | - | 配置测试环境下元数据存储数据库地址 |
-| SQL_TEST_ECHO | No | bool | False | 配置测试环境下是否打印Sql详细语句 |
-
-### 服务发现
-| Name | Required  | Type | Default Value | Explanation |
-| --------------------------- | -------- | -------- | ------------- | ------------- |
-| DISCOVERY_PLUGIN_PATH | No | string | - | 用户自定义服务发现插件搜索路径，默认使用系统搜索路径|
-| DISCOVERY_CLASS_NAME | No | string | static | 在服务发现插件搜索路径下搜索类并实例化。目前系统提供 **static** 和 **kubernetes** 两种类，默认使用 **static** |
-| DISCOVERY_STATIC_HOSTS | No | list | [] | **DISCOVERY_CLASS_NAME** 为 **static** 时，配置服务地址列表，例"192.168.1.188,192.168.1.190"|
-| DISCOVERY_STATIC_PORT | No | int | 19530 | **DISCOVERY_CLASS_NAME** 为 **static** 时，配置 Hosts 监听端口 |
-| DISCOVERY_KUBERNETES_NAMESPACE | No | string | - | **DISCOVERY_CLASS_NAME** 为 **kubernetes** 时，配置集群 namespace |
-| DISCOVERY_KUBERNETES_IN_CLUSTER | No | bool | False | **DISCOVERY_CLASS_NAME** 为 **kubernetes** 时，标明服务发现是否在集群中运行 |
-| DISCOVERY_KUBERNETES_POLL_INTERVAL | No | int | 5 | **DISCOVERY_CLASS_NAME** 为 **kubernetes** 时，标明服务发现监听服务列表频率,单位 Second |
-| DISCOVERY_KUBERNETES_POD_PATT | No | string | - | **DISCOVERY_CLASS_NAME** 为 **kubernetes** 时，匹配可读 Milvus 实例的正则表达式 |
-| DISCOVERY_KUBERNETES_LABEL_SELECTOR | No | string | - | **SD_PROVIDER** 为**Kubernetes**时，匹配可读Milvus实例的标签选择 |
-
-### 链路追踪
-| Name | Required  | Type | Default Value | Explanation |
-| --------------------------- | -------- | -------- | ------------- | ------------- |
-| TRACER_PLUGIN_PATH | No | string | - | 用户自定义链路追踪插件搜索路径，默认使用系统搜索路径|
-| TRACER_CLASS_NAME | No | string | "" | 链路追踪方案选择，目前只实现 **Jaeger**, 默认不使用|
-| TRACING_SERVICE_NAME | No | string | "mishards" | **TRACING_TYPE** 为 **Jaeger** 时，链路追踪服务名 |
-| TRACING_SAMPLER_TYPE | No | string | "const" | **TRACING_TYPE** 为 **Jaeger** 时，链路追踪采样类型 |
-| TRACING_SAMPLER_PARAM | No | int | 1 | **TRACING_TYPE** 为 **Jaeger** 时，链路追踪采样频率 |
-| TRACING_LOG_PAYLOAD | No | bool | False | **TRACING_TYPE** 为 **Jaeger** 时，链路追踪是否采集 Payload |
-
-### 日志
-| Name | Required  | Type | Default Value | Explanation |
-| --------------------------- | -------- | -------- | ------------- | ------------- |
-| LOG_LEVEL | No | string | "DEBUG" if Debug is ON else "INFO" | 日志记录级别 |
-| LOG_PATH | No | string | "/tmp/mishards" | 日志记录路径 |
-| LOG_NAME | No | string | "logfile" | 日志记录名 |
-
-### 路由
-| Name | Required  | Type | Default Value | Explanation |
-| --------------------------- | -------- | -------- | ------------- | ------------- |
-| ROUTER_PLUGIN_PATH | No | string | - | 用户自定义路由插件搜索路径，默认使用系统搜索路径|
-| ROUTER_CLASS_NAME | No | string | FileBasedHashRingRouter | 处理请求路由类名, 可注册自定义类。目前系统只提供了类 **FileBasedHashRingRouter** |
-| ROUTER_CLASS_TEST_NAME | No | string | FileBasedHashRingRouter | 测试环境下处理请求路由类名, 可注册自定义类 |