add new query interface for specified files

Former-commit-id: 5679e6c73f5475b04ce6db79de197cfd5d3e5499

cpp/CHANGELOG.md

@@ -34,6 +34,7 @@ Please mark all change in change log and use the ticket from JIRA.
 - MS-81 - fix faiss ptx issue; change cuda gencode
 - MS-84 - cmake: add arrow, jemalloc and jsoncons third party; default build option OFF
 - MS-85 - add NetIO metric
+- MS-96 - add new query interface for specified files
 
 ## Task
 - MS-74 - Change README.md in cpp

cpp/src/db/DB.h

@@ -38,6 +38,10 @@ public:
     virtual Status Query(const std::string& table_id, uint64_t k, uint64_t nq,
             const float* vectors, const meta::DatesT& dates, QueryResults& results) = 0;
 
+    virtual Status Query(const std::string& table_id, const std::vector<std::string>& file_ids,
+            uint64_t k, uint64_t nq, const float* vectors,
+            const meta::DatesT& dates, QueryResults& results) = 0;
+
     virtual Status Size(uint64_t& result) = 0;
 
     virtual Status DropAll() = 0;

cpp/src/db/DBImpl.cpp

@@ -216,10 +216,41 @@ Status DBImpl::Query(const std::string& table_id, uint64_t k, uint64_t nq,
 #if 0
     return QuerySync(table_id, k, nq, vectors, dates, results);
 #else
-    return QueryAsync(table_id, k, nq, vectors, dates, results);
+
+    //get all table files from table
+    meta::DatePartionedTableFilesSchema files;
+    auto status = pMeta_->FilesToSearch(table_id, dates, files);
+    if (!status.ok()) { return status; }
+
+    meta::TableFilesSchema file_id_array;
+    for (auto &day_files : files) {
+        for (auto &file : day_files.second) {
+            file_id_array.push_back(file);
+        }
+    }
+
+    return QueryAsync(table_id, file_id_array, k, nq, vectors, dates, results);
 #endif
 }
 
