From 99470b4dfa85c05606e11c5e3190e647d9e557a4 Mon Sep 17 00:00:00 2001 From: groot Date: Mon, 23 Mar 2020 18:26:18 +0800 Subject: [PATCH] #1702 Optimize request handler to combine similar query (#1727) * #1686 API search_in_files cannot work correctly when vectors is stored in certain non-default partition Signed-off-by: yhmo * #1686 API search_in_files cannot work correctly when vectors is stored in certain non-default partition Signed-off-by: groot * refine request code Signed-off-by: groot * typo Signed-off-by: groot * combine search request Signed-off-by: groot * combine search request Signed-off-by: groot * #1728 Optimize request handler to combine similar query Signed-off-by: groot * typo Signed-off-by: groot * remove some log --- core/src/CMakeLists.txt | 2 + core/src/server/delivery/RequestQueue.cpp | 77 ++++ core/src/server/delivery/RequestQueue.h | 44 +++ core/src/server/delivery/RequestScheduler.cpp | 6 +- core/src/server/delivery/RequestScheduler.h | 5 +- .../server/delivery/request/BaseRequest.cpp | 75 +++- .../src/server/delivery/request/BaseRequest.h | 65 +++- .../server/delivery/request/CmdRequest.cpp | 8 +- core/src/server/delivery/request/CmdRequest.h | 4 +- .../delivery/request/CompactRequest.cpp | 6 +- .../server/delivery/request/CompactRequest.h | 4 +- .../delivery/request/CountTableRequest.cpp | 9 +- .../delivery/request/CountTableRequest.h | 5 +- .../delivery/request/CreateIndexRequest.cpp | 11 +- .../delivery/request/CreateIndexRequest.h | 6 +- .../request/CreatePartitionRequest.cpp | 8 +- .../delivery/request/CreatePartitionRequest.h | 5 +- .../delivery/request/CreateTableRequest.cpp | 11 +- .../delivery/request/CreateTableRequest.h | 6 +- .../delivery/request/DeleteByIDRequest.cpp | 8 +- .../delivery/request/DeleteByIDRequest.h | 4 +- .../delivery/request/DescribeIndexRequest.cpp | 8 +- .../delivery/request/DescribeIndexRequest.h | 5 +- .../delivery/request/DescribeTableRequest.cpp | 8 +- .../delivery/request/DescribeTableRequest.h | 5 +- .../delivery/request/DropIndexRequest.cpp | 7 +- .../delivery/request/DropIndexRequest.h | 4 +- .../delivery/request/DropPartitionRequest.cpp | 8 +- .../delivery/request/DropPartitionRequest.h | 5 +- .../delivery/request/DropTableRequest.cpp | 7 +- .../delivery/request/DropTableRequest.h | 4 +- .../server/delivery/request/FlushRequest.cpp | 8 +- .../server/delivery/request/FlushRequest.h | 4 +- .../delivery/request/GetVectorByIDRequest.cpp | 9 +- .../delivery/request/GetVectorByIDRequest.h | 6 +- .../delivery/request/GetVectorIDsRequest.cpp | 9 +- .../delivery/request/GetVectorIDsRequest.h | 6 +- .../delivery/request/HasTableRequest.cpp | 7 +- .../server/delivery/request/HasTableRequest.h | 5 +- .../server/delivery/request/InsertRequest.cpp | 6 +- .../server/delivery/request/InsertRequest.h | 8 +- .../delivery/request/PreloadTableRequest.cpp | 7 +- .../delivery/request/PreloadTableRequest.h | 4 +- .../delivery/request/SearchByIDRequest.cpp | 37 +- .../delivery/request/SearchByIDRequest.h | 11 +- .../delivery/request/SearchCombineRequest.cpp | 363 ++++++++++++++++++ .../delivery/request/SearchCombineRequest.h | 62 +++ .../server/delivery/request/SearchRequest.cpp | 73 ++-- .../server/delivery/request/SearchRequest.h | 46 ++- .../request/ShowPartitionsRequest.cpp | 8 +- .../delivery/request/ShowPartitionsRequest.h | 4 +- .../delivery/request/ShowTableInfoRequest.cpp | 8 +- .../delivery/request/ShowTableInfoRequest.h | 6 +- .../delivery/request/ShowTablesRequest.cpp | 8 +- .../delivery/request/ShowTablesRequest.h | 5 +- .../delivery/strategy/RequestStrategy.h | 39 ++ .../delivery/strategy/SearchReqStrategy.cpp | 77 ++++ .../delivery/strategy/SearchReqStrategy.h | 33 ++ core/src/utils/BlockingQueue.h | 5 +- core/src/utils/ValidationUtil.cpp | 37 +- core/src/utils/ValidationUtil.h | 8 +- core/unittest/CMakeLists.txt | 4 +- core/unittest/server/test_rpc.cpp | 43 +-- core/unittest/server/test_util.cpp | 7 +- 64 files changed, 1134 insertions(+), 259 deletions(-) create mode 100644 core/src/server/delivery/RequestQueue.cpp create mode 100644 core/src/server/delivery/RequestQueue.h create mode 100644 core/src/server/delivery/request/SearchCombineRequest.cpp create mode 100644 core/src/server/delivery/request/SearchCombineRequest.h create mode 100644 core/src/server/delivery/strategy/RequestStrategy.h create mode 100644 core/src/server/delivery/strategy/SearchReqStrategy.cpp create mode 100644 core/src/server/delivery/strategy/SearchReqStrategy.h diff --git a/core/src/CMakeLists.txt b/core/src/CMakeLists.txt index 479c01ef2c..da650b0673 100644 --- a/core/src/CMakeLists.txt +++ b/core/src/CMakeLists.txt @@ -74,10 +74,12 @@ set(thirdparty_files aux_source_directory(${MILVUS_ENGINE_SRC}/server server_service_files) aux_source_directory(${MILVUS_ENGINE_SRC}/server/delivery/request delivery_request_files) +aux_source_directory(${MILVUS_ENGINE_SRC}/server/delivery/strategy delivery_strategy_files) aux_source_directory(${MILVUS_ENGINE_SRC}/server/delivery delivery_files) set(server_files ${server_service_files} ${delivery_request_files} + ${delivery_strategy_files} ${delivery_files} ) diff --git a/core/src/server/delivery/RequestQueue.cpp b/core/src/server/delivery/RequestQueue.cpp new file mode 100644 index 0000000000..a35f02cf42 --- /dev/null +++ b/core/src/server/delivery/RequestQueue.cpp @@ -0,0 +1,77 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed 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. + +#include "server/delivery/RequestQueue.h" +#include "server/delivery/strategy/RequestStrategy.h" +#include "server/delivery/strategy/SearchReqStrategy.h" +#include "utils/Log.h" + +#include +#include +#include +#include + +namespace milvus { +namespace server { + +namespace { +Status +ScheduleRequest(const BaseRequestPtr& request, std::queue& queue) { +#if 1 + if (request == nullptr) { + return Status(SERVER_NULL_POINTER, "request schedule cannot handle null object"); + } + + if (queue.empty()) { + queue.push(request); + return Status::OK(); + } + + static std::map s_schedulers = { + {BaseRequest::kSearch, std::make_shared()}}; + + auto iter = s_schedulers.find(request->GetRequestType()); + if (iter == s_schedulers.end() || iter->second == nullptr) { + queue.push(request); + } else { + iter->second->ReScheduleQueue(request, queue); + } +#else + queue.push(request); +#endif + + return Status::OK(); +} +} // namespace + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +RequestQueue::RequestQueue() { +} + +RequestQueue::~RequestQueue() { +} + +BaseRequestPtr +RequestQueue::TakeRequest() { + return Take(); +} + +Status +RequestQueue::PutRequest(const BaseRequestPtr& request_ptr) { + std::unique_lock lock(mtx); + full_.wait(lock, [this] { return (queue_.size() < capacity_); }); + auto status = ScheduleRequest(request_ptr, queue_); + empty_.notify_all(); + return status; +} + +} // namespace server +} // namespace milvus diff --git a/core/src/server/delivery/RequestQueue.h b/core/src/server/delivery/RequestQueue.h new file mode 100644 index 0000000000..65292cc47c --- /dev/null +++ b/core/src/server/delivery/RequestQueue.h @@ -0,0 +1,44 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed 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. + +#pragma once + +#include "server/delivery/request/BaseRequest.h" +#include "utils/BlockingQueue.h" +#include "utils/Status.h" + +#include +#include +#include +#include +#include + +namespace milvus { +namespace server { + +using BlockingRequestQueue = BlockingQueue; + +class RequestQueue : public BlockingRequestQueue { + public: + RequestQueue(); + virtual ~RequestQueue(); + + BaseRequestPtr + TakeRequest(); + + Status + PutRequest(const BaseRequestPtr& request_ptr); +}; + +using RequestQueuePtr = std::shared_ptr; + +} // namespace server +} // namespace milvus diff --git a/core/src/server/delivery/RequestScheduler.cpp b/core/src/server/delivery/RequestScheduler.cpp index ffa9086407..90c0e1ca68 100644 --- a/core/src/server/delivery/RequestScheduler.cpp +++ b/core/src/server/delivery/RequestScheduler.cpp @@ -105,7 +105,7 @@ RequestScheduler::TakeToExecute(RequestQueuePtr request_queue) { } while (true) { - BaseRequestPtr request = request_queue->Take(); + BaseRequestPtr request = request_queue->TakeRequest(); if (request == nullptr) { SERVER_LOG_ERROR << "Take null from request queue, stop thread"; break; // stop the thread @@ -131,10 +131,10 @@ RequestScheduler::PutToQueue(const BaseRequestPtr& request_ptr) { std::string group_name = request_ptr->RequestGroup(); if (request_groups_.count(group_name) > 0) { - request_groups_[group_name]->Put(request_ptr); + request_groups_[group_name]->PutRequest(request_ptr); } else { RequestQueuePtr queue = std::make_shared(); - queue->Put(request_ptr); + queue->PutRequest(request_ptr); request_groups_.insert(std::make_pair(group_name, queue)); fiu_do_on("RequestScheduler.PutToQueue.null_queue", queue = nullptr); diff --git a/core/src/server/delivery/RequestScheduler.h b/core/src/server/delivery/RequestScheduler.h index 10172f2b17..c7e2a32369 100644 --- a/core/src/server/delivery/RequestScheduler.h +++ b/core/src/server/delivery/RequestScheduler.h @@ -11,8 +11,7 @@ #pragma once -#include "server/delivery/request/BaseRequest.h" -#include "utils/BlockingQueue.h" +#include "server/delivery/RequestQueue.h" #include "utils/Status.h" #include @@ -24,8 +23,6 @@ namespace milvus { namespace server { -using RequestQueue = BlockingQueue; -using RequestQueuePtr = std::shared_ptr; using ThreadPtr = std::shared_ptr; class RequestScheduler { diff --git a/core/src/server/delivery/request/BaseRequest.cpp b/core/src/server/delivery/request/BaseRequest.cpp index ed5aef28c3..70996c3b42 100644 --- a/core/src/server/delivery/request/BaseRequest.cpp +++ b/core/src/server/delivery/request/BaseRequest.cpp @@ -11,13 +11,72 @@ #include "server/delivery/request/BaseRequest.h" #include "utils/CommonUtil.h" +#include "utils/Exception.h" #include "utils/Log.h" +#include + namespace milvus { namespace server { -BaseRequest::BaseRequest(const std::shared_ptr& context, const std::string& request_group, bool async) - : context_(context), request_group_(request_group), async_(async), done_(false) { +static const char* DQL_REQUEST_GROUP = "dql"; +static const char* DDL_DML_REQUEST_GROUP = "ddl_dml"; +static const char* INFO_REQUEST_GROUP = "info"; + +namespace { +std::string +RequestGroup(BaseRequest::RequestType type) { + static std::map s_map_type_group = { + // general operations + {BaseRequest::kCmd, INFO_REQUEST_GROUP}, + + // data operations + {BaseRequest::kInsert, DDL_DML_REQUEST_GROUP}, + {BaseRequest::kCompact, DDL_DML_REQUEST_GROUP}, + {BaseRequest::kFlush, DDL_DML_REQUEST_GROUP}, + {BaseRequest::kDeleteByID, DDL_DML_REQUEST_GROUP}, + {BaseRequest::kGetVectorByID, INFO_REQUEST_GROUP}, + {BaseRequest::kGetVectorIDs, INFO_REQUEST_GROUP}, + + // table operations + {BaseRequest::kShowTables, INFO_REQUEST_GROUP}, + {BaseRequest::kCreateTable, DDL_DML_REQUEST_GROUP}, + {BaseRequest::kHasTable, INFO_REQUEST_GROUP}, + {BaseRequest::kDescribeTable, INFO_REQUEST_GROUP}, + {BaseRequest::kCountTable, INFO_REQUEST_GROUP}, + {BaseRequest::kShowTableInfo, INFO_REQUEST_GROUP}, + {BaseRequest::kDropTable, DDL_DML_REQUEST_GROUP}, + {BaseRequest::kPreloadTable, DQL_REQUEST_GROUP}, + + // partition operations + {BaseRequest::kCreatePartition, DDL_DML_REQUEST_GROUP}, + {BaseRequest::kShowPartitions, INFO_REQUEST_GROUP}, + {BaseRequest::kDropPartition, DDL_DML_REQUEST_GROUP}, + + // index operations + {BaseRequest::kCreateIndex, DDL_DML_REQUEST_GROUP}, + {BaseRequest::kDescribeIndex, INFO_REQUEST_GROUP}, + {BaseRequest::kDropIndex, DDL_DML_REQUEST_GROUP}, + + // search operations + {BaseRequest::kSearchByID, DQL_REQUEST_GROUP}, + {BaseRequest::kSearch, DQL_REQUEST_GROUP}, + {BaseRequest::kSearchCombine, DQL_REQUEST_GROUP}, + }; + + auto iter = s_map_type_group.find(type); + if (iter == s_map_type_group.end()) { + SERVER_LOG_ERROR << "Unsupported request type: " << type; + throw Exception(SERVER_NOT_IMPLEMENT, "request group undefined"); + } + return iter->second; +} +} // namespace + +BaseRequest::BaseRequest(const std::shared_ptr& context, BaseRequest::RequestType type, + bool async) + : context_(context), type_(type), async_(async), done_(false) { + request_group_ = milvus::server::RequestGroup(type); } BaseRequest::~BaseRequest() { @@ -37,11 +96,12 @@ BaseRequest::Done() { finish_cond_.notify_all(); } -Status -BaseRequest::SetStatus(ErrorCode error_code, const std::string& error_msg) { - status_ = Status(error_code, error_msg); - SERVER_LOG_ERROR << error_msg; - return status_; +void +BaseRequest::set_status(const Status& status) { + status_ = status; + if (!status_.ok()) { + SERVER_LOG_ERROR << status_.message(); + } } std::string @@ -55,7 +115,6 @@ Status BaseRequest::WaitToFinish() { std::unique_lock lock(finish_mtx_); finish_cond_.wait(lock, [this] { return done_; }); - return status_; } diff --git a/core/src/server/delivery/request/BaseRequest.h b/core/src/server/delivery/request/BaseRequest.h index 7ee665695a..3a6c63d66b 100644 --- a/core/src/server/delivery/request/BaseRequest.h +++ b/core/src/server/delivery/request/BaseRequest.h @@ -31,10 +31,6 @@ namespace milvus { namespace server { -static const char* DQL_REQUEST_GROUP = "dql"; -static const char* DDL_DML_REQUEST_GROUP = "ddl_dml"; -static const char* INFO_REQUEST_GROUP = "info"; - struct TableSchema { std::string table_name_; int64_t dimension_; @@ -117,8 +113,47 @@ struct TableInfo { }; class BaseRequest { + public: + enum RequestType { + // general operations + kCmd = 100, + + // data operations + kInsert = 200, + kCompact, + kFlush, + kDeleteByID, + kGetVectorByID, + kGetVectorIDs, + + // table operations + kShowTables = 300, + kCreateTable, + kHasTable, + kDescribeTable, + kCountTable, + kShowTableInfo, + kDropTable, + kPreloadTable, + + // partition operations + kCreatePartition = 400, + kShowPartitions, + kDropPartition, + + // index operations + kCreateIndex = 500, + kDescribeIndex, + kDropIndex, + + // search operations + kSearchByID = 600, + kSearch, + kSearchCombine, + }; + protected: - BaseRequest(const std::shared_ptr& context, const std::string& request_group, bool async = false); + BaseRequest(const std::shared_ptr& context, BaseRequest::RequestType type, bool async = false); virtual ~BaseRequest(); @@ -132,6 +167,11 @@ class BaseRequest { Status WaitToFinish(); + RequestType + GetRequestType() const { + return type_; + } + std::string RequestGroup() const { return request_group_; @@ -142,6 +182,9 @@ class BaseRequest { return status_; } + void + set_status(const Status& status); + bool IsAsync() const { return async_; @@ -151,22 +194,26 @@ class BaseRequest { virtual Status OnExecute() = 0; - Status - SetStatus(ErrorCode error_code, const std::string& error_msg); - std::string TableNotExistMsg(const std::string& table_name); protected: - const std::shared_ptr& context_; + const std::shared_ptr& context_; mutable std::mutex finish_mtx_; std::condition_variable finish_cond_; + RequestType type_; std::string request_group_; bool async_; bool done_; Status status_; + + public: + const std::shared_ptr& + Context() const { + return context_; + } }; using BaseRequestPtr = std::shared_ptr; diff --git a/core/src/server/delivery/request/CmdRequest.cpp b/core/src/server/delivery/request/CmdRequest.cpp index bd11b2f9a2..d262288486 100644 --- a/core/src/server/delivery/request/CmdRequest.cpp +++ b/core/src/server/delivery/request/CmdRequest.cpp @@ -21,12 +21,14 @@ namespace milvus { namespace server { -CmdRequest::CmdRequest(const std::shared_ptr& context, const std::string& cmd, std::string& result) - : BaseRequest(context, INFO_REQUEST_GROUP), cmd_(cmd), result_(result) { +CmdRequest::CmdRequest(const std::shared_ptr& context, const std::string& cmd, + std::string& result) + : BaseRequest(context, BaseRequest::kCmd), cmd_(cmd), result_(result) { } BaseRequestPtr -CmdRequest::Create(const std::shared_ptr& context, const std::string& cmd, std::string& result) { +CmdRequest::Create(const std::shared_ptr& context, const std::string& cmd, + std::string& result) { return std::shared_ptr(new CmdRequest(context, cmd, result)); } diff --git a/core/src/server/delivery/request/CmdRequest.h b/core/src/server/delivery/request/CmdRequest.h index 9fc3428906..efb840fdf1 100644 --- a/core/src/server/delivery/request/CmdRequest.h +++ b/core/src/server/delivery/request/CmdRequest.h @@ -22,10 +22,10 @@ namespace server { class CmdRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& cmd, std::string& result); + Create(const std::shared_ptr& context, const std::string& cmd, std::string& result); protected: - CmdRequest(const std::shared_ptr& context, const std::string& cmd, std::string& result); + CmdRequest(const std::shared_ptr& context, const std::string& cmd, std::string& result); Status OnExecute() override; diff --git a/core/src/server/delivery/request/CompactRequest.cpp b/core/src/server/delivery/request/CompactRequest.cpp index edaa12a323..60e004ea46 100644 --- a/core/src/server/delivery/request/CompactRequest.cpp +++ b/core/src/server/delivery/request/CompactRequest.cpp @@ -26,12 +26,12 @@ namespace milvus { namespace server { -CompactRequest::CompactRequest(const std::shared_ptr& context, const std::string& table_name) - : BaseRequest(context, DDL_DML_REQUEST_GROUP), table_name_(table_name) { +CompactRequest::CompactRequest(const std::shared_ptr& context, const std::string& table_name) + : BaseRequest(context, BaseRequest::kCompact), table_name_(table_name) { } BaseRequestPtr -CompactRequest::Create(const std::shared_ptr& context, const std::string& table_name) { +CompactRequest::Create(const std::shared_ptr& context, const std::string& table_name) { return std::shared_ptr(new CompactRequest(context, table_name)); } diff --git a/core/src/server/delivery/request/CompactRequest.h b/core/src/server/delivery/request/CompactRequest.h index f1f8559a8b..a19e4955b0 100644 --- a/core/src/server/delivery/request/CompactRequest.h +++ b/core/src/server/delivery/request/CompactRequest.h @@ -28,10 +28,10 @@ namespace server { class CompactRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name); + Create(const std::shared_ptr& context, const std::string& table_name); protected: - CompactRequest(const std::shared_ptr& context, const std::string& table_name); + CompactRequest(const std::shared_ptr& context, const std::string& table_name); Status OnExecute() override; diff --git a/core/src/server/delivery/request/CountTableRequest.cpp b/core/src/server/delivery/request/CountTableRequest.cpp index 5496bc632c..efb1d28a5d 100644 --- a/core/src/server/delivery/request/CountTableRequest.cpp +++ b/core/src/server/delivery/request/CountTableRequest.cpp @@ -22,13 +22,14 @@ namespace milvus { namespace server { -CountTableRequest::CountTableRequest(const std::shared_ptr& context, const std::string& table_name, - int64_t& row_count) - : BaseRequest(context, INFO_REQUEST_GROUP), table_name_(table_name), row_count_(row_count) { +CountTableRequest::CountTableRequest(const std::shared_ptr& context, + const std::string& table_name, int64_t& row_count) + : BaseRequest(context, BaseRequest::kCountTable), table_name_(table_name), row_count_(row_count) { } BaseRequestPtr -CountTableRequest::Create(const std::shared_ptr& context, const std::string& table_name, int64_t& row_count) { +CountTableRequest::Create(const std::shared_ptr& context, const std::string& table_name, + int64_t& row_count) { return std::shared_ptr(new CountTableRequest(context, table_name, row_count)); } diff --git a/core/src/server/delivery/request/CountTableRequest.h b/core/src/server/delivery/request/CountTableRequest.h index 2887da689e..d8f5d6d7cb 100644 --- a/core/src/server/delivery/request/CountTableRequest.h +++ b/core/src/server/delivery/request/CountTableRequest.h @@ -22,10 +22,11 @@ namespace server { class CountTableRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name, int64_t& row_count); + Create(const std::shared_ptr& context, const std::string& table_name, int64_t& row_count); protected: - CountTableRequest(const std::shared_ptr& context, const std::string& table_name, int64_t& row_count); + CountTableRequest(const std::shared_ptr& context, const std::string& table_name, + int64_t& row_count); Status OnExecute() override; diff --git a/core/src/server/delivery/request/CreateIndexRequest.cpp b/core/src/server/delivery/request/CreateIndexRequest.cpp index d1b00c1a2c..c800382dbf 100644 --- a/core/src/server/delivery/request/CreateIndexRequest.cpp +++ b/core/src/server/delivery/request/CreateIndexRequest.cpp @@ -24,17 +24,18 @@ namespace milvus { namespace server { -CreateIndexRequest::CreateIndexRequest(const std::shared_ptr& context, const std::string& table_name, - int64_t index_type, const milvus::json& json_params) - : BaseRequest(context, DDL_DML_REQUEST_GROUP), +CreateIndexRequest::CreateIndexRequest(const std::shared_ptr& context, + const std::string& table_name, int64_t index_type, + const milvus::json& json_params) + : BaseRequest(context, BaseRequest::kCreateIndex), table_name_(table_name), index_type_(index_type), json_params_(json_params) { } BaseRequestPtr -CreateIndexRequest::Create(const std::shared_ptr& context, const std::string& table_name, int64_t index_type, - const milvus::json& json_params) { +CreateIndexRequest::Create(const std::shared_ptr& context, const std::string& table_name, + int64_t index_type, const milvus::json& json_params) { return std::shared_ptr(new CreateIndexRequest(context, table_name, index_type, json_params)); } diff --git a/core/src/server/delivery/request/CreateIndexRequest.h b/core/src/server/delivery/request/CreateIndexRequest.h index 2f52fe94f0..efc50bca35 100644 --- a/core/src/server/delivery/request/CreateIndexRequest.h +++ b/core/src/server/delivery/request/CreateIndexRequest.h @@ -21,12 +21,12 @@ namespace server { class CreateIndexRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name, int64_t index_type, + Create(const std::shared_ptr& context, const std::string& table_name, int64_t index_type, const milvus::json& json_params); protected: - CreateIndexRequest(const std::shared_ptr& context, const std::string& table_name, int64_t index_type, - const milvus::json& json_params); + CreateIndexRequest(const std::shared_ptr& context, const std::string& table_name, + int64_t index_type, const milvus::json& json_params); Status OnExecute() override; diff --git a/core/src/server/delivery/request/CreatePartitionRequest.cpp b/core/src/server/delivery/request/CreatePartitionRequest.cpp index 87512b2cf8..fecd2ff72d 100644 --- a/core/src/server/delivery/request/CreatePartitionRequest.cpp +++ b/core/src/server/delivery/request/CreatePartitionRequest.cpp @@ -22,13 +22,13 @@ namespace milvus { namespace server { -CreatePartitionRequest::CreatePartitionRequest(const std::shared_ptr& context, const std::string& table_name, - const std::string& tag) - : BaseRequest(context, DDL_DML_REQUEST_GROUP), table_name_(table_name), tag_(tag) { +CreatePartitionRequest::CreatePartitionRequest(const std::shared_ptr& context, + const std::string& table_name, const std::string& tag) + : BaseRequest(context, BaseRequest::kCreatePartition), table_name_(table_name), tag_(tag) { } BaseRequestPtr -CreatePartitionRequest::Create(const std::shared_ptr& context, const std::string& table_name, +CreatePartitionRequest::Create(const std::shared_ptr& context, const std::string& table_name, const std::string& tag) { return std::shared_ptr(new CreatePartitionRequest(context, table_name, tag)); } diff --git a/core/src/server/delivery/request/CreatePartitionRequest.h b/core/src/server/delivery/request/CreatePartitionRequest.h index aaea05a8f8..286a423f16 100644 --- a/core/src/server/delivery/request/CreatePartitionRequest.h +++ b/core/src/server/delivery/request/CreatePartitionRequest.h @@ -21,10 +21,11 @@ namespace server { class CreatePartitionRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& partition_name, const std::string& tag); + Create(const std::shared_ptr& context, const std::string& partition_name, + const std::string& tag); protected: - CreatePartitionRequest(const std::shared_ptr& context, const std::string& table_name, + CreatePartitionRequest(const std::shared_ptr& context, const std::string& table_name, const std::string& tag); Status diff --git a/core/src/server/delivery/request/CreateTableRequest.cpp b/core/src/server/delivery/request/CreateTableRequest.cpp index 9f4a3878e3..cfcb05f7e6 100644 --- a/core/src/server/delivery/request/CreateTableRequest.cpp +++ b/core/src/server/delivery/request/CreateTableRequest.cpp @@ -24,9 +24,10 @@ namespace milvus { namespace server { -CreateTableRequest::CreateTableRequest(const std::shared_ptr& context, const std::string& table_name, - int64_t dimension, int64_t index_file_size, int64_t metric_type) - : BaseRequest(context, DDL_DML_REQUEST_GROUP), +CreateTableRequest::CreateTableRequest(const std::shared_ptr& context, + const std::string& table_name, int64_t dimension, int64_t index_file_size, + int64_t metric_type) + : BaseRequest(context, BaseRequest::kCreateTable), table_name_(table_name), dimension_(dimension), index_file_size_(index_file_size), @@ -34,8 +35,8 @@ CreateTableRequest::CreateTableRequest(const std::shared_ptr& context, } BaseRequestPtr -CreateTableRequest::Create(const std::shared_ptr& context, const std::string& table_name, int64_t dimension, - int64_t index_file_size, int64_t metric_type) { +CreateTableRequest::Create(const std::shared_ptr& context, const std::string& table_name, + int64_t dimension, int64_t index_file_size, int64_t metric_type) { return std::shared_ptr( new CreateTableRequest(context, table_name, dimension, index_file_size, metric_type)); } diff --git a/core/src/server/delivery/request/CreateTableRequest.h b/core/src/server/delivery/request/CreateTableRequest.h index efee9fb871..27f01b1165 100644 --- a/core/src/server/delivery/request/CreateTableRequest.h +++ b/core/src/server/delivery/request/CreateTableRequest.h @@ -22,12 +22,12 @@ namespace server { class CreateTableRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name, int64_t dimension, + Create(const std::shared_ptr& context, const std::string& table_name, int64_t dimension, int64_t index_file_size, int64_t metric_type); protected: - CreateTableRequest(const std::shared_ptr& context, const std::string& table_name, int64_t dimension, - int64_t index_file_size, int64_t metric_type); + CreateTableRequest(const std::shared_ptr& context, const std::string& table_name, + int64_t dimension, int64_t index_file_size, int64_t metric_type); Status OnExecute() override; diff --git a/core/src/server/delivery/request/DeleteByIDRequest.cpp b/core/src/server/delivery/request/DeleteByIDRequest.cpp index dac7e28776..9262c8386a 100644 --- a/core/src/server/delivery/request/DeleteByIDRequest.cpp +++ b/core/src/server/delivery/request/DeleteByIDRequest.cpp @@ -29,13 +29,13 @@ namespace milvus { namespace server { -DeleteByIDRequest::DeleteByIDRequest(const std::shared_ptr& context, const std::string& table_name, - const std::vector& vector_ids) - : BaseRequest(context, DDL_DML_REQUEST_GROUP), table_name_(table_name), vector_ids_(vector_ids) { +DeleteByIDRequest::DeleteByIDRequest(const std::shared_ptr& context, + const std::string& table_name, const std::vector& vector_ids) + : BaseRequest(context, BaseRequest::kDeleteByID), table_name_(table_name), vector_ids_(vector_ids) { } BaseRequestPtr -DeleteByIDRequest::Create(const std::shared_ptr& context, const std::string& table_name, +DeleteByIDRequest::Create(const std::shared_ptr& context, const std::string& table_name, const std::vector& vector_ids) { return std::shared_ptr(new DeleteByIDRequest(context, table_name, vector_ids)); } diff --git a/core/src/server/delivery/request/DeleteByIDRequest.h b/core/src/server/delivery/request/DeleteByIDRequest.h index 91efaac52e..4f89fed296 100644 --- a/core/src/server/delivery/request/DeleteByIDRequest.h +++ b/core/src/server/delivery/request/DeleteByIDRequest.h @@ -29,11 +29,11 @@ namespace server { class DeleteByIDRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name, + Create(const std::shared_ptr& context, const std::string& table_name, const std::vector& vector_ids); protected: - DeleteByIDRequest(const std::shared_ptr& context, const std::string& table_name, + DeleteByIDRequest(const std::shared_ptr& context, const std::string& table_name, const std::vector& vector_ids); Status diff --git a/core/src/server/delivery/request/DescribeIndexRequest.cpp b/core/src/server/delivery/request/DescribeIndexRequest.cpp index fea640611b..737f8ab0a8 100644 --- a/core/src/server/delivery/request/DescribeIndexRequest.cpp +++ b/core/src/server/delivery/request/DescribeIndexRequest.cpp @@ -21,13 +21,13 @@ namespace milvus { namespace server { -DescribeIndexRequest::DescribeIndexRequest(const std::shared_ptr& context, const std::string& table_name, - IndexParam& index_param) - : BaseRequest(context, INFO_REQUEST_GROUP), table_name_(table_name), index_param_(index_param) { +DescribeIndexRequest::DescribeIndexRequest(const std::shared_ptr& context, + const std::string& table_name, IndexParam& index_param) + : BaseRequest(context, BaseRequest::kDescribeIndex), table_name_(table_name), index_param_(index_param) { } BaseRequestPtr -DescribeIndexRequest::Create(const std::shared_ptr& context, const std::string& table_name, +DescribeIndexRequest::Create(const std::shared_ptr& context, const std::string& table_name, IndexParam& index_param) { return std::shared_ptr(new DescribeIndexRequest(context, table_name, index_param)); } diff --git a/core/src/server/delivery/request/DescribeIndexRequest.h b/core/src/server/delivery/request/DescribeIndexRequest.h index e4c4dfc4a0..d4f4c4727c 100644 --- a/core/src/server/delivery/request/DescribeIndexRequest.h +++ b/core/src/server/delivery/request/DescribeIndexRequest.h @@ -22,10 +22,11 @@ namespace server { class DescribeIndexRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name, IndexParam& index_param); + Create(const std::shared_ptr& context, const std::string& table_name, + IndexParam& index_param); protected: - DescribeIndexRequest(const std::shared_ptr& context, const std::string& table_name, + DescribeIndexRequest(const std::shared_ptr& context, const std::string& table_name, IndexParam& index_param); Status diff --git a/core/src/server/delivery/request/DescribeTableRequest.cpp b/core/src/server/delivery/request/DescribeTableRequest.cpp index ff4f683236..edbcac846c 100644 --- a/core/src/server/delivery/request/DescribeTableRequest.cpp +++ b/core/src/server/delivery/request/DescribeTableRequest.cpp @@ -21,13 +21,13 @@ namespace milvus { namespace server { -DescribeTableRequest::DescribeTableRequest(const std::shared_ptr& context, const std::string& table_name, - TableSchema& schema) - : BaseRequest(context, INFO_REQUEST_GROUP), table_name_(table_name), schema_(schema) { +DescribeTableRequest::DescribeTableRequest(const std::shared_ptr& context, + const std::string& table_name, TableSchema& schema) + : BaseRequest(context, BaseRequest::kDescribeTable), table_name_(table_name), schema_(schema) { } BaseRequestPtr -DescribeTableRequest::Create(const std::shared_ptr& context, const std::string& table_name, +DescribeTableRequest::Create(const std::shared_ptr& context, const std::string& table_name, TableSchema& schema) { return std::shared_ptr(new DescribeTableRequest(context, table_name, schema)); } diff --git a/core/src/server/delivery/request/DescribeTableRequest.h b/core/src/server/delivery/request/DescribeTableRequest.h index 0d609ff54a..45c3e6bd1e 100644 --- a/core/src/server/delivery/request/DescribeTableRequest.h +++ b/core/src/server/delivery/request/DescribeTableRequest.h @@ -22,10 +22,11 @@ namespace server { class DescribeTableRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name, TableSchema& schema); + Create(const std::shared_ptr& context, const std::string& table_name, TableSchema& schema); protected: - DescribeTableRequest(const std::shared_ptr& context, const std::string& table_name, TableSchema& schema); + DescribeTableRequest(const std::shared_ptr& context, const std::string& table_name, + TableSchema& schema); Status OnExecute() override; diff --git a/core/src/server/delivery/request/DropIndexRequest.cpp b/core/src/server/delivery/request/DropIndexRequest.cpp index a65949aead..fd3e0273f3 100644 --- a/core/src/server/delivery/request/DropIndexRequest.cpp +++ b/core/src/server/delivery/request/DropIndexRequest.cpp @@ -21,12 +21,13 @@ namespace milvus { namespace server { -DropIndexRequest::DropIndexRequest(const std::shared_ptr& context, const std::string& table_name) - : BaseRequest(context, DDL_DML_REQUEST_GROUP), table_name_(table_name) { +DropIndexRequest::DropIndexRequest(const std::shared_ptr& context, + const std::string& table_name) + : BaseRequest(context, BaseRequest::kDropIndex), table_name_(table_name) { } BaseRequestPtr -DropIndexRequest::Create(const std::shared_ptr& context, const std::string& table_name) { +DropIndexRequest::Create(const std::shared_ptr& context, const std::string& table_name) { return std::shared_ptr(new DropIndexRequest(context, table_name)); } diff --git a/core/src/server/delivery/request/DropIndexRequest.h b/core/src/server/delivery/request/DropIndexRequest.h index fb38f9bf06..c79bba3baa 100644 --- a/core/src/server/delivery/request/DropIndexRequest.h +++ b/core/src/server/delivery/request/DropIndexRequest.h @@ -22,10 +22,10 @@ namespace server { class DropIndexRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name); + Create(const std::shared_ptr& context, const std::string& table_name); protected: - DropIndexRequest(const std::shared_ptr& context, const std::string& table_name); + DropIndexRequest(const std::shared_ptr& context, const std::string& table_name); Status OnExecute() override; diff --git a/core/src/server/delivery/request/DropPartitionRequest.cpp b/core/src/server/delivery/request/DropPartitionRequest.cpp index 5a44246534..c8f99693d1 100644 --- a/core/src/server/delivery/request/DropPartitionRequest.cpp +++ b/core/src/server/delivery/request/DropPartitionRequest.cpp @@ -22,13 +22,13 @@ namespace milvus { namespace server { -DropPartitionRequest::DropPartitionRequest(const std::shared_ptr& context, const std::string& table_name, - const std::string& tag) - : BaseRequest(context, DDL_DML_REQUEST_GROUP), table_name_(table_name), tag_(tag) { +DropPartitionRequest::DropPartitionRequest(const std::shared_ptr& context, + const std::string& table_name, const std::string& tag) + : BaseRequest(context, BaseRequest::kDropPartition), table_name_(table_name), tag_(tag) { } BaseRequestPtr -DropPartitionRequest::Create(const std::shared_ptr& context, const std::string& table_name, +DropPartitionRequest::Create(const std::shared_ptr& context, const std::string& table_name, const std::string& tag) { return std::shared_ptr(new DropPartitionRequest(context, table_name, tag)); } diff --git a/core/src/server/delivery/request/DropPartitionRequest.h b/core/src/server/delivery/request/DropPartitionRequest.h index af7fcc5b5e..f82e84cbd7 100644 --- a/core/src/server/delivery/request/DropPartitionRequest.h +++ b/core/src/server/delivery/request/DropPartitionRequest.h @@ -21,10 +21,11 @@ namespace server { class DropPartitionRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name, const std::string& tag); + Create(const std::shared_ptr& context, const std::string& table_name, + const std::string& tag); protected: - DropPartitionRequest(const std::shared_ptr& context, const std::string& table_name, + DropPartitionRequest(const std::shared_ptr& context, const std::string& table_name, const std::string& tag); Status diff --git a/core/src/server/delivery/request/DropTableRequest.cpp b/core/src/server/delivery/request/DropTableRequest.cpp index 0a9999a958..86eabd868c 100644 --- a/core/src/server/delivery/request/DropTableRequest.cpp +++ b/core/src/server/delivery/request/DropTableRequest.cpp @@ -22,12 +22,13 @@ namespace milvus { namespace server { -DropTableRequest::DropTableRequest(const std::shared_ptr& context, const std::string& table_name) - : BaseRequest(context, DDL_DML_REQUEST_GROUP), table_name_(table_name) { +DropTableRequest::DropTableRequest(const std::shared_ptr& context, + const std::string& table_name) + : BaseRequest(context, BaseRequest::kDropTable), table_name_(table_name) { } BaseRequestPtr -DropTableRequest::Create(const std::shared_ptr& context, const std::string& table_name) { +DropTableRequest::Create(const std::shared_ptr& context, const std::string& table_name) { return std::shared_ptr(new DropTableRequest(context, table_name)); } diff --git a/core/src/server/delivery/request/DropTableRequest.h b/core/src/server/delivery/request/DropTableRequest.h index 3a0fe9dcd1..7ef2b3cfd2 100644 --- a/core/src/server/delivery/request/DropTableRequest.h +++ b/core/src/server/delivery/request/DropTableRequest.h @@ -22,10 +22,10 @@ namespace server { class DropTableRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name); + Create(const std::shared_ptr& context, const std::string& table_name); protected: - DropTableRequest(const std::shared_ptr& context, const std::string& table_name); + DropTableRequest(const std::shared_ptr& context, const std::string& table_name); Status OnExecute() override; diff --git a/core/src/server/delivery/request/FlushRequest.cpp b/core/src/server/delivery/request/FlushRequest.cpp index d326373432..d0560fae7f 100644 --- a/core/src/server/delivery/request/FlushRequest.cpp +++ b/core/src/server/delivery/request/FlushRequest.cpp @@ -26,12 +26,14 @@ namespace milvus { namespace server { -FlushRequest::FlushRequest(const std::shared_ptr& context, const std::vector& table_names) - : BaseRequest(context, DDL_DML_REQUEST_GROUP), table_names_(table_names) { +FlushRequest::FlushRequest(const std::shared_ptr& context, + const std::vector& table_names) + : BaseRequest(context, BaseRequest::kFlush), table_names_(table_names) { } BaseRequestPtr -FlushRequest::Create(const std::shared_ptr& context, const std::vector& table_names) { +FlushRequest::Create(const std::shared_ptr& context, + const std::vector& table_names) { return std::shared_ptr(new FlushRequest(context, table_names)); } diff --git a/core/src/server/delivery/request/FlushRequest.h b/core/src/server/delivery/request/FlushRequest.h index f7aa7a08a9..5872c41863 100644 --- a/core/src/server/delivery/request/FlushRequest.h +++ b/core/src/server/delivery/request/FlushRequest.h @@ -29,10 +29,10 @@ namespace server { class FlushRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::vector& table_names); + Create(const std::shared_ptr& context, const std::vector& table_names); protected: - FlushRequest(const std::shared_ptr& context, const std::vector& table_names); + FlushRequest(const std::shared_ptr& context, const std::vector& table_names); Status OnExecute() override; diff --git a/core/src/server/delivery/request/GetVectorByIDRequest.cpp b/core/src/server/delivery/request/GetVectorByIDRequest.cpp index e6a7d4f554..b8fda90323 100644 --- a/core/src/server/delivery/request/GetVectorByIDRequest.cpp +++ b/core/src/server/delivery/request/GetVectorByIDRequest.cpp @@ -27,13 +27,14 @@ namespace milvus { namespace server { -GetVectorByIDRequest::GetVectorByIDRequest(const std::shared_ptr& context, const std::string& table_name, - const std::vector& ids, engine::VectorsData& vectors) - : BaseRequest(context, INFO_REQUEST_GROUP), table_name_(table_name), ids_(ids), vectors_(vectors) { +GetVectorByIDRequest::GetVectorByIDRequest(const std::shared_ptr& context, + const std::string& table_name, const std::vector& ids, + engine::VectorsData& vectors) + : BaseRequest(context, BaseRequest::kGetVectorByID), table_name_(table_name), ids_(ids), vectors_(vectors) { } BaseRequestPtr -GetVectorByIDRequest::Create(const std::shared_ptr& context, const std::string& table_name, +GetVectorByIDRequest::Create(const std::shared_ptr& context, const std::string& table_name, const std::vector& ids, engine::VectorsData& vectors) { return std::shared_ptr(new GetVectorByIDRequest(context, table_name, ids, vectors)); } diff --git a/core/src/server/delivery/request/GetVectorByIDRequest.h b/core/src/server/delivery/request/GetVectorByIDRequest.h index 525836f54c..e10b19965d 100644 --- a/core/src/server/delivery/request/GetVectorByIDRequest.h +++ b/core/src/server/delivery/request/GetVectorByIDRequest.h @@ -29,11 +29,11 @@ namespace server { class GetVectorByIDRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name, const std::vector& ids, - engine::VectorsData& vectors); + Create(const std::shared_ptr& context, const std::string& table_name, + const std::vector& ids, engine::VectorsData& vectors); protected: - GetVectorByIDRequest(const std::shared_ptr& context, const std::string& table_name, + GetVectorByIDRequest(const std::shared_ptr& context, const std::string& table_name, const std::vector& ids, engine::VectorsData& vectors); Status diff --git a/core/src/server/delivery/request/GetVectorIDsRequest.cpp b/core/src/server/delivery/request/GetVectorIDsRequest.cpp index 5e88c2f966..7020816640 100644 --- a/core/src/server/delivery/request/GetVectorIDsRequest.cpp +++ b/core/src/server/delivery/request/GetVectorIDsRequest.cpp @@ -27,16 +27,17 @@ namespace milvus { namespace server { -GetVectorIDsRequest::GetVectorIDsRequest(const std::shared_ptr& context, const std::string& table_name, - const std::string& segment_name, std::vector& vector_ids) - : BaseRequest(context, INFO_REQUEST_GROUP), +GetVectorIDsRequest::GetVectorIDsRequest(const std::shared_ptr& context, + const std::string& table_name, const std::string& segment_name, + std::vector& vector_ids) + : BaseRequest(context, BaseRequest::kGetVectorIDs), table_name_(table_name), segment_name_(segment_name), vector_ids_(vector_ids) { } BaseRequestPtr -GetVectorIDsRequest::Create(const std::shared_ptr& context, const std::string& table_name, +GetVectorIDsRequest::Create(const std::shared_ptr& context, const std::string& table_name, const std::string& segment_name, std::vector& vector_ids) { return std::shared_ptr(new GetVectorIDsRequest(context, table_name, segment_name, vector_ids)); } diff --git a/core/src/server/delivery/request/GetVectorIDsRequest.h b/core/src/server/delivery/request/GetVectorIDsRequest.h index 52b7f83503..bea8ad3ec3 100644 --- a/core/src/server/delivery/request/GetVectorIDsRequest.h +++ b/core/src/server/delivery/request/GetVectorIDsRequest.h @@ -29,11 +29,11 @@ namespace server { class GetVectorIDsRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name, const std::string& segment_name, - std::vector& vector_ids); + Create(const std::shared_ptr& context, const std::string& table_name, + const std::string& segment_name, std::vector& vector_ids); protected: - GetVectorIDsRequest(const std::shared_ptr& context, const std::string& table_name, + GetVectorIDsRequest(const std::shared_ptr& context, const std::string& table_name, const std::string& segment_name, std::vector& vector_ids); Status diff --git a/core/src/server/delivery/request/HasTableRequest.cpp b/core/src/server/delivery/request/HasTableRequest.cpp index ccde75772b..9465ffbde8 100644 --- a/core/src/server/delivery/request/HasTableRequest.cpp +++ b/core/src/server/delivery/request/HasTableRequest.cpp @@ -21,13 +21,14 @@ namespace milvus { namespace server { -HasTableRequest::HasTableRequest(const std::shared_ptr& context, const std::string& table_name, +HasTableRequest::HasTableRequest(const std::shared_ptr& context, const std::string& table_name, bool& has_table) - : BaseRequest(context, INFO_REQUEST_GROUP), table_name_(table_name), has_table_(has_table) { + : BaseRequest(context, BaseRequest::kHasTable), table_name_(table_name), has_table_(has_table) { } BaseRequestPtr -HasTableRequest::Create(const std::shared_ptr& context, const std::string& table_name, bool& has_table) { +HasTableRequest::Create(const std::shared_ptr& context, const std::string& table_name, + bool& has_table) { return std::shared_ptr(new HasTableRequest(context, table_name, has_table)); } diff --git a/core/src/server/delivery/request/HasTableRequest.h b/core/src/server/delivery/request/HasTableRequest.h index 7397030d9a..117f7d3087 100644 --- a/core/src/server/delivery/request/HasTableRequest.h +++ b/core/src/server/delivery/request/HasTableRequest.h @@ -22,10 +22,11 @@ namespace server { class HasTableRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name, bool& has_table); + Create(const std::shared_ptr& context, const std::string& table_name, bool& has_table); protected: - HasTableRequest(const std::shared_ptr& context, const std::string& table_name, bool& has_table); + HasTableRequest(const std::shared_ptr& context, const std::string& table_name, + bool& has_table); Status OnExecute() override; diff --git a/core/src/server/delivery/request/InsertRequest.cpp b/core/src/server/delivery/request/InsertRequest.cpp index a739d86b9f..d48b37f6cd 100644 --- a/core/src/server/delivery/request/InsertRequest.cpp +++ b/core/src/server/delivery/request/InsertRequest.cpp @@ -28,16 +28,16 @@ namespace milvus { namespace server { -InsertRequest::InsertRequest(const std::shared_ptr& context, const std::string& table_name, +InsertRequest::InsertRequest(const std::shared_ptr& context, const std::string& table_name, engine::VectorsData& vectors, const std::string& partition_tag) - : BaseRequest(context, DDL_DML_REQUEST_GROUP), + : BaseRequest(context, BaseRequest::kInsert), table_name_(table_name), vectors_data_(vectors), partition_tag_(partition_tag) { } BaseRequestPtr -InsertRequest::Create(const std::shared_ptr& context, const std::string& table_name, +InsertRequest::Create(const std::shared_ptr& context, const std::string& table_name, engine::VectorsData& vectors, const std::string& partition_tag) { return std::shared_ptr(new InsertRequest(context, table_name, vectors, partition_tag)); } diff --git a/core/src/server/delivery/request/InsertRequest.h b/core/src/server/delivery/request/InsertRequest.h index e862b7500b..0cfed97b9f 100644 --- a/core/src/server/delivery/request/InsertRequest.h +++ b/core/src/server/delivery/request/InsertRequest.h @@ -23,12 +23,12 @@ namespace server { class InsertRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name, engine::VectorsData& vectors, - const std::string& partition_tag); + Create(const std::shared_ptr& context, const std::string& table_name, + engine::VectorsData& vectors, const std::string& partition_tag); protected: - InsertRequest(const std::shared_ptr& context, const std::string& table_name, engine::VectorsData& vectors, - const std::string& partition_tag); + InsertRequest(const std::shared_ptr& context, const std::string& table_name, + engine::VectorsData& vectors, const std::string& partition_tag); Status OnExecute() override; diff --git a/core/src/server/delivery/request/PreloadTableRequest.cpp b/core/src/server/delivery/request/PreloadTableRequest.cpp index bb5cee53db..4648a8faea 100644 --- a/core/src/server/delivery/request/PreloadTableRequest.cpp +++ b/core/src/server/delivery/request/PreloadTableRequest.cpp @@ -21,12 +21,13 @@ namespace milvus { namespace server { -PreloadTableRequest::PreloadTableRequest(const std::shared_ptr& context, const std::string& table_name) - : BaseRequest(context, DQL_REQUEST_GROUP), table_name_(table_name) { +PreloadTableRequest::PreloadTableRequest(const std::shared_ptr& context, + const std::string& table_name) + : BaseRequest(context, BaseRequest::kPreloadTable), table_name_(table_name) { } BaseRequestPtr -PreloadTableRequest::Create(const std::shared_ptr& context, const std::string& table_name) { +PreloadTableRequest::Create(const std::shared_ptr& context, const std::string& table_name) { return std::shared_ptr(new PreloadTableRequest(context, table_name)); } diff --git a/core/src/server/delivery/request/PreloadTableRequest.h b/core/src/server/delivery/request/PreloadTableRequest.h index 8ff4c2c6c1..abbc78581f 100644 --- a/core/src/server/delivery/request/PreloadTableRequest.h +++ b/core/src/server/delivery/request/PreloadTableRequest.h @@ -22,10 +22,10 @@ namespace server { class PreloadTableRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name); + Create(const std::shared_ptr& context, const std::string& table_name); protected: - PreloadTableRequest(const std::shared_ptr& context, const std::string& table_name); + PreloadTableRequest(const std::shared_ptr& context, const std::string& table_name); Status OnExecute() override; diff --git a/core/src/server/delivery/request/SearchByIDRequest.cpp b/core/src/server/delivery/request/SearchByIDRequest.cpp index 5fce20fc48..e53d984fa0 100644 --- a/core/src/server/delivery/request/SearchByIDRequest.cpp +++ b/core/src/server/delivery/request/SearchByIDRequest.cpp @@ -33,10 +33,11 @@ namespace milvus { namespace server { -SearchByIDRequest::SearchByIDRequest(const std::shared_ptr& context, const std::string& table_name, - int64_t vector_id, int64_t topk, const milvus::json& extra_params, - const std::vector& partition_list, TopKQueryResult& result) - : BaseRequest(context, DQL_REQUEST_GROUP), +SearchByIDRequest::SearchByIDRequest(const std::shared_ptr& context, + const std::string& table_name, int64_t vector_id, int64_t topk, + const milvus::json& extra_params, const std::vector& partition_list, + TopKQueryResult& result) + : BaseRequest(context, BaseRequest::kSearchByID), table_name_(table_name), vector_id_(vector_id), topk_(topk), @@ -46,8 +47,8 @@ SearchByIDRequest::SearchByIDRequest(const std::shared_ptr& context, co } BaseRequestPtr -SearchByIDRequest::Create(const std::shared_ptr& context, const std::string& table_name, int64_t vector_id, - int64_t topk, const milvus::json& extra_params, +SearchByIDRequest::Create(const std::shared_ptr& context, const std::string& table_name, + int64_t vector_id, int64_t topk, const milvus::json& extra_params, const std::vector& partition_list, TopKQueryResult& result) { return std::shared_ptr( new SearchByIDRequest(context, table_name, vector_id, topk, extra_params, partition_list, result)); @@ -71,7 +72,13 @@ SearchByIDRequest::OnExecute() { return status; } - // step 3: check table existence + // step 3: check search topk + status = ValidationUtil::ValidateSearchTopk(topk_); + if (!status.ok()) { + return status; + } + + // step 4: check table existence // only process root table, ignore partition table engine::meta::TableSchema table_schema; table_schema.table_id_ = table_name_; @@ -88,12 +95,13 @@ SearchByIDRequest::OnExecute() { } } + // step 5: check search parameters status = ValidationUtil::ValidateSearchParams(extra_params_, table_schema, topk_); if (!status.ok()) { return status; } - // Check whether GPU search resource is enabled + // step 6: check whether GPU search resource is enabled #ifdef MILVUS_GPU_VERSION Config& config = Config::GetInstance(); bool gpu_enable; @@ -109,7 +117,7 @@ SearchByIDRequest::OnExecute() { } #endif - // Check table's index type supports search by id + // step 7: check table's index type supports search by id if (table_schema.engine_type_ != (int32_t)engine::EngineType::FAISS_IDMAP && table_schema.engine_type_ != (int32_t)engine::EngineType::FAISS_BIN_IDMAP && table_schema.engine_type_ != (int32_t)engine::EngineType::FAISS_IVFFLAT && @@ -121,15 +129,9 @@ SearchByIDRequest::OnExecute() { return Status(SERVER_UNSUPPORTED_ERROR, err_msg); } - // step 4: check search parameter - status = ValidationUtil::ValidateSearchTopk(topk_, table_schema); - if (!status.ok()) { - return status; - } - rc.RecordSection("check validation"); - // step 5: search vectors + // step 8: search vectors engine::ResultIds result_ids; engine::ResultDistances result_distances; @@ -158,14 +160,13 @@ SearchByIDRequest::OnExecute() { auto post_query_ctx = context_->Child("Constructing result"); - // step 7: construct result array + // step 9: construct result array result_.row_num_ = 1; result_.distance_list_ = result_distances; result_.id_list_ = result_ids; post_query_ctx->GetTraceContext()->GetSpan()->Finish(); - // step 8: print time cost percent rc.RecordSection("construct result and send"); rc.ElapseFromBegin("totally cost"); } catch (std::exception& ex) { diff --git a/core/src/server/delivery/request/SearchByIDRequest.h b/core/src/server/delivery/request/SearchByIDRequest.h index 1a85dc5d9d..8c1fe9ac52 100644 --- a/core/src/server/delivery/request/SearchByIDRequest.h +++ b/core/src/server/delivery/request/SearchByIDRequest.h @@ -29,13 +29,14 @@ namespace server { class SearchByIDRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name, int64_t vector_id, int64_t topk, - const milvus::json& extra_params, const std::vector& partition_list, TopKQueryResult& result); + Create(const std::shared_ptr& context, const std::string& table_name, int64_t vector_id, + int64_t topk, const milvus::json& extra_params, const std::vector& partition_list, + TopKQueryResult& result); protected: - SearchByIDRequest(const std::shared_ptr& context, const std::string& table_name, int64_t vector_id, - int64_t topk, const milvus::json& extra_params, const std::vector& partition_list, - TopKQueryResult& result); + SearchByIDRequest(const std::shared_ptr& context, const std::string& table_name, + int64_t vector_id, int64_t topk, const milvus::json& extra_params, + const std::vector& partition_list, TopKQueryResult& result); Status OnExecute() override; diff --git a/core/src/server/delivery/request/SearchCombineRequest.cpp b/core/src/server/delivery/request/SearchCombineRequest.cpp new file mode 100644 index 0000000000..c8791d6bdd --- /dev/null +++ b/core/src/server/delivery/request/SearchCombineRequest.cpp @@ -0,0 +1,363 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed 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. + +#include "server/delivery/request/SearchCombineRequest.h" +#include "db/Utils.h" +#include "server/DBWrapper.h" +#include "server/context/Context.h" +#include "utils/CommonUtil.h" +#include "utils/Log.h" +#include "utils/TimeRecorder.h" +#include "utils/ValidationUtil.h" + +#include +#include + +namespace milvus { +namespace server { + +namespace { + +constexpr int64_t MAX_TOPK_GAP = 200; + +void +GetUniqueList(const std::vector& list, std::set& unique_list) { + for (const std::string& item : list) { + unique_list.insert(item); + } +} + +bool +IsSameList(const std::set& left, const std::set& right) { + if (left.size() != right.size()) { + return false; + } + + std::set::const_iterator iter_left; + std::set::const_iterator iter_right; + for (iter_left = left.begin(), iter_right = right.begin(); iter_left != left.end(); iter_left++, iter_right++) { + if ((*iter_left) != (*iter_right)) { + return false; + } + } + + return true; +} + +void +FreeRequest(SearchRequestPtr& request, const Status& status) { + request->set_status(status); + request->Done(); +} +} // namespace + +SearchCombineRequest::SearchCombineRequest() : BaseRequest(nullptr, BaseRequest::kSearchCombine) { +} + +Status +SearchCombineRequest::Combine(const SearchRequestPtr& request) { + if (request == nullptr) { + return Status(SERVER_NULL_POINTER, ""); + } + + // the request must be tested by CanCombine before invoke this function + // reset some parameters in necessary + if (request_list_.empty()) { + // validate first request input + auto status = ValidationUtil::ValidateTableName(request->TableName()); + if (!status.ok()) { + return status; + } + + status = ValidationUtil::ValidateSearchTopk(request->TopK()); + if (!status.ok()) { + return status; + } + + // assign base parameters + table_name_ = request->TableName(); + min_topk_ = request->TopK() - MAX_TOPK_GAP / 2; + if (min_topk_ < 0) { + min_topk_ = 0; + } + max_topk_ = request->TopK() + MAX_TOPK_GAP / 2; + if (max_topk_ > QUERY_MAX_TOPK) { + max_topk_ = QUERY_MAX_TOPK; + } + extra_params_ = request->ExtraParams(); + + GetUniqueList(request->PartitionList(), partition_list_); + GetUniqueList(request->FileIDList(), file_id_list_); + } + + request_list_.push_back(request); + return Status::OK(); +} + +bool +SearchCombineRequest::CanCombine(const SearchRequestPtr& request) { + if (table_name_ != request->TableName()) { + return false; + } + + if (extra_params_ != request->ExtraParams()) { + return false; + } + + // topk must within certain range + if (request->TopK() < min_topk_ || request->TopK() > max_topk_) { + return false; + } + + // partition list must be equal for each one + std::set partition_list; + GetUniqueList(request->PartitionList(), partition_list); + if (!IsSameList(partition_list_, partition_list)) { + return false; + } + + // file id list must be equal for each one + std::set file_id_list; + GetUniqueList(request->FileIDList(), file_id_list); + if (!IsSameList(file_id_list_, file_id_list)) { + return false; + } + + return true; +} + +bool +SearchCombineRequest::CanCombine(const SearchRequestPtr& left, const SearchRequestPtr& right) { + if (left->TableName() != right->TableName()) { + return false; + } + + if (left->ExtraParams() != right->ExtraParams()) { + return false; + } + + // topk must within certain range + if (abs(left->TopK() - right->TopK() > MAX_TOPK_GAP)) { + return false; + } + + // partition list must be equal for each one + std::set left_partition_list, right_partition_list; + GetUniqueList(left->PartitionList(), left_partition_list); + GetUniqueList(right->PartitionList(), right_partition_list); + if (!IsSameList(left_partition_list, right_partition_list)) { + return false; + } + + // file id list must be equal for each one + std::set left_file_id_list, right_file_id_list; + GetUniqueList(left->FileIDList(), left_file_id_list); + GetUniqueList(right->FileIDList(), right_file_id_list); + if (!IsSameList(left_file_id_list, right_file_id_list)) { + return false; + } + + return true; +} + +Status +SearchCombineRequest::FreeRequests(const Status& status) { + for (auto request : request_list_) { + FreeRequest(request, status); + } + + return Status::OK(); +} + +Status +SearchCombineRequest::OnExecute() { + try { + size_t combined_request = request_list_.size(); + SERVER_LOG_DEBUG << "SearchCombineRequest begin execute, combined requests=" << combined_request + << ", extra_params=" << extra_params_.dump(); + std::string hdr = "SearchCombineRequest(table=" + table_name_ + ")"; + + TimeRecorder rc(hdr); + + // step 1: check table name + auto status = ValidationUtil::ValidateTableName(table_name_); + if (!status.ok()) { + FreeRequests(status); + return status; + } + + // step 2: check table existence + // only process root table, ignore partition table + engine::meta::TableSchema table_schema; + table_schema.table_id_ = table_name_; + status = DBWrapper::DB()->DescribeTable(table_schema); + if (!status.ok()) { + if (status.code() == DB_NOT_FOUND) { + status = Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(table_name_)); + FreeRequests(status); + return status; + } else { + FreeRequests(status); + return status; + } + } else { + if (!table_schema.owner_table_.empty()) { + status = Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(table_name_)); + FreeRequests(status); + return status; + } + } + + // step 3: check input + size_t run_request = 0; + std::vector::iterator iter = request_list_.begin(); + for (; iter != request_list_.end();) { + SearchRequestPtr& request = *iter; + status = ValidationUtil::ValidateSearchTopk(request->TopK()); + if (!status.ok()) { + // check failed, erase request and let it return error status + FreeRequest(request, status); + iter = request_list_.erase(iter); + continue; + } + + status = ValidationUtil::ValidateSearchParams(extra_params_, table_schema, request->TopK()); + if (!status.ok()) { + // check failed, erase request and let it return error status + FreeRequest(request, status); + iter = request_list_.erase(iter); + continue; + } + + status = ValidationUtil::ValidateVectorData(request->VectorsData(), table_schema); + if (!status.ok()) { + // check failed, erase request and let it return error status + FreeRequest(request, status); + iter = request_list_.erase(iter); + continue; + } + + status = ValidationUtil::ValidatePartitionTags(request->PartitionList()); + if (!status.ok()) { + // check failed, erase request and let it return error status + FreeRequest(request, status); + iter = request_list_.erase(iter); + continue; + } + + // reset topk + search_topk_ = request->TopK() > search_topk_ ? request->TopK() : search_topk_; + + // next one + run_request++; + iter++; + } + + // all requests are skipped + if (request_list_.empty()) { + SERVER_LOG_DEBUG << "all combined requests were skipped"; + return Status::OK(); + } + + SERVER_LOG_DEBUG << (combined_request - run_request) << " requests were skipped"; + SERVER_LOG_DEBUG << "reset topk to " << search_topk_; + rc.RecordSection("check validation"); + + // step 5: construct vectors_data and set search_topk + SearchRequestPtr& first_request = *request_list_.begin(); + uint64_t total_count = 0; + for (auto& request : request_list_) { + total_count += request->VectorsData().vector_count_; + } + vectors_data_.vector_count_ = total_count; + + uint16_t dimension = table_schema.dimension_; + bool is_float = true; + if (!first_request->VectorsData().float_data_.empty()) { + vectors_data_.float_data_.resize(total_count * dimension); + } else { + vectors_data_.binary_data_.resize(total_count * dimension / 8); + is_float = false; + } + + int64_t offset = 0; + for (auto& request : request_list_) { + const engine::VectorsData& src = request->VectorsData(); + size_t data_size = 0; + if (is_float) { + data_size = src.vector_count_ * dimension; + memcpy(vectors_data_.float_data_.data() + offset, src.float_data_.data(), data_size); + } else { + data_size = src.vector_count_ * dimension / 8; + memcpy(vectors_data_.binary_data_.data() + offset, src.binary_data_.data(), data_size); + } + offset += data_size; + } + SERVER_LOG_DEBUG << total_count << " query vectors combined"; + + // step 6: search vectors + const std::vector& partition_list = first_request->PartitionList(); + const std::vector& file_id_list = first_request->FileIDList(); + auto context = first_request->Context(); + + engine::ResultIds result_ids; + engine::ResultDistances result_distances; + + if (file_id_list_.empty()) { + status = DBWrapper::DB()->Query(context, table_name_, partition_list, (size_t)search_topk_, extra_params_, + vectors_data_, result_ids, result_distances); + } else { + status = DBWrapper::DB()->QueryByFileID(context, file_id_list, (size_t)search_topk_, extra_params_, + vectors_data_, result_ids, result_distances); + } + + rc.RecordSection("search combined vectors from engine"); + + if (!status.ok()) { + // let all request return + FreeRequests(status); + return status; + } + if (result_ids.empty()) { + status = Status(DB_ERROR, "no result returned for combined request"); + // let all request return + FreeRequests(status); + return status; + } + + // step 6: construct result array + offset = 0; + for (auto& request : request_list_) { + uint64_t count = request->VectorsData().vector_count_; + int64_t topk = request->TopK(); + uint64_t element_cnt = count * topk; + TopKQueryResult& result = request->QueryResult(); + result.id_list_.resize(element_cnt); + result.distance_list_.resize(element_cnt); + memcpy(result.id_list_.data(), result_ids.data() + offset, element_cnt * sizeof(int64_t)); + memcpy(result.distance_list_.data(), result_distances.data() + offset, element_cnt * sizeof(float)); + offset += (count * search_topk_); + + // let request return + FreeRequest(request, Status::OK()); + } + + rc.RecordSection("construct result and send"); + rc.ElapseFromBegin("totally cost"); + } catch (std::exception& ex) { + return Status(SERVER_UNEXPECTED_ERROR, ex.what()); + } + + return Status::OK(); +} + +} // namespace server +} // namespace milvus diff --git a/core/src/server/delivery/request/SearchCombineRequest.h b/core/src/server/delivery/request/SearchCombineRequest.h new file mode 100644 index 0000000000..7cea09b1f0 --- /dev/null +++ b/core/src/server/delivery/request/SearchCombineRequest.h @@ -0,0 +1,62 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed 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. + +#pragma once + +#include "server/delivery/request/BaseRequest.h" +#include "server/delivery/request/SearchRequest.h" + +#include +#include +#include +#include + +namespace milvus { +namespace server { + +class SearchCombineRequest : public BaseRequest { + public: + SearchCombineRequest(); + + Status + Combine(const SearchRequestPtr& request); + + bool + CanCombine(const SearchRequestPtr& request); + + static bool + CanCombine(const SearchRequestPtr& left, const SearchRequestPtr& right); + + protected: + Status + OnExecute() override; + + private: + Status + FreeRequests(const Status& status); + + private: + std::string table_name_; + engine::VectorsData vectors_data_; + int64_t min_topk_ = 0; + int64_t search_topk_ = 0; + int64_t max_topk_ = 0; + milvus::json extra_params_; + std::set partition_list_; + std::set file_id_list_; + + std::vector request_list_; +}; + +using SearchCombineRequestPtr = std::shared_ptr; + +} // namespace server +} // namespace milvus diff --git a/core/src/server/delivery/request/SearchRequest.cpp b/core/src/server/delivery/request/SearchRequest.cpp index fb0fb21d9c..346a2e9429 100644 --- a/core/src/server/delivery/request/SearchRequest.cpp +++ b/core/src/server/delivery/request/SearchRequest.cpp @@ -19,6 +19,7 @@ #include #include + #ifdef MILVUS_ENABLE_PROFILING #include #endif @@ -26,11 +27,11 @@ namespace milvus { namespace server { -SearchRequest::SearchRequest(const std::shared_ptr& context, const std::string& table_name, +SearchRequest::SearchRequest(const std::shared_ptr& context, const std::string& table_name, const engine::VectorsData& vectors, int64_t topk, const milvus::json& extra_params, const std::vector& partition_list, const std::vector& file_id_list, TopKQueryResult& result) - : BaseRequest(context, DQL_REQUEST_GROUP), + : BaseRequest(context, BaseRequest::kSearch), table_name_(table_name), vectors_data_(vectors), topk_(topk), @@ -41,7 +42,7 @@ SearchRequest::SearchRequest(const std::shared_ptr& context, const std: } BaseRequestPtr -SearchRequest::Create(const std::shared_ptr& context, const std::string& table_name, +SearchRequest::Create(const std::shared_ptr& context, const std::string& table_name, const engine::VectorsData& vectors, int64_t topk, const milvus::json& extra_params, const std::vector& partition_list, const std::vector& file_id_list, TopKQueryResult& result) { @@ -56,8 +57,9 @@ SearchRequest::OnExecute() { uint64_t vector_count = vectors_data_.vector_count_; auto pre_query_ctx = context_->Child("Pre query"); + SERVER_LOG_DEBUG << "SearchRequest begin execute, extra_params=" << extra_params_.dump(); std::string hdr = "SearchRequest(table=" + table_name_ + ", nq=" + std::to_string(vector_count) + - ", k=" + std::to_string(topk_) + ", extra_params=" + extra_params_.dump() + ")"; + ", k=" + std::to_string(topk_) + ")"; TimeRecorder rc(hdr); @@ -67,7 +69,13 @@ SearchRequest::OnExecute() { return status; } - // step 2: check table existence + // step 2: check search topk + status = ValidationUtil::ValidateSearchTopk(topk_); + if (!status.ok()) { + return status; + } + + // step 3: check table existence // only process root table, ignore partition table engine::meta::TableSchema table_schema; table_schema.table_id_ = table_name_; @@ -85,54 +93,29 @@ SearchRequest::OnExecute() { } } + // step 4: check search parameters status = ValidationUtil::ValidateSearchParams(extra_params_, table_schema, topk_); if (!status.ok()) { return status; } - // step 3: check search parameter - status = ValidationUtil::ValidateSearchTopk(topk_, table_schema); + // step 5: check vector data according to metric type + status = ValidationUtil::ValidateVectorData(vectors_data_, table_schema); if (!status.ok()) { return status; } - if (vectors_data_.float_data_.empty() && vectors_data_.binary_data_.empty()) { - return Status(SERVER_INVALID_ROWRECORD_ARRAY, - "The vector array is empty. Make sure you have entered vector records."); + // step 6: check partition tags + status = ValidationUtil::ValidatePartitionTags(partition_list_); + fiu_do_on("SearchRequest.OnExecute.invalid_partition_tags", + status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); + if (!status.ok()) { + return status; } rc.RecordSection("check validation"); - // step 4: check metric type - if (engine::utils::IsBinaryMetricType(table_schema.metric_type_)) { - // check prepared binary data - if (vectors_data_.binary_data_.size() % vector_count != 0) { - return Status(SERVER_INVALID_ROWRECORD_ARRAY, - "The vector dimension must be equal to the table dimension."); - } - - if (vectors_data_.binary_data_.size() * 8 / vector_count != table_schema.dimension_) { - return Status(SERVER_INVALID_VECTOR_DIMENSION, - "The vector dimension must be equal to the table dimension."); - } - } else { - // check prepared float data - fiu_do_on("SearchRequest.OnExecute.invalod_rowrecord_array", - vector_count = vectors_data_.float_data_.size() + 1); - if (vectors_data_.float_data_.size() % vector_count != 0) { - return Status(SERVER_INVALID_ROWRECORD_ARRAY, - "The vector dimension must be equal to the table dimension."); - } - fiu_do_on("SearchRequest.OnExecute.invalid_dim", table_schema.dimension_ = -1); - if (vectors_data_.float_data_.size() / vector_count != table_schema.dimension_) { - return Status(SERVER_INVALID_VECTOR_DIMENSION, - "The vector dimension must be equal to the table dimension."); - } - } - - rc.RecordSection("prepare vector data"); - - // step 5: search vectors + // step 7: search vectors engine::ResultIds result_ids; engine::ResultDistances result_distances; @@ -144,13 +127,6 @@ SearchRequest::OnExecute() { pre_query_ctx->GetTraceContext()->GetSpan()->Finish(); if (file_id_list_.empty()) { - status = ValidationUtil::ValidatePartitionTags(partition_list_); - fiu_do_on("SearchRequest.OnExecute.invalid_partition_tags", - status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); - if (!status.ok()) { - return status; - } - status = DBWrapper::DB()->Query(context_, table_name_, partition_list_, (size_t)topk_, extra_params_, vectors_data_, result_ids, result_distances); } else { @@ -174,14 +150,13 @@ SearchRequest::OnExecute() { auto post_query_ctx = context_->Child("Constructing result"); - // step 7: construct result array + // step 8: construct result array result_.row_num_ = vector_count; result_.distance_list_ = result_distances; result_.id_list_ = result_ids; post_query_ctx->GetTraceContext()->GetSpan()->Finish(); - // step 8: print time cost percent rc.RecordSection("construct result and send"); rc.ElapseFromBegin("totally cost"); } catch (std::exception& ex) { diff --git a/core/src/server/delivery/request/SearchRequest.h b/core/src/server/delivery/request/SearchRequest.h index 43db9cfff9..d4d2915866 100644 --- a/core/src/server/delivery/request/SearchRequest.h +++ b/core/src/server/delivery/request/SearchRequest.h @@ -23,12 +23,48 @@ namespace server { class SearchRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name, const engine::VectorsData& vectors, - int64_t topk, const milvus::json& extra_params, const std::vector& partition_list, - const std::vector& file_id_list, TopKQueryResult& result); + Create(const std::shared_ptr& context, const std::string& table_name, + const engine::VectorsData& vectors, int64_t topk, const milvus::json& extra_params, + const std::vector& partition_list, const std::vector& file_id_list, + TopKQueryResult& result); + + const std::string& + TableName() const { + return table_name_; + } + + const engine::VectorsData& + VectorsData() const { + return vectors_data_; + } + + int64_t + TopK() const { + return topk_; + } + + const milvus::json& + ExtraParams() const { + return extra_params_; + } + + const std::vector& + PartitionList() const { + return partition_list_; + } + + const std::vector& + FileIDList() const { + return file_id_list_; + } + + TopKQueryResult& + QueryResult() { + return result_; + } protected: - SearchRequest(const std::shared_ptr& context, const std::string& table_name, + SearchRequest(const std::shared_ptr& context, const std::string& table_name, const engine::VectorsData& vectors, int64_t topk, const milvus::json& extra_params, const std::vector& partition_list, const std::vector& file_id_list, TopKQueryResult& result); @@ -47,5 +83,7 @@ class SearchRequest : public BaseRequest { TopKQueryResult& result_; }; +using SearchRequestPtr = std::shared_ptr; + } // namespace server } // namespace milvus diff --git a/core/src/server/delivery/request/ShowPartitionsRequest.cpp b/core/src/server/delivery/request/ShowPartitionsRequest.cpp index fd22f4d482..a7e97ac7cb 100644 --- a/core/src/server/delivery/request/ShowPartitionsRequest.cpp +++ b/core/src/server/delivery/request/ShowPartitionsRequest.cpp @@ -22,13 +22,13 @@ namespace milvus { namespace server { -ShowPartitionsRequest::ShowPartitionsRequest(const std::shared_ptr& context, const std::string& table_name, - std::vector& partition_list) - : BaseRequest(context, INFO_REQUEST_GROUP), table_name_(table_name), partition_list_(partition_list) { +ShowPartitionsRequest::ShowPartitionsRequest(const std::shared_ptr& context, + const std::string& table_name, std::vector& partition_list) + : BaseRequest(context, BaseRequest::kShowPartitions), table_name_(table_name), partition_list_(partition_list) { } BaseRequestPtr -ShowPartitionsRequest::Create(const std::shared_ptr& context, const std::string& table_name, +ShowPartitionsRequest::Create(const std::shared_ptr& context, const std::string& table_name, std::vector& partition_list) { return std::shared_ptr(new ShowPartitionsRequest(context, table_name, partition_list)); } diff --git a/core/src/server/delivery/request/ShowPartitionsRequest.h b/core/src/server/delivery/request/ShowPartitionsRequest.h index 9473161731..58221b212d 100644 --- a/core/src/server/delivery/request/ShowPartitionsRequest.h +++ b/core/src/server/delivery/request/ShowPartitionsRequest.h @@ -23,11 +23,11 @@ namespace server { class ShowPartitionsRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name, + Create(const std::shared_ptr& context, const std::string& table_name, std::vector& partition_list); protected: - ShowPartitionsRequest(const std::shared_ptr& context, const std::string& table_name, + ShowPartitionsRequest(const std::shared_ptr& context, const std::string& table_name, std::vector& partition_list); Status diff --git a/core/src/server/delivery/request/ShowTableInfoRequest.cpp b/core/src/server/delivery/request/ShowTableInfoRequest.cpp index 641c0c1afd..361b66d86c 100644 --- a/core/src/server/delivery/request/ShowTableInfoRequest.cpp +++ b/core/src/server/delivery/request/ShowTableInfoRequest.cpp @@ -43,13 +43,13 @@ ConstructPartitionStat(const engine::PartitionStat& partition_stat, PartitionSta req_partition_stat.total_row_num_ = row_count; } -ShowTableInfoRequest::ShowTableInfoRequest(const std::shared_ptr& context, const std::string& table_name, - TableInfo& table_info) - : BaseRequest(context, INFO_REQUEST_GROUP), table_name_(table_name), table_info_(table_info) { +ShowTableInfoRequest::ShowTableInfoRequest(const std::shared_ptr& context, + const std::string& table_name, TableInfo& table_info) + : BaseRequest(context, BaseRequest::kShowTableInfo), table_name_(table_name), table_info_(table_info) { } BaseRequestPtr -ShowTableInfoRequest::Create(const std::shared_ptr& context, const std::string& table_name, +ShowTableInfoRequest::Create(const std::shared_ptr& context, const std::string& table_name, TableInfo& table_info) { return std::shared_ptr(new ShowTableInfoRequest(context, table_name, table_info)); } diff --git a/core/src/server/delivery/request/ShowTableInfoRequest.h b/core/src/server/delivery/request/ShowTableInfoRequest.h index 8523648201..b709de7ff8 100644 --- a/core/src/server/delivery/request/ShowTableInfoRequest.h +++ b/core/src/server/delivery/request/ShowTableInfoRequest.h @@ -29,10 +29,12 @@ namespace server { class ShowTableInfoRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, const std::string& table_name, TableInfo& table_info); + Create(const std::shared_ptr& context, const std::string& table_name, + TableInfo& table_info); protected: - ShowTableInfoRequest(const std::shared_ptr& context, const std::string& table_name, TableInfo& table_info); + ShowTableInfoRequest(const std::shared_ptr& context, const std::string& table_name, + TableInfo& table_info); Status OnExecute() override; diff --git a/core/src/server/delivery/request/ShowTablesRequest.cpp b/core/src/server/delivery/request/ShowTablesRequest.cpp index e82f6c608e..af28b8e11e 100644 --- a/core/src/server/delivery/request/ShowTablesRequest.cpp +++ b/core/src/server/delivery/request/ShowTablesRequest.cpp @@ -22,12 +22,14 @@ namespace milvus { namespace server { -ShowTablesRequest::ShowTablesRequest(const std::shared_ptr& context, std::vector& table_name_list) - : BaseRequest(context, INFO_REQUEST_GROUP), table_name_list_(table_name_list) { +ShowTablesRequest::ShowTablesRequest(const std::shared_ptr& context, + std::vector& table_name_list) + : BaseRequest(context, BaseRequest::kShowTables), table_name_list_(table_name_list) { } BaseRequestPtr -ShowTablesRequest::Create(const std::shared_ptr& context, std::vector& table_name_list) { +ShowTablesRequest::Create(const std::shared_ptr& context, + std::vector& table_name_list) { return std::shared_ptr(new ShowTablesRequest(context, table_name_list)); } diff --git a/core/src/server/delivery/request/ShowTablesRequest.h b/core/src/server/delivery/request/ShowTablesRequest.h index e36ff9c49e..e49b775982 100644 --- a/core/src/server/delivery/request/ShowTablesRequest.h +++ b/core/src/server/delivery/request/ShowTablesRequest.h @@ -23,10 +23,11 @@ namespace server { class ShowTablesRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, std::vector& table_name_list); + Create(const std::shared_ptr& context, std::vector& table_name_list); protected: - ShowTablesRequest(const std::shared_ptr& context, std::vector& table_name_list); + ShowTablesRequest(const std::shared_ptr& context, + std::vector& table_name_list); Status OnExecute() override; diff --git a/core/src/server/delivery/strategy/RequestStrategy.h b/core/src/server/delivery/strategy/RequestStrategy.h new file mode 100644 index 0000000000..3456deb5f6 --- /dev/null +++ b/core/src/server/delivery/strategy/RequestStrategy.h @@ -0,0 +1,39 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed 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. + +#pragma once + +#include "server/delivery/request/BaseRequest.h" +#include "utils/BlockingQueue.h" +#include "utils/Status.h" + +#include +#include +#include +#include +#include + +namespace milvus { +namespace server { + +class RequestStrategy { + protected: + RequestStrategy() = default; + + public: + virtual Status + ReScheduleQueue(const BaseRequestPtr& request, std::queue& queue) = 0; +}; + +using RequestStrategyPtr = std::shared_ptr; + +} // namespace server +} // namespace milvus diff --git a/core/src/server/delivery/strategy/SearchReqStrategy.cpp b/core/src/server/delivery/strategy/SearchReqStrategy.cpp new file mode 100644 index 0000000000..8cdb306966 --- /dev/null +++ b/core/src/server/delivery/strategy/SearchReqStrategy.cpp @@ -0,0 +1,77 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed 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. + +#include "server/delivery/strategy/SearchReqStrategy.h" +#include "server/delivery/request/SearchCombineRequest.h" +#include "server/delivery/request/SearchRequest.h" +#include "utils/CommonUtil.h" +#include "utils/Error.h" +#include "utils/Log.h" +#include "utils/TimeRecorder.h" + +#include +#include + +namespace milvus { +namespace server { + +SearchReqStrategy::SearchReqStrategy() { +} + +Status +SearchReqStrategy::ReScheduleQueue(const BaseRequestPtr& request, std::queue& queue) { + if (request->GetRequestType() != BaseRequest::kSearch) { + std::string msg = "search strategy can only handle search request"; + SERVER_LOG_ERROR << msg; + return Status(SERVER_UNSUPPORTED_ERROR, msg); + } + + // TimeRecorderAuto rc("SearchReqStrategy::ReScheduleQueue"); + SearchRequestPtr new_search_req = std::static_pointer_cast(request); + + BaseRequestPtr last_req = queue.back(); + if (last_req->GetRequestType() == BaseRequest::kSearch) { + SearchRequestPtr last_search_req = std::static_pointer_cast(last_req); + if (SearchCombineRequest::CanCombine(last_search_req, new_search_req)) { + // pop last request + queue.pop(); + + // combine request + SearchCombineRequestPtr combine_request = std::make_shared(); + combine_request->Combine(last_search_req); + combine_request->Combine(new_search_req); + queue.push(combine_request); + SERVER_LOG_DEBUG << "Combine 2 search request"; + } else { + // directly put to queue + queue.push(request); + } + } else if (last_req->GetRequestType() == BaseRequest::kSearchCombine) { + SearchCombineRequestPtr combine_req = std::static_pointer_cast(last_req); + if (combine_req->CanCombine(new_search_req)) { + // combine request + combine_req->Combine(new_search_req); + SERVER_LOG_DEBUG << "Combine more search request"; + } else { + // directly put to queue + queue.push(request); + } + } else { + std::string msg = "unsupported request type for search strategy"; + SERVER_LOG_ERROR << msg; + return Status(SERVER_UNSUPPORTED_ERROR, msg); + } + + return Status::OK(); +} + +} // namespace server +} // namespace milvus diff --git a/core/src/server/delivery/strategy/SearchReqStrategy.h b/core/src/server/delivery/strategy/SearchReqStrategy.h new file mode 100644 index 0000000000..20093c66c2 --- /dev/null +++ b/core/src/server/delivery/strategy/SearchReqStrategy.h @@ -0,0 +1,33 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed 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. + +#pragma once + +#include "server/delivery/strategy/RequestStrategy.h" +#include "utils/Status.h" + +#include +#include + +namespace milvus { +namespace server { + +class SearchReqStrategy : public RequestStrategy { + public: + SearchReqStrategy(); + + Status + ReScheduleQueue(const BaseRequestPtr& request, std::queue& queue) override; +}; + +using RequestStrategyPtr = std::shared_ptr; +} // namespace server +} // namespace milvus diff --git a/core/src/utils/BlockingQueue.h b/core/src/utils/BlockingQueue.h index ccdfc3e5f4..0003e594e5 100644 --- a/core/src/utils/BlockingQueue.h +++ b/core/src/utils/BlockingQueue.h @@ -26,6 +26,9 @@ class BlockingQueue { BlockingQueue() : mtx(), full_(), empty_() { } + virtual ~BlockingQueue() { + } + BlockingQueue(const BlockingQueue& rhs) = delete; BlockingQueue& @@ -52,7 +55,7 @@ class BlockingQueue { void SetCapacity(const size_t capacity); - private: + protected: mutable std::mutex mtx; std::condition_variable full_; std::condition_variable empty_; diff --git a/core/src/utils/ValidationUtil.cpp b/core/src/utils/ValidationUtil.cpp index 047d6ca5b5..39dbc5c23b 100644 --- a/core/src/utils/ValidationUtil.cpp +++ b/core/src/utils/ValidationUtil.cpp @@ -306,6 +306,39 @@ ValidationUtil::ValidateSearchParams(const milvus::json& search_params, const en return Status::OK(); } +Status +ValidationUtil::ValidateVectorData(const engine::VectorsData& vectors, const engine::meta::TableSchema& table_schema) { + if (vectors.float_data_.empty() && vectors.binary_data_.empty()) { + return Status(SERVER_INVALID_ROWRECORD_ARRAY, + "The vector array is empty. Make sure you have entered vector records."); + } + + uint64_t vector_count = vectors.vector_count_; + if (engine::utils::IsBinaryMetricType(table_schema.metric_type_)) { + // check prepared binary data + if (vectors.binary_data_.size() % vector_count != 0) { + return Status(SERVER_INVALID_ROWRECORD_ARRAY, "The vector dimension must be equal to the table dimension."); + } + + if (vectors.binary_data_.size() * 8 / vector_count != table_schema.dimension_) { + return Status(SERVER_INVALID_VECTOR_DIMENSION, + "The vector dimension must be equal to the table dimension."); + } + } else { + // check prepared float data + fiu_do_on("SearchRequest.OnExecute.invalod_rowrecord_array", vector_count = vectors.float_data_.size() + 1); + if (vectors.float_data_.size() % vector_count != 0) { + return Status(SERVER_INVALID_ROWRECORD_ARRAY, "The vector dimension must be equal to the table dimension."); + } + if (vectors.float_data_.size() / vector_count != table_schema.dimension_) { + return Status(SERVER_INVALID_VECTOR_DIMENSION, + "The vector dimension must be equal to the table dimension."); + } + } + + return Status::OK(); +} + Status ValidationUtil::ValidateTableIndexFileSize(int64_t index_file_size) { if (index_file_size <= 0 || index_file_size > INDEX_FILE_SIZE_LIMIT) { @@ -331,8 +364,8 @@ ValidationUtil::ValidateTableIndexMetricType(int32_t metric_type) { } Status -ValidationUtil::ValidateSearchTopk(int64_t top_k, const engine::meta::TableSchema& table_schema) { - if (top_k <= 0 || top_k > 2048) { +ValidationUtil::ValidateSearchTopk(int64_t top_k) { + if (top_k <= 0 || top_k > QUERY_MAX_TOPK) { std::string msg = "Invalid topk: " + std::to_string(top_k) + ". " + "The topk must be within the range of 1 ~ 2048."; SERVER_LOG_ERROR << msg; diff --git a/core/src/utils/ValidationUtil.h b/core/src/utils/ValidationUtil.h index 787adc12ec..ec8960cad2 100644 --- a/core/src/utils/ValidationUtil.h +++ b/core/src/utils/ValidationUtil.h @@ -11,6 +11,7 @@ #pragma once +#include "db/Types.h" #include "db/meta/MetaTypes.h" #include "utils/Json.h" #include "utils/Status.h" @@ -21,6 +22,8 @@ namespace milvus { namespace server { +constexpr int64_t QUERY_MAX_TOPK = 2048; + class ValidationUtil { private: ValidationUtil() = default; @@ -43,6 +46,9 @@ class ValidationUtil { ValidateSearchParams(const milvus::json& search_params, const engine::meta::TableSchema& table_schema, int64_t topk); + static Status + ValidateVectorData(const engine::VectorsData& vectors, const engine::meta::TableSchema& table_schema); + static Status ValidateTableIndexFileSize(int64_t index_file_size); @@ -50,7 +56,7 @@ class ValidationUtil { ValidateTableIndexMetricType(int32_t metric_type); static Status - ValidateSearchTopk(int64_t top_k, const engine::meta::TableSchema& table_schema); + ValidateSearchTopk(int64_t top_k); static Status ValidatePartitionName(const std::string& partition_name); diff --git a/core/unittest/CMakeLists.txt b/core/unittest/CMakeLists.txt index 5a2bfc3689..dc1119ab11 100644 --- a/core/unittest/CMakeLists.txt +++ b/core/unittest/CMakeLists.txt @@ -89,9 +89,11 @@ set(web_server_files aux_source_directory(${MILVUS_ENGINE_SRC}/server/delivery server_delivery_impl_files) aux_source_directory(${MILVUS_ENGINE_SRC}/server/delivery/request server_delivery_request_files) +aux_source_directory(${MILVUS_ENGINE_SRC}/server/delivery/strategy server_delivery_strategy_files) set(server_delivery_files ${server_delivery_impl_files} - ${server_delivery_request_files}) + ${server_delivery_request_files} + ${server_delivery_strategy_files}) aux_source_directory(${MILVUS_ENGINE_SRC}/utils utils_files) aux_source_directory(${MILVUS_ENGINE_SRC}/index/archive wrapper_files) diff --git a/core/unittest/server/test_rpc.cpp b/core/unittest/server/test_rpc.cpp index f12f0bad54..e6b0513c24 100644 --- a/core/unittest/server/test_rpc.cpp +++ b/core/unittest/server/test_rpc.cpp @@ -709,13 +709,14 @@ class DummyRequest : public milvus::server::BaseRequest { } static milvus::server::BaseRequestPtr - Create(std::string& dummy) { - return std::shared_ptr(new DummyRequest(dummy)); + Create() { + return std::shared_ptr(new DummyRequest()); } public: - explicit DummyRequest(std::string& dummy) - : BaseRequest(std::make_shared("dummy_request_id"), dummy) { + DummyRequest() + : BaseRequest(std::make_shared("dummy_request_id"), + milvus::server::BaseRequest::kCmd) { } }; @@ -723,8 +724,7 @@ class RpcSchedulerTest : public testing::Test { protected: void SetUp() override { - std::string dummy = "dql"; - request_ptr = std::make_shared(dummy); + request_ptr = std::make_shared(); } std::shared_ptr request_ptr; @@ -738,17 +738,15 @@ class AsyncDummyRequest : public milvus::server::BaseRequest { } static milvus::server::BaseRequestPtr - Create(std::string& dummy) { - return std::shared_ptr(new DummyRequest(dummy)); - } - - void TestSetStatus() { - SetStatus(milvus::SERVER_INVALID_ARGUMENT, ""); + Create() { + return std::shared_ptr(new DummyRequest()); } public: - explicit AsyncDummyRequest(std::string& dummy) - : BaseRequest(std::make_shared("dummy_request_id2"), dummy, true) { + AsyncDummyRequest() + : BaseRequest(std::make_shared("dummy_request_id2"), + milvus::server::BaseRequest::kCmd, + true) { } }; } // namespace @@ -761,8 +759,7 @@ TEST_F(RpcSchedulerTest, BASE_TASK_TEST) { // milvus::server::RequestScheduler::GetInstance().Stop(); // milvus::server::RequestScheduler::GetInstance().Start(); - std::string dummy = "dql"; - milvus::server::BaseRequestPtr base_task_ptr = DummyRequest::Create(dummy); + milvus::server::BaseRequestPtr base_task_ptr = DummyRequest::Create(); milvus::server::RequestScheduler::ExecRequest(base_task_ptr); milvus::server::RequestScheduler::GetInstance().ExecuteRequest(request_ptr); @@ -778,20 +775,17 @@ TEST_F(RpcSchedulerTest, BASE_TASK_TEST) { // milvus::server::RequestScheduler::GetInstance().ExecuteRequest(base_task_ptr2); // fiu_disable("RequestScheduler.PutToQueue.null_queue"); - std::string dummy3 = "dql3"; - milvus::server::BaseRequestPtr base_task_ptr3 = DummyRequest::Create(dummy3); + milvus::server::BaseRequestPtr base_task_ptr3 = DummyRequest::Create(); fiu_enable("RequestScheduler.TakeToExecute.throw_std_exception", 1, NULL, 0); milvus::server::RequestScheduler::GetInstance().ExecuteRequest(base_task_ptr3); fiu_disable("RequestScheduler.TakeToExecute.throw_std_exception"); - std::string dummy4 = "dql4"; - milvus::server::BaseRequestPtr base_task_ptr4 = DummyRequest::Create(dummy4); + milvus::server::BaseRequestPtr base_task_ptr4 = DummyRequest::Create(); fiu_enable("RequestScheduler.TakeToExecute.execute_fail", 1, NULL, 0); milvus::server::RequestScheduler::GetInstance().ExecuteRequest(base_task_ptr4); fiu_disable("RequestScheduler.TakeToExecute.execute_fail"); - std::string dummy5 = "dql5"; - milvus::server::BaseRequestPtr base_task_ptr5 = DummyRequest::Create(dummy5); + milvus::server::BaseRequestPtr base_task_ptr5 = DummyRequest::Create(); fiu_enable("RequestScheduler.PutToQueue.push_null_thread", 1, NULL, 0); milvus::server::RequestScheduler::GetInstance().ExecuteRequest(base_task_ptr5); fiu_disable("RequestScheduler.PutToQueue.push_null_thread"); @@ -802,11 +796,10 @@ TEST_F(RpcSchedulerTest, BASE_TASK_TEST) { milvus::server::BaseRequestPtr null_ptr = nullptr; milvus::server::RequestScheduler::ExecRequest(null_ptr); - std::string async_dummy = "AsyncDummyRequest"; - auto async_ptr = std::make_shared(async_dummy); + auto async_ptr = std::make_shared(); auto base_ptr = std::static_pointer_cast(async_ptr); milvus::server::RequestScheduler::ExecRequest(base_ptr); - async_ptr->TestSetStatus(); + async_ptr->set_status(milvus::Status(milvus::SERVER_INVALID_ARGUMENT, "")); milvus::server::RequestScheduler::GetInstance().Stop(); milvus::server::RequestScheduler::GetInstance().Start(); diff --git a/core/unittest/server/test_util.cpp b/core/unittest/server/test_util.cpp index ec92529bbd..d8b786947c 100644 --- a/core/unittest/server/test_util.cpp +++ b/core/unittest/server/test_util.cpp @@ -623,10 +623,9 @@ TEST(ValidationUtilTest, VALIDATE_SEARCH_PARAMS_TEST) { } TEST(ValidationUtilTest, VALIDATE_TOPK_TEST) { - milvus::engine::meta::TableSchema schema; - ASSERT_EQ(milvus::server::ValidationUtil::ValidateSearchTopk(10, schema).code(), milvus::SERVER_SUCCESS); - ASSERT_NE(milvus::server::ValidationUtil::ValidateSearchTopk(65536, schema).code(), milvus::SERVER_SUCCESS); - ASSERT_NE(milvus::server::ValidationUtil::ValidateSearchTopk(0, schema).code(), milvus::SERVER_SUCCESS); + ASSERT_EQ(milvus::server::ValidationUtil::ValidateSearchTopk(10).code(), milvus::SERVER_SUCCESS); + ASSERT_NE(milvus::server::ValidationUtil::ValidateSearchTopk(65536).code(), milvus::SERVER_SUCCESS); + ASSERT_NE(milvus::server::ValidationUtil::ValidateSearchTopk(0).code(), milvus::SERVER_SUCCESS); } TEST(ValidationUtilTest, VALIDATE_PARTITION_TAGS) {