+Status DBImpl::Query(const std::string& table_id, const std::vector<std::string>& file_ids,
+        uint64_t k, uint64_t nq, const float* vectors,
+        const meta::DatesT& dates, QueryResults& results) {
+    //get specified files
+    meta::TableFilesSchema files_array;
+    for (auto &id : file_ids) {
+        meta::TableFileSchema table_file;
+        table_file.table_id_ = id;
+        auto status = pMeta_->GetTableFile(table_file);
+        if (!status.ok()) {
+            return status;
+        }
+        files_array.emplace_back(table_file);
+    }
+
+    return QueryAsync(table_id, files_array, k, nq, vectors, dates, results);
+}
+
 Status DBImpl::QuerySync(const std::string& table_id, uint64_t k, uint64_t nq,
                  const float* vectors, const meta::DatesT& dates, QueryResults& results) {
     meta::DatePartionedTableFilesSchema files;
@@ -359,23 +390,16 @@ Status DBImpl::QuerySync(const std::string& table_id, uint64_t k, uint64_t nq,
     return Status::OK();
 }
 
-Status DBImpl::QueryAsync(const std::string& table_id, uint64_t k, uint64_t nq,
-                  const float* vectors, const meta::DatesT& dates, QueryResults& results) {
+Status DBImpl::QueryAsync(const std::string& table_id, const meta::TableFilesSchema& files,
+                          uint64_t k, uint64_t nq, const float* vectors,
+                          const meta::DatesT& dates, QueryResults& results) {
 
     //step 1: get files to search
-    meta::DatePartionedTableFilesSchema files;
-    auto status = pMeta_->FilesToSearch(table_id, dates, files);
-    if (!status.ok()) { return status; }
-
     ENGINE_LOG_DEBUG << "Search DateT Size=" << files.size();
-
     SearchContextPtr context = std::make_shared<SearchContext>(k, nq, vectors);
-
-    for (auto &day_files : files) {
-        for (auto &file : day_files.second) {
-            TableFileSchemaPtr file_ptr = std::make_shared<meta::TableFileSchema>(file);
-            context->AddIndexFile(file_ptr);
-        }
+    for (auto &file : files) {
+        TableFileSchemaPtr file_ptr = std::make_shared<meta::TableFileSchema>(file);
+        context->AddIndexFile(file_ptr);
     }
 
     //step 2: put search task to scheduler

cpp/src/db/DBImpl.h

@@ -48,6 +48,10 @@ public:
     virtual Status Query(const std::string& table_id, uint64_t k, uint64_t nq,
             const float* vectors, const meta::DatesT& dates, QueryResults& results) override;
 
+    virtual Status Query(const std::string& table_id, const std::vector<std::string>& file_ids,
+                         uint64_t k, uint64_t nq, const float* vectors,
+                         const meta::DatesT& dates, QueryResults& results) override;
+
     virtual Status DropAll() override;
 
     virtual Status Size(uint64_t& result) override;
@@ -58,8 +62,9 @@ private:
     Status QuerySync(const std::string& table_id, uint64_t k, uint64_t nq,
             const float* vectors, const meta::DatesT& dates, QueryResults& results);
 
-    Status QueryAsync(const std::string& table_id, uint64_t k, uint64_t nq,
-            const float* vectors, const meta::DatesT& dates, QueryResults& results);
+    Status QueryAsync(const std::string& table_id, const meta::TableFilesSchema& files,
+            uint64_t k, uint64_t nq, const float* vectors,
+            const meta::DatesT& dates, QueryResults& results);
 
 
     void BackgroundBuildIndex();

cpp/src/server/RequestHandler.cpp

@@ -32,19 +32,32 @@ RequestHandler::DeleteTable(const std::string &table_name) {
 
 void
 RequestHandler::AddVector(std::vector<int64_t> &_return,
-        const std::string &table_name,
-        const std::vector<thrift::RowRecord> &record_array) {
+                          const std::string &table_name,
+                          const std::vector<thrift::RowRecord> &record_array) {
     BaseTaskPtr task_ptr = AddVectorTask::Create(table_name, record_array, _return);
     RequestScheduler::ExecTask(task_ptr);
 }
 
 void
-RequestHandler::SearchVector(std::vector<thrift::TopKQueryResult> & _return,
-                                       const std::string& table_name,
-                                       const std::vector<thrift::RowRecord> & query_record_array,
-                                       const std::vector<thrift::Range> & query_range_array,
-                                       const int64_t topk) {
-    BaseTaskPtr task_ptr = SearchVectorTask::Create(table_name, query_record_array, query_range_array, topk, _return);
+RequestHandler::SearchVector(std::vector<thrift::TopKQueryResult> &_return,
+                             const std::string &table_name,
+                             const std::vector<thrift::RowRecord> &query_record_array,
+                             const std::vector<thrift::Range> &query_range_array,
+                             const int64_t topk) {
+    BaseTaskPtr task_ptr = SearchVectorTask::Create(table_name, std::vector<std::string>(), query_record_array,
+            query_range_array, topk, _return);
+    RequestScheduler::ExecTask(task_ptr);
+}
+
+void
+RequestHandler::SearchVectorInFiles(std::vector<::milvus::thrift::TopKQueryResult> &_return,
+                                    const std::string& table_name,
+                                    const std::vector<std::string> &file_id_array,
+                                    const std::vector<::milvus::thrift::RowRecord> &query_record_array,
+                                    const std::vector<::milvus::thrift::Range> &query_range_array,
+                                    const int64_t topk) {
+    BaseTaskPtr task_ptr = SearchVectorTask::Create(table_name, file_id_array, query_record_array,
+            query_range_array, topk, _return);
     RequestScheduler::ExecTask(task_ptr);
 }
 

cpp/src/server/RequestHandler.h

@@ -82,6 +82,30 @@ public:
             const std::vector<::milvus::thrift::Range> & query_range_array,
             const int64_t topk);
 
+    /**
+   * @brief Internal use query interface
+   *
+   * This method is used to query vector in specified files.
+   *
+   * @param file_id_array, specified files id array, queried.
+   * @param query_record_array, all vector are going to be queried.
+   * @param query_range_array, optional ranges for conditional search. If not specified, search whole table
+   * @param topk, how many similarity vectors will be searched.
+   *
+   * @return query result array.
+   *
+   * @param file_id_array
+   * @param query_record_array
+   * @param query_range_array
+   * @param topk
+   */
+    virtual void SearchVectorInFiles(std::vector<::milvus::thrift::TopKQueryResult> & _return,
+            const std::string& table_name,
+            const std::vector<std::string> & file_id_array,
+            const std::vector<::milvus::thrift::RowRecord> & query_record_array,
+            const std::vector<::milvus::thrift::Range> & query_range_array,
+            const int64_t topk);
+
     /**
      * @brief Get table schema
      *

cpp/src/server/RequestTask.cpp

@@ -447,26 +447,29 @@ ServerError AddVectorTask::OnExecute() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-SearchVectorTask::SearchVectorTask(const std::string& table_name,
-                                   const std::vector<thrift::RowRecord> & query_record_array,
-                                   const std::vector<thrift::Range> & query_range_array,
+SearchVectorTask::SearchVectorTask(const std::string &table_name,
+                                   const std::vector<std::string>& file_id_array,
+                                   const std::vector<thrift::RowRecord> &query_record_array,
+                                   const std::vector<thrift::Range> &query_range_array,
                                    const int64_t top_k,
-                                   std::vector<thrift::TopKQueryResult>& result_array)
-    : BaseTask(DQL_TASK_GROUP),
-      table_name_(table_name),
-      record_array_(query_record_array),
-      range_array_(query_range_array),
-      top_k_(top_k),
-      result_array_(result_array) {
+                                   std::vector<thrift::TopKQueryResult> &result_array)
+        : BaseTask(DQL_TASK_GROUP),
+          table_name_(table_name),
+          file_id_array_(file_id_array),
+          record_array_(query_record_array),
+          range_array_(query_range_array),
+          top_k_(top_k),
+          result_array_(result_array) {
 
 }
 
 BaseTaskPtr SearchVectorTask::Create(const std::string& table_name,
+                                     const std::vector<std::string>& file_id_array,
                                      const std::vector<thrift::RowRecord> & query_record_array,
                                      const std::vector<thrift::Range> & query_range_array,
                                      const int64_t top_k,
                                      std::vector<thrift::TopKQueryResult>& result_array) {
-    return std::shared_ptr<BaseTask>(new SearchVectorTask(table_name,
+    return std::shared_ptr<BaseTask>(new SearchVectorTask(table_name, file_id_array,
             query_record_array, query_range_array, top_k, result_array));
 }
 
@@ -523,7 +526,13 @@ ServerError SearchVectorTask::OnExecute() {
         //step 4: search vectors
         engine::QueryResults results;
         uint64_t record_count = (uint64_t)record_array_.size();
-        stat = DB()->Query(table_name_, (size_t)top_k_, record_count, vec_f.data(), dates, results);
+
+        if(file_id_array_.empty()) {
+            stat = DB()->Query(table_name_, (size_t) top_k_, record_count, vec_f.data(), dates, results);
+        } else {
+            stat = DB()->Query(table_name_, file_id_array_, (size_t) top_k_, record_count, vec_f.data(), dates, results);
+        }
+
         rc.Record("search vectors from engine");
         if(!stat.ok()) {
             SERVER_LOG_ERROR << "Engine failed: " << stat.ToString();
@@ -555,6 +564,7 @@ ServerError SearchVectorTask::OnExecute() {
         }
         rc.Record("construct result");
         rc.Elapse("totally cost");
+
     } catch (std::exception& ex) {
         error_code_ = SERVER_UNEXPECTED_ERROR;
         error_msg_ = ex.what();

cpp/src/server/RequestTask.h

@@ -102,6 +102,7 @@ private:
 class SearchVectorTask : public BaseTask {
 public:
     static BaseTaskPtr Create(const std::string& table_name,
+                              const std::vector<std::string>& file_id_array,
                               const std::vector<::milvus::thrift::RowRecord> & query_record_array,
                               const std::vector<::milvus::thrift::Range> & query_range_array,
                               const int64_t top_k,
@@ -109,6 +110,7 @@ public:
 
 protected:
     SearchVectorTask(const std::string& table_name,
+                     const std::vector<std::string>& file_id_array,
                      const std::vector<::milvus::thrift::RowRecord> & query_record_array,
                      const std::vector<::milvus::thrift::Range> & query_range_array,
                      const int64_t top_k,
@@ -118,6 +120,7 @@ protected:
 
 private:
     std::string table_name_;
+    std::vector<std::string> file_id_array_;
     int64_t top_k_;
     const std::vector<::milvus::thrift::RowRecord>& record_array_;
     const std::vector<::milvus::thrift::Range>& range_array_;

cpp/src/thrift/gen-cpp/MilvusService.h

@@ -80,6 +80,26 @@ class MilvusServiceIf {
    */
   virtual void SearchVector(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk) = 0;
 
+  /**
+   * @brief Internal use query interface
+   * 
+   * This method is used to query vector in specified files.
+   * 
+   * @param file_id_array, specified files id array, queried.
+   * @param query_record_array, all vector are going to be queried.
+   * @param query_range_array, optional ranges for conditional search. If not specified, search whole table
+   * @param topk, how many similarity vectors will be searched.
+   * 
+   * @return query result array.
+   * 
+   * @param table_name
+   * @param file_id_array
+   * @param query_record_array
+   * @param query_range_array
+   * @param topk
+   */
+  virtual void SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk) = 0;
+
   /**
    * @brief Get table schema
    * 
@@ -167,6 +187,9 @@ class MilvusServiceNull : virtual public MilvusServiceIf {
   void SearchVector(std::vector<TopKQueryResult> & /* _return */, const std::string& /* table_name */, const std::vector<RowRecord> & /* query_record_array */, const std::vector<Range> & /* query_range_array */, const int64_t /* topk */) {
     return;
   }
+  void SearchVectorInFiles(std::vector<TopKQueryResult> & /* _return */, const std::string& /* table_name */, const std::vector<std::string> & /* file_id_array */, const std::vector<RowRecord> & /* query_record_array */, const std::vector<Range> & /* query_range_array */, const int64_t /* topk */) {
+    return;
+  }
   void DescribeTable(TableSchema& /* _return */, const std::string& /* table_name */) {
     return;
   }
@@ -642,6 +665,146 @@ class MilvusService_SearchVector_presult {
 
 };
 
+typedef struct _MilvusService_SearchVectorInFiles_args__isset {
+  _MilvusService_SearchVectorInFiles_args__isset() : table_name(false), file_id_array(false), query_record_array(false), query_range_array(false), topk(false) {}
+  bool table_name :1;
+  bool file_id_array :1;
+  bool query_record_array :1;
+  bool query_range_array :1;
+  bool topk :1;
+} _MilvusService_SearchVectorInFiles_args__isset;
+
+class MilvusService_SearchVectorInFiles_args {
+ public:
+
+  MilvusService_SearchVectorInFiles_args(const MilvusService_SearchVectorInFiles_args&);
+  MilvusService_SearchVectorInFiles_args& operator=(const MilvusService_SearchVectorInFiles_args&);
+  MilvusService_SearchVectorInFiles_args() : table_name(), topk(0) {
+  }
+
+  virtual ~MilvusService_SearchVectorInFiles_args() throw();
+  std::string table_name;
+  std::vector<std::string>  file_id_array;
+  std::vector<RowRecord>  query_record_array;
+  std::vector<Range>  query_range_array;
+  int64_t topk;
+
+  _MilvusService_SearchVectorInFiles_args__isset __isset;
+
+  void __set_table_name(const std::string& val);
+
+  void __set_file_id_array(const std::vector<std::string> & val);
+
+  void __set_query_record_array(const std::vector<RowRecord> & val);
+
+  void __set_query_range_array(const std::vector<Range> & val);
+
+  void __set_topk(const int64_t val);
+
+  bool operator == (const MilvusService_SearchVectorInFiles_args & rhs) const
+  {
+    if (!(table_name == rhs.table_name))
+      return false;
+    if (!(file_id_array == rhs.file_id_array))
+      return false;
+    if (!(query_record_array == rhs.query_record_array))
+      return false;
+    if (!(query_range_array == rhs.query_range_array))
+      return false;
+    if (!(topk == rhs.topk))
+      return false;
+    return true;
+  }
+  bool operator != (const MilvusService_SearchVectorInFiles_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const MilvusService_SearchVectorInFiles_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class MilvusService_SearchVectorInFiles_pargs {
+ public:
+
+
+  virtual ~MilvusService_SearchVectorInFiles_pargs() throw();
+  const std::string* table_name;
+  const std::vector<std::string> * file_id_array;
+  const std::vector<RowRecord> * query_record_array;
+  const std::vector<Range> * query_range_array;
+  const int64_t* topk;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _MilvusService_SearchVectorInFiles_result__isset {
+  _MilvusService_SearchVectorInFiles_result__isset() : success(false), e(false) {}
+  bool success :1;
+  bool e :1;
+} _MilvusService_SearchVectorInFiles_result__isset;
+
+class MilvusService_SearchVectorInFiles_result {
+ public:
+
+  MilvusService_SearchVectorInFiles_result(const MilvusService_SearchVectorInFiles_result&);
+  MilvusService_SearchVectorInFiles_result& operator=(const MilvusService_SearchVectorInFiles_result&);
+  MilvusService_SearchVectorInFiles_result() {
+  }
+
+  virtual ~MilvusService_SearchVectorInFiles_result() throw();
+  std::vector<TopKQueryResult>  success;
+  Exception e;
+
+  _MilvusService_SearchVectorInFiles_result__isset __isset;
+
+  void __set_success(const std::vector<TopKQueryResult> & val);
+
+  void __set_e(const Exception& val);
+
+  bool operator == (const MilvusService_SearchVectorInFiles_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(e == rhs.e))
+      return false;
+    return true;
+  }
+  bool operator != (const MilvusService_SearchVectorInFiles_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const MilvusService_SearchVectorInFiles_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _MilvusService_SearchVectorInFiles_presult__isset {
+  _MilvusService_SearchVectorInFiles_presult__isset() : success(false), e(false) {}
+  bool success :1;
+  bool e :1;
+} _MilvusService_SearchVectorInFiles_presult__isset;
+
+class MilvusService_SearchVectorInFiles_presult {
+ public:
+
+
+  virtual ~MilvusService_SearchVectorInFiles_presult() throw();
+  std::vector<TopKQueryResult> * success;
+  Exception e;
+
+  _MilvusService_SearchVectorInFiles_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
 typedef struct _MilvusService_DescribeTable_args__isset {
   _MilvusService_DescribeTable_args__isset() : table_name(false) {}
   bool table_name :1;
@@ -1115,6 +1278,9 @@ class MilvusServiceClient : virtual public MilvusServiceIf {
   void SearchVector(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
   void send_SearchVector(const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
   void recv_SearchVector(std::vector<TopKQueryResult> & _return);
+  void SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
+  void send_SearchVectorInFiles(const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
+  void recv_SearchVectorInFiles(std::vector<TopKQueryResult> & _return);
   void DescribeTable(TableSchema& _return, const std::string& table_name);
   void send_DescribeTable(const std::string& table_name);
   void recv_DescribeTable(TableSchema& _return);
@@ -1146,6 +1312,7 @@ class MilvusServiceProcessor : public ::apache::thrift::TDispatchProcessor {
   void process_DeleteTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_AddVector(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_SearchVector(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_SearchVectorInFiles(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_DescribeTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_GetTableRowCount(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_ShowTables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
@@ -1157,6 +1324,7 @@ class MilvusServiceProcessor : public ::apache::thrift::TDispatchProcessor {
     processMap_["DeleteTable"] = &MilvusServiceProcessor::process_DeleteTable;
     processMap_["AddVector"] = &MilvusServiceProcessor::process_AddVector;
     processMap_["SearchVector"] = &MilvusServiceProcessor::process_SearchVector;
+    processMap_["SearchVectorInFiles"] = &MilvusServiceProcessor::process_SearchVectorInFiles;
     processMap_["DescribeTable"] = &MilvusServiceProcessor::process_DescribeTable;
     processMap_["GetTableRowCount"] = &MilvusServiceProcessor::process_GetTableRowCount;
     processMap_["ShowTables"] = &MilvusServiceProcessor::process_ShowTables;
@@ -1227,6 +1395,16 @@ class MilvusServiceMultiface : virtual public MilvusServiceIf {
     return;
   }
 
+  void SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->SearchVectorInFiles(_return, table_name, file_id_array, query_record_array, query_range_array, topk);
+    }
+    ifaces_[i]->SearchVectorInFiles(_return, table_name, file_id_array, query_record_array, query_range_array, topk);
+    return;
+  }
+
   void DescribeTable(TableSchema& _return, const std::string& table_name) {
     size_t sz = ifaces_.size();
     size_t i = 0;
@@ -1308,6 +1486,9 @@ class MilvusServiceConcurrentClient : virtual public MilvusServiceIf {
   void SearchVector(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
   int32_t send_SearchVector(const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
   void recv_SearchVector(std::vector<TopKQueryResult> & _return, const int32_t seqid);
+  void SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
+  int32_t send_SearchVectorInFiles(const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
+  void recv_SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const int32_t seqid);
   void DescribeTable(TableSchema& _return, const std::string& table_name);
   int32_t send_DescribeTable(const std::string& table_name);
   void recv_DescribeTable(TableSchema& _return, const int32_t seqid);

cpp/src/thrift/gen-cpp/MilvusService_server.skeleton.cpp

@@ -90,6 +90,29 @@ class MilvusServiceHandler : virtual public MilvusServiceIf {
     printf("SearchVector\n");
   }
 
+  /**
+   * @brief Internal use query interface
+   * 
+   * This method is used to query vector in specified files.
+   * 
+   * @param file_id_array, specified files id array, queried.
+   * @param query_record_array, all vector are going to be queried.
+   * @param query_range_array, optional ranges for conditional search. If not specified, search whole table
+   * @param topk, how many similarity vectors will be searched.
+   * 
+   * @return query result array.
+   * 
+   * @param table_name
+   * @param file_id_array
+   * @param query_record_array
+   * @param query_range_array
+   * @param topk
+   */
+  void SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk) {
+    // Your implementation goes here
+    printf("SearchVectorInFiles\n");
+  }
+
   /**
    * @brief Get table schema
    * 

cpp/src/thrift/milvus.thrift

@@ -123,6 +123,23 @@ service MilvusService {
                                        4: list<Range> query_range_array,
                                        5: i64 topk) throws(1: Exception e);
 
+    /**
+     * @brief Internal use query interface
+     *
+     * This method is used to query vector in specified files.
+     *
+     * @param file_id_array, specified files id array, queried.
+     * @param query_record_array, all vector are going to be queried.
+     * @param query_range_array, optional ranges for conditional search. If not specified, search whole table
+     * @param topk, how many similarity vectors will be searched.
+     *
+     * @return query result array.
+     */
+    list<TopKQueryResult> SearchVectorInFiles(2: string table_name,
+                                              3: list<string> file_id_array,
+                                              4: list<RowRecord> query_record_array,
+                                              5: list<Range> query_range_array,
+                                              6: i64 topk) throws(1: Exception e);
 
     /**
      * @brief Get table schema